IncludeCPP 3.4.2__py3-none-any.whl → 3.4.10__py3-none-any.whl

includecpp/core/cssl_bridge.py

@@ -5,7 +5,105 @@ Provides CsslLang class for executing CSSL code from Python.
 
 import threading
 from pathlib import Path
-from typing import Any, List, Optional, Callable
+from typing import Any, List, Optional, Callable, Dict
+
+
+class CSSLModule:
+    """
+    A callable CSSL module that executes code with arguments.
+
+    Created via CSSL.module() - the code is executed each time the module is called,
+    with arguments accessible via parameter.get(index).
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str):
+        self._cssl = cssl_instance
+        self._code = code
+
+    def __call__(self, *args) -> Any:
+        """Execute the module code with the given arguments."""
+        return self._cssl.exec(self._code, *args)
+
+    def __repr__(self) -> str:
+        return f"<CSSLModule code_len={len(self._code)}>"
+
+
+class CSSLFunctionModule:
+    """
+    A CSSL module with accessible functions as methods.
+
+    Created via CSSL.makemodule() - functions defined in the CSSL code
+    become callable attributes on this module.
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str):
+        self._cssl = cssl_instance
+        self._code = code
+        self._runtime = None
+        self._functions: Dict[str, Any] = {}
+        self._initialized = False
+
+    def _ensure_initialized(self):
+        """Initialize the module by parsing and registering functions."""
+        if self._initialized:
+            return
+
+        from .cssl import CSSLRuntime, parse_cssl_program, ASTNode
+
+        # Create a dedicated runtime for this module
+        self._runtime = CSSLRuntime()
+
+        # Parse the code
+        ast = parse_cssl_program(self._code)
+
+        # Execute to register all function definitions
+        for child in ast.children:
+            if child.type == 'function':
+                func_info = child.value
+                func_name = func_info.get('name')
+                self._functions[func_name] = child
+                self._runtime.scope.set(func_name, child)
+            else:
+                # Execute other statements (like struct definitions)
+                try:
+                    self._runtime._execute_node(child)
+                except Exception:
+                    pass
+
+        self._initialized = True
+
+    def __getattr__(self, name: str) -> Callable:
+        """Get a function from the module."""
+        # Avoid recursion for internal attributes
+        if name.startswith('_'):
+            raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+
+        self._ensure_initialized()
+
+        if name in self._functions:
+            func_node = self._functions[name]
+
+            def wrapper(*args):
+                from .cssl import Parameter
+                # Set up parameter object for this call
+                self._runtime.global_scope.set('parameter', Parameter(list(args)))
+                self._runtime.global_scope.set('args', list(args))
+                self._runtime.global_scope.set('argc', len(args))
+                return self._runtime._call_function(func_node, list(args))
+
+            return wrapper
+
+        raise AttributeError(f"CSSL module has no function '{name}'")
+
+    def __dir__(self) -> List[str]:
+        """List available functions."""
+        self._ensure_initialized()
+        return list(self._functions.keys())
+
+    def __repr__(self) -> str:
+        self._ensure_initialized()
+        funcs = ', '.join(self._functions.keys())
+        return f"<CSSLFunctionModule functions=[{funcs}]>"
 
 
 class CsslLang:
@@ -46,7 +144,8 @@ class CsslLang:
             *args: Arguments to pass to the script
 
         Returns:
