WIP dev thoughts for cw

[thorwhalen]

To jot down thoughts and research about cw

[thorwhalen]

Enabling CLI Users to Parameterize Function Calls

Background

I have a function that accepts callable parameters:

def func(get_data: Union[str, Callable], process_data: Union[str, Callable]):
    data = get_data()
    return process_data(data)

This function is exposed as a CLI command using argh.dispatch_command(func), where string arguments are resolved to actual functions internally.

Currently, users can invoke it like:

func --get-data key_to_a_data_get_function --process_data key_to_a_process_data_function

The Challenge

I want to enable CLI users to not only specify functions by key, but also to parameterize them using functools.partial.

Example scenario:

• get_data function: def multiple_has(n=1): return "ha" * n
• process_data function: def prefix_it(x, prefix=''): return prefix + x

Desired Python equivalent:

from functools import partial
func(
    get_data=partial(multiple_has, n=2), 
    process_data=partial(prefix_it, prefix="-->")
)

Desired CLI usage:
Something like:

func --get-data {"multiple_has": {"n": 2}} --process_data {"prefix_it": {"prefix": "-->"}}

or:

func --get-data (multiple_has -n 2) --process_data (prefix_it -prefix "-->")

Questions

1. Does argh have built-in support for this kind of function parameterization?

2. Do other Python CLI libraries (like click, fire, typer) provide mechanisms for this?

3. What is the standard or most user-friendly "language" for enabling CLI users to parameterize function calls?

   • Is there an established convention that CLI users would be familiar with?
   • What syntax would be most intuitive and least error-prone?

Implementation Considerations

If no existing solution exists, I'm considering creating a decorator that preprocesses the arguments before passing them to argh.dispatch_command(). The decorator would parse the parameterization syntax and create the appropriate functools.partial objects.

Any insights on established patterns or best practices would be greatly appreciated!

[thorwhalen]

Claude answer (not deep search)

Now let me search for information about CLI parameterization patterns and what the different Python CLI libraries offer:

Let me search more specifically for function parameterization in CLI tools:

Let me search for more specific information about standard CLI parameterization patterns:

Let me search for more specific information about configuration file standards for CLI tools:

Based on my research, I can now provide comprehensive answers to your questions. Let me format the GitHub discussion and answers:

Answers to Your Questions

(1) Does argh have something for this?

No, argh does not have built-in support for function parameterization or functools.partial functionality. Argh is designed to infer everything from function signatures and type annotations, automatically mapping function arguments to CLI arguments. However, it doesn't provide mechanisms for users to pass partial function arguments through the CLI.

(2) Do other packages for python-to-cli have anything for this?

The major Python CLI libraries I researched (click, typer, fire) also do not have built-in support for this specific use case:

• Click: Has sophisticated parameter handling and callbacks for validation/transformation, but no built-in function parameterization support
• Typer: Offers parameter callbacks and various type conversions, but not function parameterization
• Fire: Automatically maps function parameters to CLI arguments but doesn't support partial application

(3) What is the standard "language" to enable users to parameterize inputs?

From my research, there are several established patterns, but JSON is the most common standard for CLI parameterization:

JSON (Most Common)

JSON is widely used for passing complex parameters in CLI tools, especially in cloud and DevOps contexts. Your proposed syntax:

func --get-data '{"multiple_has": {"n": 2}}' --process-data '{"prefix_it": {"prefix": "-->"}}'

This aligns with common patterns like Azure Resource Manager parameter files and various cloud deployment tools.

Alternative Patterns

1. YAML: Popular for configuration files due to human readability, but less common for single CLI arguments
2. TOML: Gaining popularity, especially in Python ecosystem (PEP-518), but more for config files than CLI args
3. Key-value pairs: Some tools use patterns like --param key=value,key2=value2
4. Configuration files: Many CLI tools accept --config-file pointing to JSON/YAML/TOML files

Recommendations

1. Use JSON syntax for your parameterization language - it's the most familiar to CLI users
2. Consider a hybrid approach: Support both inline JSON and config files
3. For your implementation: Create a decorator that:
   • Parses JSON strings in your function resolution logic
   • Creates functools.partial objects as needed
   • Falls back to simple function resolution for non-parameterized cases

