style(python): improve code formatting across multiple files

Author: hakula139

python/__init__.py

@@ -7,8 +7,7 @@
 __version__ = '1.0.0'
 __author__ = 'Demo Project Team'
 
-from . import (algorithms, containers, exceptions, memory, random, shapes,
-               timing)
+from . import algorithms, containers, exceptions, memory, random, shapes, timing
 
 __all__ = [
     'algorithms',

python/containers.py

@@ -32,13 +32,9 @@ def __init__(self, container_type: type[T], data: Iterable[T] | None = None):
             case int:
                 self._container = _containers.IntContainer(list(data) if data else [])
             case float:
-                self._container = _containers.DoubleContainer(
-                    list(data) if data else []
-                )
+                self._container = _containers.DoubleContainer(list(data) if data else [])
             case str:
-                self._container = _containers.StringContainer(
-                    list(data) if data else []
-                )
+                self._container = _containers.StringContainer(list(data) if data else [])
             case _:
                 raise ValueError(f'Unsupported container type: {container_type}')
 

python/exceptions.py

@@ -201,9 +201,7 @@ def ok(value: T) -> 'Result[T]':
                 raise ValueError(f'Unsupported result type: {type(value)}')
 
     @staticmethod
-    def error(
-        message: str, severity: ErrorSeverity = ErrorSeverity.ERROR
-    ) -> 'Result[Any]':
+    def error(message: str, severity: ErrorSeverity = ErrorSeverity.ERROR) -> 'Result[Any]':
         """Create an error Result.
 
         Parameters

python/shapes.py

@@ -97,9 +97,7 @@ def create_shape(shape_type: str | ShapeType, *args: float) -> _shapes.Shape:
 
         case ShapeType.RECTANGLE | 'rectangle':
             if len(args) != 2:
-                raise ValueError(
-                    'Rectangle requires exactly 2 arguments (width, height)'
-                )
+                raise ValueError('Rectangle requires exactly 2 arguments (width, height)')
             return _shapes.create_rectangle(args[0], args[1])
 
         case ShapeType.SQUARE | 'square':

python/timing.py

@@ -207,14 +207,10 @@ def get_statistics(self) -> dict[str, Any]:
             'median_ms': statistics.median(measurements_ms),
             'min_ms': min(measurements_ms),
             'max_ms': max(measurements_ms),
-            'stdev_ms': (
-                statistics.stdev(measurements_ms) if len(measurements_ms) > 1 else 0.0
-            ),
+            'stdev_ms': (statistics.stdev(measurements_ms) if len(measurements_ms) > 1 else 0.0),
             'measurements_ns': self.measurements.copy(),
             'human_readable': {
-                'mean': _timing.to_human_readable(
-                    int(statistics.mean(self.measurements))
-                ),
+                'mean': _timing.to_human_readable(int(statistics.mean(self.measurements))),
                 'min': _timing.to_human_readable(min(self.measurements)),
                 'max': _timing.to_human_readable(max(self.measurements)),
             },

python_examples/advanced_usage.py

@@ -11,8 +11,7 @@
 # Add the python module to the path
 sys.path.insert(0, str(Path(__file__).parent.parent / 'python'))
 
-from python import (algorithms, containers, exceptions, memory, random, shapes,
-                    timing)
+from python import algorithms, containers, exceptions, memory, random, shapes, timing
 
 
 class ShapeAnalyzer:
@@ -68,8 +67,7 @@ def create_shapes():
 
         # Transform for efficiency ratios (area/perimeter)
         efficiency_ratios = algorithms.transform(
-            list(zip(areas, perimeters)),
-            lambda ap: ap[0] / ap[1] if ap[1] > 0 else 0
+            list(zip(areas, perimeters)), lambda ap: ap[0] / ap[1] if ap[1] > 0 else 0
         )
 
         self.operation_count += 1
@@ -81,10 +79,10 @@ def create_shapes():
             'statistics': {
                 'large_shapes': large_shapes,
                 'complex_shapes': complex_shapes,
-                'avg_efficiency': sum(efficiency_ratios) / len(efficiency_ratios)
+                'avg_efficiency': sum(efficiency_ratios) / len(efficiency_ratios),
             },
             'creation_time': creation_stats['human_readable']['mean'],
-            'operation_count': self.operation_count
+            'operation_count': self.operation_count,
         }
 
 
@@ -125,7 +123,7 @@ def safe_statistical_analysis(squares):
                     'max': max_val,
                     'median': squares[len(squares) // 2],
                     'sum': sum(squares),
-                    'large_values': algorithms.count_if(squares, lambda x: x > 1000)
+                    'large_values': algorithms.count_if(squares, lambda x: x > 1000),
                 }
 
             # Execute pipeline
@@ -174,12 +172,13 @@ def benchmark_sorting_algorithms(self) -> dict:
             'large_random': lambda: random.RandomGenerator(42).integers(1, 1000, 1000),
             'already_sorted': lambda: list(range(1, 501)),
             'reverse_sorted': lambda: list(range(500, 0, -1)),
-            'mostly_sorted': lambda: list(range(1, 500)) + [499, 498, 497]
+            'mostly_sorted': lambda: list(range(1, 500)) + [499, 498, 497],
         }
 
         results = {}
 
         for scenario_name, data_gen in scenarios.items():
+
             def sort_test():
                 data = data_gen()
                 algorithms.sort_inplace(data)
@@ -189,7 +188,7 @@ def sort_test():
             results[scenario_name] = {
                 'mean_time': stats['human_readable']['mean'],
                 'iterations': stats['iterations'],
-                'data_size': len(data_gen())
+                'data_size': len(data_gen()),
             }
 
         return results
@@ -217,7 +216,7 @@ def mixed_operations():
         operations = {
             'filter': filter_operation,
             'transform': transform_operation,
-            'mixed': mixed_operations
+            'mixed': mixed_operations,
         }
 
         results = {}
@@ -250,7 +249,7 @@ def cleanup_heavy_operations():
 
         operations = {
             'shape_creation': create_many_shapes,
-            'cleanup_operations': cleanup_heavy_operations
+            'cleanup_operations': cleanup_heavy_operations,
         }
 
         results = {}
@@ -268,7 +267,7 @@ def run_full_benchmark(self) -> dict:
             self.results = {
                 'sorting': self.benchmark_sorting_algorithms(),
                 'containers': self.benchmark_container_operations(),
-                'memory': self.benchmark_memory_management()
+                'memory': self.benchmark_memory_management(),
             }
 
         return self.results
@@ -289,8 +288,7 @@ def monte_carlo_pi_estimation(samples: int = 1000000) -> exceptions.Result[float
 
         # Count points inside unit circle
         inside_circle = algorithms.count_if(
-            list(zip(x_coords, y_coords)),
-            lambda p: p[0]**2 + p[1]**2 <= 1.0
+            list(zip(x_coords, y_coords)), lambda p: p[0] ** 2 + p[1] ** 2 <= 1.0
         )
 
         # Estimate π
@@ -311,24 +309,26 @@ def advanced_functional_programming_example():
     data = gen.integers(1, 100, 50)
 
     # Complex functional chain with multiple transformations
-    result = (algorithms.functional_chain(data)
-              .filter(lambda x: x % 3 == 0)  # Divisible by 3
-              .map(lambda x: x * x)          # Square them
-              .filter(lambda x: x < 1000)    # Keep reasonable size
-              .sort(reverse=True)             # Sort descending
-              .take(10)                       # Take top 10
-              .map(lambda x: x / 9)          # Divide by 9
-              .collect())
+    result = (
+        algorithms.functional_chain(data)
+        .filter(lambda x: x % 3 == 0)  # Divisible by 3
+        .map(lambda x: x * x)  # Square them
+        .filter(lambda x: x < 1000)  # Keep reasonable size
+        .sort(reverse=True)  # Sort descending
+        .take(10)  # Take top 10
+        .map(lambda x: x / 9)  # Divide by 9
+        .collect()
+    )
 
     print(f'Functional chain result: {result}')
 
     # Pipeline composition
     numerical_pipeline = algorithms.pipeline(
-        lambda nums: [x for x in nums if x > 20],     # Filter
-        lambda nums: [x * 2 for x in nums],           # Double
+        lambda nums: [x for x in nums if x > 20],  # Filter
+        lambda nums: [x * 2 for x in nums],  # Double
         lambda nums: algorithms.transform(nums, lambda x: x + 1),  # Add 1
-        lambda nums: sorted(nums),                     # Sort
-        lambda nums: nums[:5]                          # Take first 5
+        lambda nums: sorted(nums),  # Sort
+        lambda nums: nums[:5],  # Take first 5
     )
 
     pipeline_result = numerical_pipeline(gen.integers(1, 50, 20))
@@ -342,6 +342,7 @@ def safe_logarithm(x: float) -> exceptions.Result[float]:
         if x <= 0:
             return exceptions.Result.error('Logarithm of non-positive number')
         import math
+
         return exceptions.Result.ok(math.log(x))
 
     # Chain safe operations
@@ -380,7 +381,9 @@ def real_world_simulation():
         print(f"Environment Analysis Results:")
         print(f"  - Total shapes: {analysis['shape_count']}")
         print(f"  - Area range: {analysis['areas']['min']:.2f} - {analysis['areas']['max']:.2f}")
-        print(f"  - Perimeter range: {analysis['perimeters']['min']:.2f} - {analysis['perimeters']['max']:.2f}")
+        print(
+            f"  - Perimeter range: {analysis['perimeters']['min']:.2f} - {analysis['perimeters']['max']:.2f}"
+        )
         print(f"  - Large shapes (area > 50): {analysis['statistics']['large_shapes']}")
         print(f"  - Complex shapes (perimeter > 20): {analysis['statistics']['complex_shapes']}")
         print(f"  - Average efficiency ratio: {analysis['statistics']['avg_efficiency']:.4f}")
@@ -445,6 +448,7 @@ def main():
     except Exception as e:
         print(f'Error running advanced examples: {e}')
         import traceback
+
         traceback.print_exc()
         return 1
 

python_examples/basic_usage.py

@@ -10,8 +10,7 @@
 # Add the python module to the path
 sys.path.insert(0, str(Path(__file__).parent.parent / 'python'))
 
-from python import (algorithms, containers, exceptions, memory, random, shapes,
-                    timing)
+from python import algorithms, containers, exceptions, memory, random, shapes, timing
 
 
 def shapes_example():
@@ -93,19 +92,19 @@ def algorithms_example():
     print(f'Min: {min_val}, Max: {max_val}')
 
     # Functional chain
-    result = (algorithms.functional_chain([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-              .filter(lambda x: x % 2 == 0)
-              .map(lambda x: x * x)
-              .take(3)
-              .collect())
+    result = (
+        algorithms.functional_chain([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+        .filter(lambda x: x % 2 == 0)
+        .map(lambda x: x * x)
+        .take(3)
+        .collect()
+    )
 
     print(f'Functional chain result: {result}')
 
     # Pipeline
     process = algorithms.pipeline(
-        lambda lst: [x for x in lst if x > 3],
-        lambda lst: [x * 2 for x in lst],
-        sum
+        lambda lst: [x for x in lst if x > 3], lambda lst: [x * 2 for x in lst], sum
     )
 
     pipeline_result = process([1, 2, 3, 4, 5, 6])
@@ -123,6 +122,7 @@ def memory_example():
     def cleanup_function(name: str):
         def cleanup():
             cleanup_log.append(f'Cleaned up {name}')
+
         return cleanup
 
     # Using resource manager as context manager
@@ -301,10 +301,7 @@ def integration_example():
         # Time a complex operation
         with timing.Timer() as timer:
             # Complex calculation involving all shapes
-            total_complexity = sum(
-                shape.get_area() * shape.get_perimeter()
-                for shape in all_shapes
-            )
+            total_complexity = sum(shape.get_area() * shape.get_perimeter() for shape in all_shapes)
 
         print(f'Complex calculation result: {total_complexity:.2f}')
         print(f'Calculation time: {timer.elapsed_string}')
@@ -339,6 +336,7 @@ def main():
     except Exception as e:
         print(f'Error running examples: {e}')
         import traceback
+
         traceback.print_exc()
         return 1