smart-data-engine-sdk 0.1.0.dev0__py3-none-any.whl

sde/types.py

@@ -0,0 +1,228 @@
+"""The neutral type vocabulary, and the mapping from Python's types onto it.
+
+Why a vocabulary at all: ``Decimal`` in Python and ``BigDecimal`` in Java have to land on the same
+bytes in the canonical IR, or the same model gets two versions and the control plane sees two
+models. So no language's own type names ever reach the IR. Each library maps its host language onto
+this closed set, and the mapping is part of the published contract rather than an implementation
+detail.
+
+The set:
+
+    bool int32 int64 float32 float64 decimal(p,s) string bytes uuid date timestamp timestamptz json
+
+``decimal`` is the only parameterised member, written ``decimal(12,2)`` - precision then scale, no
+spaces. It is parameterised because a decimal without precision is not a storable type in any of the
+engines we place data in, and asking the engine to pick would make the physical schema depend on
+something the model did not say.
+
+**Floats are in the vocabulary, and this needed a correction to the specification.** The first draft
+of the format contract said "no floating point anywhere", conflating two different things. Canonical
+*encoding* must contain no float literals, because their textual form differs between languages -
+that rule stands and ``canonical.py`` enforces it. But a *field* may perfectly well be a float:
+sensor readings are the obvious case, and IoT at scale is one of the segments this product is aimed
+at. A field of type ``float64`` is recorded in the IR as the string ``"float64"``, so there is no
+float literal involved and no conflict. Forbidding the type would have meant telling a client to
+store temperatures as decimals, which is worse engineering than the rule was worth.
+
+Two mappings are defaults rather than one-to-one, and both are documented here because a silent
+default in a type mapping is the kind of thing that surfaces two years later as a timezone bug:
+
+* ``int`` maps to ``int64``. Python's integers are unbounded, so any choice is a narrowing; 64 bits
+  is what every target engine has a native type for. Use :data:`Int32` to say so explicitly.
+* ``datetime`` maps to ``timestamptz``. A naive timestamp is a latent bug in a system that may move
+  data between engines and regions, so the safe reading is the default and the narrow one has to be
+  asked for by name with :data:`Timestamp`.
+
+Anything with no mapping - a bare ``Decimal``, a custom class, ``complex`` - is a
+:class:`~sde.errors.DeclarationError`. Guessing would produce a physical schema the model did not
+ask for.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import decimal as _decimal
+import types as _pytypes
+import typing
+import uuid as _uuid
+from dataclasses import dataclass
+from typing import Annotated, Any, Final, get_args, get_origin
+
+from .errors import DeclarationError
+
+__all__ = [
+    "NEUTRAL_TYPES",
+    "Float32",
+    "Int32",
+    "Json",
+    "Timestamp",
+    "precision",
+    "resolve_type",
+]
+
+NEUTRAL_TYPES: Final[frozenset[str]] = frozenset(
+    {
+        "bool",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "string",
+        "bytes",
+        "uuid",
+        "date",
+        "timestamp",
+        "timestamptz",
+        "json",
+        # decimal is parameterised and validated by pattern, not by membership here.
+    }
+)
+
+
+@dataclass(frozen=True)
+class _Marker:
+    """Base for the annotations that disambiguate a mapping."""
+
+    kind: str
+
+
+@dataclass(frozen=True)
+class _Precision(_Marker):
+    digits: int
+    scale: int
+
+
+def precision(digits: int, scale: int) -> _Precision:
+    """Annotate a ``Decimal`` field with its precision and scale.
+
+    ``total: Annotated[Decimal, precision(12, 2)]``
+
+    Both are required. A decimal without them is not a storable type, and letting the engine choose
+    would make the physical schema depend on something the model never stated.
+    """
+    if digits < 1 or scale < 0 or scale > digits:
+        raise DeclarationError(
+            f"precision({digits}, {scale}) is not a usable decimal: digits must be at least 1 and "
+            "scale must be between 0 and digits"
+        )
+    return _Precision(kind="precision", digits=digits, scale=scale)
+
+
+Int32 = Annotated[int, _Marker(kind="int32")]
+"""A 32-bit integer, said explicitly. Bare ``int`` maps to ``int64``."""
+
+Float32 = Annotated[float, _Marker(kind="float32")]
+"""A single-precision float. Bare ``float`` maps to ``float64``."""
+
+Timestamp = Annotated[_dt.datetime, _Marker(kind="naive")]
+"""A timestamp without a zone. Bare ``datetime`` maps to ``timestamptz`` on purpose."""
+
+Json = Annotated[object, _Marker(kind="json")]
+"""An opaque JSON document. Use when the shape genuinely is not fixed, not to avoid declaring it."""
+
+_SIMPLE: Final[dict[Any, str]] = {
+    bool: "bool",
+    int: "int64",
+    float: "float64",
+    str: "string",
+    bytes: "bytes",
+    _uuid.UUID: "uuid",
+    _dt.date: "date",
+    _dt.datetime: "timestamptz",
+    dict: "json",
+    list: "json",
+}
+
+
+def _markers(annotation: object) -> tuple[object, tuple[_Marker, ...]]:
+    """Peel ``Annotated`` and ``Optional`` off an annotation.
+
+    Returns the bare type plus any markers found. Nullability is handled by the caller, which needs
+    to record it separately in the IR rather than as part of the type name.
+    """
+    markers: list[_Marker] = []
+    current = annotation
+    while get_origin(current) is Annotated:
+        args = get_args(current)
+        current = args[0]
+        markers.extend(m for m in args[1:] if isinstance(m, _Marker))
+    return current, tuple(markers)
+
+
+def _is_optional(annotation: object) -> tuple[bool, object]:
+    """Peel ``| None`` off, and refuse anything wider.
+
+    ``str | None`` is a nullable string. ``int | str`` is not a field: it has no single physical
+    representation, so there is no column we could create for it and no index we could put on it.
+    Refusing here rather than falling through to the vocabulary check matters only for the error
+    message, and the error message is the whole product for someone who mistyped an annotation.
+    """
+    origin = get_origin(annotation)
+    if origin is typing.Union or origin is _pytypes.UnionType:
+        args = get_args(annotation)
+        non_none = [a for a in args if a is not type(None)]
+        if len(non_none) != 1:
+            raise DeclarationError(
+                f"{annotation!r} is a union of several types. A field has one type; a union of two "
+                "real types has no single physical representation, so it cannot be placed. Model "
+                "it "
+                "as separate nullable fields, or as json if the shape really is not fixed."
+            )
+        return len(non_none) != len(args), non_none[0]
+    return False, annotation
+
+
+def resolve_type(annotation: object, *, field: str, entity: str) -> tuple[str, bool]:
+    """Map a Python annotation onto ``(neutral_type, nullable)``.
+
+    Raises :class:`~sde.errors.DeclarationError` naming the field, because the reader has to fix
+    their declaration and a traceback into this module tells them nothing.
+    """
+    nullable, inner = _is_optional(annotation)
+    bare, markers = _markers(inner)
+    # Optional may sit inside Annotated as well: Annotated[int | None, ...].
+    nested_nullable, bare = _is_optional(bare)
+    nullable = nullable or nested_nullable
+
+    kinds = {m.kind for m in markers}
+
+    if bare is _decimal.Decimal:
+        found = [m for m in markers if isinstance(m, _Precision)]
+        if not found:
+            raise DeclarationError(
+                f"{entity}.{field} is a Decimal without precision. Write "
+                f"Annotated[Decimal, precision(digits, scale)] - a decimal without precision is "
+                "not "
+                "a storable type in any engine we place data in, and choosing for you would make "
+                "the physical schema depend on something your model did not say."
+            )
+        p = found[0]
+        return f"decimal({p.digits},{p.scale})", nullable
+
+    if "json" in kinds:
+        return "json", nullable
+    if "int32" in kinds:
+        return "int32", nullable
+    if "float32" in kinds:
+        return "float32", nullable
+    if "naive" in kinds:
+        if bare is not _dt.datetime:
+            raise DeclarationError(
+                f"{entity}.{field} is annotated as a naive timestamp but is not a datetime"
+            )
+        return "timestamp", nullable
+
+    origin = get_origin(bare)
+    if origin in (dict, list):
+        return "json", nullable
+
+    mapped = _SIMPLE.get(bare)
+    if mapped is not None:
+        return mapped, nullable
+
+    raise DeclarationError(
+        f"{entity}.{field} has type {bare!r}, which has no place in the neutral type vocabulary "
+        f"({', '.join(sorted(NEUTRAL_TYPES))}, decimal(p,s)). Map it yourself - to a string, to "
+        "json, to a decimal with stated precision - so that the choice is visible in the model "
+        "instead of being guessed here."
+    )

sde/watermark.py

@@ -0,0 +1,222 @@
+"""Refusing a placement map that goes backwards, and the durable state that makes it possible.
+
+A signed map for version 3 verifies correctly forever - that is what a signature is. So replacing
+the client's map file with an older signed one loads cleanly, routes writes to the previous
+placement, and **nothing protests**. Today that costs a client a stale schema. Once the migration
+state travels in the map, it costs them writes: a library reverted from dual-write to single-write
+in the middle of a migration drops exactly the rows the migration exists not to drop.
+
+Refusing it needs one thing the library has never had: **memory**. Everything else here is a pure
+function of a document, a model and a key, which is why it can be verified by reading it. This
+module is the exception, and each of the three obvious places to keep that memory is worse than the
+one chosen:
+
+- **in the process** protects until the first restart, and a restart is when a swapped file is
+  read. A protection that lapses exactly when it is needed;
+- **in a file** needs a configured path, and in a container that path is usually ephemeral - so it
+  degrades to the first option while continuing to look like the third. The worst property
+  available: a guarantee that is present in the code and absent in production;
+- **with us** would mean the library asking our service whether it may start, which is the one
+  thing this product promises it will never need to do. Our outage would become the client's.
+
+So it lives **in the client's own engines**, in a table this library owns. The library already
+creates tables there; this is one more, it holds no client data, and we still never see a row of it.
+
+Four properties, and the first two are what make it safe rather than merely present.
+
+**Append-only, and the watermark is `max(map_version)`.** No update, no key enforcement, no
+row-level contention - and therefore identical semantics in PostgreSQL and in ClickHouse, which is
+the engine that has no unique constraint to offer. A stale row can never lower the bar. It also
+leaves an audit trail for free: which map versions this deployment has seen, and when.
+
+**Every participating engine is written, and the watermark is the maximum over all of them.**
+Losing an engine cannot lose the protection, and one engine lagging cannot weaken it.
+
+**An engine that cannot store it does not participate, and that is reported rather than hidden.**
+The orderbook engine has a schema fixed in its own source and no room for bookkeeping, so a client
+whose only engine is that one has no rollback protection and cannot have any. The honest maximum is
+to say so - :class:`WatermarkCheck` carries it and ``Session`` exposes it, because a protection
+whose state cannot be read is a protection taken on trust.
+
+**Only signed maps are checked.** An unsigned map is the client's own document: hand-writing one and
+pointing a library at it is the no-account mode, and their business what they replace it with. A
+signed map is one we issued, which is precisely when we are the authority on what the newest version
+is. In pure no-account mode this module does nothing at all - no table, no query, no cost.
+
+The escape hatch is deliberately not a parameter. A legitimate rollback - we issued a bad map -
+means clearing the bookkeeping, and the refusal says how. A parameter called ``allow_rollback``
+would be set once during an incident and left set.
+
+**A limitation worth stating.** The watermark is per engine and the format has no field naming which
+stream of maps a document belongs to, so an engine shared by two independent map streams would have
+the higher one refusing the lower. The fix is a separate database per stream, which a shared engine
+wants regardless; inventing a stream identifier would mean a new key in a signed document, which is
+a loosening of the format and a contract bump in every language at once.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, Protocol, runtime_checkable
+
+from .capabilities import satisfies
+from .errors import MapRolledBack
+from .logging import log
+from .placement import WATERMARK_TABLE, PlacementMap
+
+__all__ = [
+    "WATERMARK_TABLE",
+    "Protection",
+    "WatermarkCheck",
+    "WatermarkStore",
+    "enforce_forward_only",
+]
+
+Protection = Literal["enforced", "unavailable", "not_applicable"]
+
+
+@runtime_checkable
+class WatermarkStore(Protocol):
+    """What an engine adapter needs to offer to take part.
+
+    A separate protocol from :class:`~sde.session.Engine`, and optional. Adding two methods to
+    ``Engine`` would break every adapter anybody has written against it - including the fakes in
+    somebody else's test suite - for a capability one of our own three engines cannot provide
+    anyway. So participation is discovered rather than required, and non-participation is a
+    reportable state instead of a crash.
+    """
+
+    def map_watermark(self) -> int | None: ...
+    def record_map_version(self, version: int, *, model_version: str) -> None: ...
+
+
+@dataclass(frozen=True)
+class WatermarkCheck:
+    """What the check did, in a form a client can assert on.
+
+    Exposed rather than kept private on purpose. A protection whose state cannot be read is a
+    protection taken on trust, and this product's whole argument is that its guarantees are
+    checkable by reading the code and now by reading this.
+    """
+
+    protection: Protection
+    map_version: int
+    highest_seen: int | None
+    participating: tuple[str, ...]
+    unable: tuple[str, ...]
+    why: str
+
+    def as_record(self) -> dict[str, Any]:
+        return {
+            "protection": self.protection,
+            "map_version": self.map_version,
+            "highest_seen": self.highest_seen,
+            "participating": list(self.participating),
+            "unable": list(self.unable),
+            "why": self.why,
+        }
+
+
+def _split(engines: Mapping[str, Any]) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    """Which engines can keep the bookkeeping and which cannot, both sorted.
+
+    Asked with :func:`sde.capabilities.satisfies` rather than `isinstance`, because a
+    runtime_checkable protocol resolves members without consulting `__getattr__` - so a client
+    wrapping one of our adapters for metrics or retries would be reported here as an engine with
+    nowhere to keep the bookkeeping, and would silently lose rollback protection under a message
+    blaming their engine's schema.
+    """
+    able = sorted(name for name, engine in engines.items() if satisfies(engine, WatermarkStore))
+    unable = sorted(set(engines) - set(able))
+    return tuple(able), tuple(unable)
+
+
+def enforce_forward_only(
+    placement: PlacementMap, engines: Mapping[str, Any]
+) -> WatermarkCheck:
+    """Refuse a signed map older than the newest one these engines have seen.
+
+    Raises :class:`~sde.errors.MapRolledBack`. Equal is allowed - restarting a process against the
+    same map is the ordinary case - and only strictly lower is refused.
+    """
+    if not placement.signed:
+        return WatermarkCheck(
+            protection="not_applicable",
+            map_version=placement.map_version,
+            highest_seen=None,
+            participating=(),
+            unable=tuple(sorted(engines)),
+            why=(
+                "this map is unsigned, so it is your own document rather than one we issued. "
+                "Replacing it with another is the no-account mode working as documented, and there "
+                "is no newest version for us to be the authority on."
+            ),
+        )
+
+    able, unable = _split(engines)
+    if not able:
+        check = WatermarkCheck(
+            protection="unavailable",
+            map_version=placement.map_version,
+            highest_seen=None,
+            participating=(),
+            unable=unable,
+            why=(
+                f"none of the engines in this map can keep bookkeeping ({list(unable)}), so a map "
+                f"that goes backwards cannot be recognised. An engine whose schema is fixed in its "
+                f"own source - ours is - has nowhere to put it. Nothing is wrong with your "
+                f"configuration; this protection simply does not exist for it."
+            ),
+        )
+        log(
+            "sde.map.rollback_unprotected",
+            map_version=placement.map_version,
+            engines=len(unable),
+        )
+        return check
+
+    seen = [store.map_watermark() for store in (engines[name] for name in able)]
+    known = [value for value in seen if value is not None]
+    highest = max(known) if known else None
+
+    if highest is not None and placement.map_version < highest:
+        raise MapRolledBack(
+            f"this map is version {placement.map_version} and version {highest} has already been "
+            f"applied against these engines. Refusing to go backwards: an older signed map "
+            f"verifies perfectly - that is what a signature is - so nothing else here would notice "
+            f"that the file was replaced, and the writes would go to the previous placement. If "
+            f"this is deliberate, because the newer map was wrong, clear the bookkeeping: "
+            f"DELETE FROM {WATERMARK_TABLE} WHERE map_version > {placement.map_version}; in "
+            f"{list(able)}, and on an engine that deletes asynchronously, let the deletion finish "
+            f"before restarting. That is a deliberate act with a stated consequence, which is why "
+            f"it is not a flag."
+        )
+
+    if highest is None or placement.map_version > highest:
+        # Written only when it moves. Recording every start would grow the table by one row per
+        # process restart, and the watermark would say nothing more than it does now.
+        for name in able:
+            store: WatermarkStore = engines[name]
+            store.record_map_version(
+                placement.map_version, model_version=placement.model_version
+            )
+
+    log(
+        "sde.map.forward_only",
+        map_version=placement.map_version,
+        highest_seen=highest,
+        engines=len(able),
+    )
+    return WatermarkCheck(
+        protection="enforced",
+        map_version=placement.map_version,
+        highest_seen=highest,
+        participating=able,
+        unable=unable,
+        why=(
+            f"the highest map version applied against these engines is "
+            f"{highest if highest is not None else placement.map_version}, kept in "
+            f"{WATERMARK_TABLE} in {list(able)}. A map older than that is refused."
+        ),
+    )

