continuo-python-runtime 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

continuo_python_runtime/hashing.py

@@ -1,34 +1,89 @@
-import copy
-import hashlib
-import json
+"""Content hashing: three independent parts folded into one content_hash.
+
+The three parts (``source_hash``, ``shared_code_hash``, ``config_hash``) are
+computed independently from already-gathered bytes/dicts and folded together
+with ``content_hash_fold``. This module is pure computation — no filesystem
+access, no knowledge of ``closure.py`` — so the known-vector tests can call
+``content_hash_fold`` on bare strings with no entry or file involved.
+
+The fold formula and the ``shared_code_hash`` sorted-digest fold are wire
+contracts mirrored byte-for-byte from continuo's manifest-controller
+(``content_hash_fold``) and its dbt-side shared-code hashing. Every byte here
+is load-bearing: manifest-controller independently recomputes the fold from
+the parts this repo emits and rejects the release artifact if the two
+results differ.
+"""
+
+from collections.abc import Iterable
+from copy import deepcopy
+from hashlib import sha256
+from json import dumps
+
+HASH_PART_FIELDS = ("source_hash", "shared_code_hash", "config_hash")
+CONTENT_HASH_FIELD = "content_hash"
 
 
 def canonical_entry(entry: dict) -> dict:
+    """Deep-copy *entry*, drop the four hash fields, whitespace-normalize reads.
+
+    Drops ``content_hash`` and all three of ``HASH_PART_FIELDS`` from the
+    basis, and whitespace-normalizes every ``str`` value in ``reads`` via
+    ``" ".join(sql.split())``. Everything else is preserved verbatim,
+    including ``config``.
     """
-    Deep-copy the entry, drop content_hash field, and whitespace-normalize
-    every value in reads via " ".join(sql.split()).
-    """
-    canonical = copy.deepcopy(entry)
+    canonical = deepcopy(entry)
 
-    # Drop content_hash if present
-    canonical.pop("content_hash", None)
+    canonical.pop(CONTENT_HASH_FIELD, None)
+    for field in HASH_PART_FIELDS:
+        canonical.pop(field, None)
 
-    # Whitespace-normalize every value in reads
-    if "reads" in canonical and isinstance(canonical["reads"], dict):
-        for key, value in canonical["reads"].items():
+    reads = canonical.get("reads")
+    if isinstance(reads, dict):
+        for key, value in reads.items():
             if isinstance(value, str):
-                canonical["reads"][key] = " ".join(value.split())
+                reads[key] = " ".join(value.split())
 
     return canonical
 
 
-def content_hash(entry: dict, script_bytes: bytes) -> str:
-    """
-    Compute content hash using the formula:
-    "sha256:" + sha256(json.dumps(canonical_entry(entry), sort_keys=True, separators=(",", ":")).encode() + b"\x00" + script_bytes).hexdigest()
-    """
-    canonical = canonical_entry(entry)
-    json_str = json.dumps(canonical, sort_keys=True, separators=(",", ":"))
-    data = json_str.encode() + b"\x00" + script_bytes
-    hash_digest = hashlib.sha256(data).hexdigest()
-    return "sha256:" + hash_digest
+def canonical_json(entry: dict) -> str:
+    """`json.dumps(canonical_entry(entry), sort_keys=True, separators=(",", ":"))`."""
+    return dumps(canonical_entry(entry), sort_keys=True, separators=(",", ":"))
+
+
+def source_hash(script_bytes: bytes) -> str:
+    """Bare hex `sha256(script_bytes)` — the node's own script, byte-for-byte."""
+    return sha256(script_bytes).hexdigest()
+
+
+def shared_code_hash(member_bytes: Iterable[bytes]) -> str:
+    """`""` when the closure is empty, else bare hex of the sorted-digest fold."""
+    unit_hashes = sorted(sha256(member).hexdigest() for member in member_bytes)
+    if not unit_hashes:
+        return ""
+    return sha256("".join(unit_hashes).encode()).hexdigest()
+
+
+def config_hash(entry: dict) -> str:
+    """Bare hex `sha256(canonical_json(entry).encode())`."""
+    return sha256(canonical_json(entry).encode()).hexdigest()
+
+
+def content_hash_fold(source: str, shared: str, config: str) -> str:
+    """`"sha256:" + sha256(f"{source}|{shared}|{config}".encode()).hexdigest()`."""
+    return "sha256:" + sha256(f"{source}|{shared}|{config}".encode()).hexdigest()
+
+
+def hash_parts(
+    entry: dict, script_bytes: bytes, member_bytes: Iterable[bytes]
+) -> dict[str, str]:
+    """Return all four fields: the three parts plus their fold."""
+    s = source_hash(script_bytes)
+    sh = shared_code_hash(member_bytes)
+    c = config_hash(entry)
+    return {
+        "source_hash": s,
+        "shared_code_hash": sh,
+        "config_hash": c,
+        "content_hash": content_hash_fold(s, sh, c),
+    }

