emquant-cli 0.1.0__tar.gz

emquant_cli-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+
+# Tool caches
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+
+# OS / editor
+.DS_Store
+.idea/
+.vscode/
+
+# EmQuant API local login artifact
+src/emq/vendor/emquantapi/python3/libs/mac/logininfo.log
+src/emq/vendor/emquantapi/python3/libs/mac/config.e

emquant_cli-0.1.0/ARCHITECHTURE.md

@@ -0,0 +1,47 @@
+# EMQ CLI Architecture Map
+
+## Overview
+
+The CLI is structured by business domains and a shared core layer:
+
+- `src/emq/cli.py`: root command and global options.
+- `src/emq/commands/*`: domain command handlers (`auth`, `market`, `portfolio`, `quota`, `raw`).
+- `src/emq/core/*`: common runtime services.
+- `src/emq/vendor/emquantapi/python3`: vendored EmQuant SDK and native libraries.
+
+## Core Modules
+
+- `config.py`: constants, env names, vendor paths.
+- `emquant_loader.py`: dynamic import + native library path patching.
+- `session.py`: login lifecycle and auto-login.
+- `state.py`: local credential state persistence.
+- `normalize.py`: convert `EmQuantData` into row-based data.
+- `output.py`: envelope creation + `json/table/csv` rendering.
+- `errors.py`: domain exceptions and exit codes.
+- `logging.py`: CLI logging initialization.
+
+## Command Flow
+
+1. Root callback parses global options (`--output`, logging, auto-login).
+2. Domain command validates inputs and invokes core session.
+3. Loader returns EmQuant client from vendored SDK.
+4. SDK result is normalized into row records.
+5. Output layer renders the unified envelope in selected format.
+
+## Session Model
+
+1. `auth login` logs in and stores credentials in `~/.emq/state.json`.
+2. Business commands call `ensure_login()` to auto-login if needed.
+3. `auth logout` calls `stop()` and clears local state.
+4. `auth status` supports local-only and remote probe modes.
+
+## Data and Error Model
+
+All commands emit:
+
+- `success`: boolean
+- `error`: `{code,message,source}` or `null`
+- `meta`: command metadata + row count
+- `data`: row records
+
+Errors from SDK (`ErrorCode != 0`) are mapped to `source=emquant`.

emquant_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 emq-cli contributors
+
+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.

emquant_cli-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: emquant-cli
+Version: 0.1.0
+Summary: Command-line client for EmQuantAPI with bundled runtime libraries.
+Author: emquant-cli maintainers
+License: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: typer<1.0.0,>=0.16.0
+Description-Content-Type: text/markdown
+
+# emquant-cli
+
+`emquant-cli` provides the `emquant` command-line client for EmQuantAPI with bundled runtime
+libraries.
+
+## Requirements
+
+- Python 3.10+
+
+## Platform Support
+
+- macOS: `x86_64`, `arm64` (universal wheel)
+- Linux: `x86_64` only
+- Windows: `amd64` only
+
+Linux `arm64/aarch64` is not supported by the vendored EmQuant Linux SDK at this time.
+
+## Quick Start
+
+```bash
+pip install emquant-cli
+emquant --help
+```
+
+Login once (credentials from flags or env):
+
+```bash
+export EMQ_USER='your_user'
+export EMQ_PASS='your_pass'
+emquant auth login
+```
+
+Sample exec query:
+
+```bash
+emquant exec csd 000001.SZ CLOSE --start 2025-01-01 --end 2025-12-31 --output csv
+```
+
+## Command Domains
+
+- `auth`: `login`, `logout`, `status`
+- `quota`: `usage`
+- `exec`: `css`, `csd`
+
+The CLI is intentionally small and focused on authentication, quota checks, and direct
+EmQuant execution commands.
+
+## Output
+
+Every command uses a unified envelope and supports:
+
+- `--output json` (default)
+- `--output csv`
+
+`--output` can be placed either before the domain command (global) or at the end of leaf commands (override).  
+If both are provided, the leaf command `--output` takes precedence.
+
+## Credential Persistence
+
+- `auth login` saves credentials to `~/.emq/state.json` (plain text, initial version).
+- Business commands auto-login from saved state or environment variables.
+- `auth logout` clears local state and calls SDK logout.
+
+## Development
+
+```bash
+uv run ruff check .
+uv run mypy src
+uv run pytest
+```
+
+## Notes
+
+- The vendored SDK lives in `src/emq/vendor/emquantapi/python3`.
+- Root `EMQuantAPI_Python` should not be kept after migration.