smart_data_engine_sdk-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.5
+Name: smart-data-engine-sdk
+Version: 0.1.0.dev0
+Summary: Smart Data Engine client library: declare a data model, we place it and move it
+Project-URL: Homepage, https://github.com/Smart-Data-Engines/smart-data-engine-sdk
+Project-URL: Repository, https://github.com/Smart-Data-Engines/smart-data-engine-sdk
+Project-URL: Issues, https://github.com/Smart-Data-Engines/smart-data-engine-sdk/issues
+Project-URL: Format contract, https://github.com/Smart-Data-Engines/smart-data-engine-sdk/blob/main/docs/format-contract.md
+Project-URL: Failure semantics, https://github.com/Smart-Data-Engines/smart-data-engine-sdk/blob/main/docs/failure-semantics.md
+Author: Smart Data Engines
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: clickhouse,database,placement,polystore,postgresql
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.11
+Provides-Extra: clickhouse
+Requires-Dist: clickhouse-connect>=0.7; extra == 'clickhouse'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
+Provides-Extra: signed
+Requires-Dist: cryptography>=42; extra == 'signed'
+Description-Content-Type: text/markdown
+
+# sde — Smart Data Engine client library for Python
+
+Declare your data model. We decide which database engine each part of it lives in, how it is laid out
+there, and when it should move — and move it while your application keeps running.
+
+Your code never names a table or an engine. That absence is the point: it is what lets the physical
+schema change underneath you without touching a line of your code.
+
+```python
+from datetime import datetime
+from decimal import Decimal
+from typing import Annotated
+from uuid import UUID
+import sde
+
+@sde.entity
+class User:
+    id: UUID
+    email: str
+
+    class Meta:
+        pii = ["email"]
+
+@sde.entity
+class Order:
+    id: UUID
+    user: sde.Ref[User]
+    total: Annotated[Decimal, sde.precision(12, 2)]
+    created_at: datetime
+
+    class Meta:
+        residency = "EU"
+
+model = sde.build_model()
+```
+
+## What you declare, and what you do not
+
+You declare entities, relations, and four invariants. Everything else about storage is ours to
+decide.
+
+The four exist because no amount of watching traffic reveals them:
+
+| Declaration | Why traffic cannot tell us |
+|---|---|
+| `atomic_with` | that two entities must commit together is a business rule, not a pattern |
+| `residency` | where data may legally live is not visible in a query |
+| `pii` | which column is personal data determines retention and what may be denormalised |
+| `cost_ceiling` | your budget is not in your workload |
+
+Anything beyond those four and the list of engines you have available would be us handing work back
+to you, which is the opposite of what this is for.
+
+## Two guarantees, and how to check them yourself
+
+**We are not in your data path.** The library connects to your engines directly and answers every
+operation from a locally cached placement map. Our service being down does not make your application
+down. There is no configuration for this — there is no code path that routes your queries through us,
+which you can confirm by reading `routing.py`: it is a dictionary lookup and three conditions.
+
+**We never see a row.** Telemetry carries operation *shapes* and counts, never values, and a shape is
+assembled from the structure of the call rather than from a query string — so there is nowhere for a
+value to come from. This is the reason the library is open source: the guarantee is checkable instead
+of promised.
+
+## It works without an account
+
+Write a placement map by hand, point the library at it, and everything runs: no key, no network, no
+account.
+
+```python
+placement = sde.load_map(json.load(open("placement.json")), model=model)
+```
+
+An unsigned map is valid. A *signed* map with no key to verify it is not, because a signature is a
+claim that it came from us and an unverifiable claim is worse than no claim. This mode is supported
+and tested, not tolerated — it is also the honest answer to what happens if you stop paying us.
+
+## Install
+
+```bash
+pip install smart-data-engine-sdk              # core, no dependencies at all
+pip install 'smart-data-engine-sdk[signed]'    # verify maps we signed
+pip install 'smart-data-engine-sdk[postgres]'  # PostgreSQL engine driver
+```
+
+The core has no runtime dependencies. This library goes into your application, so every dependency
+would be one you inherit and a version conflict you might have to resolve.
+
+**The distribution is `smart-data-engine-sdk` and the import is `sde`, and neither half of that is a
+preference.** `sde` alone is taken on PyPI by somebody else, and renaming the import to a
+squatting-adjacent misspelling is worse for you than a distribution name that differs from it. The
+obvious distribution name, `smart-data-engine`, is *refused by PyPI*: it answers 400, "the name is
+too similar to an existing project". The project is `smartdata-engine`, registered by somebody else
+with zero releases — PyPI compares names after stripping `._-` and folding `l`/`i` to `1` and `o` to
+`0`, and both reduce to `smartdataeng1ne`. The suffix changes the reduction, and it matches the
+repository name, which is the consistency worth having regardless.
+
+**`smart-data-engine-sdk` is unclaimed on PyPI, so those three commands install nothing today.** That
+is the honest state and not a typo: the library is not published yet. Read it as a warning rather
+than a footnote, because three error messages inside this library point at the same commands - if
+someone else registers the name before we do, a person who is already debugging gets told, by code
+they had decided to trust, to install a stranger's package.
+[`../docs/publishing.md`](../docs/publishing.md) is what closes this.
+
+## Conformance
+
+Everything in `canonical.py`, `model.py`, `shapes.py` and `routing.py` implements a cross-language
+contract, pinned by vectors in `../conformance/vectors`. The Python, TypeScript, Java and Rust
+libraries run the same vectors in their own test runners, so a divergence is a red test for whoever
+caused it rather than an operation written to the wrong engine in production.
+
+If you are porting this to another language, `docs/format-contract.md` is meant to be sufficient on
+its own. If it is not, that is a bug in the document.
+
+## Licence
+
+Apache-2.0.

