IncludeCPP 4.6.2__tar.gz → 4.6.6__tar.gz

{includecpp-4.6.2 → includecpp-4.6.6}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.6.2
+Version: 4.6.6
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.6.2 → includecpp-4.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.6.2
+Version: 4.6.6
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.6.2 → includecpp-4.6.6}/includecpp/CHANGELOG.md

@@ -1,5 +1,24 @@
 # IncludeCPP Changelog
 
+## v4.6.6 (2026-01-14)
+
+### New Features
+- **ENUM support**: Expose C++ enums to Python via `ENUM(EnumName) CLASS { values... }` syntax
+- **Multiple SOURCE support**: `SOURCE(file1) && SOURCE(file2)` in .cp files
+- **FIELD_ARRAY support**: C-style arrays now properly bound as read-only `bytes` properties
+- Automatic detection of array fields in plugin command
+
+### Bug Fixes
+- Fixed signed/unsigned comparison warning from pybind11 enum bindings
+- Removed SIGNED_UNSIGNED from error catalog (was a warning, not error)
+- Fixed array fields causing `invalid array assignment` error
+- Version display now shows X.X format in build output
+
+### Breaking Changes
+- Array fields in structs are now read-only (accessible as `bytes`)
+
+---
+
 ## v4.3.2 (2026-01-08)
 
 ### New Features

{includecpp-4.6.2 → includecpp-4.6.6}/includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "4.6.2"
+__version__ = "4.6.6"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-4.6.2 → includecpp-4.6.6}/includecpp/__init__.pyi

@@ -147,7 +147,7 @@ __version__: str
 # Dynamic module access via: from includecpp import <module_name>
 # Auto-generated module declarations
 # These allow: from includecpp import <module_name>
-cssl_core: Cssl_coreModuleWrapper
+stepcompiler: StepcompilerModuleWrapper
 
 def __dir__() -> List[str]:
     """List available modules including dynamically loaded C++ modules."""

{includecpp-4.6.2 → includecpp-4.6.6}/includecpp/cli/commands.py

@@ -868,6 +868,11 @@ def _check_for_updates_silent():
 def _parse_cp_sources(cp_path):
     """Parse SOURCE() and HEADER() paths from an existing .cp file.
 
+    Supports multiple formats:
+        - Single SOURCE with multiple files: SOURCE(file1.cpp file2.cpp)
+        - Multiple SOURCE declarations: SOURCE(file1.cpp) && SOURCE(file2.cpp)
+        - Same for HEADER()
+
     Returns:
         Tuple of (source_files, header_files) as lists of Path objects
     """
@@ -881,11 +886,10 @@ def _parse_cp_sources(cp_path):
         content = cp_path.read_text()
         project_root = cp_path.parent.parent  # plugins/ -> project root
 
-        # Find SOURCE(...) declarations
-        source_match = re.search(r'SOURCE\s*\(\s*([^)]+)\s*\)', content)
-        if source_match:
-            sources_str = source_match.group(1)
-            # Handle multiple files: SOURCE(file1.cpp file2.cpp) or SOURCE(file1.cpp, file2.cpp)
+        # Find ALL SOURCE(...) declarations (supports multiple SOURCE() && SOURCE())
+        source_matches = re.findall(r'SOURCE\s*\(\s*([^)]+)\s*\)', content)
+        for sources_str in source_matches:
+            # Handle multiple files within one SOURCE(): SOURCE(file1.cpp file2.cpp) or SOURCE(file1.cpp, file2.cpp)
             sources = re.split(r'[,\s]+', sources_str.strip())
             for src in sources:
                 src = src.strip()
@@ -896,10 +900,9 @@ def _parse_cp_sources(cp_path):
                     if p.exists():
                         source_files.append(p)
 