emquant_cli-0.1.0/README.md

@@ -0,0 +1,75 @@
+# emquant-cli
+
+`emquant-cli` provides the `emquant` command-line client for EmQuantAPI with bundled runtime
+libraries.
+
+## Requirements
+
+- Python 3.10+
+
+## Platform Support
+
+- macOS: `x86_64`, `arm64` (universal wheel)
+- Linux: `x86_64` only
+- Windows: `amd64` only
+
+Linux `arm64/aarch64` is not supported by the vendored EmQuant Linux SDK at this time.
+
+## Quick Start
+
+```bash
+pip install emquant-cli
+emquant --help
+```
+
+Login once (credentials from flags or env):
+
+```bash
+export EMQ_USER='your_user'
+export EMQ_PASS='your_pass'
+emquant auth login
+```
+
+Sample exec query:
+
+```bash
+emquant exec csd 000001.SZ CLOSE --start 2025-01-01 --end 2025-12-31 --output csv
+```
+
+## Command Domains
+
+- `auth`: `login`, `logout`, `status`
+- `quota`: `usage`
+- `exec`: `css`, `csd`
+
+The CLI is intentionally small and focused on authentication, quota checks, and direct
+EmQuant execution commands.
+
+## Output
+
+Every command uses a unified envelope and supports:
+
+- `--output json` (default)
+- `--output csv`
+
+`--output` can be placed either before the domain command (global) or at the end of leaf commands (override).  
+If both are provided, the leaf command `--output` takes precedence.
+
+## Credential Persistence
+
+- `auth login` saves credentials to `~/.emq/state.json` (plain text, initial version).
+- Business commands auto-login from saved state or environment variables.
+- `auth logout` clears local state and calls SDK logout.
+
+## Development
+
+```bash
+uv run ruff check .
+uv run mypy src
+uv run pytest
+```
+
+## Notes
+
+- The vendored SDK lives in `src/emq/vendor/emquantapi/python3`.
+- Root `EMQuantAPI_Python` should not be kept after migration.

