onyx-database 0.0.4__py3-none-any.whl

onyx_database/__init__.py

@@ -0,0 +1,107 @@
+"""Public entrypoint for the Onyx Database Python SDK."""
+
+from .errors import (
+    OnyxConfigError,
+    OnyxHTTPError,
+    OnyxUnauthorizedError,
+    OnyxNotFoundError,
+    OnyxRateLimitedError,
+    OnyxClientError,
+    OnyxServerError,
+    OnyxTimeoutError,
+)
+from .onyx import OnyxFacade, onyx
+from .helpers.conditions import (
+    eq,
+    neq,
+    within,
+    not_within,
+    in_op,
+    not_in,
+    between,
+    gt,
+    gte,
+    lt,
+    lte,
+    like,
+    not_like,
+    contains,
+    not_contains,
+    starts_with,
+    not_starts_with,
+    matches,
+    not_matches,
+    is_null,
+    not_null,
+)
+from .helpers.sort import asc, desc
+from .onyx_async import OnyxAsyncFacade, onyx_async
+from .helpers.aggregates import (
+    avg,
+    sum,
+    count,
+    min,
+    max,
+    std,
+    variance,
+    median,
+    upper,
+    lower,
+    substring,
+    replace,
+    percentile,
+)
+
+__all__ = [
+    "OnyxFacade",
+    "OnyxAsyncFacade",
+    "onyx",
+    "onyx_async",
+    "OnyxConfigError",
+    "OnyxHTTPError",
+    "OnyxUnauthorizedError",
+    "OnyxNotFoundError",
+    "OnyxRateLimitedError",
+    "OnyxClientError",
+    "OnyxServerError",
+    "OnyxTimeoutError",
+    # conditions
+    "eq",
+    "neq",
+    "within",
+    "not_within",
+    "in_op",
+    "not_in",
+    "between",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "like",
+    "not_like",
+    "contains",
+    "not_contains",
+    "starts_with",
+    "not_starts_with",
+    "matches",
+    "not_matches",
+    "is_null",
+    "not_null",
+    # sort
+    "asc",
+    "desc",
+    # aggregates
+    "avg",
+    "sum",
+    "count",
+    "min",
+    "max",
+    "std",
+    "variance",
+    "median",
+    "upper",
+    "lower",
+    "substring",
+    "replace",
+    "percentile",
+]

onyx_database/cli.py

