only use std shared ptr (#201)

* update install instructions

* Update TODO for current roadmap

* Migrate to Cython 3 only

* Remove workflow file changes

* Drop Boost smart_ptr and use std::shared_ptr

* Remove legacy shared_ptr and include_boost API parameters

Now that autowrap uses std::shared_ptr exclusively:
- Remove shared_ptr parameter from CodeGenerator.__init__ and generate_code()
- Remove include_boost parameter from generate_code(), parse_and_generate_code(),
  and Main.create_wrapper_code()
- Simplify fixed_include_dirs() and get_include_dirs() to take no arguments
- Remove include_shared_ptr attribute from CodeGenerator

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Replace boost::shared_ptr with std::shared_ptr (#209)

* Initial plan

* Replace boost/shared_ptr.hpp with memory header in test files

Co-authored-by: timosachsenberg <5803621+timosachsenberg@users.noreply.github.com>

* Replace boost::shared_ptr with std::shared_ptr

Co-authored-by: timosachsenberg <5803621+timosachsenberg@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: timosachsenberg <5803621+timosachsenberg@users.noreply.github.com>

* fix include

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>

Author: 3 people

MIGRATION_PLAN.MD

@@ -0,0 +1,131 @@
+## Migration Plan: Cython 3+ Only
+
+This document outlines how to drop legacy Cython 0.x / “Cython 2-style”
+compatibility and make `autowrap` cleanly target Cython 3+.
+
+### 1. Tighten Cython Version Requirements
+
+- Update `pyproject.toml` to require Cython 3+ (for example
+  `Cython>=3.0` instead of `Cython>=0.19`).
+- Optionally add a runtime guard that checks
+  `Cython.Compiler.Version.version` and raises a clear error if it is
+  `< 3`.
+
+### 2. Simplify `PXDParser` for Cython 3 Only
+
+Key points:
+
+- `autowrap/PXDParser.py:406–418`:
+  conversion of `node.templates` from `[(string, bool)]` to `[string]`
+  is still used and matches current Cython 3 behavior, so it remains.
+- `autowrap/PXDParser.py:627–632`:
+  legacy `options.create_context()` (Cython 0.x) use has been removed in
+  favor of `Context.from_options(options)` (Cython 3).
+
+Planned/implemented changes:
+
+- Assume the Cython 3 AST / options API:
+  - Keep the `template_parameters` conversion as an internal
+    normalization step for template arguments.
+  - Unconditionally use `Context.from_options(options)` (or the
+    canonical Cython 3 way to construct a `Context`).
+- Keep or simplify `options.language_level`:
+  - Currently set to `sys.version_info.major`; optionally hard-code to
+    `3` if we want explicit Python 3 semantics everywhere.
+
+### 3. Simplify `run_cython` (CLI) to Cython 3 Only
+
+Current compatibility code in `autowrap/Main.py:176–188`:
+
+- Tries `from Cython.Compiler.Options import directive_defaults`,
+  falls back to `Cython.Compiler.Options.get_directive_defaults()` for
+  Cython 0.25.
+- Commented as “for backwards-compat to Cython 0.X”.
+
+Planned changes:
+
+- Assume Cython 3+:
+  - Drop the `try/except ImportError` and always import
+    `directive_defaults` from `Cython.Compiler.Options`.
+  - Remove the fallback call to `get_directive_defaults()`.
+- Revisit directives (behavior, not compatibility):
+  - Decide whether `binding=False` should be kept or whether Cython 3
+    defaults are sufficient.
+  - Keep `boundscheck=False`, `wraparound=False`, and the chosen
+    `language_level` setting.
+
+### 4. Clean Up Tests Assuming Cython < 3
+
+Current version-specific logic:
+
+- `tests/test_code_generator.py:test_enums`:
+  - Imports `cython_version` from `Cython.Compiler.Version`.
+  - Returns early if `int(cython_version[0]) < 3`.
+
+Planned changes:
+
+- Remove the version check and the `cython_version` import so that
+  `test_enums` always runs (since Cython 3+ is now the minimum).
+- If any other tests gate behavior on “Cython < 3”, remove those
+  branches as well.
+
+### 5. Address `language_level=2` Test Files
+
+Many test `.pxd` / `.pyx` files currently include:
+
+- `# cython: language_level=2` (e.g. `tests/test_files/minimal.pxd`,
+  `A.pxd`, `B.pxd`, `C.pxd`, `D.pxd`, `Cycle0/1/2.pxd`,
+  `libcpp_test.pxd`, `templated.pxd`, `base*.pxd`,
+  `int_container_class.pxd`, `gil_testing.pxd`, etc.).
+- Some `.pyx` files rely on Python 2 syntax (e.g.
+  `print "dealloc called"` in `tests/test_files/itertest.pyx`).
+
+Options:
+
+- **Option A (fully modernize)**:
+  - Remove `language_level=2` pragmas and rely on the global
+    `language_level` from `directive_defaults` (Python 3 semantics).
+  - Update any Python 2-only syntax in test files to Python 3 syntax
+    (e.g. use `print("…")`).
+  - Confirm that the C AST expected by `PXDParser` is unchanged for
+    these declarations.
+- **Option B (keep as historical fixtures)**:
+  - Leave `language_level=2` pragmas if they still compile under
+    Cython 3 and if Python 2 semantics in tests are acceptable.
+  - This keeps autowrap itself Cython 3-only while tolerating older
+    directives in test fixtures.
+
+If the goal is “fully Cython 3 / Python 3 semantics everywhere”,
+Option A should be implemented.
+
+### 6. Refresh Docs and Examples for Cython 3
+
+Not strictly required for compatibility, but desirable for clarity:
+
+- `example/setup.py` and `tests/test_full_library.py` use
+  `from Cython.Distutils import build_ext`; this still works under
+  Cython 3, but more modern examples might use `cythonize`.
+- `docs/README.md` and `README.md` may include Python 2-style code
+  snippets or wording that implicitly references “Cython 0.X”.
+
+Planned changes:
+
+- Update documentation to state that autowrap targets Cython 3+.
+- Modernize any Python 2-style examples (e.g. `print` statements) to
+  Python 3 syntax where appropriate.
+- Optionally update example build instructions to show idiomatic
+  Cython 3 usage.
+
+### 7. Verification After Changes
+
+After applying the above steps:
+
+- Run the full test suite under Cython 3.x:
+  - `pytest -v` from the project root.
+  - Ensure all tests run (no early returns based on Cython version).
+- Optionally add a small test or import-time assertion that:
+  - Checks `int(Cython.Compiler.Version.version[0]) >= 3`, and
+  - Fails fast if someone accidentally runs under an older Cython.
+
+This will ensure that autowrap’s parser, code generator, and CLI are
+all consistently using Cython 3 APIs and Python 3 semantics.

_codeql_detected_source_root

@@ -0,0 +1 @@
+.

autowrap/CodeGenerator.py

@@ -93,18 +93,14 @@ def augment_arg_names(method):
     ]
 
 
-def fixed_include_dirs(include_boost: bool) -> List[AnyStr]:
+def fixed_include_dirs() -> List[AnyStr]:
     from importlib.resources import files
 
     autowrap_files = files("autowrap")
-    boost = str(autowrap_files.joinpath("data_files/boost"))
     data = str(autowrap_files.joinpath("data_files"))
     autowrap_internal = str(autowrap_files.joinpath("data_files/autowrap"))
 
-    if not include_boost:
-        return [autowrap_internal]
-    else:
-        return [boost, data, autowrap_internal]
+    return [data, autowrap_internal]
 
 
 class CodeGenerator(object):
@@ -121,7 +117,6 @@ class CodeGenerator(object):
     pxd_dir: Optional[AnyStr]
     manual_code: Dict[str, Code]
     extra_cimports: Collection[str]
-    include_shared_ptr: str
     include_refholder: bool
     include_numpy: bool
     add_relative: bool
@@ -164,7 +159,6 @@ def __init__(
         extra_cimports=None,
         all_decl=None,
         add_relative=False,
-        shared_ptr="boost",
     ):
         self.pxd_dir = None
         if all_decl is None:
@@ -174,7 +168,6 @@ def __init__(
 
         self.manual_code: Dict[str, Code] = manual_code
         self.extra_cimports: Collection[str] = extra_cimports
-        self.include_shared_ptr: str = shared_ptr
         self.include_refholder: bool = True
         self.include_numpy: bool = False
         self.add_relative: bool = add_relative
@@ -251,11 +244,11 @@ def __init__(
         self.wrapped_classes_cnt: int = 0
         self.wrapped_methods_cnt: int = 0
 
-    def get_include_dirs(self, include_boost: bool) -> List[AnyStr]:
+    def get_include_dirs(self) -> List[AnyStr]:
         if self.pxd_dir is not None:
-            return fixed_include_dirs(include_boost) + [self.pxd_dir]
+            return fixed_include_dirs() + [self.pxd_dir]
         else:
-            return fixed_include_dirs(include_boost)
+            return fixed_include_dirs()
 
     def setup_cimport_paths(self) -> None:
         """
@@ -2039,18 +2032,11 @@ def create_default_cimports(self):
                    |from  AutowrapConstPtrHolder cimport AutowrapConstPtrHolder
                    """
             )
-        if self.include_shared_ptr == "boost":
-            code.add(
-                """
-                   |from  smart_ptr       cimport shared_ptr
-                   """
-            )
-        elif self.include_shared_ptr == "std":
-            code.add(
-                """
+        code.add(
+            """
                    |from  libcpp.memory   cimport shared_ptr
                    """
-            )
+        )
         if self.include_numpy:
             code.add(
                 """

autowrap/Main.py

@@ -199,7 +199,6 @@ def create_wrapper_code(
     out,
     extra_inc_dirs,
     extra_opts,
-    include_boost=True,
     allDecl=[],
 ):
     cimports, manual_code = collect_manual_code(addons)
@@ -211,7 +210,6 @@ def create_wrapper_code(
         debug=False,
         manual_code=manual_code,
         extra_cimports=cimports,
-        include_boost=include_boost,
         all_decl=allDecl,
     )
 

autowrap/__init__.py

@@ -78,11 +78,9 @@ def generate_code(
     debug=False,
     manual_code=None,
     extra_cimports=None,
-    include_boost=True,
     include_numpy=False,
     all_decl=[],
     add_relative=False,
-    shared_ptr="boost",
 ):
     import autowrap.CodeGenerator
 
@@ -94,11 +92,10 @@ def generate_code(
         extra_cimports=extra_cimports,
         all_decl=all_decl,
         add_relative=add_relative,
-        shared_ptr=shared_ptr,
     )
     gen.include_numpy = include_numpy
     gen.create_pyx_file(debug)
-    includes = gen.get_include_dirs(include_boost)
+    includes = gen.get_include_dirs()
     print(
         "Autowrap has wrapped %s classes, %s methods and %s enums"
         % (gen.wrapped_classes_cnt, gen.wrapped_methods_cnt, gen.wrapped_enums_cnt)
@@ -113,11 +110,10 @@ def parse_and_generate_code(
     debug,
     manual_code=None,
     extra_cimports=None,
-    include_boost=True,
 ):
     print("Autowrap will start to parse and generate code. " "Will parse %s files" % len(files))
     decls, instance_map = parse(files, root)
     print("Done parsing the files, will generate the code...")
     return generate_code(
-        decls, instance_map, target, debug, manual_code, extra_cimports, include_boost
+        decls, instance_map, target, debug, manual_code, extra_cimports
     )