-        # Find HEADER(...) declarations
-        header_match = re.search(r'HEADER\s*\(\s*([^)]+)\s*\)', content)
-        if header_match:
-            headers_str = header_match.group(1)
+        # Find ALL HEADER(...) declarations
+        header_matches = re.findall(r'HEADER\s*\(\s*([^)]+)\s*\)', content)
+        for headers_str in header_matches:
             headers = re.split(r'[,\s]+', headers_str.strip())
             for hdr in headers:
                 hdr = hdr.strip()
@@ -943,10 +946,16 @@ def rebuild(clean, keep, verbose, no_incremental, incremental, parallel, jobs, m
     """Rebuild C++ modules with automatic generator updates."""
     from ..core.build_manager import BuildManager
     from ..core.error_formatter import BuildErrorFormatter, BuildSuccessFormatter
+    from .. import __version__
     import time
     import json
     from datetime import datetime
 
+    # Show version (X.X format)
+    short_version = '.'.join(__version__.split('.')[:2])
+    click.secho(f"[IncludeCPP v{short_version}] ", fg='cyan', nl=False)
+    click.echo("Build starting...")
+
     # Combine -m modules with positional arguments
     # Allows both: includecpp rebuild -m gamekit AND includecpp rebuild gamekit
     all_modules = list(modules) + list(module_args)
@@ -2488,6 +2497,7 @@ def plugin(plugin_name, files, private):
     classes = {}
     functions = set()
     template_functions = {}  # v3.1.6: {name: set of types}
+    enums = {}  # v4.6.5: {name: {'is_class': bool, 'values': list}}
     namespaces = set()
 
     def find_matching_brace(text, start_pos):
@@ -2898,15 +2908,27 @@ def plugin(plugin_name, files, private):
                         if '&' not in actual_type:
                             actual_type += '&'
 
-                    # Remove array brackets if present
+                    # v4.6.6: Detect array fields and capture size
+                    array_size = 0
                     if '[' in name:
-                        name = name[:name.find('[')]
+                        # Extract array size: "magic[4]" -> size=4, name="magic"
+                        bracket_idx = name.find('[')
+                        end_bracket = name.find(']')
+                        if end_bracket > bracket_idx:
+                            size_str = name[bracket_idx+1:end_bracket].strip()
+                            try:
+                                array_size = int(size_str) if size_str else 0
+                            except ValueError:
+                                array_size = 0  # Unknown/variable size
+                        name = name[:bracket_idx].strip()
 
                     # Validate field name
                     if name and re.match(r'^[a-zA-Z_]\w*$', name):
                         # Skip if name is a keyword
                         if name.lower() not in cpp_keywords:
-                            fields.append((actual_type, name))
+                            # v4.6.6: Include array info (type, name, array_size)
+                            # array_size=0 means not an array
+                            fields.append((actual_type, name, array_size))
 
         return fields
 
@@ -2946,6 +2968,11 @@ def plugin(plugin_name, files, private):
             is_struct = keyword == 'struct'
             brace_start = match.end() - 1
 
+            # v4.6.5: Skip "enum class" declarations - check if preceded by "enum"
+            text_before_match = content[max(0, match.start()-10):match.start()]
+            if re.search(r'\benum\s*$', text_before_match):
+                continue
+
             text_before = content[:match.start()]
             open_braces = text_before.count('{')
             close_braces = text_before.count('}')
@@ -3071,23 +3098,67 @@ def plugin(plugin_name, files, private):
                 if func_name not in template_func_names:
                     functions.add(func_name)
 
+        # v4.6.5: Find enum declarations
+        enum_pattern = re.compile(
+            r'\benum\s+(class\s+)?(\w+)\s*\{([^}]*)\}',
+            re.MULTILINE | re.DOTALL
+        )
+
+        for match in enum_pattern.finditer(content):
+            is_class_enum = bool(match.group(1))
+            enum_name = match.group(2)
+            enum_body = match.group(3)
+
+            # Parse enum values
+            values = []
+            # Split by comma and extract value names (ignoring assignments)
+            for part in enum_body.split(','):
+                part = part.strip()
+                if not part:
+                    continue
+                # Get the value name (before any = assignment)
+                value_name = part.split('=')[0].strip()
+                if value_name and re.match(r'^[a-zA-Z_]\w*$', value_name):
+                    values.append(value_name)
+
+            if enum_name not in enums and values:
+                enums[enum_name] = {
+                    'is_class': is_class_enum,
+                    'values': values
+                }
+
     private_set = set(private) if private else set()
     public_functions = functions - private_set - set(classes.keys())
 
     cp_file = plugins_dir / f"{plugin_name}.cp"
 
-    cpp_sources = ' '.join(str(f.relative_to(project_root) if f.is_relative_to(project_root) else f).replace('\\', '/') for f in cpp_files)
-    h_headers = ' '.join(str(f.relative_to(project_root) if f.is_relative_to(project_root) else f).replace('\\', '/') for f in h_files) if h_files else None
+    # Generate individual SOURCE() declarations for each file (cleaner format)
+    cpp_paths = [str(f.relative_to(project_root) if f.is_relative_to(project_root) else f).replace('\\', '/') for f in cpp_files]
+    h_paths = [str(f.relative_to(project_root) if f.is_relative_to(project_root) else f).replace('\\', '/') for f in h_files] if h_files else []
 
     with open(cp_file, 'w', encoding='utf-8') as f:
-        if h_headers:
-            f.write(f'SOURCE({cpp_sources}) && HEADER({h_headers}) {plugin_name}\n\n')
-        else:
-            f.write(f'SOURCE({cpp_sources}) {plugin_name}\n\n')
+        # Build the declaration line: SOURCE(file1) && SOURCE(file2) && HEADER(h1) plugin_name
+        parts = [f'SOURCE({p})' for p in cpp_paths]
+        parts.extend([f'HEADER({p})' for p in h_paths])
+        declaration = ' && '.join(parts) + f' {plugin_name}'
+        f.write(declaration + '\n\n')
 
-        if classes or public_functions or template_functions:
+        if classes or public_functions or template_functions or enums:
             f.write('PUBLIC(\n')
 
+            # v4.6.5: Write enum bindings
+            for enum_name in sorted(enums.keys()):
+                enum_info = enums[enum_name]
+                is_class = enum_info.get('is_class', False)
+                values = enum_info.get('values', [])
+
+                class_kw = ' CLASS' if is_class else ''
+                values_str = ' '.join(values)
+                f.write(f'    {plugin_name} ENUM({enum_name}){class_kw} {{ {values_str} }}\n')
+
+            if enums and classes:
+                f.write('\n')
+
             for cls_name in sorted(classes.keys()):
                 cls_info = classes[cls_name]
                 f.write(f'    {plugin_name} CLASS({cls_name}) {{\n')
@@ -3128,10 +3199,22 @@ def plugin(plugin_name, files, private):
                     for method in sorted(cls_info['methods']):
                         f.write(f'        METHOD({method})\n')
 
-                # v3.2.2: Write fields (name only, type not needed in .cp)
+                # v3.2.2: Write fields
+                # v4.6.6: Support array fields with FIELD_ARRAY(name, type, size)
                 if cls_info.get('fields'):
-                    for field_type, field_name in cls_info['fields']:
-                        f.write(f'        FIELD({field_name})\n')
+                    for field_info in cls_info['fields']:
+                        # Handle both old (type, name) and new (type, name, array_size) formats
+                        if len(field_info) >= 3:
+                            field_type, field_name, array_size = field_info
+                        else:
+                            field_type, field_name = field_info
+                            array_size = 0
+
+                        if array_size > 0:
+                            # Array field: use FIELD_ARRAY with type info for proper binding
+                            f.write(f'        FIELD_ARRAY({field_name}, {field_type}, {array_size})\n')
+                        else:
+                            f.write(f'        FIELD({field_name})\n')
 
                 f.write(f'    }}\n')
 
@@ -3155,6 +3238,7 @@ def plugin(plugin_name, files, private):
             f.write(')\n')
 
     click.secho(f"Generated plugin: {cp_file}", fg='green', bold=True)
+    click.echo(f"Enums found: {len(enums)}")
     click.echo(f"Classes found: {len(classes)}")
     total_fields = sum(len(c.get('fields', [])) for c in classes.values())
     if total_fields:
@@ -6439,21 +6523,45 @@ def cppy_convert(files, to_cpp, to_py, no_header, output, ns, verbose, use_ai, u
 
 
 def _resolve_cp_source(cp_file: Path, project_root: Path) -> Path:
-    """Resolve SOURCE() directive from .cp file to actual source file."""
+    """Resolve SOURCE() directive from .cp file to actual source file.
+
+    Returns the first valid source file found. Supports:
+        - Single file: SOURCE(file.cpp)
+        - Multiple files in one SOURCE: SOURCE(file1.cpp file2.cpp)
+        - Multiple SOURCE declarations: SOURCE(file1.cpp) && SOURCE(file2.cpp)
+    """
     try:
         content = cp_file.read_text(encoding='utf-8', errors='replace')
         import re
-        source_match = re.search(r'SOURCE\s*\(\s*([^)]+)\s*\)', content)
-        if source_match:
-            source_name = source_match.group(1).strip().strip('"\'')
-            include_dir = project_root / "include"
-            for ext in ['.cpp', '.h', '.hpp', '.cc', '.cxx']:
-                candidate = include_dir / (source_name.replace('.cpp', '').replace('.h', '') + ext)
-                if candidate.exists():
-                    return candidate
-            direct = include_dir / source_name
-            if direct.exists():
-                return direct
+
+        # Find all SOURCE() declarations
+        source_matches = re.findall(r'SOURCE\s*\(\s*([^)]+)\s*\)', content)
+        for sources_str in source_matches:
+            # Handle multiple files within one SOURCE()
+            sources = re.split(r'[,\s]+', sources_str.strip())
+            for source_name in sources:
+                source_name = source_name.strip().strip('"\'')
+                if not source_name:
+                    continue
+
+                include_dir = project_root / "include"
+
+                # Try direct path first (relative to project root)
+                direct_from_root = project_root / source_name
+                if direct_from_root.exists():
+                    return direct_from_root
+
+                # Try in include directory
+                direct = include_dir / source_name
+                if direct.exists():
+                    return direct
+
+                # Try with different extensions
+                for ext in ['.cpp', '.h', '.hpp', '.cc', '.cxx']:
+                    base_name = source_name.replace('.cpp', '').replace('.h', '').replace('.hpp', '')
+                    candidate = include_dir / (base_name + ext)
+                    if candidate.exists():
+                        return candidate
     except Exception:
         pass
     return None

{includecpp-4.6.2 → includecpp-4.6.6}/includecpp/core/build_manager.py

@@ -387,9 +387,11 @@ target_include_directories(api PRIVATE
 )
 
 if(MSVC)
-    target_compile_options(api PRIVATE /W3 /O2 /EHsc /MT)
+    # /wd4018: disable signed/unsigned comparison warning (pybind11 enum issue)
+    target_compile_options(api PRIVATE /W3 /O2 /EHsc /MT /wd4018 /wd4267)
 else()
-    target_compile_options(api PRIVATE -Wall -O3 -pthread)
+    # -Wno-sign-compare: disable signed/unsigned comparison warning (pybind11 enum issue)
+    target_compile_options(api PRIVATE -Wall -O3 -pthread -Wno-sign-compare)
     # MinGW on Windows: static linking for MinGW runtime and pthread
     if(WIN32)
         target_link_options(api PRIVATE -static-libgcc -static-libstdc++ -Wl,-Bstatic -lpthread -Wl,-Bdynamic -lws2_32)

includecpp-4.6.6/includecpp/core/cpp_api_extensions.pyi

@@ -0,0 +1,165 @@
+"""Auto-generated type stubs for IncludeCPP module wrappers.
+
+This file enables VSCode IntelliSense autocomplete for C++ modules.
+DO NOT EDIT - Auto-generated by IncludeCPP build system.
+"""
+
+from typing import Any, List, Dict, Optional, Union, Protocol, overload
+
+class StepcompilerModuleWrapper(Protocol):
+    """Type hints for stepcompiler module wrapper (VSCode autocomplete support)."""
+
+    def getInfo(self) -> Dict[str, Any]:
+        """Get stepcompiler module information."""
+        ...
+
+    class CryptoUtils:
+        """C++ class: CryptoUtils"""
+
+        def __init__(self) -> None:
+            """Initialize CryptoUtils instance"""
+            ...
+
+        def binaryToByte(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: binaryToByte"""
+            ...
+
+        def byteToBinary(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: byteToBinary"""
+            ...
+
+        def compress(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: compress"""
+            ...
+
+        def crc32(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: crc32"""
+            ...
+
+        def decompress(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: decompress"""
+            ...
+
+        def deriveKeyStream(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: deriveKeyStream"""
+            ...
+
+        def fromHexString(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: fromHexString"""
+            ...
+
+        def generateIV(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: generateIV"""
+            ...
+
+        def hashKey(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: hashKey"""
+            ...
+
+        def scramble(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: scramble"""
+            ...
+
+        def toHexString(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: toHexString"""
+            ...
+
+        def xorEncrypt(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: xorEncrypt"""
+            ...
+
+
+    class HDFileHeader:
+        """C++ class: HDFileHeader"""
+
+        def __init__(self) -> None:
+            """Initialize HDFileHeader instance"""
+            ...
+
+        pass
+
+    class StepCompiler:
+        """C++ class: StepCompiler"""
+
+        @overload
+        def __init__(self) -> None: ...
+        @overload
+        def __init__(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: bool, arg5: bool) -> None: ...
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            """Initialize StepCompiler instance"""
+            ...
+
+        def Decrypt(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: Decrypt"""
+            ...
+
+        def Encrypt(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: Encrypt"""
+            ...
+
+        def GetHeader(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: GetHeader"""
+            ...
+
+        def GetOutputPath(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: GetOutputPath"""
+            ...
+
+        def GetStatusMessage(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: GetStatusMessage"""
+            ...
+
+        def Init(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: Init"""
+            ...
+
+        def Process(self, *args: Any, **kwargs: Any) -> Any:
+            """C++ method: Process"""
+            ...
+
+
+
+
+# CppApi with typed include() overloads for each module
+class CppApi:
+    """C++ API Manager with typed module loading.
+
+    The include() method returns a module wrapper with full type hints
+    for VSCode/PyCharm autocomplete support.
+    """
+
+    def __init__(self, project_root: Optional[str] = None, auto_update: bool = True) -> None:
+        """Initialize CppApi.
+
+        Args:
+            project_root: Path to project root (default: auto-detect)
+            auto_update: Whether to auto-rebuild on source changes
+        """
+        ...
+
+    @overload
+    def include(self, module_name: str = "stepcompiler", auto_update: Optional[bool] = None) -> StepcompilerModuleWrapper: ...
+
+    @overload
+    def include(self, module_name: str, auto_update: Optional[bool] = None) -> Any: ...
+
+    def include(self, module_name: str, auto_update: Optional[bool] = None) -> Any:
+        """Load a C++ module.
+
+        Args:
+            module_name: Name of the module to load
+            auto_update: Override auto-update setting for this module
+
+        Returns:
+            ModuleWrapper with access to C++ classes, functions, and structs
+        """
+        ...
+
+    def rebuild(self, verbose: bool = False) -> bool:
+        """Rebuild all C++ modules."""
+        ...
+
+    def list_modules(self) -> List[str]:
+        """List available modules."""
+        ...