-            Execution result
+            Execution result. If parameter.return() was called, returns
+            the list of returned values (or single value if only one).
         """
         runtime = self._get_runtime()
 
@@ -58,12 +157,22 @@ class CsslLang:
             source = path_or_code
 
         # Set arguments in runtime scope
+        from .cssl import Parameter
+        param = Parameter(list(args))
         runtime.global_scope.set('args', list(args))
         runtime.global_scope.set('argc', len(args))
+        runtime.global_scope.set('parameter', param)
 
         # Execute as standalone program
         try:
             result = runtime.execute_program(source)
+
+            # Check if parameter.return() was used (generator-like returns)
+            if param.has_returns():
+                returns = param.returns()
+                # Return single value if only one, else return list
+                return returns[0] if len(returns) == 1 else returns
+
             return result
         except Exception as e:
             raise RuntimeError(f"CSSL Error: {e}") from e
@@ -120,6 +229,53 @@ class CsslLang:
         runtime = self._get_runtime()
         return runtime.global_scope.get(name)
 
+    def module(self, code: str) -> 'CSSLModule':
+        """
+        Create a callable CSSL module from code.
+
+        The module can be called with arguments that are passed to the CSSL code.
+
+        Usage:
+            module = CSSL.module('''
+                printl(parameter.get(0));
+            ''')
+            module("Hello")  # Prints "Hello"
+
+        Args:
+            code: CSSL code string
+
+        Returns:
+            CSSLModule - a callable module
+        """
+        return CSSLModule(self, code)
+
+    def makemodule(self, code: str) -> 'CSSLFunctionModule':
+        """
+        Create a CSSL module with accessible functions.
+
+        Functions defined in the code become methods on the returned module.
+
+        Usage:
+            module = CSSL.makemodule('''
+                string greet(string name) {
+                    return "Hello, " + name + "!";
+                }
+
+                int add(int a, int b) {
+                    return a + b;
+                }
+            ''')
+            module.greet("World")  # Returns "Hello, World!"
+            module.add(2, 3)       # Returns 5
+
+        Args:
+            code: CSSL code string with function definitions
+
+        Returns:
+            CSSLFunctionModule - module with callable function attributes
+        """
+        return CSSLFunctionModule(self, code)
+
 
 # Singleton for convenience
 _default_instance: Optional[CsslLang] = None
@@ -130,3 +286,133 @@ def get_cssl() -> CsslLang:
     if _default_instance is None:
         _default_instance = CsslLang()
     return _default_instance
+
+
+# Module-level convenience functions
+def exec(path_or_code: str, *args) -> Any:
+    """
+    Execute CSSL code or file.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.exec("script.cssl", arg1, arg2)
+        CSSL.exec("printl('Hello World');")
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    return get_cssl().exec(path_or_code, *args)
+
+
+def T_exec(path_or_code: str, *args, callback: Optional[Callable[[Any], None]] = None) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.T_exec("async_script.cssl", arg1, callback=on_done)
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    return get_cssl().T_exec(path_or_code, *args, callback=callback)
+
+
+def set_global(name: str, value: Any) -> None:
+    """Set a global variable in CSSL runtime."""
+    get_cssl().set_global(name, value)
+
+
+def get_global(name: str) -> Any:
+    """Get a global variable from CSSL runtime."""
+    return get_cssl().get_global(name)
+
+
+def get_output() -> List[str]:
+    """Get output buffer from last execution."""
+    return get_cssl().get_output()
+
+
+def clear_output() -> None:
+    """Clear output buffer."""
+    get_cssl().clear_output()
+
+
+# Aliases to avoid conflict with Python builtin exec
+_exec = exec
+_T_exec = T_exec
+
+
+def module(code: str) -> CSSLModule:
+    """
+    Create a callable CSSL module from code.
+
+    Usage:
+        from includecpp import CSSL
+        greet = CSSL.module('''
+            printl("Hello, " + parameter.get(0) + "!");
+        ''')
+        greet("World")  # Prints "Hello, World!"
+
+    Args:
+        code: CSSL code string
+
+    Returns:
+        CSSLModule - a callable module
+    """
+    return get_cssl().module(code)
+
+
+def makemodule(code: str) -> CSSLFunctionModule:
+    """
+    Create a CSSL module with accessible functions.
+
+    Usage:
+        from includecpp import CSSL
+        math_mod = CSSL.makemodule('''
+            int add(int a, int b) {
+                return a + b;
+            }
+
+            int multiply(int a, int b) {
+                return a * b;
+            }
+        ''')
+        math_mod.add(2, 3)       # Returns 5
+        math_mod.multiply(4, 5)  # Returns 20
+
+    Args:
+        code: CSSL code string with function definitions
+
+    Returns:
+        CSSLFunctionModule - module with callable function attributes
+    """
+    return get_cssl().makemodule(code)
+
+
+# Export all
+__all__ = [
+    'CsslLang',
+    'CSSLModule',
+    'CSSLFunctionModule',
+    'get_cssl',
+    'exec',
+    '_exec',  # Alias for exec (avoids Python builtin conflict)
+    'T_exec',
+    '_T_exec',  # Alias for T_exec
+    'set_global',
+    'get_global',
+    'get_output',
+    'clear_output',
+    'module',
+    'makemodule',
+]

