clibind 0.0.1__tar.gz

clibind-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r8763754383405076
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clibind-0.0.1/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: clibind
+Version: 0.0.1
+Summary: Bridge an argument parser and python callables seamlessly.
+Author: r8763754383405076
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# The "clibind" Package
+
+## Introduction
+
+The `clibind` package provides comprehensive utilities that link CLI arguments from an `argparse.ArgumentParser` directly to Python callables (functions or classes). The core operational steps include:
+1. Automatically configuring an argument parser based on the parameter signatures of a callable.
+2. Building a valid keyword arguments (`kwargs`) dictionary from parsed CLI inputs to dynamically execute the target callable.
+
+---
+
+## Preparation
+
+To ensure `clibind` correctly parses parameter definitions, each tracked argument in your callable must meet at least one of the following criteria:
+- Be assigned a explicit default value (other than `None`).
+- Have an explicit Python type annotation.
+
+### Supported Types
+Currently, only the following core primitives are supported:
+- `int`
+- `float`
+- `bool`
+- `str`
+
+*(Note: `Optional[T]` or `T | None` definitions are perfectly supported for the primitive types above).*
+
+### Basic Decorator Configuration
+Wrap your target callable object using the `@setup_clibind()` decorator. `setup_clibind` accepts two optional parameters:
+- **`help_messages`** *(dict[str, str])*: Map explicit argument names to terminal help string messages.
+- **`ignore_patterns`** *(list[str])*: Regex patterns matching arguments that should be skipped by the parser generator. By default, `"self"`, `"cls"`, and any variable names ending with an underscore (`_`) are automatically filtered out.
+
+---
+
+## Important Constraints
+
+When designing your callables for `clibind`, keep the following intentional design constraints in mind:
+
+1. **Parameter Name Collisions**: If you map multiple callables to a single `argparse.ArgumentParser` instance (as shown in the application pattern below), you must ensure that their parameter names do not collide. Registering overlapping argument names to the same parser instance will cause `argparse` to raise an `ArgumentError`. It is the user's responsibility to maintain unique parameter names across combined callables.
+2. **Mandatory Boolean Arguments**: Any parameter annotated with the `bool` type that lacks an explicit default value will automatically default to `False` and configure the parser with `action='store_true'`. This design choice ensures seamless integration with standard CLI toggle mechanics. If a strictly required boolean choice is needed, handle it via alternative validation or explicit defaults.
+
+---
+
+## Usage Workflow
+
+- **`setup_clibind`**: Attaches internal tracking metadata and analyzes target function/method definitions. If a class object is decorated, its `__init__` constructor method is evaluated.
+- **`callable_to_parser`**: Registers tracked arguments safely onto a provided `argparse.ArgumentParser` instance.
+- **`parser_to_callable`**: Extracts the structured keyword arguments (`kwargs`) matching the component signatures from the parsed execution context.
+
+---
+
+## Example
+
+```python
+import argparse
+import typing
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+@setup_clibind(
+    help_messages={
+        "var_1": "help message for var_1",
+        "var_a": "help message for var_a",
+        "var_f": "help message for var_f"
+    }
+)
+class TargetClass:
+    def __init__(
+        self,
+        var_to_skip_1_: list,
+        var_to_skip_2_: list,
+        var_1: int,
+        var_2: float,
+        var_3: str,
+        var_a=1,
+        var_b=1.1,
+        var_c="",
+        var_d1: int | None = None,
+        var_d2: typing.Optional[int] = None,
+        var_e=True,
+        var_f=False,
+        var_to_skip_3_=""
+    ):
+        pass
+
+# Initialize parser instance
+parser = argparse.ArgumentParser()
+callable_to_parser(obj=TargetClass, parser=parser)
+
+# View generated help documentation
+parser.print_help()
+```
+
+## Generated Layout
+
+```
+usage: main.py [-h] --var-1 INT --var-2 FLOAT --var-3 STR
+                       [--var-a INT] [--var-b FLOAT] [--var-c STR]
+                       [--var-d1 INT] [--var-d2 INT] [--var-e-toggle]
+                       [--var-f-toggle]
+
+options:
+  -h, --help           show this help message and exit
+
+arguments for "__main__.TargetClass":
+  --var-1 INT          help message for var_1
+  --var-2 FLOAT
+  --var-3 STR
+  --var-a INT          (default: 1) help message for var_a
+  --var-b FLOAT        (default: 1.1)
+  --var-c STR          (default: '')
+  --var-d1 INT         (default: None)
+  --var-d2 INT         (default: None)
+  --var-e-toggle       (default: True)
+  --var-f-toggle       (default: False) help message for var_f
+```
+
+## Production / Application Pattern
+
+In extensive systems (such as machine learning training pipelines), this architecture cleans up modular execution flows:
+
+```python
+# main.py
+import argparse
+import experiments.train
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers()
+
+    parser_train = subparsers.add_parser("train")
+    experiments.train.setup(parser_train)
+    parser_train.set_defaults(func=experiments.train.handle)
+
+
+# experiments/train.py
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+def setup(parser):
+    callable_to_parser(read_data, parser)
+    callable_to_parser(run, parser)
+
+def handle(args):
+    data_reader_args = parser_to_callable(args, read_data)
+    run_args = parser_to_callable(args, run)
+    
+    # Safely forward mapped variables 
+    run(data_reader_args_=data_reader_args, **run_args)
+
+@setup_clibind()
+def run(data_reader_args_: dict, epochs: int = 10):
+    train_ds, val_ds = read_data(**data_reader_args_)
+    # Train execution logic...
+
+@setup_clibind()
+def read_data(dataset_dir: str):
+    # Data extraction logic...
+    pass
+```