emquant_cli-0.1.0/pyproject.toml

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["hatchling>=1.24.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "emquant-cli"
+version = "0.1.0"
+description = "Command-line client for EmQuantAPI with bundled runtime libraries."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "emquant-cli maintainers" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+  "typer>=0.16.0,<1.0.0",
+]
+
+[project.scripts]
+emquant = "emq.cli:main"
+
+[dependency-groups]
+dev = [
+  "coverage[toml]>=7.8.0,<8.0.0",
+  "mypy>=1.15.0,<2.0.0",
+  "pytest>=8.3.0,<9.0.0",
+  "ruff>=0.11.0,<0.12.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+extend-exclude = ["EMQuantAPI_Python", "src/emq/vendor"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+mypy_path = ["src"]
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+check_untyped_defs = true
+strict_equality = true
+exclude = "(^src/emq/vendor/|^EMQuantAPI_Python/)"
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/emq"]
+[tool.hatch.build]
+include = [
+  "src/emq/**",
+  "README.md",
+  "ARCHITECHTURE.md",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/emq",
+  "tests",
+  "README.md",
+  "ARCHITECHTURE.md",
+]

emquant_cli-0.1.0/src/emq/__init__.py

@@ -0,0 +1 @@
+"""emq package."""

emquant_cli-0.1.0/src/emq/__main__.py

@@ -0,0 +1,4 @@
+from emq.cli import main
+
+if __name__ == "__main__":
+    main()

emquant_cli-0.1.0/src/emq/cli.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import typer
+
+from emq.commands._common import normalize_output
+from emq.commands.auth import app as auth_app
+from emq.commands.quota import app as quota_app
+from emq.commands.raw import public_app as exec_app
+from emq.core.logging import setup_logging
+
+app = typer.Typer(
+    name="emquant",
+    help="EmQuant command line interface.",
+    add_completion=False,
+)
+
+app.add_typer(auth_app, name="auth")
+app.add_typer(quota_app, name="quota")
+app.add_typer(exec_app, name="exec")
+
+
+@app.callback()
+def callback(
+    ctx: typer.Context,
+    output: str = typer.Option("json", "--output", help="Output format: json|csv."),
+    log_level: str = typer.Option("INFO", "--log-level", help="Log level."),
+    log_file: str | None = typer.Option(None, "--log-file", help="Optional log file path."),
+    no_auto_login: bool = typer.Option(False, "--no-auto-login", help="Disable automatic login."),
+) -> None:
+    setup_logging(log_level, log_file)
+    fmt = normalize_output(output)
+
+    ctx.ensure_object(dict)
+    ctx.obj["output"] = fmt
+    ctx.obj["no_auto_login"] = no_auto_login
+
+
+def main() -> None:
+    app()

emquant_cli-0.1.0/src/emq/commands/_common.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from ctypes import ArgumentError
+from typing import Any
+
+import typer
+
+from emq.core.errors import EmqCliError
+from emq.core.normalize import normalize_emquant_data
+from emq.core.output import build_envelope, emit
+from emq.core.platform_support import ensure_sdk_runtime_supported
+from emq.core.session import stop_active_session
+from emq.types import ErrorInfo
+
+
+def normalize_output(value: str) -> str:
+    fmt = value.lower().strip()
+    if fmt not in {"json", "csv"}:
+        raise typer.BadParameter("--output must be one of: json, csv")
+    return fmt
+
+
+def apply_output_override(ctx: typer.Context, output_override: str | None) -> None:
+    if output_override is None:
+        return
+    ctx.ensure_object(dict)
+    ctx.obj["output"] = normalize_output(output_override)
+
+
+def get_global_output(ctx: typer.Context) -> str:
+    obj = ctx.obj or {}
+    return str(obj.get("output", "json"))
+
+
+def get_no_auto_login(ctx: typer.Context) -> bool:
+    obj = ctx.obj or {}
+    return bool(obj.get("no_auto_login", False))
+
+
+def emit_success(
+    ctx: typer.Context,
+    *,
+    command: str,
+    rows: list[dict[str, Any]],
+    meta: dict[str, Any] | None = None,
+) -> None:
+    output = get_global_output(ctx)
+    envelope = build_envelope(command=command, data=rows, output=output, meta=meta)
+    emit(envelope, output)
+
+
+def emit_error(ctx: typer.Context, *, command: str, error: EmqCliError) -> None:
+    output = get_global_output(ctx)
+    envelope = build_envelope(
+        command=command,
+        data=[],
+        output=output,
+        error=ErrorInfo(code=error.code, message=error.message, source=error.source),
+    )
+    emit(envelope, output)
+    raise typer.Exit(code=error.exit_code)
+
+
+def execute_sdk_command(
+    ctx: typer.Context,
+    *,
+    command: str,
+    fn: Callable[[], Any],
+) -> None:
+    try:
+        ensure_sdk_runtime_supported()
+        result = fn()
+        if hasattr(result, "ErrorCode") and int(result.ErrorCode) != 0:
+            raise EmqCliError(
+                str(getattr(result, "ErrorMsg", "EmQuant API error")),
+                code=int(result.ErrorCode),
+                source="emquant",
+                exit_code=3,
+            )
+
+        if hasattr(result, "Data"):
+            rows, meta = normalize_emquant_data(result)
+            emit_success(ctx, command=command, rows=rows, meta=meta)
+        elif isinstance(result, dict):
+            emit_success(ctx, command=command, rows=[result], meta={"row_count": 1})
+        elif isinstance(result, list):
+            normalized_rows = [{"value": item} for item in result]
+            emit_success(
+                ctx,
+                command=command,
+                rows=normalized_rows,
+                meta={"row_count": len(result)},
+            )
+        else:
+            emit_success(ctx, command=command, rows=[{"value": result}], meta={"row_count": 1})
+    except (OSError, ImportError) as exc:
+        emit_error(
+            ctx,
+            command=command,
+            error=EmqCliError(
+                f"Failed to load EmQuant native runtime: {exc}",
+                code="EMQUANT_NATIVE_LOAD_ERROR",
+                source="emquant",
+                exit_code=3,
+            ),
+        )
+    except (ArgumentError, TypeError, ValueError) as exc:
+        emit_error(
+            ctx,
+            command=command,
+            error=EmqCliError(
+                f"Invalid arguments for EmQuant command: {exc}",
+                code="EMQUANT_ARGUMENT_ERROR",
+                source="emquant",
+                exit_code=2,
+            ),
+        )
+    except EmqCliError as exc:
+        emit_error(ctx, command=command, error=exc)
+    finally:
+        # The CLI is one-shot. Always stop the SDK session before process exit so
+        # background threads do not linger and crash the interpreter on Linux.
+        stop_active_session()

emquant_cli-0.1.0/src/emq/commands/auth.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import typer
+
+from emq.commands._common import apply_output_override, execute_sdk_command
+from emq.core.session import login, logout, status
+
+app = typer.Typer(help="Authentication commands.")
+
+
+@app.command("login")
+def login_cmd(
+    ctx: typer.Context,
+    user: str | None = typer.Option(None, "--user", help="EMQ username."),
+    password: str | None = typer.Option(None, "--password", help="EMQ password."),
+    force_login: bool = typer.Option(
+        True, "--force-login/--no-force-login", help="Set ForceLogin."
+    ),
+    save: bool = typer.Option(True, "--save/--no-save", help="Save credentials to local state."),
+    output: str | None = typer.Option(
+        None, "--output", help="Output format override: json|csv."
+    ),
+) -> None:
+    apply_output_override(ctx, output)
+    execute_sdk_command(
+        ctx,
+        command="auth.login",
+        fn=lambda: login(user=user, password=password, force_login=force_login, save=save),
+    )
+
+
+@app.command("logout")
+def logout_cmd(
+    ctx: typer.Context,
+    output: str | None = typer.Option(
+        None, "--output", help="Output format override: json|csv."
+    ),
+) -> None:
+    apply_output_override(ctx, output)
+    execute_sdk_command(ctx, command="auth.logout", fn=logout)
+
+
+@app.command("status")
+def status_cmd(
+    ctx: typer.Context,
+    check: bool = typer.Option(False, "--check", help="Probe remote API status."),
+    output: str | None = typer.Option(
+        None, "--output", help="Output format override: json|csv."
+    ),
+) -> None:
+    apply_output_override(ctx, output)
+    no_auto_login = bool((ctx.obj or {}).get("no_auto_login", False))
+    execute_sdk_command(
+        ctx,
+        command="auth.status",
+        fn=lambda: status(check=check, no_auto_login=no_auto_login),
+    )

emquant_cli-0.1.0/src/emq/commands/market.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from emq.commands._common import apply_output_override, execute_sdk_command, get_no_auto_login
+from emq.core.emquant_loader import get_emquant_client
+from emq.core.session import ensure_login
+
+app = typer.Typer(help="Market data commands.")
+
+
+@app.command("snapshot")
+def snapshot(
+    ctx: typer.Context,
+    codes: str = typer.Argument(..., help="Codes, comma-separated."),
+    indicators: str = typer.Argument(..., help="Indicators, comma-separated."),
+    options: str = typer.Option("", "--options", help="Raw EmQuant options string."),
+    output: str | None = typer.Option(
+        None, "--output", help="Output format override: json|table|csv."
+    ),
+) -> None:
+    apply_output_override(ctx, output)
+    execute_sdk_command(
+        ctx,
+        command="market.snapshot",
+        fn=lambda: _snapshot(codes, indicators, options, get_no_auto_login(ctx)),
+    )
+
+
+@app.command("series")
+def series(
+    ctx: typer.Context,
+    codes: str = typer.Argument(..., help="Codes, comma-separated."),
+    indicators: str = typer.Argument(..., help="Indicators, comma-separated."),
+    start: str = typer.Option(..., "--start", help="Start date YYYY-MM-DD."),
+    end: str = typer.Option(..., "--end", help="End date YYYY-MM-DD."),
+    options: str = typer.Option("", "--options", help="Raw EmQuant options string."),
+    output: str | None = typer.Option(
+        None, "--output", help="Output format override: json|table|csv."
+    ),
+) -> None:
+    apply_output_override(ctx, output)
+    execute_sdk_command(
+        ctx,
+        command="market.series",
+        fn=lambda: _series(codes, indicators, start, end, options, get_no_auto_login(ctx)),
+    )
+
+
+def _snapshot(codes: str, indicators: str, options: str, no_auto_login: bool) -> Any:
+    ensure_login(no_auto_login=no_auto_login)
+    c = get_emquant_client()
+    return c.css(codes, indicators, options)
+
+
+def _series(
+    codes: str, indicators: str, start: str, end: str, options: str, no_auto_login: bool
+) -> Any:
+    ensure_login(no_auto_login=no_auto_login)
+    c = get_emquant_client()
+    return c.csd(codes, indicators, start, end, options)