argbind-dbraun 0.5.2__tar.gz

argbind_dbraun-0.5.2/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020, Prem Seetharaman
+Copyright (c) 2024-2026, David Braun (fork maintainer)
+
+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.

argbind_dbraun-0.5.2/PKG-INFO

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: argbind-dbraun
+Version: 0.5.2
+Summary: Simple way to bind function arguments to the command line. An extended fork of pseeth/argbind with new features (imported as `argbind`).
+Author-email: Prem Seetharaman <prem@descript.com>
+Maintainer-email: David Braun <braun@ccrma.stanford.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/DBraun/argbind/
+Project-URL: Repository, https://github.com/DBraun/argbind/
+Project-URL: Original project, https://github.com/pseeth/argbind/
+Keywords: command-line,configuration,yaml,argument,parsing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pyyaml
+Requires-Dist: docstring-parser
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Dynamic: license-file
+
+# ArgBind
+
+**Build CLIs via docstrings and type annotations, with YAML support.**
+
+[![Tests](https://github.com/DBraun/argbind/actions/workflows/tests.yml/badge.svg)](https://github.com/DBraun/argbind/actions/workflows/tests.yml)
+[![PyPI version](https://badge.fury.io/py/argbind-dbraun.svg)](https://pypi.org/project/argbind-dbraun/)
+[![Python versions](https://img.shields.io/pypi/pyversions/argbind-dbraun)](https://pypi.org/project/argbind-dbraun/)
+[![Downloads](https://static.pepy.tech/badge/argbind-dbraun)](https://pepy.tech/project/argbind-dbraun)
+
+> **Note:** This is an extended fork of [pseeth/argbind](https://github.com/pseeth/argbind) that
+> adds new features — modern type annotations (PEP 585/604), `Literal` and flexible boolean
+> handling, dataclass `default_factory`, and YAML `$include` — published on PyPI as
+> [`argbind-dbraun`](https://pypi.org/project/argbind-dbraun/). The import name is unchanged
+> (`import argbind`), so it remains a drop-in replacement.
+
+*ArgBind is a simple way to bind function or class arguments to the command line or to .yml files!*
+It supports scoping of arguments, similar to other frameworks like
+[Hydra](https://github.com/facebookresearch/hydra) and
+[gin-config](https://github.com/google/gin-config).
+ArgBind is *very* small (only ~800 lines of code, in one file), can be used to make complex and well-documented command line programs, and allows
+you to configure program execution from .yml files.
+
+If you're migrating from an ArgParse script to an ArgBind script, check out the
+[migration guide](./examples/migration). Scroll down to see some [examples](#examples). Please also look at the
+current known [limitations](#limitations-and-known-issues) of ArgBind.
+
+## Why ArgBind?
+
+ArgBind was written by [Prem Seetharaman](https://github.com/pseeth) to help configure machine
+learning experiments. ML experiment configuration is often highly nested, and can get out of hand
+quickly. Rather than switching workflows around too much to accommodate a new framework, the goal
+was to make already-written scripts easily adaptable, to achieve a few things:
+
+1. Configure scripts using `.yml` files. Be able to save `.yml` files that can be used to rerun scripts the exact same way twice.
+2. Spend time writing actual functions needed to run experiments, not argument parsers.
+3. Be able to run experiment code from other Python scripts, notebooks, or the command line.
+4. Be able to specify arguments from the command line directly to various functions.
+5. Be able to use scoping patterns, so a function can run inside a `train` scope and `test` scope, with different results (e.g., for getting a train dataset and a test dataset).
+
+Nothing out there really fit the bill, so Prem wrote ArgBind. If you have
+an `argparse` based script, converting it to ArgBind should be very quick! ArgBind is simple,
+small, and easy to use. To get a feel for how it works, check out [usage](#usage), [design](#design), and [examples](#examples)!
+
+## Installation
+
+Install via `pip`:
+
+```
+python -m pip install argbind-dbraun
+```
+
+Or from source:
+
+```
+git clone https://github.com/DBraun/argbind.git
+cd argbind
+python -m pip install -e .
+```
+
+This project uses [uv](https://docs.astral.sh/uv/). To create a dev environment with the
+test dependencies and run the suite:
+
+```
+uv sync --extra tests
+uv run pytest
+```
+
+Install the [pre-commit](https://pre-commit.com/) hooks (ruff format + lint) so they run
+on every commit:
+
+```
+uvx pre-commit install
+```
+
+## Examples
+
+- [Example 1: Hello World](./examples/hello_world/)
+- [Example 2: Scope patterns](./examples/scoping/)
+- [Example 3: Typing](./examples/typing/)
+- [Example 4: Modern type annotations (PEP 585/604)](./examples/modern_typing)
+- [Example 5: Literal arguments](./examples/literal)
+- [Example 6: Flexible boolean syntax](./examples/booleans)
+- [Example 7: Using default_factory with dataclasses](./examples/default_factory)
+- [Example 8: Loading, saving, and using .yml files](./examples/yaml)
+- [Example 9: Nested .yml files with `$include`](./examples/nested_yaml)
+- [Example 10: Multi-stage programs](./examples/multistage)
+- [Example 11: Mimic more traditional CLI, without `func.arg` notation](./examples/without_prefix)
+- [Example 12: Debug mode](./examples/debug)
+- [Example 13: Migrating from ArgParse](./examples/migration)
+- [Example 14: Binding existing functions and classes](./examples/bind_existing)
+- [Example 15: Binding functions to specific groups](./examples/groups)
+
+## Usage
+
+There are six main functions.
+
+- `bind`: Binds keyword arguments (and positional arguments if `positional=True`) of a function or class to ArgBind.
+- `parse_args`: Actually parses command line arguments into a dictionary.
+- `scope`: Context manager that scopes a dictionary containing function arguments to be used by the functions.
+- `dump_args`: Dumps the args dictionary to a `.yml` file. Used internally when program is called with `--args.save path/to/save.yml`.
+- `load_args`: Loads args from a `.yml` file. Used internally when program is called with `--args.load path/to/load.yml`.
+- `get_used_args`: Gets arguments that have actually been used by call functions up to this point.
+
+Your code with ArgBind generally follows this pattern:
+
+1. Write a function with a good docstring, and typed arguments. If arguments are not typed, their type will be inferred from the type of the default.
+2. Bind it via `bind`.
+3. When program is called, parse the arguments via `parse_args`.
+4. Scope the arguments, and call the bound function within the context block.
+5. Optionally call program with `--args.save` to save the current execution configuration to a `.yml` file or `--args.load` to load arguments from a prior saved execution configuration to run it the same way twice.
+6. Optionally, run your script with `--args.debug=1` to see exactly how every bound function is called.
+
+In your program, you can call `get_used_args` to see which arguments were actually used. Here's a minimal example:
+
+```python
+import argbind
+
+@argbind.bind()
+def hello(
+    name : str = 'world'
+):
+    """Say hello to someone.
+
+    Parameters
+    ----------
+    name : str, optional
+        Who you're saying hello to, by default 'world'
+    """
+    print("Hello " + name)
+
+if __name__ == "__main__":
+    # Arguments for CLI automatically generated from bound functions under the pattern
+    # function_name.function_arg.
+    args = argbind.parse_args()
+    # When called within a scope, the keyword arguments map to those from CLI or
+    # from defaults.
+    with argbind.scope(args):
+        hello()
+    # get_used_args() returns the arguments that were actually used by the bound
+    # functions that ran -- here, {'hello.name': 'world'}.
+    print(argbind.get_used_args())
+```
+
+Help text is automatically generated from the docstring:
+
+```
+❯ python examples/hello_world/with_argbind.py -h
+usage: with_argbind.py [-h] [--args.save ARGS.SAVE] [--args.load ARGS.LOAD] [--args.debug ARGS.DEBUG] [--hello.name HELLO.NAME]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --args.save ARGS.SAVE
+                        Path to save all arguments used to run script to.
+  --args.load ARGS.LOAD
+                        Path to load arguments from, stored as a .yml file.
+  --args.debug ARGS.DEBUG
+                        Print arguments as they are passed to each function.
+
+Generated arguments for function hello:
+  Say hello to someone.
+
+  --hello.name HELLO.NAME
+                        Who you're saying hello to, by default 'world'
+```
+
+Execution of this could look like:
+
+```
+# Default arguments
+❯ python examples/hello_world/with_argbind.py
+Hello world
+# Binding name from the command line and saving the args.
+❯ python examples/hello_world/with_argbind.py --hello.name=you --args.save=/tmp/args.yml
+Hello you
+# Loading saved arguments.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml
+Hello you
+# Loading saved arguments, and overriding via command line.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --hello.name=me
+Hello me
+# See how each function is called with args.debug=1.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --args.debug=1
+hello(
+  name : str = you
+)
+Hello you
+```
+
+You can also run the `hello` function from another Python script or a Jupyter notebook:
+
+```python
+import argbind
+# Import the bound function
+from .hello_world import hello
+# Load the args
+args = argbind.load_args('/tmp/args.yml')
+# Scope the args
+with argbind.scope(args):
+    # Run the bound function
+    hello() # Prints 'Hello you'.
+hello() # Prints 'Hello world', as it's outside scope.
+# Can edit the args before scoping again.
+args['hello.name'] = 'me'
+with argbind.scope(args):
+    hello() # Prints 'Hello me'.
+```
+
+You'll notice that ArgBind forces you to document and type your
+function arguments, which is always a good idea!
+Please check out the [examples](#examples) for more details!
+
+
+## Design
+
+ArgBind is designed around a decorator that can be used on
+functions the user wants to expose to command line or to a .yml file.
+The arguments to that function are
+then bound to a dictionary. When the function is called,
+each argument is looked up in the dictionary and its
+value is replaced with the corresponding value in the dictionary. The
+dictionary that the function looks for values in is controlled by
+`scope`:
+
+```python
+import argbind
+
+@argbind.bind()
+def func(arg : str = 'default'):
+    print(arg)
+
+dict1 = {
+    'func.arg': 1,
+}
+dict2 = {
+    'func.arg': 2
+}
+
+with argbind.scope(dict1):
+    func() # prints 1
+with argbind.scope(dict2):
+    func() # prints 2
+func(arg=3) # prints 3.
+```
+
+The function arguments are bound to the command line. Continuing the
+simple program from above:
+
+```python
+if __name__ == "__main__":
+    args = argbind.parse_args()
+    with argbind.scope(args):
+        func()
+    with argbind.scope(args):
+        func(arg=3)
+```
+
+You can call this function like so:
+
+```bash
+❯ python examples/readme_example.py --func.arg 5
+1 # Looks up `arg` in dict1
+2 # Looks up `arg` in dict2
+3 # arg is passed in on python call `func(arg=3)`
+5 # Looks up `arg` from command line call `--func.arg 5`
+3 # arg is passed in from two places: `func(arg=3)` and `--func.arg 5`. Former overrides the latter.
+```
+
+The logic here is that arguments that are bound that are closer to the actual function call get priority. From highest priority, to lowest, it goes:
+
+1. Bound explicitly in Python code
+2. Bound via command line
+3. Bound via .yml file
+4. Bound via default for kwarg
+
+You can also use `bind` directly on classes - see [here](./examples/bind_existing).
+
+# Limitations and known issues
+
+There are some limitations to ArgBind, some due to how Python function decorators work,
+and others out of a desire to keep ArgBind's code simple and straightforward.
+
+## Bound function names should be unique
+
+Functions that are bound must be unique, even if they are in different files. The
+function name is resolved in the argument parser only using the immediate name, not
+a path to the function etc.
+
+## Supported docstring formats
+
+ArgBind uses [docstring-parser](https://github.com/rr-/docstring_parser), and so
+the only supported styles are: ReST, Google, and Numpydoc-style docstrings.
+
+## Not all types are supported
+
+ArgBind supports most types that might pop up in your script, but not all. The
+supported types can be seen in the [typing](./examples/typing/) and
+[modern annotations](./examples/modern_typing/) examples.
+
+## Positional arguments should not be saved into .yml files
+
+If a positional argument is saved into a .yml file and loaded via `--args.load`,
+then any positional argument passed in the command line will be overridden. Take
+care not to pass positional arguments via `.yml` files.
+
+# Issues? Questions?
+
+If you've run into some issues with ArgBind, or have some questions, please ask
+via GitHub Issues. Projects like ArgBind are pretty tricky to get right, so there
+may be some edge cases that have been missed.

argbind_dbraun-0.5.2/README.md

@@ -0,0 +1,309 @@
+# ArgBind
+
+**Build CLIs via docstrings and type annotations, with YAML support.**
+
+[![Tests](https://github.com/DBraun/argbind/actions/workflows/tests.yml/badge.svg)](https://github.com/DBraun/argbind/actions/workflows/tests.yml)
+[![PyPI version](https://badge.fury.io/py/argbind-dbraun.svg)](https://pypi.org/project/argbind-dbraun/)
+[![Python versions](https://img.shields.io/pypi/pyversions/argbind-dbraun)](https://pypi.org/project/argbind-dbraun/)
+[![Downloads](https://static.pepy.tech/badge/argbind-dbraun)](https://pepy.tech/project/argbind-dbraun)
+
+> **Note:** This is an extended fork of [pseeth/argbind](https://github.com/pseeth/argbind) that
+> adds new features — modern type annotations (PEP 585/604), `Literal` and flexible boolean
+> handling, dataclass `default_factory`, and YAML `$include` — published on PyPI as
+> [`argbind-dbraun`](https://pypi.org/project/argbind-dbraun/). The import name is unchanged
+> (`import argbind`), so it remains a drop-in replacement.
+
+*ArgBind is a simple way to bind function or class arguments to the command line or to .yml files!*
+It supports scoping of arguments, similar to other frameworks like
+[Hydra](https://github.com/facebookresearch/hydra) and
+[gin-config](https://github.com/google/gin-config).
+ArgBind is *very* small (only ~800 lines of code, in one file), can be used to make complex and well-documented command line programs, and allows
+you to configure program execution from .yml files.
+
+If you're migrating from an ArgParse script to an ArgBind script, check out the
+[migration guide](./examples/migration). Scroll down to see some [examples](#examples). Please also look at the
+current known [limitations](#limitations-and-known-issues) of ArgBind.
+
+## Why ArgBind?
+
+ArgBind was written by [Prem Seetharaman](https://github.com/pseeth) to help configure machine
+learning experiments. ML experiment configuration is often highly nested, and can get out of hand
+quickly. Rather than switching workflows around too much to accommodate a new framework, the goal
+was to make already-written scripts easily adaptable, to achieve a few things:
+
+1. Configure scripts using `.yml` files. Be able to save `.yml` files that can be used to rerun scripts the exact same way twice.
+2. Spend time writing actual functions needed to run experiments, not argument parsers.
+3. Be able to run experiment code from other Python scripts, notebooks, or the command line.
+4. Be able to specify arguments from the command line directly to various functions.
+5. Be able to use scoping patterns, so a function can run inside a `train` scope and `test` scope, with different results (e.g., for getting a train dataset and a test dataset).
+
+Nothing out there really fit the bill, so Prem wrote ArgBind. If you have
+an `argparse` based script, converting it to ArgBind should be very quick! ArgBind is simple,
+small, and easy to use. To get a feel for how it works, check out [usage](#usage), [design](#design), and [examples](#examples)!
+
+## Installation
+
+Install via `pip`:
+
+```
+python -m pip install argbind-dbraun
+```
+
+Or from source:
+
+```
+git clone https://github.com/DBraun/argbind.git
+cd argbind
+python -m pip install -e .
+```
+
+This project uses [uv](https://docs.astral.sh/uv/). To create a dev environment with the
+test dependencies and run the suite:
+
+```
+uv sync --extra tests
+uv run pytest
+```
+
+Install the [pre-commit](https://pre-commit.com/) hooks (ruff format + lint) so they run
+on every commit:
+
+```
+uvx pre-commit install
+```
+
+## Examples
+
+- [Example 1: Hello World](./examples/hello_world/)
+- [Example 2: Scope patterns](./examples/scoping/)
+- [Example 3: Typing](./examples/typing/)
+- [Example 4: Modern type annotations (PEP 585/604)](./examples/modern_typing)
+- [Example 5: Literal arguments](./examples/literal)
+- [Example 6: Flexible boolean syntax](./examples/booleans)
+- [Example 7: Using default_factory with dataclasses](./examples/default_factory)
+- [Example 8: Loading, saving, and using .yml files](./examples/yaml)
+- [Example 9: Nested .yml files with `$include`](./examples/nested_yaml)
+- [Example 10: Multi-stage programs](./examples/multistage)
+- [Example 11: Mimic more traditional CLI, without `func.arg` notation](./examples/without_prefix)
+- [Example 12: Debug mode](./examples/debug)
+- [Example 13: Migrating from ArgParse](./examples/migration)
+- [Example 14: Binding existing functions and classes](./examples/bind_existing)
+- [Example 15: Binding functions to specific groups](./examples/groups)
+
+## Usage
+
+There are six main functions.
+
+- `bind`: Binds keyword arguments (and positional arguments if `positional=True`) of a function or class to ArgBind.
+- `parse_args`: Actually parses command line arguments into a dictionary.
+- `scope`: Context manager that scopes a dictionary containing function arguments to be used by the functions.
+- `dump_args`: Dumps the args dictionary to a `.yml` file. Used internally when program is called with `--args.save path/to/save.yml`.
+- `load_args`: Loads args from a `.yml` file. Used internally when program is called with `--args.load path/to/load.yml`.
+- `get_used_args`: Gets arguments that have actually been used by call functions up to this point.
+
+Your code with ArgBind generally follows this pattern:
+
+1. Write a function with a good docstring, and typed arguments. If arguments are not typed, their type will be inferred from the type of the default.
+2. Bind it via `bind`.
+3. When program is called, parse the arguments via `parse_args`.
+4. Scope the arguments, and call the bound function within the context block.
+5. Optionally call program with `--args.save` to save the current execution configuration to a `.yml` file or `--args.load` to load arguments from a prior saved execution configuration to run it the same way twice.
+6. Optionally, run your script with `--args.debug=1` to see exactly how every bound function is called.
+
+In your program, you can call `get_used_args` to see which arguments were actually used. Here's a minimal example:
+
+```python
+import argbind
+
+@argbind.bind()
+def hello(
+    name : str = 'world'
+):
+    """Say hello to someone.
+
+    Parameters
+    ----------
+    name : str, optional
+        Who you're saying hello to, by default 'world'
+    """
+    print("Hello " + name)
+
+if __name__ == "__main__":
+    # Arguments for CLI automatically generated from bound functions under the pattern
+    # function_name.function_arg.
+    args = argbind.parse_args()
+    # When called within a scope, the keyword arguments map to those from CLI or
+    # from defaults.
+    with argbind.scope(args):
+        hello()
+    # get_used_args() returns the arguments that were actually used by the bound
+    # functions that ran -- here, {'hello.name': 'world'}.
+    print(argbind.get_used_args())
+```
+
+Help text is automatically generated from the docstring:
+
+```
+❯ python examples/hello_world/with_argbind.py -h
+usage: with_argbind.py [-h] [--args.save ARGS.SAVE] [--args.load ARGS.LOAD] [--args.debug ARGS.DEBUG] [--hello.name HELLO.NAME]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --args.save ARGS.SAVE
+                        Path to save all arguments used to run script to.
+  --args.load ARGS.LOAD
+                        Path to load arguments from, stored as a .yml file.
+  --args.debug ARGS.DEBUG
+                        Print arguments as they are passed to each function.
+
+Generated arguments for function hello:
+  Say hello to someone.
+
+  --hello.name HELLO.NAME
+                        Who you're saying hello to, by default 'world'
+```
+
+Execution of this could look like:
+
+```
+# Default arguments
+❯ python examples/hello_world/with_argbind.py
+Hello world
+# Binding name from the command line and saving the args.
+❯ python examples/hello_world/with_argbind.py --hello.name=you --args.save=/tmp/args.yml
+Hello you
+# Loading saved arguments.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml
+Hello you
+# Loading saved arguments, and overriding via command line.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --hello.name=me
+Hello me
+# See how each function is called with args.debug=1.
+❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --args.debug=1
+hello(
+  name : str = you
+)
+Hello you
+```
+
+You can also run the `hello` function from another Python script or a Jupyter notebook:
+
+```python
+import argbind
+# Import the bound function
+from .hello_world import hello
+# Load the args
+args = argbind.load_args('/tmp/args.yml')
+# Scope the args
+with argbind.scope(args):
+    # Run the bound function
+    hello() # Prints 'Hello you'.
+hello() # Prints 'Hello world', as it's outside scope.
+# Can edit the args before scoping again.
+args['hello.name'] = 'me'
+with argbind.scope(args):
+    hello() # Prints 'Hello me'.
+```
+
+You'll notice that ArgBind forces you to document and type your
+function arguments, which is always a good idea!
+Please check out the [examples](#examples) for more details!
+
+
+## Design
+
+ArgBind is designed around a decorator that can be used on
+functions the user wants to expose to command line or to a .yml file.
+The arguments to that function are
+then bound to a dictionary. When the function is called,
+each argument is looked up in the dictionary and its
+value is replaced with the corresponding value in the dictionary. The
+dictionary that the function looks for values in is controlled by
+`scope`:
+
+```python
+import argbind
+
+@argbind.bind()
+def func(arg : str = 'default'):
+    print(arg)
+
+dict1 = {
+    'func.arg': 1,
+}
+dict2 = {
+    'func.arg': 2
+}
+
+with argbind.scope(dict1):
+    func() # prints 1
+with argbind.scope(dict2):
+    func() # prints 2
+func(arg=3) # prints 3.
+```
+
+The function arguments are bound to the command line. Continuing the
+simple program from above:
+
+```python
+if __name__ == "__main__":
+    args = argbind.parse_args()
+    with argbind.scope(args):
+        func()
+    with argbind.scope(args):
+        func(arg=3)
+```
+
+You can call this function like so:
+
+```bash
+❯ python examples/readme_example.py --func.arg 5
+1 # Looks up `arg` in dict1
+2 # Looks up `arg` in dict2
+3 # arg is passed in on python call `func(arg=3)`
+5 # Looks up `arg` from command line call `--func.arg 5`
+3 # arg is passed in from two places: `func(arg=3)` and `--func.arg 5`. Former overrides the latter.
+```
+
+The logic here is that arguments that are bound that are closer to the actual function call get priority. From highest priority, to lowest, it goes:
+
+1. Bound explicitly in Python code
+2. Bound via command line
+3. Bound via .yml file
+4. Bound via default for kwarg
+
+You can also use `bind` directly on classes - see [here](./examples/bind_existing).
+
+# Limitations and known issues
+
+There are some limitations to ArgBind, some due to how Python function decorators work,
+and others out of a desire to keep ArgBind's code simple and straightforward.
+
+## Bound function names should be unique
+
+Functions that are bound must be unique, even if they are in different files. The
+function name is resolved in the argument parser only using the immediate name, not
+a path to the function etc.
+
+## Supported docstring formats
+
+ArgBind uses [docstring-parser](https://github.com/rr-/docstring_parser), and so
+the only supported styles are: ReST, Google, and Numpydoc-style docstrings.
+
+## Not all types are supported
+
+ArgBind supports most types that might pop up in your script, but not all. The
+supported types can be seen in the [typing](./examples/typing/) and
+[modern annotations](./examples/modern_typing/) examples.
+
+## Positional arguments should not be saved into .yml files
+
+If a positional argument is saved into a .yml file and loaded via `--args.load`,
+then any positional argument passed in the command line will be overridden. Take
+care not to pass positional arguments via `.yml` files.
+
+# Issues? Questions?
+
+If you've run into some issues with ArgBind, or have some questions, please ask
+via GitHub Issues. Projects like ArgBind are pretty tricky to get right, so there
+may be some edge cases that have been missed.

argbind_dbraun-0.5.2/argbind/__init__.py

@@ -0,0 +1,21 @@
+from .argbind import (
+    bind,
+    bind_module,
+    build_parser,
+    dump_args,
+    get_used_args,
+    load_args,
+    parse_args,
+    scope,
+)
+
+__all__ = [
+    "bind",
+    "bind_module",
+    "build_parser",
+    "parse_args",
+    "dump_args",
+    "load_args",
+    "get_used_args",
+    "scope",
+]