IncludeCPP 3.4.0__tar.gz → 3.4.1__tar.gz

{includecpp-3.4.0 → includecpp-3.4.1}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.4.0
+Version: 3.4.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -625,6 +625,15 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 # Changelog
 
+## v3.4.1
+- **Bug Fixes:**
+  - fix command: Fixed false positives for unused variables (sum, memory_) using word-boundary matching
+  - CPPY: C++ reserved words (double, int, void, etc.) now properly escaped as Python identifiers
+  - CPPY: C++ STL functions (accumulate, find, sort, reverse) properly converted to Python equivalents
+  - CPPY: Member variables with trailing underscore (memory_) now get self. prefix
+  - CPPY: Private class members now detected for self. prefix conversion
+  - Plugin: Auto-detect header files from #include directives in source files
+
 ## v3.4.0
 - **CodeMaker Major Update:**
   - New Source node type with 8 connection ports for code generation
@@ -787,4 +796,4 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 ---
 
-MIT License | v3.4.0 | [GitHub](https://github.com/liliassg/IncludeCPP)
+MIT License | v3.4.1 | [GitHub](https://github.com/liliassg/IncludeCPP)

{includecpp-3.4.0 → includecpp-3.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.4.0
+Version: 3.4.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -625,6 +625,15 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 # Changelog
 
+## v3.4.1
+- **Bug Fixes:**
+  - fix command: Fixed false positives for unused variables (sum, memory_) using word-boundary matching
+  - CPPY: C++ reserved words (double, int, void, etc.) now properly escaped as Python identifiers
+  - CPPY: C++ STL functions (accumulate, find, sort, reverse) properly converted to Python equivalents
+  - CPPY: Member variables with trailing underscore (memory_) now get self. prefix
+  - CPPY: Private class members now detected for self. prefix conversion
+  - Plugin: Auto-detect header files from #include directives in source files
+
 ## v3.4.0
 - **CodeMaker Major Update:**
   - New Source node type with 8 connection ports for code generation
@@ -787,4 +796,4 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 ---
 
-MIT License | v3.4.0 | [GitHub](https://github.com/liliassg/IncludeCPP)
+MIT License | v3.4.1 | [GitHub](https://github.com/liliassg/IncludeCPP)

{includecpp-3.4.0 → includecpp-3.4.1}/README.md

@@ -591,6 +591,15 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 # Changelog
 
+## v3.4.1
+- **Bug Fixes:**
+  - fix command: Fixed false positives for unused variables (sum, memory_) using word-boundary matching
+  - CPPY: C++ reserved words (double, int, void, etc.) now properly escaped as Python identifiers
+  - CPPY: C++ STL functions (accumulate, find, sort, reverse) properly converted to Python equivalents
+  - CPPY: Member variables with trailing underscore (memory_) now get self. prefix
+  - CPPY: Private class members now detected for self. prefix conversion
+  - Plugin: Auto-detect header files from #include directives in source files
+
 ## v3.4.0
 - **CodeMaker Major Update:**
   - New Source node type with 8 connection ports for code generation
@@ -753,4 +762,4 @@ Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCP
 
 ---
 
-MIT License | v3.4.0 | [GitHub](https://github.com/liliassg/IncludeCPP)
+MIT License | v3.4.1 | [GitHub](https://github.com/liliassg/IncludeCPP)

{includecpp-3.4.0 → includecpp-3.4.1}/includecpp/__init__.py

@@ -1,7 +1,7 @@
 from .core.cpp_api import CppApi
 import warnings
 
-__version__ = "3.4.0"
+__version__ = "3.4.1"
 __all__ = ["CppApi"]
 
 # Module-level cache for C++ modules

{includecpp-3.4.0 → includecpp-3.4.1}/includecpp/cli/commands.py

@@ -4436,8 +4436,10 @@ def fix(module_name, all_modules, exclude, undo, auto_fix, verbose, use_ai):
             if var_decl:
                 var_name = var_decl.group(1)
                 # Check if variable appears again in rest of content
+                # v3.4.1: Use word boundaries to avoid false positives from substring matches
                 rest_content = '\n'.join(lines[i:])
-                if rest_content.count(var_name) <= 1:
+                uses = len(re.findall(rf'\b{re.escape(var_name)}\b', rest_content))
+                if uses <= 1:
                     add_issue('info', 'Mistake', file_path, i, 'C003',
                               f"Variable '{var_name}' may be unused",
                               "Remove unused variable or mark as [[maybe_unused]]")

{includecpp-3.4.0 → includecpp-3.4.1}/includecpp/core/cppy_converter.py

@@ -34,6 +34,24 @@ PYTHON_KEYWORDS = {
     'while', 'with', 'yield'
 }
 
+# v3.4.1: C++ reserved words that need escaping when used as Python identifiers
+# These are C++ types/keywords that are valid Python identifiers but confusing
+CPP_RESERVED_WORDS = {
+    # Primitive types
+    'int', 'float', 'double', 'char', 'bool', 'void', 'auto',
+    'short', 'long', 'signed', 'unsigned', 'wchar_t',
+    # Type modifiers
+    'const', 'static', 'virtual', 'volatile', 'mutable', 'extern',
+    'register', 'inline', 'explicit', 'constexpr', 'consteval',
+    # Access modifiers
+    'public', 'private', 'protected',
+    # Other keywords
+    'template', 'typename', 'namespace', 'using', 'typedef',
+    'struct', 'union', 'enum', 'sizeof', 'alignof', 'decltype',
+    'new', 'delete', 'operator', 'friend', 'this',
+    'throw', 'catch', 'noexcept', 'final', 'override',
+}
+
 
 def _escape_python_keyword(name: str) -> str:
     """Escape Python reserved keywords by adding underscore suffix.
@@ -45,6 +63,27 @@ def _escape_python_keyword(name: str) -> str:
     return name
 
 
+def _escape_cpp_reserved(name: str) -> str:
+    """Escape C++ reserved words when used as Python identifiers.
+
+    Example: 'double' -> 'double_', 'int' -> 'int_', 'void' -> 'void_'
+    v3.4.1: Prevents C++ type names from being used as Python function/variable names.
+    """
+    if name in CPP_RESERVED_WORDS:
+        return name + '_'
+    return name
+
+
+def _escape_identifier(name: str) -> str:
+    """Escape both Python keywords and C++ reserved words.
+
+    Combines both escaping functions for comprehensive identifier safety.
+    """
+    name = _escape_python_keyword(name)
+    name = _escape_cpp_reserved(name)
+    return name
+
+
 # Python type to C++ type mapping
 PY_TO_CPP_TYPES = {
     'int': 'int',
@@ -2225,11 +2264,31 @@ class CppToPythonConverter:
 
     def _parse_class_fields(self, body: str) -> List[Tuple[str, str, Optional[str]]]:
         fields = []
+        all_field_names = set()  # v3.4.1: Track ALL fields for self. prefix
 
+        # v3.4.1: Parse fields from ALL sections (public, private, protected)
+        # for self. prefix detection, but only return public fields for dataclass
         sections = re.split(r'(?:public|private|protected)\s*:', body)
-        public_section = sections[1] if len(sections) > 1 else body
 
         field_pattern = r'(\w+(?:<[^>]+>)?)\s+(\w+)\s*(?:=\s*([^;]+))?\s*;'
+
+        # First pass: collect ALL field names from all sections
+        for section in sections:
+            for match in re.finditer(field_pattern, section):
+                field_type = match.group(1)
+                field_name = match.group(2)
+
+                if '(' in field_type or field_type in ('return', 'if', 'for', 'while'):
+                    continue
+
+                all_field_names.add(field_name)
+
+        # Store all field names for self. prefix detection
+        self._current_class_fields = all_field_names
+
+        # Second pass: return only public fields for the Python class definition
+        public_section = sections[1] if len(sections) > 1 else body
+
         for match in re.finditer(field_pattern, public_section):
             field_type = match.group(1)
             field_name = match.group(2)
@@ -2594,13 +2653,30 @@ class CppToPythonConverter:
         expr = re.sub(r'std::max\(([^,]+),\s*([^)]+)\)', r'max(\1, \2)', expr)
 
         # Handle std::accumulate(container.begin(), container.end(), init) -> sum(container) [+ init]
+        # v3.4.1: Also handle accumulate without std:: prefix
         def _accumulate_to_sum(m):
             container = m.group(1)
             init_val = m.group(2).strip()
             if init_val == '0' or init_val == '0.0':
                 return f'sum({container})'
             return f'sum({container}) + {init_val}'
-        expr = re.sub(r'std::accumulate\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', _accumulate_to_sum, expr)
+        expr = re.sub(r'(?:std::)?accumulate\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', _accumulate_to_sum, expr)
+
+        # v3.4.1: Handle std::find, std::count, std::sort with .begin()/.end()
+        # std::find(vec.begin(), vec.end(), val) -> val in vec
+        expr = re.sub(r'(?:std::)?find\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)\s*!=\s*\1\.end\(\)', r'\2 in \1', expr)
+        # std::count(vec.begin(), vec.end(), val) -> vec.count(val)
+        expr = re.sub(r'(?:std::)?count\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', r'\1.count(\2)', expr)
+        # std::sort(vec.begin(), vec.end()) -> vec.sort()
+        expr = re.sub(r'(?:std::)?sort\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.sort()', expr)
+        # std::reverse(vec.begin(), vec.end()) -> vec.reverse()
+        expr = re.sub(r'(?:std::)?reverse\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.reverse()', expr)
+
+        # v3.4.1: Clean up any remaining .begin()/.end() that couldn't be converted
+        # container.begin() -> iter(container) for iteration context
+        # But typically these are errors - flag as comment if they remain
+        expr = re.sub(r'(\w+)\.begin\(\)', r'\1[0]', expr)  # Approximate as first element
+        expr = re.sub(r'(\w+)\.end\(\)', r'len(\1)', expr)  # Approximate as length
 
         # Handle .size() -> len()
         expr = re.sub(r'(\w+)\.size\(\)', r'len(\1)', expr)
@@ -2646,26 +2722,33 @@ class CppToPythonConverter:
                 # Fixed lookahead to be more permissive - match non-word chars or end
                 expr = re.sub(rf'(?<![.\w])(?<!self\.){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
 
-        # v3.3.22: Also handle common C++ member naming conventions (m_* and _*)
-        # Convert m_name or _name to self.name when in class context
+        # v3.4.1: Handle common C++ member naming conventions
+        # Convert m_name to self.name when in class context
         if self._current_class_fields:
             # Convert m_xxx to self.xxx
             expr = re.sub(r'(?<![.\w])m_(\w+)(?=\W|$)', r'self.\1', expr)
+            # Convert _xxx to self.xxx (leading underscore)
+            expr = re.sub(r'(?<![.\w])_(\w+)(?=\W|$)', r'self.\1', expr)
+            # v3.4.1: Convert xxx_ to self.xxx_ (trailing underscore - Google style)
+            # Only if it's a known field or matches the pattern
+            for field in self._current_class_fields:
+                if field.endswith('_') and field not in ('self_',):
+                    expr = re.sub(rf'(?<![.\w]){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
 
         return expr
 
     def _generate_struct(self, struct: StructInfo) -> List[str]:
         lines = ['@dataclass']
-        # v3.3.22: Escape Python keywords in struct/class names
-        struct_name = _escape_python_keyword(struct.name)
+        # v3.4.1: Escape Python keywords and C++ reserved words in struct/class names
+        struct_name = _escape_identifier(struct.name)
         lines.append(f'class {struct_name}:')
 
         if not struct.fields:
             lines.append(f'{self.indent}pass')
         else:
             for fname, ftype in struct.fields:
-                # v3.3.22: Escape Python keywords in field names
-                escaped_fname = _escape_python_keyword(fname)
+                # v3.4.1: Escape Python keywords and C++ reserved words in field names
+                escaped_fname = _escape_identifier(fname)
                 lines.append(f'{self.indent}{escaped_fname}: {ftype}')
 
         return lines
@@ -2673,8 +2756,8 @@ class CppToPythonConverter:
     def _generate_class(self, cls: ClassInfo) -> List[str]:
         lines = []
 
-        # v3.3.22: Escape Python keywords in class names
-        class_name = _escape_python_keyword(cls.name)
+        # v3.4.1: Escape Python keywords and C++ reserved words in class names
+        class_name = _escape_identifier(cls.name)
         if cls.bases:
             lines.append(f'class {class_name}({", ".join(cls.bases)}):')
         else:
@@ -2700,8 +2783,8 @@ class CppToPythonConverter:
 
         params = ['self'] if not method.is_static else []
         for pname, ptype in method.params:
-            # v3.3.22: Escape Python keywords in parameter names
-            escaped_pname = _escape_python_keyword(pname)
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
                 params.append(f'{escaped_pname}: {ptype}')
             else:
@@ -2711,8 +2794,8 @@ class CppToPythonConverter:
         if not is_init and method.return_type and method.return_type != 'None':
             ret_type = f' -> {method.return_type}'
 
-        # v3.3.22: Escape Python keywords in method names
-        method_name = '__init__' if is_init else _escape_python_keyword(method.name)
+        # v3.4.1: Escape Python keywords and C++ reserved words in method names
+        method_name = '__init__' if is_init else _escape_identifier(method.name)
         lines.append(f'{self.indent}def {method_name}({", ".join(params)}){ret_type}:')
 
         body_lines = method.body.split('\n')
@@ -2729,8 +2812,8 @@ class CppToPythonConverter:
 
         params = []
         for pname, ptype in func.params:
-            # v3.3.22: Escape Python keywords in parameter names
-            escaped_pname = _escape_python_keyword(pname)
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
                 params.append(f'{escaped_pname}: {ptype}')
             else:
@@ -2740,8 +2823,8 @@ class CppToPythonConverter:
         if func.return_type and func.return_type != 'None':
             ret_type = f' -> {func.return_type}'
 
-        # v3.3.22: Escape Python keywords in function names
-        func_name = _escape_python_keyword(func.name)
+        # v3.4.1: Escape Python keywords and C++ reserved words in function names
+        func_name = _escape_identifier(func.name)
         lines.append(f'def {func_name}({", ".join(params)}){ret_type}:')
 
         body_lines = func.body.split('\n')

{includecpp-3.4.0 → includecpp-3.4.1}/includecpp/generator/parser.cpp

@@ -700,6 +700,47 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
         validate_namespace_includecpp(desc.source_path, desc.module_name);
     }
 
+    // v3.4.1: Auto-detect header from #include directives in source file
+    if (!desc.has_header && !desc.source_path.empty()) {
+        std::ifstream source_file(desc.source_path);
+        if (source_file.is_open()) {
+            std::string line;
+            std::regex include_regex(R"(^\s*#include\s*"([^"]+\.h(?:pp)?)")");
+            std::smatch match;
+
+            while (std::getline(source_file, line)) {
+                if (std::regex_search(line, match, include_regex)) {
+                    std::string header_name = match[1].str();
+                    // Skip standard headers and pybind11 headers
+                    if (header_name.find("pybind11") == std::string::npos &&
+                        header_name.find("std") == std::string::npos) {
+                        // Found a local header - construct the path
+                        std::filesystem::path source_path(desc.source_path);
+                        std::filesystem::path header_path = source_path.parent_path() / header_name;
+
+                        // Check if the header file exists
+                        if (std::filesystem::exists(header_path)) {
+                            desc.header_path = header_path.string();
+                            desc.has_header = true;
+                            std::cout << "NOTE: Auto-detected header for '" << desc.module_name
+                                      << "': " << desc.header_path << std::endl;
+                            break;
+                        }
+                        // Also try in include/ subdirectory
+                        header_path = source_path.parent_path().parent_path() / "include" / header_name;
+                        if (std::filesystem::exists(header_path)) {
+                            desc.header_path = header_path.string();
+                            desc.has_header = true;
+                            std::cout << "NOTE: Auto-detected header for '" << desc.module_name
+                                      << "': " << desc.header_path << std::endl;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     return desc;
 }
 

{includecpp-3.4.0 → includecpp-3.4.1}/pyproject.toml

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

{includecpp-3.4.0 → includecpp-3.4.1}/setup.py

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