av-cli 0.1.0__tar.gz

av_cli-0.1.0/.gitignore

@@ -0,0 +1,34 @@
+# GitHub Actions config secrets
+.github/config-*.json
+
+# Editor / IDE
+.gemini
+.vscode
+
+# OS
+*.DS_Store
+
+# Environment
+.venv
+.env
+.env.bak
+.env*
+
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# AWS SAM build artifacts
+.aws-sam/
+
+# Dev docs
+dev_docs
+
+# Generated / local files
+requirements.txt
+sessions.db
+mcp.json

av_cli-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: av-cli
+Version: 0.1.0
+Summary: CLI wrapper for Alpha Vantage APIs
+Requires-Python: >=3.10
+Requires-Dist: av-api
+Requires-Dist: click
+Requires-Dist: httpx
+Requires-Dist: loguru

av_cli-0.1.0/README.md

@@ -0,0 +1,15 @@
+# av-cli
+
+CLI wrapper for Alpha Vantage APIs.
+
+## Install
+
+```
+pip install av-cli
+```
+
+## Usage
+
+```
+av-cli --version
+```

av_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "av-cli"
+version = "0.1.0"
+description = "CLI wrapper for Alpha Vantage APIs"
+requires-python = ">=3.10"
+dependencies = [
+    "av-api",
+    "click",
+    "httpx",
+    "loguru",
+]
+
+[project.scripts]
+av-cli = "av_cli.main:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/av_cli"]
+
+[tool.uv.sources]
+av-api = { workspace = true }

av_cli-0.1.0/src/av_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

av_cli-0.1.0/src/av_cli/main.py

@@ -0,0 +1,147 @@
+import inspect
+import json
+import os
+import sys
+from typing import Union, get_type_hints
+
+import click
+
+from av_cli import __version__
+
+
+def _python_type_to_click(param_type):
+    """Map a Python type hint to a Click type."""
+    if param_type == bool or param_type == 'bool':
+        return bool
+    if param_type == int or param_type == 'int':
+        return click.INT
+    if param_type == float or param_type == 'float':
+        return click.FLOAT
+    # Handle Optional[X]
+    if hasattr(param_type, '__origin__') and param_type.__origin__ is Union:
+        args = param_type.__args__
+        if len(args) == 2 and type(None) in args:
+            inner = args[0] if args[1] is type(None) else args[1]
+            return _python_type_to_click(inner)
+    return click.STRING
+
+
+def _make_tool_command(func, tool_name):
+    """Build a Click command for a single tool function."""
+    from av_api.registry import extract_description
+
+    sig = inspect.signature(func)
+    try:
+        hints = get_type_hints(func)
+    except Exception:
+        hints = {}
+
+    # Build short option flags, skipping conflicts with -h (help)
+    used_shorts = {'h'}
+    short_map = {}
+    for pname in sig.parameters:
+        for ch in pname.lower():
+            if ch.isalpha() and ch not in used_shorts:
+                used_shorts.add(ch)
+                short_map[pname] = f'-{ch}'
+                break
+
+    params = []
+    for pname, param in sig.parameters.items():
+        ptype = hints.get(pname, str)
+        click_type = _python_type_to_click(ptype)
+        short = short_map.get(pname)
+
+        if click_type is bool:
+            params.append(
+                click.Option(
+                    [f'--{pname}/--no-{pname}'],
+                    default=param.default if param.default is not inspect.Parameter.empty else False,
+                    help=f'{pname} flag',
+                )
+            )
+        else:
+            required = param.default is inspect.Parameter.empty
+            decls = [f'--{pname}']
+            if short:
+                decls.append(short)
+            params.append(
+                click.Option(
+                    decls,
+                    type=click_type,
+                    required=required,
+                    default=None if required else param.default,
+                    help=pname,
+                )
+            )
+
+    def callback(**kwargs):
+        from av_api.context import set_api_key
+
+        ctx = click.get_current_context()
+        api_key = ctx.obj.get('api_key') or os.getenv('ALPHA_VANTAGE_API_KEY')
+        if not api_key:
+            click.echo('Error: API key required. Use --api-key or set ALPHA_VANTAGE_API_KEY.', err=True)
+            sys.exit(1)
+
+        set_api_key(api_key)
+        result = func(**kwargs)
+
+        if isinstance(result, str):
+            click.echo(result)
+        else:
+            click.echo(json.dumps(result, indent=2, default=str))
+
+    cmd = click.Command(
+        name=tool_name,
+        callback=callback,
+        params=params,
+        help=extract_description(func),
+    )
+    return cmd
+
+
+class ToolGroup(click.Group):
+    """Click group that lazily loads tool commands from the registry."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._tools_loaded = False
+
+    def _load_tools(self):
+        if self._tools_loaded:
+            return
+        self._tools_loaded = True
+
+        from av_api.registry import _all_tools_registry, ensure_tools_loaded
+
+        ensure_tools_loaded()
+
+        for func in _all_tools_registry:
+            name = func.__name__
+            cmd = _make_tool_command(func, name)
+            self.add_command(cmd)
+
+    def list_commands(self, ctx):
+        self._load_tools()
+        return super().list_commands(ctx)
+
+    def get_command(self, ctx, cmd_name):
+        self._load_tools()
+        return super().get_command(ctx, cmd_name.lower())
+
+
+@click.group(cls=ToolGroup, context_settings=dict(help_option_names=['-h', '--help']))
+@click.version_option(version=__version__, prog_name="av-cli")
+@click.option('--api-key', '-k', envvar='ALPHA_VANTAGE_API_KEY', help='Alpha Vantage API key')
+@click.option('--verbose', '-v', is_flag=True, help='Enable verbose logging')
+@click.pass_context
+def cli(ctx, api_key, verbose):
+    """Alpha Vantage CLI - direct access to all Alpha Vantage API tools."""
+    ctx.ensure_object(dict)
+    ctx.obj['api_key'] = api_key
+    ctx.obj['verbose'] = verbose
+
+
+if __name__ == "__main__":
+    cli()