@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/cdh/tools/generate_shared.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-"""Generate shared types from OpenAPI and AsyncAPI contracts."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-import tempfile
-import time
-import traceback
-from pathlib import Path
-from typing import Any
-
-import yaml  # type: ignore[import-untyped]
-
-try:
-    from cdh.generators._runtime import build_context
-    from cdh.generators.cli import discover_all_plugins_merged
-    from cdh.generators.registry import (
-        DEFAULT_GENERATORS_DIR,
-        PluginManifest,
-        discover_plugins,
-        render,
-        set_plugins,
-    )
-except ModuleNotFoundError:
-    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-    from cdh.generators._runtime import build_context
-    from cdh.generators.cli import discover_all_plugins_merged
-    from cdh.generators.registry import (
-        DEFAULT_GENERATORS_DIR,
-        PluginManifest,
-        discover_plugins,
-        render,
-        set_plugins,
-    )
-
-
-class GenerateError(Exception):
-    pass
-
-
-ALIASES = {"ts": "typescript", "py": "python", "cs": "csharp", "graphql": "graphql-schema", "proto": "protobuf"}
-SELF_TEST_IDENTIFIERS = {
-    "typescript": "export interface",
-    "python": "@dataclass",
-    "java": "public record",
-    "go": "struct",
-    "rust": "pub fn",
-    "csharp": "public class",
-    "kotlin": "data class",
-    "swift": "protocol",
-    "graphql-schema": "type Query",
-    "protobuf": "message Item",
-}
-SELF_TEST_SCHEMA: dict[str, Any] = {
-    "openapi": "3.0.0",
-    "info": {"title": "SelfTest", "version": "1.0.0"},
-    "components": {
-        "schemas": {
-            "Item": {
-                "type": "object",
-                "description": "An item used to verify generator plugins.",
-                "required": ["id", "name", "status"],
-                "properties": {
-                    "id": {"type": "string", "format": "uuid"},
-                    "name": {"type": "string"},
-                    "price": {"type": "number", "format": "double", "nullable": True},
-                    "status": {"type": "string", "enum": ["active", "archived"]},
-                    "createdAt": {"type": "string", "format": "date-time"},
-                    "tags": {"type": "array", "items": {"type": "string"}},
-                },
-            }
-        }
-    },
-}
-
-
-def _default_generators_dir() -> Path:
-    bundled = Path(__file__).resolve().parent.parent / "generators"
-    if bundled.is_dir():
-        return bundled
-    return DEFAULT_GENERATORS_DIR
-
-
-def _discover_with_user_and_project(
-    generators_dir: Path | None,
-    project_root: Path,
-) -> dict[str, PluginManifest]:
-    """Scan the bundled dir plus user and project-local plugin dirs.
-
-    If ``generators_dir`` is provided, only that directory is scanned
-    (backwards-compatible behaviour). Otherwise the bundled generators
-    are merged with ``~/.cdh/generators`` and ``<project>/aidlc/generators``
-    so plugins installed via ``cdh aidlc generators install`` are picked
-    up automatically. Later sources override earlier ones by plugin name.
-    """
-    if generators_dir is not None:
-        return discover_plugins(generators_dir)
-    merged: dict[str, PluginManifest] = {}
-    for _source, plugin in discover_all_plugins_merged(project_root=project_root).values():
-        merged[plugin.name] = plugin
-    return merged
-
-
-def _load_yaml(path: Path) -> dict[str, Any]:
-    try:
-        document = yaml.safe_load(path.read_text(encoding="utf-8"))
-    except (OSError, yaml.YAMLError) as exc:
-        raise GenerateError(f"Unable to read {path}: {exc}") from exc
-    if not isinstance(document, dict):
-        raise GenerateError(f"Root YAML value must be a mapping: {path}")
-    return document
-
-
-def _find_yaml_files(project_root: Path) -> list[Path]:
-    files: list[Path] = []
-    for relative in ("aidlc/contracts/api", "aidlc/contracts/events"):
-        directory = project_root / relative
-        if directory.is_dir():
-            files.extend(sorted(directory.glob("*.yaml")))
-            files.extend(sorted(directory.glob("*.yml")))
-    return files
-
-
-def _canonical_language(language: str, plugins: dict[str, PluginManifest]) -> str:
-    value = ALIASES.get(language.strip(), language.strip())
-    if value not in plugins:
-        raise GenerateError(f"Unknown language '{language}'. Valid: {', '.join(sorted(plugins))}")
-    return value
-
-
-def _legacy_outdirs(
-    ts_outdir: Path | None,
-    py_outdir: Path | None,
-    java_outdir: Path | None,
-    go_outdir: Path | None,
-    rust_outdir: Path | None,
-) -> dict[str, Path | None]:
-    return {
-        "typescript": ts_outdir,
-        "python": py_outdir,
-        "java": java_outdir,
-        "go": go_outdir,
-        "rust": rust_outdir,
-    }
-
-
-def _write_indexes(language: str, output_dir: Path, files: list[Path]) -> list[Path]:
-    if language == "typescript":
-        index = output_dir / "index.ts"
-        exports = ["// Auto-generated by generate_shared.py", ""]
-        exports.extend(f"export * from './{path.stem}';" for path in files)
-        index.write_text("\n".join(exports) + "\n", encoding="utf-8")
-        return [index]
-    if language == "python":
-        index = output_dir / "__init__.py"
-        imports = ['"""Auto-generated by generate_shared.py"""', ""]
-        imports.extend(f"from .{path.stem} import *" for path in files)
-        index.write_text("\n".join(imports) + "\n", encoding="utf-8")
-        return [index]
-    return []
-
-
-def generate(
-    project_root: Path,
-    ts_outdir: Path | None = None,
-    py_outdir: Path | None = None,
-    java_outdir: Path | None = None,
-    go_outdir: Path | None = None,
-    rust_outdir: Path | None = None,
-    languages: list[str] | None = None,
-    generators_dir: Path | None = None,
-    output_dirs: dict[str, Path] | None = None,
-    package_name: str | None = None,
-) -> list[Path]:
-    plugins = _discover_with_user_and_project(generators_dir, project_root)
-    set_plugins(plugins)
-    selected = [_canonical_language(language, plugins) for language in (languages or ["typescript", "python"])]
-    legacy = _legacy_outdirs(ts_outdir, py_outdir, java_outdir, go_outdir, rust_outdir)
-    overrides = output_dirs or {}
-    contracts = _find_yaml_files(project_root)
-    generated: list[Path] = []
-    shared = project_root / "aidlc" / "packages" / "shared"
-    for language in selected:
-        plugin = plugins[language]
-        output_dir = overrides.get(language) or legacy.get(language)
-        if output_dir is None:
-            output_dir = shared if plugin.default_outdir in ("", ".") else shared / plugin.default_outdir
-        output_dir.mkdir(parents=True, exist_ok=True)
-        stubs: list[Path] = []
-        for source in contracts:
-            document = _load_yaml(source)
-            context = build_context(document, source, language, package_name or plugin.package_name_default)
-            filename = plugin.output_filename_template.format(name=source.stem)
-            target = output_dir / filename
-            target.write_text(render(language, context), encoding="utf-8")
-            stubs.append(target)
-            generated.append(target)
-            print(f"  {plugin.display_name:<16} {target}")
-        generated.extend(_write_indexes(language, output_dir, stubs))
-    return generated
-
-
-def _self_test(generators_dir: Path | None = None) -> int:
-    failures: list[str] = []
-    with tempfile.TemporaryDirectory() as temporary:
-        root = Path(temporary)
-        contract_dir = root / "aidlc" / "contracts" / "api"
-        contract_dir.mkdir(parents=True)
-        (contract_dir / "selftest.yaml").write_text(yaml.safe_dump(SELF_TEST_SCHEMA), encoding="utf-8")
-        plugins = _discover_with_user_and_project(generators_dir, root)
-        set_plugins(plugins)
-        output_dirs = {name: root / "output" / name for name in plugins}
-        try:
-            generate(root, languages=list(plugins), generators_dir=generators_dir, output_dirs=output_dirs)
-        except Exception as exc:
-            traceback.print_exc()
-            failures.append(f"generation raised: {exc}")
-        for name, plugin in plugins.items():
-            output = output_dirs[name] / plugin.output_filename_template.format(name="selftest")
-            if not output.is_file():
-                failures.append(f"[{name}] missing {output.name}")
-                continue
-            identifier = SELF_TEST_IDENTIFIERS.get(name)
-            if identifier and identifier not in output.read_text(encoding="utf-8"):
-                failures.append(f"[{name}] missing expected identifier: {identifier}")
-    if failures:
-        print("Self-test FAILED:")
-        for failure in failures:
-            print(f"  - {failure}")
-        return 1
-    print(f"Self-test PASSED: all {len(plugins)} plugins produced expected output.")
-    return 0
-
-
-def _watch(project_root: Path, arguments: argparse.Namespace, languages: list[str]) -> None:
-    previous = {path: path.stat().st_mtime_ns for path in _find_yaml_files(project_root)}
-    while True:
-        try:
-            time.sleep(2)
-            current_files = _find_yaml_files(project_root)
-            current = {path: path.stat().st_mtime_ns for path in current_files}
-            if current != previous:
-                previous = current
-                generate(project_root, languages=languages, generators_dir=arguments.generators_dir)
-        except KeyboardInterrupt:
-            return
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--project-root", default=".")
-    parser.add_argument("--generators-dir", type=Path)
-    parser.add_argument("--languages", help="Comma-separated plugin names")
-    parser.add_argument("--package-name")
-    parser.add_argument("--ts-outdir", type=Path)
-    parser.add_argument("--py-outdir", type=Path)
-    parser.add_argument("--java-outdir", type=Path)
-    parser.add_argument("--go-outdir", type=Path)
-    parser.add_argument("--rust-outdir", type=Path)
-    parser.add_argument("--watch", action="store_true")
-    parser.add_argument("--self-test", action="store_true")
-    parser.add_argument("--list-generators", action="store_true")
-    return parser
-
-
-def main() -> None:
-    arguments = _parser().parse_args()
-    project_root = Path(arguments.project_root).resolve()
-    if arguments.generators_dir is not None:
-        plugins = discover_plugins(arguments.generators_dir)
-    else:
-        plugins = _discover_with_user_and_project(None, project_root)
-    if arguments.list_generators:
-        for name, plugin in plugins.items():
-            print(f"{name}\t{plugin.display_name}\t{plugin.file_extension}")
-        return
-    if arguments.self_test:
-        raise SystemExit(_self_test(arguments.generators_dir))
-    languages = [part.strip() for part in arguments.languages.split(",")] if arguments.languages else ["typescript", "python"]
-    root = Path(arguments.project_root).resolve()
-    kwargs = {
-        "ts_outdir": arguments.ts_outdir,
-        "py_outdir": arguments.py_outdir,
-        "java_outdir": arguments.java_outdir,
-        "go_outdir": arguments.go_outdir,
-        "rust_outdir": arguments.rust_outdir,
-        "languages": languages,
-        "generators_dir": arguments.generators_dir,
-        "package_name": arguments.package_name,
-    }
-    generated = generate(root, **kwargs)
-    print(f"Generated {len(generated)} file(s).")
-    if arguments.watch:
-        _watch(root, arguments, languages)
-
-
-if __name__ == "__main__":
-    main()

package/cdh/tools/iac_gen.py

@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-"""Generate Pulumi and Terraform resource declarations from provider YAML."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-from typing import Any
-
-try:
-    import yaml
-except ImportError:  # pragma: no cover
-    yaml = None
-
-PROVIDERS = {"tcb", "aliyun"}
-ENVIRONMENTS = {"preview", "staging", "production"}
-FORMATS = {"pulumi-py", "pulumi-ts", "terraform", "all"}
-
-
-def _load_yaml(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        return {}
-    if yaml is None:
-        raise RuntimeError("PyYAML is required; install the 'pyyaml' package")
-    value = yaml.safe_load(path.read_text(encoding="utf-8"))
-    return value if isinstance(value, dict) else {}
-
-
-def _project_components(project: dict[str, Any]) -> list[str]:
-    stack = project.get("stack", {})
-    components = stack.get("components", []) if isinstance(stack, dict) else []
-    result: list[str] = []
-    for component in components:
-        if isinstance(component, str):
-            result.append(component)
-        elif isinstance(component, dict) and component.get("id"):
-            result.append(str(component["id"]))
-    return result
-
-
-def _resource_map(provider: str, name: str, config: dict[str, Any]) -> list[dict[str, Any]]:
-    kind = str(config.get("type", name)).lower()
-    if provider == "tcb":
-        types = {
-            "backend": "cloudbase_run.Service",
-            "cloudbase_run": "cloudbase_run.Service",
-            "web": "hosting.StaticSite",
-            "cloudbase_hosting": "hosting.StaticSite",
-            "database": "document_db.Database",
-            "documentdb": "document_db.Database",
-            "storage": "storage.Bucket",
-        }
-        return [{"name": name, "type": types.get(kind, kind), "config": config}]
-    types = {
-        "backend": "fc.Function",
-        "function": "fc.Function",
-        "web": "oss.Bucket",
-        "oss": "oss.Bucket",
-        "database": "rds.Instance",
-        "rds": "rds.Instance",
-        "storage": "oss.Bucket",
-    }
-    resources = [{"name": name, "type": types.get(kind, kind), "config": config}]
-    if name == "web" and config.get("cdn_enabled"):
-        resources.append({"name": "web_cdn", "type": "cdn.Distribution", "config": config})
-    return resources
-
-
-def _resources(provider: str, deployment: dict[str, Any], project: dict[str, Any]) -> list[dict[str, Any]]:
-    declared = deployment.get("resources", {})
-    if not isinstance(declared, dict):
-        declared = {}
-    names = list(declared)
-    for name in _project_components(project):
-        if name not in names and name in {"backend", "web", "database", "storage"}:
-            names.append(name)
-    result: list[dict[str, Any]] = []
-    for name in names:
-        config = declared.get(name, {})
-        result.extend(_resource_map(provider, str(name), config if isinstance(config, dict) else {}))
-    return result
-
-
-def _identifier(value: str) -> str:
-    value = re.sub(r"[^A-Za-z0-9_]", "_", value)
-    return value if value and not value[0].isdigit() else f"resource_{value}"
-
-
-def _py_value(value: Any, indent: int = 0) -> str:
-    return repr(value)
-
-
-def render_pulumi_py(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
-    module = "pulumi_tcb" if provider == "tcb" else "pulumi_alicloud"
-    lines = [f"import {module} as cloud", "", f"environment = {_py_value(environment)}", ""]
-    for resource in resources:
-        config = resource["config"]
-        args: list[str] = []
-        for key, value in config.items():
-            if key == "type":
-                continue
-            args.append(f"    {key}={_py_value(value)},")
-        lines.append(f'{_identifier(resource["name"])} = cloud.{resource["type"]}({resource["name"]!r},')
-        lines.extend(args)
-        lines.append(")")
-        lines.append("")
-    return "\n".join(lines).rstrip() + "\n"
-
-
-def _hcl_key(key: str) -> str:
-    return {"runtime": "runtime_environment", "memory_mb": "memory", "timeout_sec": "timeout"}.get(key, key)
-
-
-def _hcl_value(value: Any) -> str:
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    if isinstance(value, (int, float)):
-        return str(value)
-    if isinstance(value, list):
-        return json.dumps(value)
-    if isinstance(value, dict):
-        return json.dumps(value)
-    return json.dumps(str(value))
-
-
-def _terraform_type(provider: str, resource: dict[str, Any]) -> str:
-    name = resource["name"]
-    kind = resource["type"]
-    if provider == "tcb":
-        return {"cloudbase_run.Service": "tencentcloud_cloud_run_service", "hosting.StaticSite": "tencentcloud_cos_bucket", "document_db.Database": "tencentcloud_mongodb_instance", "storage.Bucket": "tencentcloud_cos_bucket"}.get(kind, "tencentcloud_resource")
-    if name == "web_cdn":
-        return "tencentcloud_cdn_domain"
-    return {"fc.Function": "alicloud_fc_function", "oss.Bucket": "alicloud_oss_bucket", "rds.Instance": "alicloud_db_instance"}.get(kind, "alicloud_resource")
-
-
-def render_terraform(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
-    lines = [f'variable "environment" {{', f'  default = {environment!r}', "}", ""]
-    for resource in resources:
-        lines.append(f'resource "{_terraform_type(provider, resource)}" "{_identifier(resource["name"])}" {{')
-        for key, value in resource["config"].items():
-            if key != "type":
-                lines.append(f"  {_hcl_key(key)} = {_hcl_value(value)}")
-        lines.append("}")
-        lines.append("")
-    return "\n".join(lines)
-
-
-def generate(project_root: Path, provider: str, environment: str, output_format: str, outdir: Path) -> list[Path]:
-    provider_dir = project_root / "aidlc" / "providers" / provider
-    deployment = _load_yaml(provider_dir / "deployment.yaml")
-    preview = _load_yaml(provider_dir / "preview.yaml")
-    project = _load_yaml(project_root / "aidlc" / "project.yaml")
-    deployment = {**preview, **deployment}
-    resources = _resources(provider, deployment, project)
-    target = project_root / outdir
-    target.mkdir(parents=True, exist_ok=True)
-    written: list[Path] = []
-    if output_format in {"pulumi-py", "all"}:
-        path = target / "pulumi" / f"{environment}.py"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(render_pulumi_py(provider, environment, resources), encoding="utf-8")
-        written.append(path)
-    if output_format in {"pulumi-ts", "all"}:
-        path = target / "pulumi" / f"{environment}.ts"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(render_pulumi_ts(provider, environment, resources), encoding="utf-8")
-        written.append(path)
-    if output_format in {"terraform", "all"}:
-        path = target / "terraform" / f"{environment}.tf"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(render_terraform(provider, environment, resources), encoding="utf-8")
-        written.append(path)
-    return written
-
-
-def _ts_value(value: Any) -> str:
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    if isinstance(value, str):
-        return json.dumps(value)
-    return json.dumps(value)
-
-
-def render_pulumi_ts(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
-    module = "@pulumi/tcb" if provider == "tcb" else "@pulumi/alicloud"
-    lines = [f'import * as cloud from "{module}";', "", f"const environment = {_ts_value(environment)};", ""]
-    for resource in resources:
-        lines.append(f"const {_identifier(resource['name'])} = new cloud.{resource['type']}({_ts_value(resource['name'])}, {{")
-        for key, value in resource["config"].items():
-            if key != "type":
-                lines.append(f"  {key}: {_ts_value(value)},")
-        lines.extend(["});", ""])
-    return "\n".join(lines).rstrip() + "\n"
-
-
-def self_test() -> None:
-    deployment = {"resources": {"backend": {"type": "cloudbase_run", "runtime": "python3.11", "memory_mb": 512, "timeout_sec": 30, "env_vars": ["DATABASE_URL"]}, "web": {"type": "cloudbase_hosting", "cdn_enabled": True}}}
-    resources = _resources("tcb", deployment, {"stack": {"components": []}})
-    assert "runtime_environment" in render_terraform("tcb", "preview", resources)
-    assert "cloudbase_run.Service" in render_pulumi_py("tcb", "preview", resources)
-    print("self-test passed")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--project-root", type=Path, default=Path("."))
-    parser.add_argument("--provider", choices=sorted(PROVIDERS), required=False, default="tcb")
-    parser.add_argument("--environment", choices=sorted(ENVIRONMENTS), default="preview")
-    parser.add_argument("--format", dest="output_format", choices=sorted(FORMATS), default="all")
-    parser.add_argument("--outdir", type=Path, default=Path("aidlc/iac"))
-    parser.add_argument("--self-test", action="store_true")
-    args = parser.parse_args()
-    if args.self_test:
-        self_test()
-        return
-    for path in generate(args.project_root, args.provider, args.environment, args.output_format, args.outdir):
-        print(path)
-
-
-if __name__ == "__main__":
-    main()

package/cdh/tools/otel_export.py

@@ -1,125 +0,0 @@
-"""Standalone OTLP exporter for the agenttrace SQLite database.
-
-Usage::
-
-    python -m cdh.tools.otel_export --endpoint http://localhost:4318 --since 2026-07-01
-    python -m cdh.tools.otel_export --service-name cdh-prod --session <sid>
-    python -m cdh.tools.otel_export --dry-run --since 2026-07-01
-
-This script is intentionally dependency-free at import time — it uses only the
-Python standard library plus the helpers in :mod:`cdh.trace.otel_exporter`.
-"""
-
-from __future__ import annotations
-
-import argparse
-import logging
-import os
-import sys
-from pathlib import Path
-
-# Make `cdh.trace.otel_exporter` importable when running this file directly
-# (i.e. ``python cdh/tools/otel_export.py``).
-_THIS = Path(__file__).resolve()
-_REPO_ROOT = _THIS.parents[2]
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
-
-from cdh.trace.otel_exporter import DEFAULT_DB_PATH, OtlpExporter  # noqa: E402
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="Export agenttrace spans from the local sqlite DB to an OTLP/HTTP collector.",
-    )
-    parser.add_argument(
-        "--endpoint",
-        default=os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318"),
-        help="OTLP/HTTP base endpoint (default: $OTEL_EXPORTER_OTLP_ENDPOINT or http://localhost:4318)",
-    )
-    parser.add_argument(
-        "--db-path",
-        type=Path,
-        default=DEFAULT_DB_PATH,
-        help=f"Path to the agenttrace sqlite DB (default: {DEFAULT_DB_PATH})",
-    )
-    parser.add_argument(
-        "--service-name",
-        default=os.environ.get("OTEL_SERVICE_NAME", "cdh"),
-        help="Value of the service.name resource attribute",
-    )
-    parser.add_argument(
-        "--since",
-        default=None,
-        help="Only export rows with timestamp >= this value (ISO date or datetime)",
-    )
-    parser.add_argument(
-        "--session",
-        default=None,
-        help="Restrict export to a single session_id",
-    )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=256,
-        help="Spans per HTTP POST (default: 256)",
-    )
-    parser.add_argument(
-        "--timeout",
-        type=float,
-        default=10.0,
-        help="Per-request HTTP timeout in seconds (default: 10)",
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Build payloads but don't POST. Prints the would-be batch count.",
-    )
-    parser.add_argument(
-        "--header",
-        action="append",
-        default=[],
-        metavar="K=V",
-        help="Extra HTTP header (repeatable). e.g. --header 'Authorization=Bearer xxx'",
-    )
-    parser.add_argument(
-        "-v", "--verbose", action="store_true", help="Enable debug logging",
-    )
-
-    args = parser.parse_args()
-    logging.basicConfig(
-        level=logging.DEBUG if args.verbose else logging.INFO,
-        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-    )
-
-    headers: dict[str, str] = {}
-    for h in args.header:
-        if "=" in h:
-            k, v = h.split("=", 1)
-            headers[k.strip()] = v.strip()
-
-    exporter = OtlpExporter(
-        db_path=args.db_path,
-        endpoint=args.endpoint,
-        service_name=args.service_name,
-        headers=headers,
-        batch_size=args.batch_size,
-        timeout_s=args.timeout,
-        dry_run=args.dry_run,
-    )
-
-    counters = exporter.export_since(since=args.since, session_id=args.session)
-
-    mode = "(dry-run) " if args.dry_run else ""
-    print(
-        f"{mode}OTLP export summary: "
-        f"read={counters['read']} sent={counters['sent']} "
-        f"failed={counters['failed']} batches={counters['batches']}"
-    )
-    if not args.dry_run and counters["failed"] > 0:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())