clibind-0.0.1/README.md

@@ -0,0 +1,156 @@
+# The "clibind" Package
+
+## Introduction
+
+The `clibind` package provides comprehensive utilities that link CLI arguments from an `argparse.ArgumentParser` directly to Python callables (functions or classes). The core operational steps include:
+1. Automatically configuring an argument parser based on the parameter signatures of a callable.
+2. Building a valid keyword arguments (`kwargs`) dictionary from parsed CLI inputs to dynamically execute the target callable.
+
+---
+
+## Preparation
+
+To ensure `clibind` correctly parses parameter definitions, each tracked argument in your callable must meet at least one of the following criteria:
+- Be assigned a explicit default value (other than `None`).
+- Have an explicit Python type annotation.
+
+### Supported Types
+Currently, only the following core primitives are supported:
+- `int`
+- `float`
+- `bool`
+- `str`
+
+*(Note: `Optional[T]` or `T | None` definitions are perfectly supported for the primitive types above).*
+
+### Basic Decorator Configuration
+Wrap your target callable object using the `@setup_clibind()` decorator. `setup_clibind` accepts two optional parameters:
+- **`help_messages`** *(dict[str, str])*: Map explicit argument names to terminal help string messages.
+- **`ignore_patterns`** *(list[str])*: Regex patterns matching arguments that should be skipped by the parser generator. By default, `"self"`, `"cls"`, and any variable names ending with an underscore (`_`) are automatically filtered out.
+
+---
+
+## Important Constraints
+
+When designing your callables for `clibind`, keep the following intentional design constraints in mind:
+
+1. **Parameter Name Collisions**: If you map multiple callables to a single `argparse.ArgumentParser` instance (as shown in the application pattern below), you must ensure that their parameter names do not collide. Registering overlapping argument names to the same parser instance will cause `argparse` to raise an `ArgumentError`. It is the user's responsibility to maintain unique parameter names across combined callables.
+2. **Mandatory Boolean Arguments**: Any parameter annotated with the `bool` type that lacks an explicit default value will automatically default to `False` and configure the parser with `action='store_true'`. This design choice ensures seamless integration with standard CLI toggle mechanics. If a strictly required boolean choice is needed, handle it via alternative validation or explicit defaults.
+
+---
+
+## Usage Workflow
+
+- **`setup_clibind`**: Attaches internal tracking metadata and analyzes target function/method definitions. If a class object is decorated, its `__init__` constructor method is evaluated.
+- **`callable_to_parser`**: Registers tracked arguments safely onto a provided `argparse.ArgumentParser` instance.
+- **`parser_to_callable`**: Extracts the structured keyword arguments (`kwargs`) matching the component signatures from the parsed execution context.
+
+---
+
+## Example
+
+```python
+import argparse
+import typing
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+@setup_clibind(
+    help_messages={
+        "var_1": "help message for var_1",
+        "var_a": "help message for var_a",
+        "var_f": "help message for var_f"
+    }
+)
+class TargetClass:
+    def __init__(
+        self,
+        var_to_skip_1_: list,
+        var_to_skip_2_: list,
+        var_1: int,
+        var_2: float,
+        var_3: str,
+        var_a=1,
+        var_b=1.1,
+        var_c="",
+        var_d1: int | None = None,
+        var_d2: typing.Optional[int] = None,
+        var_e=True,
+        var_f=False,
+        var_to_skip_3_=""
+    ):
+        pass
+
+# Initialize parser instance
+parser = argparse.ArgumentParser()
+callable_to_parser(obj=TargetClass, parser=parser)
+
+# View generated help documentation
+parser.print_help()
+```
+
+## Generated Layout
+
+```
+usage: main.py [-h] --var-1 INT --var-2 FLOAT --var-3 STR
+                       [--var-a INT] [--var-b FLOAT] [--var-c STR]
+                       [--var-d1 INT] [--var-d2 INT] [--var-e-toggle]
+                       [--var-f-toggle]
+
+options:
+  -h, --help           show this help message and exit
+
+arguments for "__main__.TargetClass":
+  --var-1 INT          help message for var_1
+  --var-2 FLOAT
+  --var-3 STR
+  --var-a INT          (default: 1) help message for var_a
+  --var-b FLOAT        (default: 1.1)
+  --var-c STR          (default: '')
+  --var-d1 INT         (default: None)
+  --var-d2 INT         (default: None)
+  --var-e-toggle       (default: True)
+  --var-f-toggle       (default: False) help message for var_f
+```
+
+## Production / Application Pattern
+
+In extensive systems (such as machine learning training pipelines), this architecture cleans up modular execution flows:
+
+```python
+# main.py
+import argparse
+import experiments.train
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers()
+
+    parser_train = subparsers.add_parser("train")
+    experiments.train.setup(parser_train)
+    parser_train.set_defaults(func=experiments.train.handle)
+
+
+# experiments/train.py
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+def setup(parser):
+    callable_to_parser(read_data, parser)
+    callable_to_parser(run, parser)
+
+def handle(args):
+    data_reader_args = parser_to_callable(args, read_data)
+    run_args = parser_to_callable(args, run)
+    
+    # Safely forward mapped variables 
+    run(data_reader_args_=data_reader_args, **run_args)
+
+@setup_clibind()
+def run(data_reader_args_: dict, epochs: int = 10):
+    train_ds, val_ds = read_data(**data_reader_args_)
+    # Train execution logic...
+
+@setup_clibind()
+def read_data(dataset_dir: str):
+    # Data extraction logic...
+    pass
+```