continuo_python_runtime/lint.py

@@ -1,9 +1,12 @@
-"""Script linting for forbidden imports, SQL literals, and data-access calls."""
+"""Script linting for forbidden imports, SQL literals, data-access calls, and
+dynamic-import constructs."""
 
 import ast
 import re
 from pathlib import Path
 
+from continuo_python_runtime.closure import dynamic_import_violations
+
 # Forbidden warehouse driver modules (check root module of imports)
 FORBIDDEN_DRIVERS = {
     "psycopg2",
@@ -127,14 +130,23 @@ def lint_source(source: str, filename: str) -> list[str]:
       they are never matched and need no exemption. Exempted: attribute
       access on ``self``/``cls`` (e.g. ``self._helper()``), so a script's own
       class-private helpers aren't flagged.
+    - L5: dynamic-import construct (``importlib`` in any form, ``__import__``,
+      ``exec``, ``eval``, or ``.import_module``). The content hash's import
+      closure is computed by static AST analysis (see ``closure.py``); a
+      construct that analysis cannot see must not exist, or a node could
+      import a module whose edits never re-fingerprint it. Detection is
+      delegated to ``continuo_python_runtime.closure.dynamic_import_violations``
+      so the predicate is defined in exactly one place.
 
     Docstrings (the first statement of a Module/ClassDef/FunctionDef/
     AsyncFunctionDef body, when it is a bare string Expr) are exempt from the
     L2 constant pass, since prose commonly contains words like "select" and
     "from". This is a best-effort, position-based exemption: the same prose
     assigned to a variable is still flagged.
+
+    Violations are returned sorted by line number; ties keep discovery order.
     """
-    violations = []
+    entries: list[tuple[int, str]] = []
 
     # Try to parse the source code
     try:
@@ -152,16 +164,16 @@ def lint_source(source: str, filename: str) -> list[str]:
             for alias in node.names:
                 root_module = alias.name.split(".")[0]
                 if root_module in FORBIDDEN_DRIVERS:
-                    violations.append(
-                        f"{filename}:{node.lineno}: forbidden warehouse driver import '{root_module}'"
+                    entries.append(
+                        (node.lineno, f"forbidden warehouse driver import '{root_module}'")
                     )
 
         elif isinstance(node, ast.ImportFrom):
             if node.module:
                 root_module = node.module.split(".")[0]
                 if root_module in FORBIDDEN_DRIVERS:
-                    violations.append(
-                        f"{filename}:{node.lineno}: forbidden warehouse driver import '{root_module}'"
+                    entries.append(
+                        (node.lineno, f"forbidden warehouse driver import '{root_module}'")
                     )
 
             # Track imports of forbidden data-access functions
@@ -171,8 +183,8 @@ def lint_source(source: str, filename: str) -> list[str]:
                     if alias.name in FORBIDDEN_CALLS:
                         local_name = alias.asname if alias.asname else alias.name
                         imported_forbidden_calls[local_name] = node.lineno
-                        violations.append(
-                            f"{filename}:{node.lineno}: forbidden data-access import '{alias.name}'"
+                        entries.append(
+                            (node.lineno, f"forbidden data-access import '{alias.name}'")
                         )
 
     # Track constants consumed in compound expressions (to avoid double-reporting)
@@ -190,9 +202,7 @@ def lint_source(source: str, filename: str) -> list[str]:
                 snippet = reconstructed[:40]
                 if len(reconstructed) > 40:
                     snippet += "..."
-                violations.append(
-                    f"{filename}:{node.lineno}: SQL string literal '{snippet}'"
-                )
+                entries.append((node.lineno, f"SQL string literal '{snippet}'"))
             # Only the literal fragments actually folded into the
             # reconstruction are consumed; FormattedValue contents are not.
             consumed_constants |= consumed
@@ -206,9 +216,7 @@ def lint_source(source: str, filename: str) -> list[str]:
                     snippet = reconstructed_text[:40]
                     if len(reconstructed_text) > 40:
                         snippet += "..."
-                    violations.append(
-                        f"{filename}:{node.lineno}: SQL string literal '{snippet}'"
-                    )
+                    entries.append((node.lineno, f"SQL string literal '{snippet}'"))
                 # Only the leaf Constants actually folded into the
                 # reconstruction are consumed - never descendants of a
                 # FormattedValue expression.
@@ -222,24 +230,22 @@ def lint_source(source: str, filename: str) -> list[str]:
                     snippet = node.value[:40]
                     if len(node.value) > 40:
                         snippet += "..."
-                    violations.append(
-                        f"{filename}:{node.lineno}: SQL string literal '{snippet}'"
-                    )
+                    entries.append((node.lineno, f"SQL string literal '{snippet}'"))
 
         # L3: Check for forbidden data-access calls
         elif isinstance(node, ast.Call):
             # Attribute access: pd.read_sql(...)
             if isinstance(node.func, ast.Attribute):
                 if node.func.attr in FORBIDDEN_CALLS:
-                    violations.append(
-                        f"{filename}:{node.lineno}: forbidden data-access call '{node.func.attr}'"
+                    entries.append(
+                        (node.lineno, f"forbidden data-access call '{node.func.attr}'")
                     )
 
             # Name reference: read_sql_table(...) or rs(...) where rs is an alias
             elif isinstance(node.func, ast.Name):
                 if node.func.id in imported_forbidden_calls:
-                    violations.append(
-                        f"{filename}:{node.lineno}: forbidden data-access call '{node.func.id}'"
+                    entries.append(
+                        (node.lineno, f"forbidden data-access call '{node.func.id}'")
                     )
 
         # L4: Check for private/protected attribute access
@@ -249,11 +255,19 @@ def lint_source(source: str, filename: str) -> list[str]:
                 "cls",
             )
             if node.attr.startswith("_") and not is_self_or_cls:
-                violations.append(
-                    f"{filename}:{node.lineno}: private attribute access '{node.attr}'"
-                )
-
-    return violations
+                entries.append((node.lineno, f"private attribute access '{node.attr}'"))
+
+    # L5: dynamic-import constructs, reported via the shared closure.py
+    # predicate (which raises on only the first hit; here every hit counts).
+    for lineno, construct in dynamic_import_violations(tree):
+        entries.append((lineno, f"dynamic import construct '{construct}'"))
+
+    # Stable sort by line number: this is what puts L5 hits "alongside" the
+    # L1-L4 hits found above instead of trailing as a separate block, while
+    # violations on the same line keep the order the passes above found them
+    # (L1 first pass, then L2-L4 second pass, then L5).
+    entries.sort(key=lambda entry: entry[0])
+    return [f"{filename}:{lineno}: {message}" for lineno, message in entries]
 
 
 def lint_paths(paths: list[Path]) -> list[str]:

continuo_python_runtime/types.py

@@ -10,6 +10,7 @@ import re
 from dataclasses import dataclass
 
 import pyarrow as pa  # type: ignore[import-untyped]
+from continuo_validation_contract.types import validate_column_type  # type: ignore[import-untyped]
 
 from continuo_python_runtime.errors import ContractError
 
@@ -36,6 +37,14 @@ class SqlType:
 def parse_sql_type(raw: str) -> SqlType:
     """Parse a SQL type string into a canonical SqlType.
 
+    ``continuo_validation_contract.types.validate_column_type`` is the single
+    acceptance authority for the grammar shape (case-insensitive, injection-
+    guarded): it runs first, and anything it rejects is rejected here too. The
+    logic below only extracts precision/scale/length and enforces the NUMERIC
+    range this repo's Arrow mapping additionally requires (1-38 precision,
+    0-precision scale) -- a semantic check the shared grammar deliberately
+    doesn't make, since it's specific to this repo's decimal128 mapping.
+
     Args:
         raw: A SQL type string (case-insensitive).
 
