IncludeCPP 2.4.2__tar.gz → 2.4.3__tar.gz

{includecpp-2.4.2 → includecpp-2.4.3}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 2.4.2
+Version: 2.4.3
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/includecpp/includecpp
 Author: IncludeCPP Team

{includecpp-2.4.2 → includecpp-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 2.4.2
+Version: 2.4.3
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/includecpp/includecpp
 Author: IncludeCPP Team

{includecpp-2.4.2 → includecpp-2.4.3}/includecpp/__init__.py

@@ -1,4 +1,4 @@
 from .core.cpp_api import CppApi
 
-__version__ = "2.4.2"
+__version__ = "2.4.3"
 __all__ = ["CppApi"]

{includecpp-2.4.2 → includecpp-2.4.3}/includecpp/cli/commands.py

@@ -1393,10 +1393,58 @@ def plugin(plugin_name, files, private):
             return class_body[public_start:public_start + next_access.start()]
         return class_body[public_start:]
 
+    def extract_param_types(params_str):
+        """Extract parameter types from a parameter string like 'double x, double y'."""
+        if not params_str or params_str.strip() == '':
+            return []
+
+        types = []
+        # Split by comma, but be careful with template types like std::vector<int, alloc>
+        depth = 0
+        current = ''
+        for char in params_str:
+            if char in '<(':
+                depth += 1
+                current += char
+            elif char in '>)':
+                depth -= 1
+                current += char
+            elif char == ',' and depth == 0:
+                types.append(current.strip())
+                current = ''
+            else:
+                current += char
+        if current.strip():
+            types.append(current.strip())
+
+        # Extract just the type from each parameter (remove variable name)
+        result = []
+        for param in types:
+            param = param.strip()
+            if not param:
+                continue
+            # Remove default value if present
+            if '=' in param:
+                param = param.split('=')[0].strip()
+            # Find the type: everything before the last word (variable name)
+            # Handle cases like "const std::string& name" -> "const std::string&"
+            parts = param.rsplit(None, 1)
+            if len(parts) == 1:
+                # Just a type, no name (e.g., in declaration "void foo(int)")
+                result.append(parts[0])
+            else:
+                # Check if last part is a pointer/reference suffix attached to type
+                type_part = parts[0]
+                # Handle cases where * or & is attached to variable name
+                if parts[1].startswith('*') or parts[1].startswith('&'):
+                    type_part = parts[0] + parts[1][0]
+                result.append(type_part)
+        return result
+
     def extract_methods(public_section, class_name):
         """Extract method names from public section, handling inline bodies."""
         methods = set()
-        constructors = 0
+        constructor_signatures = []  # v2.4.3: List of (param_types) tuples
 
         # Method pattern that handles return types, const, and inline bodies
         # Match: [modifiers] return_type method_name(params) [const] [{ body } | ;]
@@ -1418,8 +1466,7 @@ def plugin(plugin_name, files, private):
 
             # Skip if method name is the class name (it's a constructor)
             if method_name == class_name:
-                constructors += 1
-                continue
+                continue  # Will be handled by dedicated constructor pattern
 
             # Skip destructors
             if method_name.startswith('~'):
@@ -1431,12 +1478,17 @@ def plugin(plugin_name, files, private):
 
             methods.add(method_name)
 
-        # Also look for explicit constructors
-        constructor_pattern = rf'\b{re.escape(class_name)}\s*\([^)]*\)'
-        constructor_matches = re.findall(constructor_pattern, public_section)
-        constructors = max(constructors, len(constructor_matches))
+        # v2.4.3: Extract constructor signatures with parameter types
+        constructor_pattern = re.compile(
+            rf'(?:explicit\s+)?{re.escape(class_name)}\s*\(([^)]*)\)',
+            re.MULTILINE
+        )
+        for match in constructor_pattern.finditer(public_section):
+            params_str = match.group(1).strip()
+            param_types = extract_param_types(params_str)
+            constructor_signatures.append(tuple(param_types))
 
-        return methods, constructors
+        return methods, constructor_signatures
 
     all_files = cpp_files + h_files
 
@@ -1470,12 +1522,17 @@ def plugin(plugin_name, files, private):
             public_section = extract_public_section(class_body, is_struct)
 
             if class_name not in classes:
-                classes[class_name] = {'methods': set(), 'constructors': 0}
+                classes[class_name] = {'methods': set(), 'constructors': []}
 
             # Extract methods from public section
-            methods, constructors = extract_methods(public_section, class_name)
+            methods, constructor_sigs = extract_methods(public_section, class_name)
             classes[class_name]['methods'].update(methods)
-            classes[class_name]['constructors'] = max(classes[class_name]['constructors'], constructors)
+            # v2.4.3: Merge constructor signatures (avoid duplicates)
+            existing_ctors = set(classes[class_name]['constructors'])
+            for sig in constructor_sigs:
+                if sig not in existing_ctors:
+                    classes[class_name]['constructors'].append(sig)
+                    existing_ctors.add(sig)
 
         # Find free functions (not inside class bodies)
         # First, remove all class bodies from content to avoid matching class methods
@@ -1524,7 +1581,18 @@ def plugin(plugin_name, files, private):
                 cls_info = classes[cls_name]
                 f.write(f'    {plugin_name} CLASS({cls_name}) {{\n')
 
-                if cls_info['constructors'] > 0:
+                # v2.4.3: Write all constructor overloads with parameter types
+                if cls_info['constructors']:
+                    for ctor_params in cls_info['constructors']:
+                        if ctor_params:
+                            # Parametrized constructor
+                            params_str = ', '.join(ctor_params)
+                            f.write(f'        CONSTRUCTOR({params_str})\n')
+                        else:
+                            # Default constructor
+                            f.write(f'        CONSTRUCTOR()\n')
+                else:
+                    # No constructors found, add default
                     f.write(f'        CONSTRUCTOR()\n')
 
                 for method in sorted(cls_info['methods']):

{includecpp-2.4.2 → includecpp-2.4.3}/includecpp/core/build_manager.py

@@ -579,10 +579,46 @@ endif()
                     else:
                         f.write(f'        """C++ class: {class_name_inner}"""\n\n')
 
-                    # Constructor
-                    f.write('        def __init__(self, *args: Any, **kwargs: Any) -> None:\n')
-                    f.write(f'            """Initialize {class_name_inner} instance"""\n')
-                    f.write('            ...\n\n')
+                    # v2.4.3: Constructor overloads with parameter types
+                    constructors = cls.get('constructors', [])
+                    if constructors and len(constructors) > 1:
+                        # Multiple constructors - use @overload
+                        for ctor in constructors:
+                            param_types = ctor.get('params', [])
+                            f.write('        @overload\n')
+                            if param_types:
+                                param_list = ['self']
+                                for i, ptype in enumerate(param_types):
+                                    py_type = self._cpp_to_python_type(ptype)
+                                    param_list.append(f'arg{i}: {py_type}')
+                                params_str = ', '.join(param_list)
+                                f.write(f'        def __init__({params_str}) -> None: ...\n')
+                            else:
+                                f.write(f'        def __init__(self) -> None: ...\n')
+                        f.write('\n')
+                        # Actual implementation signature
+                        f.write('        def __init__(self, *args: Any, **kwargs: Any) -> None:\n')
+                        f.write(f'            """Initialize {class_name_inner} instance"""\n')
+                        f.write('            ...\n\n')
+                    elif constructors and len(constructors) == 1:
+                        # Single constructor
+                        param_types = constructors[0].get('params', [])
+                        if param_types:
+                            param_list = ['self']
+                            for i, ptype in enumerate(param_types):
+                                py_type = self._cpp_to_python_type(ptype)
+                                param_list.append(f'arg{i}: {py_type}')
+                            params_str = ', '.join(param_list)
+                            f.write(f'        def __init__({params_str}) -> None:\n')
+                        else:
+                            f.write(f'        def __init__(self) -> None:\n')
+                        f.write(f'            """Initialize {class_name_inner} instance"""\n')
+                        f.write('            ...\n\n')
+                    else:
+                        # Fallback - generic constructor
+                        f.write('        def __init__(self, *args: Any, **kwargs: Any) -> None:\n')
+                        f.write(f'            """Initialize {class_name_inner} instance"""\n')
+                        f.write('            ...\n\n')
 
                     # Generate methods
                     methods = cls.get('methods', [])
@@ -645,6 +681,52 @@ endif()
 
                 f.write('\n\n')
 
+            # v2.4.3: Generate CppApi class with overloaded include() methods
+            # This is the KEY to making VSCode autocomplete work for module.Class
+            f.write('# CppApi with typed include() overloads for each module\n')
+            f.write('class CppApi:\n')
+            f.write('    """C++ API Manager with typed module loading.\n\n')
+            f.write('    The include() method returns a module wrapper with full type hints\n')
+            f.write('    for VSCode/PyCharm autocomplete support.\n')
+            f.write('    """\n\n')
+
+            f.write('    def __init__(self, project_root: Optional[str] = None, auto_update: bool = True) -> None:\n')
+            f.write('        """Initialize CppApi.\n\n')
+            f.write('        Args:\n')
+            f.write('            project_root: Path to project root (default: auto-detect)\n')
+            f.write('            auto_update: Whether to auto-rebuild on source changes\n')
+            f.write('        """\n')
+            f.write('        ...\n\n')
+
+            # Generate overloaded include() methods for each module
+            for module_name, _ in modules.items():
+                wrapper_class = f"{module_name.capitalize()}ModuleWrapper"
+                f.write('    @overload\n')
+                f.write(f'    def include(self, module_name: str = "{module_name}", auto_update: Optional[bool] = None) -> {wrapper_class}: ...\n\n')
+
+            # Fallback overload for unknown modules
+            f.write('    @overload\n')
+            f.write('    def include(self, module_name: str, auto_update: Optional[bool] = None) -> Any: ...\n\n')
+
+            # Actual implementation signature
+            f.write('    def include(self, module_name: str, auto_update: Optional[bool] = None) -> Any:\n')
+            f.write('        """Load a C++ module.\n\n')
+            f.write('        Args:\n')
+            f.write('            module_name: Name of the module to load\n')
+            f.write('            auto_update: Override auto-update setting for this module\n\n')
+            f.write('        Returns:\n')
+            f.write('            ModuleWrapper with access to C++ classes, functions, and structs\n')
+            f.write('        """\n')
+            f.write('        ...\n\n')
+
+            f.write('    def rebuild(self, verbose: bool = False) -> bool:\n')
+            f.write('        """Rebuild all C++ modules."""\n')
+            f.write('        ...\n\n')
+
+            f.write('    def list_modules(self) -> List[str]:\n')
+            f.write('        """List available modules."""\n')
+            f.write('        ...\n')
+
         if verbose:
             print(f"Generated VSCode IntelliSense stubs: {pyi_file}")
 
@@ -728,25 +810,61 @@ endif()
                 else:
                     f.write(f'    """C++ class: {class_name}"""\n\n')
 
-                # Constructor with parameters if available
-                constructor_params = cls.get('constructor_params', [])
-                if constructor_params:
-                    param_list = ['self']
-                    for param in constructor_params:
-                        param_name = param.get('name', 'arg')
-                        param_type = self._cpp_to_python_type(param.get('type', 'Any'))
-                        param_default = param.get('default', None)
-                        if param_default:
-                            py_default = self._convert_cpp_default(param_default, param_type)
-                            param_list.append(f'{param_name}: {param_type} = {py_default}')
+                # v2.4.3: Constructor overloads with parameter types
+                constructors = cls.get('constructors', [])
+                if constructors and len(constructors) > 1:
+                    # Multiple constructors - use @overload
+                    for ctor in constructors:
+                        param_types = ctor.get('params', [])
+                        f.write('    @overload\n')
+                        if param_types:
+                            param_list = ['self']
+                            for i, ptype in enumerate(param_types):
+                                py_type = self._cpp_to_python_type(ptype)
+                                param_list.append(f'arg{i}: {py_type}')
+                            params_str = ', '.join(param_list)
+                            f.write(f'    def __init__({params_str}) -> None: ...\n')
                         else:
-                            param_list.append(f'{param_name}: {param_type}')
-                    params_str = ', '.join(param_list)
-                    f.write(f'    def __init__({params_str}) -> None:\n')
-                else:
+                            f.write(f'    def __init__(self) -> None: ...\n')
+                    f.write('\n')
+                    # Actual implementation signature
                     f.write(f'    def __init__(self, *args: Any, **kwargs: Any) -> None:\n')
-                f.write(f'        """Initialize {class_name} instance."""\n')
-                f.write('        ...\n\n')
+                    f.write(f'        """Initialize {class_name} instance."""\n')
+                    f.write('        ...\n\n')
+                elif constructors and len(constructors) == 1:
+                    # Single constructor
+                    param_types = constructors[0].get('params', [])
+                    if param_types:
+                        param_list = ['self']
+                        for i, ptype in enumerate(param_types):
+                            py_type = self._cpp_to_python_type(ptype)
+                            param_list.append(f'arg{i}: {py_type}')
+                        params_str = ', '.join(param_list)
+                        f.write(f'    def __init__({params_str}) -> None:\n')
+                    else:
+                        f.write(f'    def __init__(self) -> None:\n')
+                    f.write(f'        """Initialize {class_name} instance."""\n')
+                    f.write('        ...\n\n')
+                else:
+                    # Fallback: legacy format or no constructor info
+                    constructor_params = cls.get('constructor_params', [])
+                    if constructor_params:
+                        param_list = ['self']
+                        for param in constructor_params:
+                            param_name = param.get('name', 'arg')
+                            param_type = self._cpp_to_python_type(param.get('type', 'Any'))
+                            param_default = param.get('default', None)
+                            if param_default:
+                                py_default = self._convert_cpp_default(param_default, param_type)
+                                param_list.append(f'{param_name}: {param_type} = {py_default}')
+                            else:
+                                param_list.append(f'{param_name}: {param_type}')
+                        params_str = ', '.join(param_list)
+                        f.write(f'    def __init__({params_str}) -> None:\n')
+                    else:
+                        f.write(f'    def __init__(self, *args: Any, **kwargs: Any) -> None:\n')
+                    f.write(f'        """Initialize {class_name} instance."""\n')
+                    f.write('        ...\n\n')
 
                 # Methods
                 methods = cls.get('methods', [])

{includecpp-2.4.2 → includecpp-2.4.3}/includecpp/generator/parser.cpp

@@ -395,7 +395,26 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                             std::string mtrim = trim(mline);
                             if (mtrim.empty()) continue;
 
-                            if (mtrim.find("METHOD") != std::string::npos) {
+                            // v2.4.3: Parse CONSTRUCTOR(type1, type2, ...) for parametrized constructors
+                            if (mtrim.find("CONSTRUCTOR") != std::string::npos) {
+                                size_t c_start = mtrim.find('(');
+                                size_t c_end = mtrim.rfind(')');
+                                if (c_start != std::string::npos && c_end != std::string::npos) {
+                                    std::string params_str = mtrim.substr(c_start + 1, c_end - c_start - 1);
+                                    ConstructorInfo ctor;
+                                    if (!params_str.empty()) {
+                                        auto params = split(params_str, ',');
+                                        for (auto& p : params) {
+                                            std::string param_type = trim(p);
+                                            if (!param_type.empty()) {
+                                                ctor.param_types.push_back(param_type);
+                                            }
+                                        }
+                                    }
+                                    cb.constructors.push_back(ctor);
+                                }
+                            }
+                            else if (mtrim.find("METHOD") != std::string::npos) {
                                 size_t m_start = mtrim.find('(');
                                 size_t m_end = mtrim.find(')');
                                 if (m_start != std::string::npos && m_end != std::string::npos) {
@@ -594,7 +613,25 @@ std::string API::generate_class_bindings(const ClassBinding& cls, const ModuleDe
 
     code << "    py::class_<" << cls.class_name << ">("
          << mod.module_name << "_module, \"" << cls.class_name << "\")\n";
-    code << "        .def(py::init<>())";
+
+    // v2.4.3: Generate all constructor overloads from CONSTRUCTOR() entries
+    if (cls.constructors.empty()) {
+        // Backward compatibility: default constructor if none specified
+        code << "        .def(py::init<>())";
+    } else {
+        bool first = true;
+        for (const auto& ctor : cls.constructors) {
+            if (!first) code << "\n";
+            first = false;
+
+            code << "        .def(py::init<";
+            for (size_t i = 0; i < ctor.param_types.size(); ++i) {
+                if (i > 0) code << ", ";
+                code << ctor.param_types[i];
+            }
+            code << ">())";
+        }
+    }
 
     // Bind Initialize static method (factory method)
     code << "\n        .def_static(\"Initialize\", []() { return " << cls.class_name << "(); })";
@@ -1141,7 +1178,7 @@ std::string API::generate_registry_json(const std::vector<ModuleDescriptor>& mod
         }
         json << "      ],\n";
 
-        // Add classes with methods and documentation
+        // Add classes with methods, constructors, and documentation
         json << "      \"classes\": [\n";
         for (size_t j = 0; j < mod.classes.size(); ++j) {
             const auto& cls = mod.classes[j];
@@ -1150,6 +1187,27 @@ std::string API::generate_registry_json(const std::vector<ModuleDescriptor>& mod
             if (!cls.documentation.empty()) {
                 json << ",\n          \"doc\": \"" << replace_all(cls.documentation, "\"", "\\\"") << "\"";
             }
+
+            // v2.4.3: Add constructor signatures
+            json << ",\n          \"constructors\": [\n";
+            if (cls.constructors.empty()) {
+                // Default constructor
+                json << "            {\"params\": []}\n";
+            } else {
+                for (size_t k = 0; k < cls.constructors.size(); ++k) {
+                    const auto& ctor = cls.constructors[k];
+                    json << "            {\"params\": [";
+                    for (size_t p = 0; p < ctor.param_types.size(); ++p) {
+                        json << "\"" << ctor.param_types[p] << "\"";
+                        if (p < ctor.param_types.size() - 1) json << ", ";
+                    }
+                    json << "]}";
+                    if (k < cls.constructors.size() - 1) json << ",";
+                    json << "\n";
+                }
+            }
+            json << "          ]";
+
             json << ",\n          \"methods\": [\n";
             for (size_t k = 0; k < cls.methods.size(); ++k) {
                 const auto& method = cls.methods[k];

{includecpp-2.4.2 → includecpp-2.4.3}/includecpp/generator/parser.h

@@ -93,12 +93,18 @@ struct FieldInfo {
     std::string documentation;
 };
 
+// v2.4.3: Constructor parameter types
+struct ConstructorInfo {
+    std::vector<std::string> param_types;  // e.g., ["double", "double"] for Vector2D(double, double)
+};
+
 struct ClassBinding {
     std::string module_name;
     std::string class_name;
     std::vector<std::pair<std::string, std::string>> params;
     std::vector<std::string> methods;    // Method names to bind
     std::vector<std::string> fields;     // Field names to bind
+    std::vector<ConstructorInfo> constructors;  // v2.4.3: Constructor overloads
     bool auto_bind_all;                  // Bind all methods automatically
     std::string documentation;           // Class documentation from DOC()
     std::map<std::string, std::string> method_docs;  // Method-specific docs: method_name -> doc

{includecpp-2.4.2 → includecpp-2.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "2.4.2"
+version = "2.4.3"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.8"

{includecpp-2.4.2 → includecpp-2.4.3}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name="IncludeCPP",
-    version="2.4.2",
+    version="2.4.3",
     author="IncludeCPP Team",
     author_email="contact@includecpp.dev",
     description="Professional C++ Python bindings with type-generic templates and native threading",