clibind-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clibind"
+authors = [
+    { name="r8763754383405076" },
+]
+description = "Bridge an argument parser and python callables seamlessly."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+dependencies = []
+
+dynamic = ["version"]
+
+[tool.setuptools.dynamic]
+version = {attr = "clibind.__version__"}

clibind-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

clibind-0.0.1/src/clibind/__init__.py

@@ -0,0 +1,8 @@
+"""
+clibind: Bridge an argument parser and python callables seamlessly.
+"""
+
+from .core import setup_clibind, callable_to_parser, parser_to_callable
+
+__version__: str = "0.0.1"
+__all__: list[str] = ["setup_clibind", "callable_to_parser", "parser_to_callable"]

clibind-0.0.1/src/clibind/core.py

@@ -0,0 +1,205 @@
+"""
+The "clibind" Package
+
+Bridge an argument parser and python callables seamlessly.
+"""
+
+import argparse
+import inspect
+import re
+import types
+import typing
+from typing import Any, Callable, TypeVar
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
+def setup_clibind(
+    help_messages: dict[str, str] | None = None, 
+    ignore_patterns: list[str] | None = None
+) -> Callable[[_F], _F]:
+    """
+    A decorator to set up "clibind" metadata directly on a callable or class object.
+
+    Args:
+        help_messages (dict[str, str] | None): Dictionary mapping argument names to their help strings.
+        ignore_patterns (list[str] | None): Regex patterns to exclude specific arguments from parser generation.
+            If None, defaults to ignoring "self", "cls", and any argument ending with an underscore "_".
+
+    Returns:
+        Callable[[_F], _F]: The decorator function that attaches configuration attributes directly to the target.
+    """
+    def decorator(obj: _F) -> _F:
+        # Utilizing Python's class attribute shadowing:
+        # Writing directly to "obj" isolates metadata for inherited sub-classes automatically.
+        obj._clibind_help_messages = help_messages
+        if ignore_patterns is None:
+            obj._clibind_ignore_patterns = [r"^self$", r"^cls$", r"^.*_$"]
+        else:
+            obj._clibind_ignore_patterns = ignore_patterns
+            
+        obj._clibind_callable_args_to_parser_args = {}
+        obj._clibind_callable_args_to_parser_configs = {}
+        
+        _analyze_callable_args(obj)
+        return obj
+        
+    return decorator
+
+
+def callable_to_parser(
+    obj: Any, 
+    parser: argparse.ArgumentParser
+) -> None:
+    """
+    Extracts analyzed metadata from a registered target and registers its arguments into the parser.
+
+    Args:
+        obj (Any): A callable or class decorated with `@setup_clibind`.
+        parser (argparse.ArgumentParser): The target argument parser instance.
+    """
+    group_title = f"arguments for \"{_get_obj_identifier(obj)}\""
+    group = parser.add_argument_group(group_title)
+    
+    for callable_arg, parser_arg in obj._clibind_callable_args_to_parser_args.items():
+        parser_flag = _get_parser_flag(parser_arg)
+        parser_config = obj._clibind_callable_args_to_parser_configs[callable_arg]
+        group.add_argument(parser_flag, **parser_config)
+
+
+def parser_to_callable(
+    args: argparse.Namespace | dict[str, Any], 
+    obj: Any
+) -> dict[str, Any]:
+    """
+    Constructs a keyword arguments dictionary for the target from parsed arguments.
+
+    Args:
+        args (argparse.Namespace | dict[str, Any]): The parsed arguments from `parser.parse_args()`.
+        obj (Any): The target callable or class decorated with `@setup_clibind`.
+
+    Returns:
+        dict[str, Any]: A dictionary of mapped arguments ready to be unpacked into the target.
+    """
+    args_dict = vars(args) if not isinstance(args, dict) else args
+    
+    callable_kwargs_dict: dict[str, Any] = {}
+    for callable_arg, parser_arg in obj._clibind_callable_args_to_parser_args.items():
+        callable_kwargs_dict[callable_arg] = args_dict[parser_arg]
+        
+    return callable_kwargs_dict
+
+
+def _analyze_callable_args(obj: Any) -> None:
+    """
+    Inspects the signature of the target object and populates its internal configuration.
+
+    Args:
+        obj (Any): The target class or function to inspect.
+
+    Raises:
+        RuntimeError: If unsupported parameter kinds, invalid types, or invalid annotations are detected.
+    """
+    # inspect.signature automatically extracts __init__ signature without "self" when a class is passed.
+    # eval_str=True dynamically resolves string annotations (from __future__ import annotations)
+    sig = inspect.signature(obj, eval_str=True)
+
+    for param in sig.parameters.values():
+        if any(re.fullmatch(pattern, param.name) for pattern in obj._clibind_ignore_patterns):
+            continue
+
+        if param.kind != param.POSITIONAL_OR_KEYWORD:
+            raise RuntimeError(
+                f"Parameter '{param.name}' in {_get_obj_identifier(obj)} is invalid. "
+                "Only POSITIONAL_OR_KEYWORD parameters are supported."
+            )
+        
+        param_has_annotation = param.annotation is not param.empty
+        param_has_default = param.default is not param.empty
+        
+        if param_has_annotation:
+            if isinstance(param.annotation, str):
+                raise RuntimeError(
+                    f"Parameter '{param.name}' in {_get_obj_identifier(obj)} "
+                    "uses an unresolvable string forward-reference annotation."
+                )
+            
+            annotation_origin = typing.get_origin(param.annotation)
+            if annotation_origin is None:
+                param_type = param.annotation
+            else:
+                # Handle Union types (e.g., Optional[T] or T | None)
+                annotation_acceptable = False
+                if annotation_origin in (typing.Union, types.UnionType):
+                    annotation_args = typing.get_args(param.annotation)
+                    non_none = [t for t in annotation_args if t is not type(None)]
+                    if len(non_none) == 1:
+                        param_type = non_none[0]
+                        annotation_acceptable = True
+                        
+                if not annotation_acceptable:
+                    raise RuntimeError(
+                        f"Annotation of '{param.name}' in {_get_obj_identifier(obj)} "
+                        f"({param.annotation}) is not supported."
+                    )
+        elif param_has_default:
+            param_type = type(param.default)
+        else:
+            raise RuntimeError(
+                f"Parameter '{param.name}' must have either a clear type annotation or a default value."
+            )
+
+        if param_type not in (int, float, bool, str):
+            raise RuntimeError(
+                "Only int, float, bool, and str types are supported, but "
+                f"'{param.name}' in {_get_obj_identifier(obj)} is evaluated as {param_type}."
+            )
+        
+        param_default_value = param.default if param_has_default else None
+        
+        if param_type is bool and param_default_value is None:
+            param_default_value = False
+        
+        parser_arg = param.name
+        if param_type is bool:
+            parser_arg += "_toggle"
+        obj._clibind_callable_args_to_parser_args[param.name] = parser_arg
+
+        param_help = obj._clibind_help_messages.get(param.name, "") if obj._clibind_help_messages else ""
+
+        if param_type is bool:
+            parser_config: dict[str, Any] = {
+                "action": "store_false" if param_default_value else "store_true",
+                "help": f"(default: {repr(param_default_value)}) {param_help}".strip()
+            }
+        else:
+            if param_has_default:
+                parser_config = {
+                    "type": param_type,
+                    "default": param_default_value,
+                    "metavar": param_type.__name__.upper(),
+                    "help": f"(default: {repr(param_default_value)}) {param_help}".strip()
+                }
+            else:
+                parser_config = {
+                    "type": param_type,
+                    "required": True,
+                    "metavar": param_type.__name__.upper(),
+                    "help": param_help.strip()
+                }
+        obj._clibind_callable_args_to_parser_configs[param.name] = parser_config
+
+
+def _get_obj_identifier(obj: Any) -> str:
+    """Generates a fully qualified identifier string for a class or function."""
+    return f"{obj.__module__}.{obj.__qualname__}"
+
+
+def _get_parser_flag(parser_arg: str) -> str:
+    """Transforms a snake_case argument name into a standard CLI double-dash flag style."""
+    return "--" + parser_arg.replace("_", "-")
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod(verbose=True)

