scalim-cli 0.8.3__tar.gz

scalim_cli-0.8.3/.gitignore

@@ -0,0 +1,301 @@
+# User Custom
+**/.vscode
+
+# .gitignore file created for free with Tower (https://www.git-tower.com/)
+# For suggestions or improvements please contact us using support@git-tower.com
+# Generated on 2026-03-05
+# Includes: python, npm, pnpm, svelte, react, rust, go
+
+### Universal ###
+# Common files that should be ignored in all projects
+
+# Logs
+*.log
+# Temporary files
+*.tmp
+*~
+
+*.bak
+# Environment files (containing secrets, API keys, credentials)
+.env
+*.env
+.env.*
+
+# Local configuration that shouldn't be shared
+*.local
+
+### Python ###
+# Python compiled files, virtual environments, and cache
+
+**/__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+pypackages/
+build/
+develop-eggs/
+dist/
+downloads/
+
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+
+.installed.cfg
+*.egg
+MANIFEST
+.venv
+env/
+
+venv/
+ENV/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# PyInstaller
+*.manifest
+*.spec
+# Installer logs
+pip-log.txt
+
+pip-delete-this-directory.txt
+# Unit test / coverage reports
+.tox/
+.nox/
+.coverage.*
+
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+
+cover/
+# Translations
+*.mo
+*.pot
+# Django
+
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+# Flask
+instance/
+
+.webassets-cache
+# Scrapy
+.scrapy
+# Sphinx
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+# pyenv
+#.python-version
+
+# pipenv
+#Pipfile.lock
+# poetry
+#poetry.lock
+# pdm
+
+.pdm.toml
+__pypackages__/
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath
+*.sage.py
+# Spyder
+.spyderproject
+.spyproject
+
+# Rope
+.ropeproject
+# Zensical docs
+/site
+# mypy
+
+.mypy_cache/
+.dmypy.json
+dmypy.json
+# Pyre
+.pyre/
+
+# pytype
+.pytype/
+# Cython
+cython_debug/
+# Poetry
+
+poetry.toml
+# ruff
+.ruff_cache/
+# LSP
+pyrightconfig.json
+
+*.sage.py
+.pdm.toml
+profile_default/
+.nox/
+.spyproject
+
+docs/site/
+
+### Npm ###
+# NPM package manager files and directories
+
+# NPM (Node Package Manager)
+node_modules/
+package-lock.json
+.npm/
+.node-gyp/
+
+npm-debug.log*
+.npmrc
+.npm-cache/
+.npm-global/
+.node_repl_history
+
+.env
+npm-shrinkwrap.json
+.npmignore
+.package-lock.json
+npm-debug.log.*
+
+.npm-debug/
+.npm-tmp/
+.npm-tarball/
+node_modules_*
+.npm-init.js
+
+.npm-update-notifier
+.node_modules.ember-try/
+.npm-version
+.node_history
+.v8flags.*
+
+.babel.json
+package.json.bak
+
+### Pnpm ###
+# pnpm package manager specific files
+
+# PNPM
+pnpm-lock.yaml
+pnpm-workspace.yaml
+.pnpm/
+.pnpm-debug.log
+
+.pnpm-store/
+pnpm-lock.yaml.bak
+.pnpmfile.cjs
+node_modules/
+.pnpm-cache/
+
+### Svelte ###
+# svelte specific files
+
+node_modules/
+build/
+.cache/
+*.log
+
+### React ###
+# React build directory and environment files
+
+build/
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.DS_*
+**/*.backup.*
+
+**/*.back.*
+*.sublime*
+psd
+thumb
+sketch
+
+coverage/
+
+### Rust ###
+# rust specific files
+
+/target/
+**/*.rs.bk
+debug/
+target/debug/
+target/release/
+
+### Go ###
+# go specific files
+
+*.exe
+*.test
+# vendor/
+*.out
+go.work
+go.sum
+
+### Project (scalim) ###
+# Bench / profiling outputs (dev-only)
+.benchmarks/memray/
+
+# Local artifacts / CI uploads (not committed)
+.tmp/
+
+# Viz replay artifacts (generated; not committed)
+artifacts/scalim-viz/
+
+# Agent skill build manifests (deprecated)
+artifacts/skills/*.build-manifest.json
+
+# Docs artifacts (generated)
+docs/doc/notebooks/**/*.html
+
+# Keep lockfiles committed (template previously ignored these)
+!pnpm-lock.yaml
+!pnpm-workspace.yaml
+
+# Local openspec sanitization rules
+openspec/sanitize_rules.local.yaml
+
+# vendors clib
+!src/scalim/vendor/yamlx/**/*.so
+
+# VS Code extension workspace (extras/vscode-scalim)
+extras/vscode-scalim/node_modules/
+extras/vscode-scalim/dist/
+extras/vscode-scalim/out/
+extras/vscode-scalim/.vscode-test/
+extras/vscode-scalim/*.vsix
+
+# Keep extension scaffolding tracked (override global ignores)
+!extras/vscode-scalim/.npmrc
+!extras/vscode-scalim/.vscode/
+!extras/vscode-scalim/.vscode/**

scalim_cli-0.8.3/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: scalim-cli
+Version: 0.8.3
+Summary: Command-line tools for scalim
+Author-email: straydragon <straydragonl@foxmail.com>
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: scalim
+Description-Content-Type: text/markdown
+
+# scalim-cli
+
+Standalone command-line utilities for `scalim` (dev/tooling only).
+
+Install:
+
+```bash
+uv tool install scalim-cli
+
+# Run once without installing:
+uvx scalim-cli --help
+```
+
+Usage:
+
+```bash
+scalim-cli --help
+scalim-cli yaml-dsl --help
+```

scalim_cli-0.8.3/README.md

@@ -0,0 +1,19 @@
+# scalim-cli
+
+Standalone command-line utilities for `scalim` (dev/tooling only).
+
+Install:
+
+```bash
+uv tool install scalim-cli
+
+# Run once without installing:
+uvx scalim-cli --help
+```
+
+Usage:
+
+```bash
+scalim-cli --help
+scalim-cli yaml-dsl --help
+```

scalim_cli-0.8.3/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "scalim-cli"
+version = "0.8.3"
+description = "Command-line tools for scalim"
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [{ name = "straydragon", email = "straydragonl@foxmail.com" }]
+classifiers = [
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+dependencies = [
+    "scalim",
+    "jsonschema>=4.0.0",
+]
+
+[project.scripts]
+scalim-cli = "scalim_cli.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+sources = ["src"]

scalim_cli-0.8.3/scalim_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Scalim CLI package (dev tooling)."""
+
+__all__ = ()

scalim_cli-0.8.3/scalim_cli/log.py

@@ -0,0 +1,199 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, Iterable, Iterator, List, Tuple
+
+from scalim.ob.structured_logging import normalize_keys_to_full
+
+_LOG_LEVEL_ERROR = 40
+_MAX_JOINED_CHARS = 1024 * 1024
+_MAX_BUFFER_LINES = 200
+
+
+def register(subparsers: Any) -> None:
+    parser = subparsers.add_parser("log", help="Structured log utilities (JSONL)")
+    _set_help_default(parser)
+    log_subparsers = parser.add_subparsers(dest="log_command")
+
+    fmt_parser = log_subparsers.add_parser("fmt", help="Render structured logs (human-friendly)")
+    _add_input_arg(fmt_parser)
+    _ = fmt_parser.add_argument("--max-fields", type=int, default=12, help="Max number of fields to show per record")
+    _ = fmt_parser.add_argument("--max-value-chars", type=int, default=120, help="Max characters per value when rendering")
+    fmt_parser.set_defaults(func=_run_fmt)
+
+    summarize_parser = log_subparsers.add_parser("summarize", help="Summarize structured logs (llm-friendly)")
+    _add_input_arg(summarize_parser)
+    _ = summarize_parser.add_argument("--budget-chars", type=int, default=8000, help="Max characters in output")
+    summarize_parser.set_defaults(func=_run_summarize)
+
+
+def _set_help_default(parser: argparse.ArgumentParser) -> None:
+    def _show_help(_args: argparse.Namespace) -> int:
+        parser.print_help()
+        return 2
+
+    parser.set_defaults(func=_show_help)
+
+
+def _add_input_arg(parser: argparse.ArgumentParser) -> None:
+    _ = parser.add_argument(
+        "input",
+        nargs="?",
+        default="-",
+        type=str,
+        help="Input JSONL or mixed log file. Use '-' for stdin.",
+    )
+
+
+def _iter_input_lines(path: str) -> Iterator[str]:
+    if path == "-" or not path:
+        for line in sys.stdin:
+            yield line
+        return
+    with Path(path).open("r", encoding="utf-8", errors="replace") as f:
+        for line in f:
+            yield line
+
+
+def _iter_json_objects(lines: Iterable[str]) -> Iterator[Dict[str, Any]]:
+    """Best-effort JSON object scanner with multiline recovery.
+
+    Strategy:
+    - Ignore non-JSON lines.
+    - When a line looks like a JSON object start, try parse; if fails, keep buffering until parse succeeds.
+    """
+    buf: List[str] = []
+    for raw in lines:
+        line = raw.rstrip("\n")
+        if not buf:
+            stripped = line.lstrip()
+            if not stripped.startswith("{"):
+                continue
+            try:
+                obj = json.loads(stripped)
+            except json.JSONDecodeError:
+                buf.append(stripped)
+                continue
+            if isinstance(obj, dict):
+                yield normalize_keys_to_full(obj)  # type: ignore[arg-type]
+            continue
+
+        buf.append(line)
+        joined = "\n".join(buf)
+        try:
+            obj = json.loads(joined)
+        except json.JSONDecodeError:
+            if len(joined) > _MAX_JOINED_CHARS or len(buf) > _MAX_BUFFER_LINES:
+                buf = []
+            continue
+        buf = []
+        if isinstance(obj, dict):
+            yield normalize_keys_to_full(obj)  # type: ignore[arg-type]
+
+
+def _shorten(value: object, *, max_chars: int) -> str:
+    text = str(value)
+    if max_chars <= 0:
+        return text
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 1] + "…"
+
+
+def _format_kv(items: Dict[str, Any], *, max_fields: int, max_value_chars: int) -> str:
+    parts: List[str] = []
+    for key in sorted(items.keys()):
+        if max_fields > 0 and len(parts) >= max_fields:
+            parts.append("…")
+            break
+        val = items[key]
+        if val is None:
+            continue
+        parts.append("{}={}".format(key, _shorten(val, max_chars=max_value_chars)))
+    return ", ".join(parts)
+
+
+def _format_human(record: Dict[str, Any], *, max_fields: int, max_value_chars: int) -> str:
+    level = int(record.get("level") or 0)
+    logger = str(record.get("logger") or "")
+    kind = str(record.get("kind") or "")
+    message = str(record.get("message") or "")
+
+    ctx = record.get("context") or {}
+    fields = record.get("fields") or {}
+    err = record.get("error") or {}
+
+    ctx_text = ""
+    if isinstance(ctx, dict) and ctx:
+        picked: Dict[str, Any] = {}
+        for k in ("demand", "workflow_node_id", "run_id", "demand_path"):
+            if k in ctx and ctx[k] not in (None, ""):
+                picked[k] = ctx[k]
+        if picked:
+            ctx_text = " ctx({})".format(_format_kv(picked, max_fields=6, max_value_chars=max_value_chars))
+
+    fields_text = ""
+    if isinstance(fields, dict) and fields:
+        fields_text = " {}".format(_format_kv(fields, max_fields=max_fields, max_value_chars=max_value_chars))
+
+    err_text = ""
+    if isinstance(err, dict) and err:
+        err_text = " err({})".format(_format_kv(err, max_fields=6, max_value_chars=max_value_chars))
+
+    head = kind or message or "<log>"
+    if logger:
+        head = "{} {}".format(logger, head)
+
+    prefix = "ERROR " if level >= _LOG_LEVEL_ERROR else ""
+    return "{}{}{}{}{}".format(prefix, head, ctx_text, fields_text, err_text).strip()
+
+
+def _run_fmt(args: argparse.Namespace) -> int:
+    path = str(getattr(args, "input", "-") or "-")
+    max_fields = int(getattr(args, "max_fields", 12) or 12)
+    max_value_chars = int(getattr(args, "max_value_chars", 120) or 120)
+    for record in _iter_json_objects(_iter_input_lines(path)):
+        sys.stdout.write(_format_human(record, max_fields=max_fields, max_value_chars=max_value_chars) + "\n")
+    return 0
+
+
+def _summarize_kinds(records: List[Dict[str, Any]]) -> List[Tuple[str, int]]:
+    counts: Dict[str, int] = {}
+    for r in records:
+        kind = str(r.get("kind") or "")
+        if not kind:
+            continue
+        counts[kind] = int(counts.get(kind, 0)) + 1
+    return sorted(counts.items(), key=lambda kv: (-int(kv[1]), kv[0]))
+
+
+def _run_summarize(args: argparse.Namespace) -> int:
+    path = str(getattr(args, "input", "-") or "-")
+    budget = int(getattr(args, "budget_chars", 8000) or 8000)
+    records = list(_iter_json_objects(_iter_input_lines(path)))
+
+    lines: List[str] = []
+    lines.append("records={}".format(len(records)))
+
+    for kind, count in _summarize_kinds(records)[:20]:
+        lines.append("{}={}".format(kind, count))
+
+    # best-effort: show last performance/relations summaries if present
+    for want_kind in ("performance.summary", "performance.loader_breakdown", "relations.summary"):
+        picked = None
+        for r in reversed(records):
+            if str(r.get("kind") or "") == want_kind:
+                picked = r
+                break
+        if picked and isinstance(picked.get("fields"), dict):
+            lines.append("{} {}".format(want_kind, _format_kv(picked["fields"], max_fields=12, max_value_chars=120)))  # type: ignore[index]
+
+    text = "\n".join(lines)
+    if budget > 0 and len(text) > budget:
+        text = text[: max(0, budget - 1)] + "…"
+    sys.stdout.write(text + "\n")
+    return 0
+
+
+__all__ = ("register",)

scalim_cli-0.8.3/scalim_cli/main.py

@@ -0,0 +1,31 @@
+import argparse
+from typing import List, Optional
+
+from . import log as log_cmd
+from . import yaml_dsl
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="scalim-cli", description="Scalim CLI")
+
+    def _show_help(_args: argparse.Namespace) -> int:
+        parser.print_help()
+        return 2
+
+    parser.set_defaults(func=_show_help)
+    subparsers = parser.add_subparsers(dest="command")
+    yaml_dsl.register(subparsers)
+    log_cmd.register(subparsers)
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)  # type: ignore[attr-defined]
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+__all__ = ()