Example implementation approach:

def _resolve_callable_with_params(spec: Union[str, dict]) -> Callable:
    """Convert string or dict spec to callable, handling partial application."""
    if isinstance(spec, str):
        # Simple function name
        return registry[spec]
    elif isinstance(spec, dict):
        # {"function_name": {"param1": "value1", "param2": "value2"}}
        func_name, params = next(iter(spec.items()))
        base_func = registry[func_name]
        return partial(base_func, **params)

This approach provides a clean, standard interface that CLI users will recognize from other tools.

[thorwhalen]

Grok (with deep search on) answer

Direct Answer

Key Points:

• It seems likely that argh does not support passing functions with partial applications directly from the CLI.
• Research suggests other Python CLI libraries like click and docopt also lack built-in support for this.
• The evidence leans toward using JSON as a standard way to parametrize functions via CLI, though it's not universally standardized.

Does argh Support This?
argh is great for turning Python functions into CLI commands, but it doesn't seem to handle passing functions as arguments with partial applications. This means you can't directly specify something like partial(multiple_has, n=2) from the command line using argh out of the box.

Do Other CLI Libraries Support This?
Other popular libraries like click, docopt, and typer also don't have built-in features for passing functions with partial applications. They focus on parsing command-line inputs and invoking functions, not handling dynamic function parameterization.

Standard Language for Parametrization?
There's no strict standard, but using JSON to pass function names and parameters (e.g., --get-data '{"func": "multiple_has", "params": {"n": 2}}') is a common and practical approach. It's widely supported, easy to parse, and user-friendly, though you might also see custom string formats like --get-data "multiple_has(n=2)".

---

Survey Note: Detailed Analysis of CLI Function Parametrization

This section provides a comprehensive exploration of enabling partial function application in command-line interfaces (CLIs) using Python libraries, addressing the user's query in depth. We will examine the capabilities of argh and other CLI libraries, and discuss standard practices for parametrizing functions via CLI.

Background and Context