@@ -0,0 +1,285 @@
+"""CLI entrypoint for `onyx-py` (schema + codegen)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+from . import onyx
+from .config import resolve_config, _candidate_paths, OnyxConfigError
+from .codegen import generate_models
+
+
+def _load_json(path: Path) -> Dict[str, Any]:
+    text = path.read_text(encoding="utf-8")
+    return json.loads(text)
+
+
+def _write_json(path: Path, data: Dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def _default_schema_path() -> Path:
+    candidates = [Path("schema/onyx.schema.json"), Path("onyx.schema.json")]
+    for c in candidates:
+        if c.exists():
+            return c
+    return candidates[0]
+
+
+def _detect_config_path() -> Path | None:
+    env_path = os.environ.get("ONYX_CONFIG_PATH")
+    if env_path:
+        p = Path(env_path)
+        if not p.is_absolute():
+            p = Path.cwd() / p
+        return p
+    for c in _candidate_paths(None):
+        if c.exists():
+            return c
+    return None
+
+
+def handle_info(args: argparse.Namespace) -> int:
+    config_path = _detect_config_path()
+    schema_env = os.environ.get("ONYX_SCHEMA_PATH")
+    schema_path = Path(schema_env) if schema_env else _default_schema_path()
+
+    env_present = any(
+        os.environ.get(k)
+        for k in ["ONYX_DATABASE_ID", "ONYX_DATABASE_API_KEY", "ONYX_DATABASE_API_SECRET", "ONYX_DATABASE_BASE_URL"]
+    )
+    source_guess = "file" if (config_path and Path(config_path).exists()) else ("env" if env_present else "default")
+
+    def _mask(value: str | None) -> str | None:
+        if not value:
+            return None
+        if len(value) <= 4:
+            return "*" * len(value)
+        return f"{value[:2]}...{value[-2:]}"
+
+    info: Dict[str, Any] = {
+        "configPath": str(config_path) if config_path else None,
+        "configPathExists": bool(config_path and Path(config_path).exists()),
+        "schemaPath": str(schema_path),
+        "schemaPathExists": schema_path.exists(),
+        "source": source_guess,
+    }
+
+    try:
+        resolved = resolve_config()
+        info.update(
+            {
+                "baseUrl": resolved.base_url,
+                "databaseId": resolved.database_id,
+                "partition": resolved.partition,
+                "requestLoggingEnabled": resolved.request_logging_enabled,
+                "responseLoggingEnabled": resolved.response_logging_enabled,
+                "apiKeyMasked": _mask(resolved.api_key),
+                "apiSecretMasked": _mask(resolved.api_secret),
+                "connection": "ok",
+            }
+        )
+    except OnyxConfigError as exc:
+        info["configError"] = str(exc)
+        info["connection"] = f"error: {exc}"
+
+    if getattr(args, "json", False):
+        print(json.dumps(info, indent=2))
+    else:
+        if "configError" in info:
+            print(f"Config error: {info['configError']}")
+        else:
+            print(f"Database ID: {info.get('databaseId')} (source: {info.get('source')})")
+            print(f"Base URL   : {info.get('baseUrl')} (source: {info.get('source')})")
+            print(f"API Key    : {info.get('apiKeyMasked')} (source: {info.get('source')})")
+            print(f"API Secret : {info.get('apiSecretMasked')} (source: {info.get('source')})")
+            print(f"Config file: {info.get('configPath')}")
+            print(f"Connection : {info.get('connection')}")
+    return 0
+
+
+def handle_schema(args: argparse.Namespace) -> int:
+    action: str = args.action
+    try:
+        db = onyx.init(
+            request_timeout_seconds=args.timeout,
+            max_retries=args.max_retries,
+            retry_backoff_seconds=args.retry_backoff,
+        )
+    except Exception as exc:
+        print(f"Config error: {exc}")
+        return 1
+
+    if action == "get":
+        tables: list[str] = []
+        if args.tables:
+            tables = [t.strip() for t in args.tables.split(",") if t.strip()]
+        schema = db.get_schema(tables=tables if tables else None)
+        if args.print_only or args.tables:
+            print(json.dumps(schema, indent=2))
+            return 0
+        out_path = Path(args.out or _default_schema_path())
+        _write_json(out_path, schema)
+        print(f"schema written to {out_path}")
+        return 0
+
+    schema_path = Path(args.schema or _default_schema_path())
+    if not schema_path.exists():
+        raise FileNotFoundError(f"Schema file not found: {schema_path}")
+    local_schema = _load_json(schema_path)
+
+    if action == "publish":
+        res = db.update_schema(local_schema, publish=True)
+        print(json.dumps(res, indent=2))
+        return 0
+
+    if action == "validate":
+        try:
+            res = db.validate_schema(local_schema)
+        except Exception as exc:  # validation API should respond 200 + errors list; if not, treat as invalid
+            print(f"Schema at {schema_path} is INVALID:")
+            print(f"  validation call failed: {exc}")
+            return 1
+
+        errors = []
+        valid_flag = None
+        if isinstance(res, dict):
+            errors = res.get("errors") or res.get("validationErrors") or []
+            valid_flag = res.get("valid")
+
+        if errors or valid_flag is False:
+            print(f"Schema at {schema_path} is INVALID:")
+            if errors:
+                print(json.dumps(errors, indent=2))
+            elif valid_flag is False:
+                print("  validation returned valid=false")
+            return 1
+
+        print(f"Schema at {schema_path} is valid.")
+        return 0
+
+    if action == "diff":
+        res = db.diff_schema(local_schema)
+        # Pretty print in a human-friendly, non-JSON style
+        print("newTables:", res.get("added_tables", []))
+        print("removedTables:", res.get("removed_tables", []))
+        print("changedTables:")
+        for table in res.get("changed_tables", []):
+            print(f"  - name: \"{table.get('name')}\"")
+            attrs = table.get("attributes") or {}
+            print("    attributes:")
+            print(f"      added: {attrs.get('added', [])}")
+            print(f"      removed: {attrs.get('removed', [])}")
+            changed_attrs = attrs.get("changed", [])
+            if changed_attrs:
+                print("      changed:")
+                for ch in changed_attrs:
+                    print(f"        - name: \"{ch.get('name')}\"")
+                    from_attr = ch.get("from") or {}
+                    to_attr = ch.get("to") or {}
+                    diffs = []
+                    for key in sorted(set(from_attr.keys()) | set(to_attr.keys())):
+                        if from_attr.get(key) != to_attr.get(key):
+                            diffs.append(f"{key} ({from_attr.get(key)} -> {to_attr.get(key)})")
+                    if diffs:
+                        print(f"          change: {', '.join(diffs)}")
+                    else:
+                        print("          change: none")
+            else:
+                print("      changed: []")
+        return 0
+
+    raise ValueError(f"Unknown schema action: {action}")
+
+
+def handle_gen(args: argparse.Namespace) -> int:
+    source = args.source
+    schema_path = Path(args.schema) if args.schema else _default_schema_path()
+    out_paths = args.out or ["./onyx"]
+    timestamp_mode = args.timestamps
+
+    try:
+        db = onyx.init(
+            request_timeout_seconds=args.timeout,
+            max_retries=args.max_retries,
+            retry_backoff_seconds=args.retry_backoff,
+        )
+    except Exception as exc:
+        print(f"Config error: {exc}")
+        return 1
+    if source == "api":
+        schema = db.get_schema()
+    else:
+        if not schema_path.exists():
+            raise FileNotFoundError(f"Schema file not found: {schema_path}")
+        schema = _load_json(schema_path)
+
+    if args.tables:
+        # subset to stdout only
+        subset = {**schema, "entities": [e for e in schema.get("entities", []) if e.get("name") in args.tables]}
+        print(json.dumps(subset, indent=2))
+        return 0
+
+    for out in out_paths:
+        out_path = Path(out)
+        pkg = args.package
+        if not pkg:
+            pkg = out_path.stem if out_path.suffix else out_path.name
+        generate_models(schema, out_path, package=pkg, timestamp_mode=timestamp_mode, models_mode=args.models)
+        print(f"generated models at {out}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="onyx-py", description="Onyx Database Python SDK CLI")
+    sub = parser.add_subparsers(dest="command")
+
+    gen = sub.add_parser("gen", help="Generate Python helpers/models from schema")
+    gen.add_argument("--source", choices=["api", "file"], default="file")
+    gen.add_argument("--schema", help="Path to schema JSON (when --source=file)")
+    gen.add_argument("--out", nargs="+", help="Output path(s) (dir or .py file). Default: ./generated")
+    gen.add_argument("--package", help="Package name when writing a package (optional)")
+    gen.add_argument("--timestamps", choices=["datetime", "string", "number"], default="datetime", help="Timestamp annotation mode")
+    gen.add_argument("--models", choices=["plain", "pydantic"], default="plain", help="Model generation style (plain classes or Pydantic BaseModel)")
+    gen.add_argument("--timeout", type=float, help="Request timeout (seconds)")
+    gen.add_argument("--max-retries", type=int, help="Max retries for GET/query requests")
+    gen.add_argument("--retry-backoff", type=float, help="Initial retry backoff in seconds")
+    gen.add_argument("--tables", nargs="+", help="When provided, print a subset of entities to stdout instead of writing files")
+
+    schema = sub.add_parser("schema", help="Schema management")
+    schema.add_argument("action", choices=["get", "publish", "validate", "diff"])
+    schema.add_argument("--schema", help="Local schema path (default: ./schema/onyx.schema.json or ./onyx.schema.json)")
+    schema.add_argument("--out", help="Output path for `schema get` (default: ./schema/onyx.schema.json)")
+    schema.add_argument("--tables", help="Comma-separated table names (for get)")
+    schema.add_argument("--timeout", type=float, help="Request timeout (seconds)")
+    schema.add_argument("--max-retries", type=int, help="Max retries for GET/query requests")
+    schema.add_argument("--retry-backoff", type=float, help="Initial retry backoff in seconds")
+    schema.add_argument("--print", dest="print_only", action="store_true", help="Print only for get")
+
+    info = sub.add_parser("info", help="Show resolved configuration and paths")
+    info.add_argument("--json", action="store_true", help="Print JSON output")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "schema":
+        return handle_schema(args)
+    if args.command == "gen":
+        return handle_gen(args)
+    if args.command == "info":
+        return handle_info(args)
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

onyx_database/codegen.py

@@ -0,0 +1,166 @@
+"""Minimal schema-driven model generator (stdlib only)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def _safe_name(name: str) -> str:
+    return "".join(ch for ch in name if ch.isalnum() or ch == "_") or "Model"
+
+
+def _timestamp_annotation(mode: str) -> str:
+    if mode == "string":
+        return "str"
+    if mode == "number":
+        return "float"
+    return "datetime.datetime"
+
+
+def _attribute_annotation(attr: Dict[str, Any], ts_mode: str) -> str:
+    type_name = attr.get("type", "String")
+    nullable = bool(attr.get("isNullable"))
+    py = "str"
+    if type_name.lower() in {"int", "integer"}:
+        py = "int"
+    elif type_name.lower() == "boolean":
+        py = "bool"
+    elif type_name.lower() in {"float", "double", "number"}:
+        py = "float"
+    elif type_name.lower() == "timestamp":
+        py = _timestamp_annotation(ts_mode)
+    elif type_name.lower() == "embeddedobject":
+        py = "dict"
+    ann = py
+    if nullable:
+        ann = f"Optional[{py}]"
+    return ann
+
+
+def _emit_tables(entities: List[Dict[str, Any]]) -> str:
+    lines = ["class tables:", "    \"\"\"Table name constants.\"\"\""]
+    if not entities:
+        lines.append("    pass")
+        return "\n".join(lines) + "\n"
+    for e in entities:
+        name = e.get("name", "")
+        safe = _safe_name(name)
+        lines.append(f"    {safe} = \"{name}\"")
+    return "\n".join(lines) + "\n"
+
+
+def _emit_init(entities: List[Dict[str, Any]]) -> str:
+    class_names = [_safe_name(e.get("name", "Model")) for e in entities]
+    imports = ", ".join(class_names)
+    model_map_items = ", ".join([f'"{e.get("name", "")}": {cls}' for e, cls in zip(entities, class_names)])
+    return "\n".join(
+        [
+            f"from .models import {imports}" if imports else "",
+            "from .tables import tables",
+            "from .schema import SCHEMA_JSON",
+            f"SCHEMA = {{{model_map_items}}}",
+            "__all__ = ['tables', 'SCHEMA_JSON', 'SCHEMA'" + (", " + ", ".join([f"'{c}'" for c in class_names]) if class_names else "") + "]",
+        ]
+    )
+
+
+def _emit_model(entity: Dict[str, Any], ts_mode: str) -> str:
+    name = _safe_name(entity.get("name", "Model"))
+    attrs: List[Dict[str, Any]] = entity.get("attributes", []) or []
+    lines = [
+        f"class {name}:",
+        '    """Generated model (plain Python class). Resolver/extra fields are allowed via **extra."""',
+    ]
+    init_params = ["self"]
+    body: List[str] = []
+    for attr in attrs:
+        field = attr.get("name", "")
+        ann = _attribute_annotation(attr, ts_mode)
+        init_params.append(f"{field}: {ann} = None")
+        body.append(f"        self.{field} = {field}")
+    init_params.append("**extra: Any")
+    body.append("        # allow resolver-attached fields or extra properties")
+    body.append("        for k, v in extra.items():")
+    body.append("            setattr(self, k, v)")
+    if not body:
+        body.append("        pass")
+    lines.append(f"    def __init__({', '.join(init_params)}):")
+    lines.extend(body)
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _emit_all_models(entities: List[Dict[str, Any]], ts_mode: str) -> str:
+    out: List[str] = ["import datetime", "from typing import Any, Optional", ""]
+    for e in entities:
+        out.append(_emit_model(e, ts_mode))
+        out.append("")
+    return "\n".join(out)
+
+
+def _emit_schema_map(schema: Dict[str, Any]) -> str:
+    cleaned = {"databaseId": schema.get("databaseId"), "revisionDescription": schema.get("revisionDescription"), "entities": schema.get("entities", [])}
+    py_literal = json.dumps(cleaned, indent=2)
+    py_literal = (
+        py_literal.replace("true", "True")
+        .replace("false", "False")
+        .replace("null", "None")
+    )
+    return "SCHEMA_JSON = " + py_literal + "\n"
+
+
+def _emit_pydantic_models(entities: List[Dict[str, Any]], ts_mode: str) -> str:
+    lines: List[str] = [
+        "from pydantic import BaseModel, ConfigDict",
+        "import datetime",
+        "from typing import Optional, Any",
+        "",
+    ]
+    for entity in entities:
+        name = _safe_name(entity.get("name", "Model"))
+        attrs: List[Dict[str, Any]] = entity.get("attributes", []) or []
+        lines.append(f"class {name}(BaseModel):")
+        if not attrs:
+            lines.append("    model_config = ConfigDict(extra='allow')")
+            lines.append("    pass")
+            lines.append("")
+            continue
+        for attr in attrs:
+            field = attr.get("name", "")
+            ann = _attribute_annotation(attr, ts_mode)
+            lines.append(f"    {field}: {ann} = None")
+        lines.append("    model_config = ConfigDict(extra='allow')")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def generate_models(schema: Dict[str, Any], out: Path, *, package: Optional[str] = None, timestamp_mode: str = "datetime", models_mode: str = "plain") -> None:
+    entities: List[Dict[str, Any]] = schema.get("entities", []) or []
+    ts_mode = timestamp_mode
+    if out.suffix == ".py":
+        out.parent.mkdir(parents=True, exist_ok=True)
+        model_block = _emit_all_models(entities, ts_mode) if models_mode == "plain" else _emit_pydantic_models(entities, ts_mode)
+        content = "\n".join(
+            [
+                "import datetime",
+                "from typing import Optional",
+                "",
+                _emit_tables(entities),
+                _emit_schema_map(schema),
+                model_block,
+            ]
+        )
+        out.write_text(content, encoding="utf-8")
+        return
+
+    # treat as directory
+    out.mkdir(parents=True, exist_ok=True)
+    init_text = _emit_init(entities)
+    (out / "__init__.py").write_text(init_text + "\n", encoding="utf-8")
+    (out / "tables.py").write_text(_emit_tables(entities), encoding="utf-8")
+    (out / "schema.py").write_text(_emit_schema_map(schema), encoding="utf-8")
+    models_path = out / "models.py"
+    model_block = _emit_all_models(entities, ts_mode) if models_mode == "plain" else _emit_pydantic_models(entities, ts_mode)
+    models_path.write_text(model_block, encoding="utf-8")