fix(python): fix errors

Author: hakula139

.gitignore

@@ -14,6 +14,14 @@ out/
 *.dylib
 *.dll
 
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+
 # Debug and temporary files
 *.log
 *.tmp

.vscode/settings.json

@@ -18,6 +18,10 @@
   "cmake.automaticReconfigure": true,
   "cmake.configureOnEdit": true,
   "cmake.configureOnOpen": true,
+  "cursorpyright.analysis.extraPaths": [
+    "build/debug/binding",
+    "build/release/binding"
+  ],
   "editor.codeActionsOnSave": {
     "source.fixAll.clangd": "explicit",
     "source.organizeImports": "explicit"
@@ -27,7 +31,6 @@
     "enabled": true
   },
   "editor.suggest.insertMode": "replace",
-  "editor.tabSize": 2,
   "files.associations": {
     "*.cpp": "cpp",
     "*.h": "cpp",

binding/memory_binding.cpp

@@ -30,12 +30,16 @@ void bind_memory(py::module &m) {
             return self.CreateUnique<Rectangle>(width, height);
           },
           py::return_value_policy::take_ownership)
-      .def("create_shared_circle",
-           [](ResourceManager &self, double radius) { return self.CreateShared<Circle>(radius); })
-      .def("create_shared_rectangle",
-           [](ResourceManager &self, double width, double height) {
-             return self.CreateShared<Rectangle>(width, height);
-           })
+      .def(
+          "create_shared_circle",
+          [](ResourceManager &self, double radius) { return self.CreateShared<Circle>(radius); },
+          py::return_value_policy::reference)
+      .def(
+          "create_shared_rectangle",
+          [](ResourceManager &self, double width, double height) {
+            return self.CreateShared<Rectangle>(width, height);
+          },
+          py::return_value_policy::reference)
       .def("register_cleanup",
            [](ResourceManager &self, std::function<void()> cleanup_func) {
              self.RegisterCleanup<int>(cleanup_func);

binding/shapes_binding.cpp

@@ -19,18 +19,21 @@ void bind_shapes(py::module &m) {
   using namespace cpp_features::shapes;
 
   // Bind the abstract Shape base class
-  py::class_<Shape>(m, "Shape", "Abstract base class for geometric shapes")
+  py::class_<Shape, std::shared_ptr<Shape>>(m, "Shape", "Abstract base class for geometric shapes")
       .def("get_area", &Shape::GetArea, "Calculate the area of the shape")
       .def("get_perimeter", &Shape::GetPerimeter, "Calculate the perimeter of the shape")
       .def("draw", &Shape::Draw, "Draw the shape")
-      .def("get_name", &Shape::GetName, "Get the name of the shape")
+      .def(
+          "get_name", [](const Shape &s) { return std::string{s.GetName()}; },
+          "Get the name of the shape")
       .def("__str__", [](const Shape &s) { return std::string{s.GetName()}; })
       .def("__repr__", [](const Shape &s) {
         return std::format("<{} at {}>", s.GetName(), static_cast<const void *>(&s));
       });
 
   // Bind Circle class
-  py::class_<Circle, Shape>(m, "Circle", "Circle shape with radius-based geometry")
+  py::class_<Circle, Shape, std::shared_ptr<Circle>>(m, "Circle",
+                                                     "Circle shape with radius-based geometry")
       .def(py::init<double>(), py::arg("radius"), "Construct a circle with the specified radius")
       .def("get_radius", &Circle::GetRadius, "Get the radius of the circle")
       .def("__eq__", [](const Circle &self, const Circle &other) { return self == other; })
@@ -60,7 +63,8 @@ void bind_shapes(py::module &m) {
       });
 
   // Bind Rectangle class
-  py::class_<Rectangle, Shape>(m, "Rectangle", "Rectangle shape with width and height geometry")
+  py::class_<Rectangle, Shape, std::shared_ptr<Rectangle>>(
+      m, "Rectangle", "Rectangle shape with width and height geometry")
       .def(py::init<Rectangle::Dimensions>(), py::arg("dimensions"),
            "Construct a rectangle from a Dimensions structure")
       .def(py::init<double, double>(), py::arg("width"), py::arg("height"),
@@ -91,36 +95,34 @@ void bind_shapes(py::module &m) {
   // Bind factory functions
   m.def(
       "create_circle",
-      [](double radius) -> std::unique_ptr<Circle> { return CreateCircle(radius); },
-      py::arg("radius"), "Factory function for creating Circle objects",
-      py::return_value_policy::take_ownership);
+      [](double radius) -> std::shared_ptr<Circle> { return std::make_shared<Circle>(radius); },
+      py::arg("radius"), "Factory function for creating Circle objects");
 
   m.def(
       "create_rectangle",
-      [](double width, double height) -> std::unique_ptr<Rectangle> {
-        return CreateRectangle(width, height);
+      [](double width, double height) -> std::shared_ptr<Rectangle> {
+        return std::make_shared<Rectangle>(width, height);
       },
-      py::arg("width"), py::arg("height"), "Factory function for creating Rectangle objects",
-      py::return_value_policy::take_ownership);
+      py::arg("width"), py::arg("height"), "Factory function for creating Rectangle objects");
 
   m.def(
-      "create_square", [](double side) -> std::unique_ptr<Rectangle> { return CreateSquare(side); },
-      py::arg("side"), "Factory function for creating square Rectangle objects",
-      py::return_value_policy::take_ownership);
+      "create_square",
+      [](double side) -> std::shared_ptr<Rectangle> { return std::make_shared<Rectangle>(side); },
+      py::arg("side"), "Factory function for creating square Rectangle objects");
 
   m.def(
       "create_shape",
-      [](const std::string &shape_type, py::args args) -> std::unique_ptr<Shape> {
+      [](const std::string &shape_type, py::args args) -> std::shared_ptr<Shape> {
         if (shape_type == "circle") {
           if (args.size() != 1) {
             throw std::invalid_argument("Circle requires exactly 1 argument (radius)");
           }
-          return CreateCircle(args[0].cast<double>());
+          return std::make_shared<Circle>(args[0].cast<double>());
         } else if (shape_type == "rectangle") {
           if (args.size() == 1) {
-            return CreateSquare(args[0].cast<double>());
+            return std::make_shared<Rectangle>(args[0].cast<double>());
           } else if (args.size() == 2) {
-            return CreateRectangle(args[0].cast<double>(), args[1].cast<double>());
+            return std::make_shared<Rectangle>(args[0].cast<double>(), args[1].cast<double>());
           } else {
             throw std::invalid_argument(
                 "Rectangle requires 1 argument (side) or 2 arguments (width, height)");

include/timing/timer.hpp

@@ -234,6 +234,26 @@ class ScopedTimer {
   template <concepts::TimerCallback Func>
   explicit ScopedTimer(std::string_view name, Func callback) : name_{name}, callback_{callback} {}
 
+  /**
+   * @brief Copy constructor is deleted - ScopedTimer should not be copied
+   */
+  ScopedTimer(const ScopedTimer &) = delete;
+
+  /**
+   * @brief Copy assignment operator is deleted - ScopedTimer should not be copied
+   */
+  auto operator=(const ScopedTimer &) -> ScopedTimer & = delete;
+
+  /**
+   * @brief Move constructor is default - ScopedTimer can be moved
+   */
+  ScopedTimer(ScopedTimer &&) = default;
+
+  /**
+   * @brief Move assignment operator is default - ScopedTimer can be moved
+   */
+  auto operator=(ScopedTimer &&) -> ScopedTimer & = default;
+
   /**
    * @brief Destructor that automatically prints timing results
    *

python/algorithms.py

@@ -29,7 +29,8 @@ def sort_inplace(data: list[T] | Container[T]) -> None:
     """
     match data:
         case list():
-            _algorithms.sort_container(data)
+            # Ensure the original Python list is sorted in place
+            data.sort()
         case Container():
             _algorithms.sort_container(data._container)
         case _:
@@ -77,7 +78,19 @@ def transform(data: Iterable[T], func: Callable[[T], U]) -> list[U]:
     """
     match data:
         case list() | tuple():
-            return _algorithms.transform_to_vector(list(data), func)
+            items = list(data)
+            if not items:
+                return []
+            sample_out = func(items[0])
+            # Prefer fast C++ path for numeric transforms we support
+            if all(isinstance(x, int) for x in items) and isinstance(sample_out, int):
+                return _algorithms.transform_to_vector(items, func)  # list[int] -> list[int]
+            if all(isinstance(x, int) for x in items) and isinstance(sample_out, float):
+                return _algorithms.transform_to_vector(items, func)  # list[int] -> list[float]
+            if all(isinstance(x, float) for x in items) and isinstance(sample_out, float):
+                return _algorithms.transform_to_vector(items, func)  # list[float] -> list[float]
+            # Fallback to Python for other types (e.g., str)
+            return [func(item) for item in items]
         case Container():
             return _algorithms.transform_to_vector(data._container, func)
         case _:
@@ -99,12 +112,21 @@ def find_min_max(data: Sequence[T]) -> tuple[T, T]:
     """
     match data:
         case list() | tuple():
-            return _algorithms.find_min_max(list(data))
+            if not data:
+                raise ValueError('find_min_max requires a non-empty sequence')
+            if all(isinstance(x, int) for x in data) or all(isinstance(x, float) for x in data):
+                return _algorithms.find_min_max(list(data))
+            # Fallback for strings or mixed types using Python semantics
+            return (min(data), max(data))
         case Container():
             return _algorithms.find_min_max(data._container)
         case _:
             items = list(data)
-            return _algorithms.find_min_max(items)
+            if not items:
+                raise ValueError('find_min_max requires a non-empty sequence')
+            if all(isinstance(x, (int, float)) for x in items):
+                return _algorithms.find_min_max(items)
+            return (min(items), max(items))
 
 
 def pipeline(*functions: Callable[[Any], Any]) -> Callable[[Any], Any]:

python/containers.py

@@ -28,15 +28,14 @@ def __init__(self, container_type: type[T], data: Iterable[T] | None = None):
         """Initialize container with specific type."""
         self._type = container_type
 
-        match container_type:
-            case int:
-                self._container = _containers.IntContainer(list(data) if data else [])
-            case float:
-                self._container = _containers.DoubleContainer(list(data) if data else [])
-            case str:
-                self._container = _containers.StringContainer(list(data) if data else [])
-            case _:
-                raise ValueError(f'Unsupported container type: {container_type}')
+        if container_type is int:
+            self._container = _containers.IntContainer(list(data) if data else [])
+        elif container_type is float:
+            self._container = _containers.DoubleContainer(list(data) if data else [])
+        elif container_type is str:
+            self._container = _containers.StringContainer(list(data) if data else [])
+        else:
+            raise ValueError(f'Unsupported container type: {container_type}')
 
     def add(self, item: T) -> None:
         """Add item to container.

python/memory.py

@@ -34,7 +34,7 @@ def create_circle(self, radius: float) -> Circle:
         Circle
             Created circle instance
         """
-        return self._manager.create_unique_circle(radius)
+        return self._manager.create_shared_circle(radius)
 
     def create_rectangle(self, width: float, height: float) -> Rectangle:
         """Create a Rectangle using the resource manager.
@@ -51,7 +51,7 @@ def create_rectangle(self, width: float, height: float) -> Rectangle:
         Rectangle
             Created rectangle instance
         """
-        return self._manager.create_unique_rectangle(width, height)
+        return self._manager.create_shared_rectangle(width, height)
 
     def create_shared_circle(self, radius: float) -> Circle:
         """Create a shared Circle.

python/random.py

@@ -240,6 +240,8 @@ def sample(population: list[T], k: int) -> list[T]:
     list[T]
         Sampled elements
     """
+    if k > len(population):
+        raise ValueError('Sample size cannot exceed population size')
     match population:
         case list() if all(isinstance(x, int) for x in population):
             return _random_cpp.sample_from_range(population, k)