includecpp/core/cssl_bridge.pyi

@@ -0,0 +1,311 @@
+"""
+CSSL Bridge - Type Stubs for Python API
+"""
+
+import threading
+from typing import Any, List, Optional, Callable, Dict
+
+
+class CSSLModule:
+    """
+    A callable CSSL module that executes code with arguments.
+
+    Created via CSSL.module() - the code is executed each time the module is called,
+    with arguments accessible via parameter.get(index).
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str) -> None: ...
+    def __call__(self, *args: Any) -> Any:
+        """Execute the module code with the given arguments."""
+        ...
+    def __repr__(self) -> str: ...
+
+
+class CSSLFunctionModule:
+    """
+    A CSSL module with accessible functions as methods.
+
+    Created via CSSL.makemodule() - functions defined in the CSSL code
+    become callable attributes on this module.
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str) -> None: ...
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        """Get a function from the module."""
+        ...
+    def __dir__(self) -> List[str]:
+        """List available functions."""
+        ...
+    def __repr__(self) -> str: ...
+
+
+class CsslLang:
+    """
+    CSSL Language interface for Python.
+
+    Usage:
+        from includecpp import CSSL
+        cssl = CSSL.CsslLang()
+        result = cssl.exec("script.cssl", arg1, arg2)
+        cssl.T_exec("async_script.cssl", arg1)  # Threaded
+    """
+
+    def __init__(self, output_callback: Optional[Callable[[str, str], None]] = ...) -> None:
+        """
+        Initialize CSSL runtime.
+
+        Args:
+            output_callback: Optional callback for output (text, level)
+        """
+        ...
+
+    def exec(self, path_or_code: str, *args: Any) -> Any:
+        """
+        Execute CSSL code or file.
+
+        Args:
+            path_or_code: Path to .cssl file or CSSL code string
+            *args: Arguments to pass to the script
+
+        Returns:
+            Execution result
+        """
+        ...
+
+    def T_exec(
+        self,
+        path_or_code: str,
+        *args: Any,
+        callback: Optional[Callable[[Any], None]] = ...
+    ) -> threading.Thread:
+        """
+        Execute CSSL code asynchronously in a thread.
+
+        Args:
+            path_or_code: Path to .cssl file or CSSL code string
+            *args: Arguments to pass to the script
+            callback: Optional callback when execution completes
+
+        Returns:
+            Thread object
+        """
+        ...
+
+    def wait_all(self, timeout: Optional[float] = ...) -> None:
+        """Wait for all async executions to complete."""
+        ...
+
+    def get_output(self) -> List[str]:
+        """Get output buffer from last execution."""
+        ...
+
+    def clear_output(self) -> None:
+        """Clear output buffer."""
+        ...
+
+    def set_global(self, name: str, value: Any) -> None:
+        """Set a global variable in CSSL runtime."""
+        ...
+
+    def get_global(self, name: str) -> Any:
+        """Get a global variable from CSSL runtime."""
+        ...
+
+    def module(self, code: str) -> CSSLModule:
+        """
+        Create a callable CSSL module from code.
+
+        Usage:
+            module = cssl.module('''
+                printl(parameter.get(0));
+            ''')
+            module("Hello")  # Prints "Hello"
+
+        Args:
+            code: CSSL code string
+
+        Returns:
+            CSSLModule - a callable module
+        """
+        ...
+
+    def makemodule(self, code: str) -> CSSLFunctionModule:
+        """
+        Create a CSSL module with accessible functions.
+
+        Usage:
+            module = cssl.makemodule('''
+                string greet(string name) {
+                    return "Hello, " + name + "!";
+                }
+            ''')
+            module.greet("World")  # Returns "Hello, World!"
+
+        Args:
+            code: CSSL code string with function definitions
+
+        Returns:
+            CSSLFunctionModule - module with callable function attributes
+        """
+        ...
+
+
+def get_cssl() -> CsslLang:
+    """Get default CSSL instance."""
+    ...
+
+
+def exec(path_or_code: str, *args: Any) -> Any:
+    """
+    Execute CSSL code or file.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.exec("script.cssl", arg1, arg2)
+        CSSL.exec("printl('Hello World');")
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    ...
+
+
+def T_exec(
+    path_or_code: str,
+    *args: Any,
+    callback: Optional[Callable[[Any], None]] = ...
+) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.T_exec("async_script.cssl", arg1, callback=on_done)
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    ...
+
+
+def set_global(name: str, value: Any) -> None:
+    """Set a global variable in CSSL runtime."""
+    ...
+
+
+def get_global(name: str) -> Any:
+    """Get a global variable from CSSL runtime."""
+    ...
+
+
+def get_output() -> List[str]:
+    """Get output buffer from last execution."""
+    ...
+
+
+def clear_output() -> None:
+    """Clear output buffer."""
+    ...
+
+
+# Aliases to avoid conflict with Python builtin exec
+def _exec(code: str, *args: Any) -> Any:
+    """
+    Execute CSSL code directly (alias for exec).
+
+    Supports triple-quoted docstrings for inline CSSL code:
+
+    Usage:
+        from includecpp import CSSL
+        CSSL._exec('''
+            global base = include("abc.cssl-mod");
+
+            void TestFunc() {
+                printl("hey");
+                @base.RechneWas(4, 5);
+            }
+
+            TestFunc();
+        ''')
+
+    Args:
+        code: CSSL code string (supports triple-quoted docstrings)
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    ...
+
+
+def _T_exec(
+    code: str,
+    *args: Any,
+    callback: Optional[Callable[[Any], None]] = ...
+) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread (alias for T_exec).
+
+    Args:
+        code: CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    ...
+
+
+def module(code: str) -> CSSLModule:
+    """
+    Create a callable CSSL module from code.
+
+    Usage:
+        from includecpp import CSSL
+        greet = CSSL.module('''
+            printl("Hello, " + parameter.get(0) + "!");
+        ''')
+        greet("World")  # Prints "Hello, World!"
+
+    Args:
+        code: CSSL code string
+
+    Returns:
+        CSSLModule - a callable module
+    """
+    ...
+
+
+def makemodule(code: str) -> CSSLFunctionModule:
+    """
+    Create a CSSL module with accessible functions.
+
+    Usage:
+        from includecpp import CSSL
+        math_mod = CSSL.makemodule('''
+            int add(int a, int b) {
+                return a + b;
+            }
+        ''')
+        math_mod.add(2, 3)  # Returns 5
+
+    Args:
+        code: CSSL code string with function definitions
+
+    Returns:
+        CSSLFunctionModule - module with callable function attributes
+    """
+    ...
+
+
+__all__: List[str]