The user has a function func that takes two arguments, get_data and process_data, both of which are functions. They are using argh to create a CLI script via argh.dispatch_command(func), allowing commands like func --get-data key_to_a_data_get_function --process_data key_to_a_process_data_function. The goal is to extend this to allow CLI users to specify partial applications, such as using multiple_has with n=2 or prefix_it with prefix="-->". In Python, this is achieved using functools.partial, and the user seeks to enable similar functionality from the CLI, exploring potential formats like JSON (--get-data {"multiple_has": {"n": 2}}) or custom strings (--get-data (multiple_has -n 2)`).

Analysis of argh Capabilities

argh is a Python library designed to create CLIs from Python functions, leveraging their signatures for simplicity. It supports dispatching functions as commands and handling their arguments, but our investigation into its documentation (Argh: The Effortless CLI) and tutorials (Tutorial — argh 0.31.3 documentation) reveals no direct support for passing functions as arguments with partial applications.

• argh functions like add_commands and dispatch_commands take lists of functions for defining commands, but these are for command registration, not for arguments within commands.
• Decorators like @arg and @expects_obj modify function behavior, but they do not address partial application of passed functions.
• The library focuses on static argument parsing based on function signatures, not dynamic function parameterization.

Thus, it seems likely that argh does not support the user's requirement out of the box, requiring a custom solution.

Survey of Other Python CLI Libraries

We extended our analysis to other popular Python CLI libraries to determine if they offer built-in support for passing functions with partial applications. The libraries examined include click, docopt, and typer, based on their prevalence and documentation.

• Click: A widely used library for creating CLIs, click supports defining commands, options, and arguments using decorators (Click and Python: Build Extensible and Composable CLI Apps). However, it does not have features for passing functions as arguments with partial applications. It focuses on parsing command-line inputs and invoking functions, not handling dynamic function parameterization (Arguments — Click Documentation (8.2.x)).
• Docopt: This library generates CLIs from help messages, returning a dictionary of parsed arguments (docopt creates beautiful command-line interfaces). While flexible for defining usage patterns, it does not support passing functions with partial applications, focusing on static argument parsing (Comparing Python Command-Line Parsing Libraries).
• Typer: Built on click, typer simplifies CLI creation but does not add support for passing functions with partial applications, as seen in its documentation (Build a Command-Line To-Do App With Python and Typer).

Our research suggests that none of these libraries provide built-in support for the user's specific need, reinforcing the need for a custom implementation.

Standard Language for Parametrizing Functions via CLI

Given the lack of built-in support, we explored standard practices for enabling CLI users to parametrize functions, particularly for partial applications. There is no universally standardized "language" for this purpose, but several approaches emerged as practical and common:

• JSON for Structured Data: Using JSON to pass function names and parameters is a standard and practical approach. For example, the CLI command could be:

  func --get-data '{"func": "multiple_has", "params": {"n": 2}}' --process-data '{"func": "prefix_it", "params": {"prefix": "-->"}}'
  

  • In the code, you can parse these JSON strings into dictionaries using Python's json module (JSON in Python) and use functools.partial to create the partially applied functions.
  • JSON is widely supported, human-readable, and easy to parse, making it suitable for CLI parameterization. It is commonly used in CLI tools for configuration, as seen in examples like config file integration with docopt (docopt creates beautiful command-line interfaces).

• Custom String Formats: Another approach is to define a custom string format, such as:

  func --get-data "multiple_has(n=2)" --process-data "prefix_it(prefix='-->')"
  

  • This requires parsing the strings into function calls, which can be done using Python's ast module for safety or a custom parser. However, this approach can be error-prone and less user-friendly compared to JSON, especially for complex parameterizations.

• Separate CLI Arguments for Parameters: You could define separate CLI arguments for each parameter, e.g.:

  func --get-data-func multiple_has --get-data-n 2 --process-data-func prefix_it --process-data-prefix "-->"
  

  • This requires knowing the parameter names in advance and defining them in the CLI interface, which can become cumbersome for functions with many parameters or arbitrary functions.

• Configuration Files: Instead of passing parameters via CLI, you could use configuration files (e.g., JSON, YAML, INI) to store function names and parameters, with the CLI accepting a path to the file. For example:

  func --config path/to/config.json
  

  • This approach is less interactive but can be more manageable for complex setups, as seen in discussions on CLI configuration (Python Command Line Arguments).

Among these, JSON stands out as the most standard and practical "language" due to its widespread use and ease of integration with Python. It allows for structured data passing, aligning with the user's examples like --get-data {"multiple_has": {"n": 2}}, though the exact format may vary based on implementation.

Implementation Considerations

To implement the desired functionality, you can:

• Use argh (or another CLI library) to define your CLI, adding custom arguments for function names and parameters (e.g., --get-data-func and --get-data-params).
• Parse the parameters (e.g., from JSON) and use functools.partial to create the partially applied functions, as described in the documentation (Partial Functions in Python).
• Ensure error handling for invalid function names or parameter formats, leveraging Python's error reporting mechanisms.

This approach allows you to achieve the desired functionality while leveraging standard tools and conventions, addressing the user's need for CLI-based partial function application.

Table: Comparison of CLI Libraries for Function Parametrization

Library	Supports Passing Functions as Arguments	Supports Partial Application	Notes
argh	No	No	Focuses on command dispatching, no dynamic function parameterization.
click	No	No	Supports static arguments, not dynamic function passing.
docopt	No	No	Returns dictionary of arguments, no function parameterization.
typer	No	No	Built on click, similar limitations.

This table summarizes the capabilities of the libraries, highlighting the lack of built-in support for the user's requirement.

Conclusion

In conclusion, neither argh nor other popular Python CLI libraries like click, docopt, and typer provide built-in support for passing functions with partial applications from the CLI. However, you can implement this functionality by using JSON to pass function names and parameters, parsing them in your code, and using functools.partial to create the partially applied functions. This approach leverages a standard and practical method for CLI parameterization, ensuring flexibility and user-friendliness.

---

Key Citations

• Argh The Effortless CLI
• Click and Python Build Extensible CLI Apps
• docopt creates beautiful command-line interfaces
• Build a Command-Line To-Do App With Python and Typer
• Partial Functions in Python
• JSON in Python
• Python Command Line Arguments