smart_data_engine_sdk-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,35 @@
+sde/__init__.py,sha256=IFbRKfe4CMEU7XIFKTwVG2Gt9NNxvj7jPj8jDDR3gVc,5510
+sde/canonical.py,sha256=NoQDuycFTikcRGjrnqARlyvLpCcmixPKwdWszAkSDbg,5986
+sde/capabilities.py,sha256=cT7RIrgfvCi6uhq16gkwMVynhJxegGtgUzONHQ3SZxU,3188
+sde/entity.py,sha256=epPnf-cM-_c1SvI0IKnNVMqVlvau32wX2kmgWtsypy4,6549
+sde/errors.py,sha256=05MgWvXZOuClhQjNbMpXpiW3rG55wl2_PRU6ZLOGEIU,3879
+sde/explain.py,sha256=BrTA6rbZVhkkeLt81NqDEwdFe7wxVEbBhtlkvKkSnjI,14917
+sde/groups.py,sha256=1g2IERLl2Dt--rMP0Y7suIvzjXNxaOYYn7svhtybK8U,4120
+sde/hashing.py,sha256=8SJ-yvTW6SVdG2FPLoWyaIg8yBKATsdN3VX1pY20Ft8,11562
+sde/infer.py,sha256=myFzi9dgCPnKwzVutOFCng_Gtx5PirkWZpjUm8p0sVc,19372
+sde/internal.py,sha256=3nadKOi-p263hhC_AT8pFfcfxFoENqXR7GFZ5-JpVvw,3678
+sde/layout.py,sha256=1erdR6hJLUjvKVTRxynuzX4p78QyU-Ol9T33BJ61Et4,32924
+sde/logging.py,sha256=R95aqmYVxVU-JOzrbAa8rSyF1HAwP3em7GT74q5LKVs,7620
+sde/migration.py,sha256=jWOuoGpoo43kR8uEcF0qGUoeZtyR9wM7ieY3bECgKzo,37845
+sde/model.py,sha256=zdbrQSRn-UHDuTpoyVqav3e-SKf1L0mv-6uoPVqtPcs,20602
+sde/placement.py,sha256=LetpAUqtu6jmze0sAueuH4Pr1L39jgeLH8f-XKLiJLc,40276
+sde/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sde/routing.py,sha256=_tvNgpT3F8sTp1TQjVQPjB9dei4QlfFncdTHy1N7ePc,3195
+sde/schema.py,sha256=58c4zfj6xaqXj0UbqPznjmMozr5jYTo8qGoSVj_aklI,19283
+sde/session.py,sha256=1m9WIhHEH9We0gpzFxHInfgFP5VhJsAYoaLAd7SgfO8,25995
+sde/shapes.py,sha256=d_mfam5U4JQhZQ1obihOrYWEBsPqStY3y6wMIGLYi1g,6521
+sde/telemetry.py,sha256=jLXxcDZL4exGxzRZNMuS0xHg5RdD46JbWjo_kmXBlDo,33770
+sde/types.py,sha256=S3YGEN_uYL0ve2ASwzD3yZadeGFuC3l1bvxfAnJQBLE,8960
+sde/watermark.py,sha256=N0Ljs9oiNveV6wboQRZc1JyXtJrepNcBEUN7BGL3PTA,10604
+sde/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sde/engines/clickhouse.py,sha256=9nBNyO1jPFOgVjPqrETaMJuAJo97E1yro4sRTY8F4mQ,35972
+sde/engines/orderbook.py,sha256=UCie44DHDRHwzpxGYFoaQKVsxYEBdJIihZCoWeWpX9o,22567
+sde/engines/postgres.py,sha256=jhC8-7M-FnhXdgG4QXGASKXXokHh2e0sMQe_8CfrMmE,34226
+sde/testing/__init__.py,sha256=T2NEZSj_YVQdpw0-CmjQOiMCHbPZIDRuyUMuwTUIJTY,670
+sde/testing/loader.py,sha256=Bdd9X3ZgEadnkvBaU9LQJiygWZoJTtIxVjmLA4Bbvgs,8889
+sde/testing/memory.py,sha256=FzEkQhPbxjgtszYDXOUUvM5yEGq3nx1bZabuhGINDJk,14900
+smart_data_engine_sdk-0.1.0.dev0.dist-info/METADATA,sha256=iROaVs982_WPrlIHJTWHUI261x2EDZ28ZESuqbyr6t4,6747
+smart_data_engine_sdk-0.1.0.dev0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+smart_data_engine_sdk-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+smart_data_engine_sdk-0.1.0.dev0.dist-info/licenses/NOTICE,sha256=J4n4FX0yCbPCA7zpguXbUyA9R6XmrWCyLqca3Hh79u4,583
+smart_data_engine_sdk-0.1.0.dev0.dist-info/RECORD,,

smart_data_engine_sdk-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any