@@ -43,44 +52,39 @@ def parse_sql_type(raw: str) -> SqlType:
         A SqlType with canonicalized base and parsed parameters.
 
     Raises:
-        ContractError: If the type is unsupported or malformed.
+        ContractError: If the type is unsupported or malformed, or a NUMERIC's
+            precision/scale is out of range.
     """
     raw = raw.strip()
-    if not raw:
-        raise ContractError("type: empty string is not a valid SQL type")
+    try:
+        validate_column_type(raw)
+    except ValueError as exc:
+        raise ContractError(str(exc)) from exc
 
     # Normalize to uppercase for parsing
     normalized = raw.upper()
 
-    # Handle DOUBLE PRECISION specially (has a space). Only the authored
-    # spelling with a space is part of the contract grammar; the internal
-    # canonical spelling (with an underscore) is not accepted as input even
-    # though it is the SqlType.base value produced above.
+    # Handle DOUBLE PRECISION specially (has a space). It is the only grammar
+    # member whose canonical SqlType.base spelling (DOUBLE_PRECISION, with an
+    # underscore) differs from its authored one.
     if normalized == "DOUBLE PRECISION":
         return SqlType("DOUBLE_PRECISION")
 
-    # Try to match parametrized types: TYPE(args)
+    # Parametrized types: TYPE(args). validate_column_type above has already
+    # rejected every shape but (NUMERIC|DECIMAL)(\d+,\s*\d+) and
+    # (VARCHAR|CHAR)(\d+), so no further shape checking is needed here.
     match = re.match(r"^([A-Z_]+)\s*\((.*)\)$", normalized)
     if match:
         base_name = match.group(1).strip()
         params_str = match.group(2).strip()
 
-        # Alias handling
-        if base_name == "INT":
-            base_name = "INTEGER"
-        elif base_name == "DECIMAL":
+        if base_name == "DECIMAL":
             base_name = "NUMERIC"
 
         if base_name == "NUMERIC":
-            # Parse NUMERIC(precision, scale) - strict format: \d+,\s*\d+ (spaces only after comma)
-            numeric_match = re.match(r"^(\d+),\s*(\d+)$", params_str)
-            if not numeric_match:
-                raise ContractError(
-                    f"type: NUMERIC requires precision and scale as unsigned integers, "
-                    f"got ({params_str})"
-                )
-            precision = int(numeric_match.group(1))
-            scale = int(numeric_match.group(2))
+            precision_str, scale_str = params_str.split(",")
+            precision = int(precision_str)
+            scale = int(scale_str)
             if not (1 <= precision <= 38):
                 raise ContractError(
                     f"type: NUMERIC precision must be between 1 and 38, got {precision}"
@@ -92,82 +96,14 @@ def parse_sql_type(raw: str) -> SqlType:
                 )
             return SqlType("NUMERIC", precision=precision, scale=scale)
 
-        elif base_name == "VARCHAR":
-            # Parse VARCHAR(length) - strict format: \d+ only
-            if "," in params_str:
-                raise ContractError(
-                    f"type: VARCHAR takes a single parameter (length), "
-                    f"got {params_str!r}"
-                )
-            varchar_match = re.match(r"^(\d+)$", params_str)
-            if not varchar_match:
-                raise ContractError(
-                    f"type: VARCHAR length must be an unsigned integer, "
-                    f"got {params_str!r}"
-                )
-            length = int(varchar_match.group(1))
-            return SqlType("VARCHAR", length=length)
+        # VARCHAR(length) or CHAR(length)
+        return SqlType(base_name, length=int(params_str))
 
-        elif base_name == "CHAR":
-            # Parse CHAR(length) - strict format: \d+ only
-            if "," in params_str:
-                raise ContractError(
-                    f"type: CHAR takes a single parameter (length), "
-                    f"got {params_str!r}"
-                )
-            char_match = re.match(r"^(\d+)$", params_str)
-            if not char_match:
-                raise ContractError(
-                    f"type: CHAR length must be an unsigned integer, "
-                    f"got {params_str!r}"
-                )
-            length = int(char_match.group(1))
-            return SqlType("CHAR", length=length)
-
-        else:
-            # No other types accept parameters
-            raise ContractError(
-                f"type: {base_name} does not accept parameters, got ({params_str})"
-            )
-
-    # No parameters - must be a bare base type
-    normalized_base = normalized
-
-    # Alias handling
-    if normalized_base == "INT":
-        normalized_base = "INTEGER"
-    elif normalized_base == "DECIMAL":
-        normalized_base = "NUMERIC"
-
-    # List of supported bare types
-    # Note: "DOUBLE_PRECISION" (underscored) is deliberately excluded here.
-    # It is the canonical SqlType.base value, but only the authored spelling
-    # "DOUBLE PRECISION" (with a space) is part of the contract grammar and
-    # is handled above.
-    supported_bare = {
-        "BIGINT",
-        "INTEGER",
-        "TEXT",
-        "TIMESTAMP",
-        "DATE",
-        "BOOLEAN",
-    }
-
-    if normalized_base in supported_bare:
-        return SqlType(normalized_base)
-
-    # Bare VARCHAR and CHAR require a length parameter
-    if normalized_base == "VARCHAR":
-        raise ContractError(f"type: VARCHAR requires a length parameter, got {raw!r}")
-    if normalized_base == "CHAR":
-        raise ContractError(f"type: CHAR requires a length parameter, got {raw!r}")
-
-    # Bare NUMERIC and DECIMAL require parameters
-    if normalized_base == "NUMERIC":
-        raise ContractError(f"type: NUMERIC requires precision and scale parameters, got {raw!r}")
-
-    # Unknown type
-    raise ContractError(f"type: unknown SQL type {raw!r}")
+    # Bare base type: BIGINT, INT, INTEGER, TEXT, TIMESTAMP, DATE, BOOLEAN --
+    # the only shapes left once DOUBLE PRECISION and the parametrized types
+    # above are ruled out.
+    normalized_base = "INTEGER" if normalized == "INT" else normalized
+    return SqlType(normalized_base)
 
 
 def arrow_type(t: SqlType) -> pa.DataType:

{continuo_python_runtime-0.1.0.dist-info → continuo_python_runtime-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: continuo-python-runtime
-Version: 0.1.0
+Version: 0.2.0
 Summary: Runtime harness, contract tooling, and CI lint for Continuo python nodes.
 Author: Simone Carolini
 Maintainer: Simone Carolini
@@ -8,9 +8,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.14
-Requires-Dist: continuo-validation-contract==0.3.0
+Requires-Dist: continuo-validation-contract==0.4.0
 Requires-Dist: pyarrow==25.0.0
 Requires-Dist: pyyaml==6.0.3
+Requires-Dist: sqlglot==30.15.0
 Description-Content-Type: text/markdown
 
 # Continuo Python Runtime
@@ -51,17 +52,26 @@ data-plane adapters here.
 | Package (distribution name) | Module | Lives in | Role |
 | --- | --- | --- | --- |
 | `continuo-python-runtime` | `continuo_python_runtime` | this repo (root) | Harness: CLI, `conform()`, `RunContext`, error taxonomy. |
-| `continuo-python-runtime-postgres` | `continuo_python_runtime_postgres` | this repo, `python-runtime-postgres/` | Data-plane `RuntimeAdapter` for Postgres (`fetch`/`ensure_table`/`load`). |
-| `continuo-python-runtime-trino` | `continuo_python_runtime_trino` | this repo, `python-runtime-trino/` | Data-plane `RuntimeAdapter` for Trino/Iceberg. |
+| `continuo-python-runtime-postgres` | `continuo_python_runtime_postgres` | this repo, `python-runtime-postgres/` | Data-plane `RuntimeAdapter` for Postgres (`fetch`/`ensure_table`/`load`). **Not published to PyPI** — built from source into the image. |
+| `continuo-python-runtime-trino` | `continuo_python_runtime_trino` | this repo, `python-runtime-trino/` | Data-plane `RuntimeAdapter` for Trino/Iceberg. **Not published to PyPI** — built from source into the image. |
 | `continuo-validation-contract` | `continuo_validation_contract` | `continuo-validation-runners` | The published contract (schema, `RuntimeAdapter` port, result-block format) both sides depend on. |
 | `continuo-validation-postgres` / `continuo-validation-trino` | `continuo_validation_postgres` / `continuo_validation_trino` | `continuo-validation-runners` | Validation-side (lint/merge, no live warehouse I/O) adapters — not to be confused with the data-plane adapters above. |
 
 All three packages built in this repo resolve `continuo-validation-contract`
-from PyPI (`==0.3.0`); the two adapter packages are uv workspace members
+from PyPI (`==0.4.0`); the two adapter packages are uv workspace members
 (`[tool.uv.workspace]` in the root `pyproject.toml`), so `uv sync
 --all-packages --all-groups` at the repo root installs everything for local
 development.
 
+**Only `continuo-python-runtime` is published to PyPI.** The two engine
+adapters are built **from source into the runtime images**: `Dockerfile.postgres`
+and `Dockerfile.trino` `pip install` them out of the build context, so each
+image ships exactly one adapter and the harness discovers it through the
+`continuo_runtime.adapters` entry-point group at run time. Nothing installs
+them from an index — the harness package does not depend on them, and domain
+repos get their adapter by building `FROM` a published base image. They are
+still built, type-checked, and tested by CI on every change.
+
 ## Quickstart for domain teams
 
 1. Copy `template/` into a new repository.
@@ -85,6 +95,28 @@ development.
    and merges the contracts, builds and pushes the image, uploads the merged
    contract to S3, and POSTs the release.
 
+### Upgrading an existing domain repo
+
+`validate` / `merge` / `hash` now hand every declared read to a real SQL
+parser (sqlglot, via `continuo_validation_contract.sql.ensure_single_read`)
+instead of scanning it for a leading `SELECT`/`WITH`. Two things follow for a
+repo written before this, on its next release: SQL a driver would accept but
+a parser will not — most commonly a driver-specific bind placeholder like
+psycopg2's `%(name)s`, which `ctx.read(name)` could never have used anyway —
+now fails validation, and engine-specific syntax (postgres `~`, `@>`, …)
+needs `--dialect <engine>`, which a repo should be passing regardless since
+Continuo bind-checks every read in the install's own warehouse dialect. Run
+the pre-flight check once before your next release; it reports every affected
+read at once:
+
+```bash
+continuo-runtime validate contracts/ --dialect postgres   # or trino
+```
+
+The runtime image does not re-run this gate, so a read that passes here is
+not re-judged under a different grammar in production. See
+`docs/boundary-contract.md` §13.1.
+
 ## The script API
 
 A node script is a Python file with exactly one required entry point:
@@ -125,6 +157,17 @@ def run(ctx):
   are the driver-import and data-access-call rules, together with the fact
   that `RunContext` only exposes `ctx.read()` — all warehouse access goes
   through it.
+- Scripts may import shared in-repo helpers. Before executing a script the
+  harness puts the repo root (`APP_ROOT`) and the script's own directory on
+  `sys.path`, so both `import helpers` (a sibling of the script) and
+  `from lib.shared import ...` (anywhere under the repo root) work, including
+  from inside `run()`. Every helper a script reaches transitively is folded
+  into `shared_code_hash`, so editing one re-fingerprints the node — but the
+  hash does not put the file in the image: **`COPY` every directory your
+  scripts import from in your `Dockerfile`**, or the release is valid and the
+  node dies with `ModuleNotFoundError` on its first run. Because the repo root
+  precedes the standard library on `sys.path`, avoid naming a top-level module
+  after a stdlib one (`types.py`, `json.py`, `logging.py`, …).
 - The harness — not the script — performs the write. It calls `conform()`
   on whatever `run()` returned and issues the only INSERT; the script never
   writes directly.
@@ -165,9 +208,9 @@ A domain repo picks its warehouse engine by which base image it builds
 `FROM`:
 
 ```dockerfile
-FROM ghcr.io/carolsimone/continuo-python-runtime:v0.1.0-postgres
+FROM ghcr.io/carolsimone/continuo-python-runtime:v0.2.0-postgres
 # or
-FROM ghcr.io/carolsimone/continuo-python-runtime:v0.1.0-trino
+FROM ghcr.io/carolsimone/continuo-python-runtime:v0.2.0-trino
 ```
 
 Each image bakes in exactly one `RuntimeAdapter` for that engine — installed

continuo_python_runtime-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+continuo_python_runtime/__init__.py,sha256=otNaXEPsTtRXJV5FLtDUsFO8VD4OC-MLAzwhtimHfOE,70
+continuo_python_runtime/cli.py,sha256=FlY1GqEKrtx4O34zMzlFVBuM6wAPaFEyAHjhN0lDcdA,5495
+continuo_python_runtime/closure.py,sha256=6e-IAQp8Lieb0bGKP1F6JE4TgVBJ_COTGXRUult2xeI,12991
+continuo_python_runtime/conform.py,sha256=a9CKCA-gT9Zerzr6c5H8aByTFOUd6uBMo02sNKSDnXg,9199
+continuo_python_runtime/context.py,sha256=ZyeN_dA2DihQbegBiiqHj1_EKk79GsxS-tATPVymUPg,1856
+continuo_python_runtime/errors.py,sha256=nfZzfBhQ2ajm7USAWKKaGY2uUlh8eNjNPNYYuaOJgZE,1032
+continuo_python_runtime/harness.py,sha256=SF5ciKsc1RawAQ41h_TuYqqkOp5mf5SSeELv0_B2EvI,12211
+continuo_python_runtime/hashing.py,sha256=70iXQb0CmjGqniTPofXY6WapydQ7aK2XOk5dzpEf-zk,3354
+continuo_python_runtime/lint.py,sha256=M59UtCHHVQnJKNolIkvkRk_AgGAFvxD9zkKAMMK-7GI,12984
+continuo_python_runtime/types.py,sha256=kecwFUMkfglv0h6fkcXTlHkEHeLziWyzJvBsimy-Bl0,5065
+continuo_python_runtime/contract/__init__.py,sha256=S79x6j_P0CmaSuCGzeWoK1U0507KvD2MZXwQl9DFWMM,37
+continuo_python_runtime/contract/loader.py,sha256=6w8uC7kZzGKMDj45pXJtWVI7Pa675CsjJG3e37LcelI,15623
+continuo_python_runtime/contract/merge.py,sha256=XCCeE2vJUm0KA60d2XsHpjRh5fIdVfFu_HsBzEyUWow,6505
+continuo_python_runtime/contract/model.py,sha256=2hKI04M0WwvTkOy9eDGl2dRZgY3bAuJYktAG-ICI-AU,936
+continuo_python_runtime/contract/paths.py,sha256=SRn70pJkDAIpXw0IcMU2iNKPKvct8w_SZP2ec-lV91M,1458
+continuo_python_runtime-0.2.0.dist-info/METADATA,sha256=Dvmmo8AgQ3gg0jFhJbcSDC3tCagVG_dSy5gfUj6L_bk,13607
+continuo_python_runtime-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+continuo_python_runtime-0.2.0.dist-info/entry_points.txt,sha256=ZvIwSm9f9B9ZmZMf6CyF5Zt4QONn8rqaIk-u-B1CF2Y,70
+continuo_python_runtime-0.2.0.dist-info/RECORD,,

continuo_python_runtime-0.1.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-continuo_python_runtime/__init__.py,sha256=otNaXEPsTtRXJV5FLtDUsFO8VD4OC-MLAzwhtimHfOE,70
-continuo_python_runtime/cli.py,sha256=Qki4Mfoab74D0DvguZd5yzSfI-FRQDmtvwC0OacxrAc,4860
-continuo_python_runtime/conform.py,sha256=a9CKCA-gT9Zerzr6c5H8aByTFOUd6uBMo02sNKSDnXg,9199
-continuo_python_runtime/context.py,sha256=ZyeN_dA2DihQbegBiiqHj1_EKk79GsxS-tATPVymUPg,1856
-continuo_python_runtime/errors.py,sha256=nfZzfBhQ2ajm7USAWKKaGY2uUlh8eNjNPNYYuaOJgZE,1032
-continuo_python_runtime/harness.py,sha256=YcWy4ummKY3HQYQ4JQ3-UI5jxDgYwJDQlWT88_GRPH4,7504
-continuo_python_runtime/hashing.py,sha256=6D4MntcjaHTEC55IQBBX2Pq9K59D0TWlxTSXGJ5Jsro,1159
-continuo_python_runtime/lint.py,sha256=HgB0BAuiQuS3DgT6BsOoB2M5A-_OKcFsGbaTWhuM7XU,11897
-continuo_python_runtime/types.py,sha256=z1qnBbbaP6nFN2mmRySXM4ZAesv5N6_4E9vZ4kv74HU,7138
-continuo_python_runtime/contract/__init__.py,sha256=S79x6j_P0CmaSuCGzeWoK1U0507KvD2MZXwQl9DFWMM,37
-continuo_python_runtime/contract/loader.py,sha256=wlxI6XZIoUZ4z9rDe1G8s26jbL0tGXnAHPGajTAM0ag,12828
-continuo_python_runtime/contract/merge.py,sha256=WFde9lzrojlMNjuEU7YW8FWOs6VPSrWPY2_Sri0ljZE,2567
-continuo_python_runtime/contract/model.py,sha256=6luq3SJcgshKoG0QsQhJPZ5fzLa8AcGAev9D4jiGgxA,849
-continuo_python_runtime/contract/paths.py,sha256=SRn70pJkDAIpXw0IcMU2iNKPKvct8w_SZP2ec-lV91M,1458
-continuo_python_runtime-0.1.0.dist-info/METADATA,sha256=YQWMZaYiS3gpRnIutzgKhT3KeB5BtUpeMrwi0qKLRUU,10953
-continuo_python_runtime-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-continuo_python_runtime-0.1.0.dist-info/entry_points.txt,sha256=ZvIwSm9f9B9ZmZMf6CyF5Zt4QONn8rqaIk-u-B1CF2Y,70
-continuo_python_runtime-0.1.0.dist-info/RECORD,,