clibind-0.0.1/src/clibind.egg-info/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: clibind
+Version: 0.0.1
+Summary: Bridge an argument parser and python callables seamlessly.
+Author: r8763754383405076
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# The "clibind" Package
+
+## Introduction
+
+The `clibind` package provides comprehensive utilities that link CLI arguments from an `argparse.ArgumentParser` directly to Python callables (functions or classes). The core operational steps include:
+1. Automatically configuring an argument parser based on the parameter signatures of a callable.
+2. Building a valid keyword arguments (`kwargs`) dictionary from parsed CLI inputs to dynamically execute the target callable.
+
+---
+
+## Preparation
+
+To ensure `clibind` correctly parses parameter definitions, each tracked argument in your callable must meet at least one of the following criteria:
+- Be assigned a explicit default value (other than `None`).
+- Have an explicit Python type annotation.
+
+### Supported Types
+Currently, only the following core primitives are supported:
+- `int`
+- `float`
+- `bool`
+- `str`
+
+*(Note: `Optional[T]` or `T | None` definitions are perfectly supported for the primitive types above).*
+
+### Basic Decorator Configuration
+Wrap your target callable object using the `@setup_clibind()` decorator. `setup_clibind` accepts two optional parameters:
+- **`help_messages`** *(dict[str, str])*: Map explicit argument names to terminal help string messages.
+- **`ignore_patterns`** *(list[str])*: Regex patterns matching arguments that should be skipped by the parser generator. By default, `"self"`, `"cls"`, and any variable names ending with an underscore (`_`) are automatically filtered out.
+
+---
+
+## Important Constraints
+
+When designing your callables for `clibind`, keep the following intentional design constraints in mind:
+
+1. **Parameter Name Collisions**: If you map multiple callables to a single `argparse.ArgumentParser` instance (as shown in the application pattern below), you must ensure that their parameter names do not collide. Registering overlapping argument names to the same parser instance will cause `argparse` to raise an `ArgumentError`. It is the user's responsibility to maintain unique parameter names across combined callables.
+2. **Mandatory Boolean Arguments**: Any parameter annotated with the `bool` type that lacks an explicit default value will automatically default to `False` and configure the parser with `action='store_true'`. This design choice ensures seamless integration with standard CLI toggle mechanics. If a strictly required boolean choice is needed, handle it via alternative validation or explicit defaults.
+
+---
+
+## Usage Workflow
+
+- **`setup_clibind`**: Attaches internal tracking metadata and analyzes target function/method definitions. If a class object is decorated, its `__init__` constructor method is evaluated.
+- **`callable_to_parser`**: Registers tracked arguments safely onto a provided `argparse.ArgumentParser` instance.
+- **`parser_to_callable`**: Extracts the structured keyword arguments (`kwargs`) matching the component signatures from the parsed execution context.
+
+---
+
+## Example
+
+```python
+import argparse
+import typing
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+@setup_clibind(
+    help_messages={
+        "var_1": "help message for var_1",
+        "var_a": "help message for var_a",
+        "var_f": "help message for var_f"
+    }
+)
+class TargetClass:
+    def __init__(
+        self,
+        var_to_skip_1_: list,
+        var_to_skip_2_: list,
+        var_1: int,
+        var_2: float,
+        var_3: str,
+        var_a=1,
+        var_b=1.1,
+        var_c="",
+        var_d1: int | None = None,
+        var_d2: typing.Optional[int] = None,
+        var_e=True,
+        var_f=False,
+        var_to_skip_3_=""
+    ):
+        pass
+
+# Initialize parser instance
+parser = argparse.ArgumentParser()
+callable_to_parser(obj=TargetClass, parser=parser)
+
+# View generated help documentation
+parser.print_help()
+```
+
+## Generated Layout
+
+```
+usage: main.py [-h] --var-1 INT --var-2 FLOAT --var-3 STR
+                       [--var-a INT] [--var-b FLOAT] [--var-c STR]
+                       [--var-d1 INT] [--var-d2 INT] [--var-e-toggle]
+                       [--var-f-toggle]
+
+options:
+  -h, --help           show this help message and exit
+
+arguments for "__main__.TargetClass":
+  --var-1 INT          help message for var_1
+  --var-2 FLOAT
+  --var-3 STR
+  --var-a INT          (default: 1) help message for var_a
+  --var-b FLOAT        (default: 1.1)
+  --var-c STR          (default: '')
+  --var-d1 INT         (default: None)
+  --var-d2 INT         (default: None)
+  --var-e-toggle       (default: True)
+  --var-f-toggle       (default: False) help message for var_f
+```
+
+## Production / Application Pattern
+
+In extensive systems (such as machine learning training pipelines), this architecture cleans up modular execution flows:
+
+```python
+# main.py
+import argparse
+import experiments.train
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers()
+
+    parser_train = subparsers.add_parser("train")
+    experiments.train.setup(parser_train)
+    parser_train.set_defaults(func=experiments.train.handle)
+
+
+# experiments/train.py
+from clibind import setup_clibind, callable_to_parser, parser_to_callable
+
+def setup(parser):
+    callable_to_parser(read_data, parser)
+    callable_to_parser(run, parser)
+
+def handle(args):
+    data_reader_args = parser_to_callable(args, read_data)
+    run_args = parser_to_callable(args, run)
+    
+    # Safely forward mapped variables 
+    run(data_reader_args_=data_reader_args, **run_args)
+
+@setup_clibind()
+def run(data_reader_args_: dict, epochs: int = 10):
+    train_ds, val_ds = read_data(**data_reader_args_)
+    # Train execution logic...
+
+@setup_clibind()
+def read_data(dataset_dir: str):
+    # Data extraction logic...
+    pass
+```

clibind-0.0.1/src/clibind.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/clibind/__init__.py
+src/clibind/core.py
+src/clibind.egg-info/PKG-INFO
+src/clibind.egg-info/SOURCES.txt
+src/clibind.egg-info/dependency_links.txt
+src/clibind.egg-info/top_level.txt

clibind-0.0.1/src/clibind.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clibind-0.0.1/src/clibind.egg-info/top_level.txt

@@ -0,0 +1 @@
+clibind