{includecpp-3.4.2.dist-info → includecpp-3.4.10.dist-info}/METADATA

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

{includecpp-3.4.2.dist-info → includecpp-3.4.10.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=kqL0S09fmUWRoVpKUN-_2lufQHL-zcd8Y80CGDfWZ5M,1613
-includecpp/__init__.pyi,sha256=gNfQTFiM0z-Z2xazX7Hk5ULtW44lEU2j6hGEipcipMY,3637
+includecpp/__init__.py,sha256=ADg4AjowwcXWGRAZLfuz0f494MvuL2vD7Ry4-LtbIBg,1673
+includecpp/__init__.pyi,sha256=SBHwNvqWSUj0c_oS0uVGoOv25uYUOYtORFMxKiN0pkY,3762
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=90-L9iy4qIvyZR5KlMPSI5YNN7cb_1e6D5p-MTPkYJo,316845
+includecpp/cli/commands.py,sha256=7ozSW7IyUaCoSY1tC0-ieV1TYNP37g7kSoG16XmOkZY,316898
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -11,30 +11,31 @@ includecpp/core/build_manager.py,sha256=uLuYsuiC6OsOGaU5wAJfl4M3IbdnIDgogfMd8VsV
 includecpp/core/cpp_api.py,sha256=8y_B1L18rhSBZln654xPPzqO2PdvAlLpJrfEjzl7Wnc,14039
 includecpp/core/cpp_api.pyi,sha256=IEiaKqaPItnn6rjL7aK32D3o9FYmRYCgCZbqiQNUwdc,3496
 includecpp/core/cppy_converter.py,sha256=b7yqu-aoa0wShNY0GvQT67TnNhYya4GyYmG7oDdqDV4,156686
-includecpp/core/cssl_bridge.py,sha256=V_55W-h4vRE0m-O1bJS5Lb_ywq9Tiq-1apG6gtiKVVk,4166
+includecpp/core/cssl_bridge.py,sha256=HpnMbX4lnGCuQq8ZjnvLSfqd-wrobMF5szhQM4T2RGI,12635
+includecpp/core/cssl_bridge.pyi,sha256=Q4zjc2Kf2wPJPnfgHS-koPEon3Kty6o3mCvp9E5Q8tE,7635
 includecpp/core/error_catalog.py,sha256=VS3N-P0yEbiHimsDPtcaYfrUb7mXQ-7pqw18PtSngaU,33869
 includecpp/core/error_formatter.py,sha256=7-MzRIT8cM4uODxy0IZ9pu7pqR4Pq2I8Si0QQZHjmVc,39239
 includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk,2459
 includecpp/core/path_discovery.py,sha256=jI0oSq6Hsd4LKXmU4dOiGSrXcEO_KWMXfQ5_ylBmXvU,2561
 includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ,141134
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
-includecpp/core/cssl/__init__.py,sha256=DZMkRkjBNCxSJ27x4elPIKbxgEFyLnKFZSIki91xVKc,1551
+includecpp/core/cssl/__init__.py,sha256=Z63V6GjWMyd61WpdoAd-hA_ZB3kgIw2RvA-RR35WBEc,1719
 includecpp/core/cssl/cssl_builtins.py,sha256=PDz4FoWqNdGjBTBLKJ2fc8SqFKpprSey_9gZxV19tIE,61896
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=mSvskKx66UvhmhxjgjfiBLfLylesaY50RsJcDBFK3so,60004
-includecpp/core/cssl/cssl_runtime.py,sha256=Qz6gNTuul-V73oAm8bE4JqnCLHIxMSWjskSEuLP_Lmg,59097
+includecpp/core/cssl/cssl_parser.py,sha256=B52QW-Cc9GBmoJGlqNlmEBq1-3cHcztVbUWNR4KuTH4,79259
+includecpp/core/cssl/cssl_runtime.py,sha256=zvhWTGIkjTxKuQBjouGO6T7miyfSL1vGCXa3RQ7v60c,66626
 includecpp/core/cssl/cssl_syntax.py,sha256=vgI-dgj6gs9cOHwNRff6JbwZZYW_fYutnwCkznlgZiE,17006
-includecpp/core/cssl/cssl_types.py,sha256=W5QAkFOHW0g6DaqQHk23bSBDvfLFTjHiTObLjfuHTo4,13003
+includecpp/core/cssl/cssl_types.py,sha256=-4kevtcUSqjCX9v6TzA_eHW3ZqaeKjEAIc92dGIAodc,17765
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
 includecpp/generator/parser.cpp,sha256=CxVpsBDb22yDaVqp0ljh7dFKBTGlUj65apUGtPRMu0s,76829
 includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo,11073
 includecpp/generator/type_resolver.cpp,sha256=MmFK_4HXd1wqxALDiDyXVuU397SXoQL_o5zb_8N8Hzs,12346
 includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDjaK5LhBSg,2590
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
-includecpp-3.4.2.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.4.2.dist-info/METADATA,sha256=ji6ffwWqoUKcDfI17Tl5jQK4TgytuLJjZutCUWRD4oM,26654
-includecpp-3.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.4.2.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.4.2.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.4.2.dist-info/RECORD,,
+includecpp-3.4.10.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.4.10.dist-info/METADATA,sha256=Pu0j0edS2IRiuGTQA6nIAhYDgBsbq3oddp6TMnDdn1E,26655
+includecpp-3.4.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.4.10.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.4.10.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.4.10.dist-info/RECORD,,