structured-data-models-client 1.0.0__py3-none-any.whl

sdm_client/wire/keys.py

@@ -0,0 +1,363 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+r"""Which rows an encoded request is about.
+
+The keys are in the envelope rather than in anything the caller still holds,
+and the two models write them differently: a relational envelope carries an
+opaque entity reference, a tabular one the caller's own key column. Reading
+that is a question about the wire, so it is answered here rather than by the
+client, which should have to ask only whether two sets of rows overlap.
+"""
+
+from __future__ import annotations
+
+import itertools
+from collections.abc import Iterable, Mapping, Sequence
+from decimal import Decimal
+from numbers import Real
+from typing import TYPE_CHECKING, Any
+
+import pandas as pd
+
+from sdm_client.schema import _as_key_tuple
+
+if TYPE_CHECKING:
+    from sdm_client.request import Request
+
+#: What a relational envelope calls the moment, when nothing of the caller's
+#: is called that already.
+_ANCHOR = '__kumo_anchor_time'
+
+#: How a relational envelope names the entity a row is about.
+_ENTITY_REF = '__kumo_entity_ref'
+
+#: What ties a related row to the instance it hangs off.
+INSTANCE_ID = 'instance_id'
+
+#: Counts the rows that name no entity, so that no two of them are one.
+_UNIDENTIFIED = itertools.count()
+
+
+def _anchor_column(payload: dict[str, Any] | None) -> str:
+    r"""What this envelope calls the moment.
+
+    Read from the task rather than assumed. The engine suffixes the name when
+    a column of the caller's own is called that, so looking only for the bare
+    name goes blind on exactly the graphs that have one.
+    """
+    task = (payload or {}).get('task')
+    named = (
+        task.get('anchor_time_column') if isinstance(task, Mapping) else None
+    )
+    return str(named) if named else _ANCHOR
+
+
+def rows_in(
+    payload: dict[str, Any] | None, half: str, *, with_anchor: bool = False
+) -> list[Any]:
+    r"""The key of every row one half of a wire envelope holds, one per row.
+
+    The row-wise reading. :func:`keys_in` is this without the duplicates, and
+    is what a question about overlap wants; a sentence that counts rows wants
+    this, because two rows about one entity are two rows.
+    """
+    if not isinstance(payload, dict):
+        return []
+    table = (payload.get(half) or {}).get('instance_table') or {}
+    columns = table.get('columns')
+    rows = table.get('rows')
+    if not isinstance(columns, list) or not isinstance(rows, list):
+        return []
+    named: Any = next(
+        (name for name in columns if str(name).startswith(_ENTITY_REF)),
+        None,
+    )
+    if named is None:
+        named = ((payload.get('schema') or {}).get('instance_table') or {}).get(
+            'primary_key'
+        )
+    if named is None:
+        return []
+    wanted = named if isinstance(named, list) else [named]
+    if any(name not in columns for name in wanted):
+        return []
+    at = [columns.index(name) for name in wanted]
+    if with_anchor:
+        anchor = _anchor_column(payload)
+        if anchor in columns:
+            at = [*at, columns.index(anchor)]
+    return [
+        _named_by(row[position] for position in at)
+        for row in rows
+        if isinstance(row, list) and len(row) > max(at)
+    ]
+
+
+def keys_in(
+    payload: dict[str, Any] | None, half: str, *, with_anchor: bool = False
+) -> frozenset[Any]:
+    r"""The entity keys one half of a wire envelope holds.
+
+    Kept when a session is opened, and only the keys: the context itself is
+    deliberately not kept, since holding a second encoded copy of a whole
+    dataset for the life of the handle is what `pinned` exists to avoid. A set
+    of keys is small enough to keep and is the only thing needed to notice that
+    a later call scores rows the context already answers.
+
+    The key is named in the schema rather than in the rows, and the two models
+    name it differently: a relational envelope carries an opaque entity
+    reference, a tabular one carries the caller's own key column.
+
+    `with_anchor` puts the moment into the key. An entity asked about over a
+    window is a different question at a different moment, so the context has
+    only answered the one it was asked at; an entity whose answer is a
+    standing value has been given away at any moment at all.
+    """
+    return frozenset(rows_in(payload, half, with_anchor=with_anchor))
+
+
+def _named_by(values: Iterable[Any]) -> str:
+    r"""One way of writing a key, whichever side of the wire it came from.
+
+    A pinned key is read from the encoded payload and a scored key from the
+    frame, and the two disagree about the same value: an integer past the
+    JS-safe range travels as a base-10 string by contract, so
+    `9007199254740993` on one side and `'9007199254740993'` on the other would
+    never meet, and the warning would go quiet on precisely the warehouse keys
+    it matters most for.
+
+    A whole number written as a float is the same entity as the integer: a
+    context typed `int64` pins entity `1` and a scored frame of floats sends
+    `1.0`, and the endpoint answers the second with the first's id. Comparing
+    the spellings called that two entities, and a session scored rows its
+    context answers without saying so.
+
+    A composite key becomes a tuple of its parts rather than nothing at all,
+    which is what reading only single-column keys amounted to.
+    """
+    named = tuple(values)
+    if any(_is_missing(value) for value in named):
+        # A row with no identifier is not the same row as another with no
+        # identifier. Named alike, two unidentified rows were reported as one
+        # entity leaking into the other, and `holdout=[None]` took every
+        # unidentified row out of the context at once.
+        return f'<unidentified {next(_UNIDENTIFIED)}>'
+    return repr(tuple(_one_spelling(value) for value in named))
+
+
+def _is_missing(value: Any) -> bool:
+    r"""Whether this value names no entity at all."""
+    if value is None:
+        return True
+    try:
+        return bool(pd.isna(value))
+    except (ArithmeticError, TypeError, ValueError):
+        # A signalling NaN raises rather than comparing. It names no entity
+        # either, and asking whether it does must not be the thing that fails.
+        return True
+
+
+def _one_spelling(value: Any) -> str:
+    r"""A value as the name of an entity, not as the type that carried it.
+
+    Every real number is read as the number it is, rather than a list of the
+    types that can hold one: ``1``, ``1.0``, a numpy float of any width and
+    ``Decimal("1.00")`` all name entity 1, and ``Decimal("1.50")`` names the
+    same entity as ``1.5``. Written by type instead, a holdout given as a
+    ``float32`` removed nothing and a trailing zero made two names for one row.
+
+    Anything that is not a number is left as it is written. A key column of
+    text has ``"1.50"`` and ``"1.5"`` as two different entities, and reading
+    them as numbers would merge two rows the schema says are distinct.
+    """
+    if isinstance(value, bool) or not isinstance(value, (Real, Decimal)):
+        return str(value)
+    try:
+        exact = Decimal(str(value))
+        # A name is not arithmetic. An infinity or a NaN is not an entity and
+        # cannot be read as one, and asking anyway raised `OverflowError` and
+        # `InvalidOperation` out of a function whose whole job is to write a
+        # name. Thus, a holdout naming one failed the call before it was sent.
+        if not exact.is_finite():
+            return str(value)
+        if exact == exact.to_integral_value():
+            return str(int(exact))
+        return str(exact.normalize())
+    except (ArithmeticError, ValueError):
+        return str(value)
+
+
+def key_dtypes(
+    table: Any, key: Sequence[str], widened_by: Any = None
+) -> dict[str, str] | None:
+    r"""One wire dtype per key column, settled the way the adapter settles it.
+
+    One per column, not one per half. Settled separately for each frame, the
+    same entity came out ``1.0`` on the side read from the context and ``1``
+    on the side read from the rows being scored, and the comparison between
+    them reported overlaps the encoded request does not have.
+
+    ``None`` where no dtype can be settled. Every caller is a warning, and a
+    warning is never worth a failure.
+    """
+    from sdm_client.adapters.tabular import _raw_dtype_of
+    from sdm_client.wire import UNTYPED, widen_tfm_dtype
+
+    try:
+        dtypes = {}
+        for name in key:
+            column = table.columns[name]
+            dtype = UNTYPED if column.untyped else column.dtype
+            if widened_by is not None and name in widened_by.columns:
+                dtype = widen_tfm_dtype(
+                    (dtype, _raw_dtype_of(widened_by[name], dtype))
+                )
+            dtypes[name] = dtype or 'string'
+        return dtypes
+    except Exception:  # noqa: BLE001 - a warning is never worth a failure
+        return None
+
+
+def keys_from_a_frame(
+    frame: Any, key: Sequence[str], dtypes: Mapping[str, str] | None
+) -> list[Any]:
+    r"""``frame``'s keys, written the way the wire will write them.
+
+    The other side of every comparison here is read from an encoded envelope,
+    so a frame read raw does not meet it: an entity held as ``1.0`` in a frame
+    is ``1`` on the wire, and the two would never match. This is how a
+    session came to score rows its pinned context answers without saying so.
+
+    Through the encoder that writes the request, given the dtypes
+    :func:`key_dtypes` settled for the request as a whole. Empty where there
+    are none or the encoding fails: every caller is a warning, and a warning
+    is never worth a failure.
+    """
+    from sdm_client.wire.tables import encode_table
+
+    if dtypes is None:
+        return []
+    try:
+        encoded = encode_table(
+            frame[list(key)], {name: dtypes[name] for name in key}
+        )
+    except Exception:  # noqa: BLE001 - a warning is never worth a failure
+        return []
+    return [_named_by(row) for row in encoded['rows']]
+
+
+def scored_rows(
+    request: Request,
+    *,
+    with_anchor: bool = False,
+    dtypes: Mapping[str, str] | None = None,
+) -> list[Any]:
+    r"""The key of every row a request asks about, one per row.
+
+    A sentence that counts rows has to be given rows: two rows asking about
+    one entity are two rows, and a set of keys had already lost one of them.
+
+    ``dtypes`` come from the other side of the comparison, namely a session's
+    pinned schema. Settled here instead, the same entity has
+    one name on each side and neither meets the other.
+    """
+    if request.payloads:
+        return [
+            named
+            for payload in request.payloads
+            for named in rows_in(payload, 'predict', with_anchor=with_anchor)
+        ]
+    frame = getattr(request.predict, 'instance_table', None)
+    table = request.schema[request.entity_table] if request.schema else None
+    names = _as_key_tuple(getattr(table, 'primary_key', None))
+    if frame is None or not names or any(n not in frame for n in names):
+        return []
+    if dtypes is None:
+        dtypes = key_dtypes(table, names, frame)
+    return keys_from_a_frame(frame, names, dtypes)
+
+
+def scored_keys(
+    request: Request, *, with_anchor: bool = False
+) -> frozenset[Any]:
+    r"""The keys a request is asking about.
+
+    Read from the envelopes where there are any, and from the frame where
+    there are not. Only the first can carry a moment: a request holding
+    frames is a single-table one, and a single-table model is not asked for a
+    window over time. The query is refused before it reaches here, so there
+    is no moment in the frame to put in the key and none to look for.
+    """
+    return frozenset(scored_rows(request, with_anchor=with_anchor))
+
+
+def without_the_keys(payload: dict[str, Any], keys: frozenset[Any]) -> int:
+    r"""Take out of ``payload``'s context every row naming one of ``keys``.
+
+    Returns how many instance rows went. Related rows that hang off them go
+    too, by the ``instance_id`` they were tied with, because a related row
+    whose instance has gone describes nothing.
+
+    The key is found the way `keys_in` finds it, so what is removed here is
+    exactly what would have been reported as an overlap there.
+    """
+    context = payload.get('context')
+    if not isinstance(context, Mapping) or not keys:
+        return 0
+    table = context.get('instance_table')
+    columns = (table or {}).get('columns')
+    rows = (table or {}).get('rows')
+    if not isinstance(columns, list) or not isinstance(rows, list):
+        return 0
+
+    named = next(
+        (name for name in columns if str(name).startswith(_ENTITY_REF)), None
+    )
+    if named is None:
+        named = ((payload.get('schema') or {}).get('instance_table') or {}).get(
+            'primary_key'
+        )
+    wanted = named if isinstance(named, list) else [named]
+    if named is None or any(name not in columns for name in wanted):
+        return 0
+
+    at = [columns.index(name) for name in wanted]
+    instance = columns.index(INSTANCE_ID) if INSTANCE_ID in columns else None
+    going, leaving = [], set()
+    for row in rows:
+        if not isinstance(row, list) or len(row) <= max(at):
+            going.append(row)
+            continue
+        if _named_by(row[position] for position in at) in keys:
+            if instance is not None and len(row) > instance:
+                leaving.add(row[instance])
+            continue
+        going.append(row)
+
+    removed = len(rows) - len(going)
+    if not removed:
+        return 0
+    table['rows'] = going
+    for related in (context.get('related_tables') or {}).values():
+        _drop_instances(related, leaving)
+    return removed
+
+
+def _drop_instances(table: Any, instances: set[Any]) -> None:
+    r"""Remove related rows tied to removed instances."""
+    columns = (table or {}).get('columns')
+    rows = (table or {}).get('rows')
+    if not isinstance(columns, list) or not isinstance(rows, list):
+        return
+    if INSTANCE_ID not in columns or not instances:
+        return
+    at = columns.index(INSTANCE_ID)
+    table['rows'] = [
+        row
+        for row in rows
+        if not (
+            isinstance(row, list) and len(row) > at and row[at] in instances
+        )
+    ]

sdm_client/wire/tables.py

@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+r"""Turning a DataFrame into the wire's ``arrays`` table."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from sdm_client.wire.dtypes import serialize_column
+
+
+def encode_table(frame: pd.DataFrame, dtypes: dict[str, str]) -> dict[str, Any]:
+    r"""Encode ``frame`` as an ``arrays`` table.
+
+    ``arrays`` is the only table format the contract defines today: an ordered
+    list of column names and a list of row arrays positionally matching it.
+    Arrow IPC is a reserved extension point everywhere in this system and is
+    not implemented.
+
+    Serialization is per column rather than per cell, because a column has one
+    dtype and the rule for writing a value follows from it. The rows are then
+    transposed out of the serialized columns, which is what keeps a column's
+    values consistently written even where a row-major walk would see mixed
+    types.
+
+    A frame with no columns still carries its row count, so an empty-column
+    table is a list of empty rows rather than an empty table. The two mean
+    different things to the server.
+
+    Args:
+        frame: The rows to encode.
+        dtypes: Wire dtype per column name. Must cover every column of
+            ``frame``.
+    """
+    columns = list(frame.columns)
+    if not columns:
+        return {
+            'format': 'arrays',
+            'columns': [],
+            'rows': [[] for _ in range(len(frame))],
+        }
+    serialized_columns = [
+        serialize_column(frame[column], dtypes[column]) for column in columns
+    ]
+    rows = [list(row) for row in zip(*serialized_columns, strict=True)]
+    return {'format': 'arrays', 'columns': columns, 'rows': rows}

structured_data_models_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: structured-data-models-client
+Version: 1.0.0
+Summary: One Python client for NVIDIA's structured-data foundation model NIMs
+Author: NVIDIA
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/NVIDIA/structured-data-models-client
+Project-URL: Source, https://github.com/NVIDIA/structured-data-models-client
+Project-URL: Issues, https://github.com/NVIDIA/structured-data-models-client/issues
+Project-URL: Changelog, https://github.com/NVIDIA/structured-data-models-client/blob/main/CHANGELOG.md
+Keywords: structured-data,foundation-model,tabular,relational
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: structured-data-models-api==1.0.0
+Requires-Dist: structured-data-models-pql==1.0.0
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: numpy>=1.23
+Requires-Dist: requests>=2.28
+Requires-Dist: urllib3>=1.26
+Provides-Extra: relational
+Requires-Dist: structured-data-models-relational-engine==1.0.0; extra == "relational"
+Provides-Extra: sqlite
+Requires-Dist: structured-data-models-connectors[sqlite]==1.0.0; extra == "sqlite"
+Provides-Extra: duckdb
+Requires-Dist: structured-data-models-connectors[duckdb]==1.0.0; extra == "duckdb"
+Provides-Extra: snowflake
+Requires-Dist: structured-data-models-connectors[snowflake]==1.0.0; extra == "snowflake"
+Provides-Extra: databricks
+Requires-Dist: structured-data-models-connectors[databricks]==1.0.0; extra == "databricks"
+Provides-Extra: postgres
+Requires-Dist: structured-data-models-connectors[postgres]==1.0.0; extra == "postgres"
+Provides-Extra: lakebase
+Requires-Dist: structured-data-models-connectors[lakebase]==1.0.0; extra == "lakebase"
+Provides-Extra: s3
+Requires-Dist: structured-data-models-connectors[s3]==1.0.0; extra == "s3"
+Provides-Extra: databricks-serving
+Requires-Dist: databricks-sdk<1.0,>=0.68.0; extra == "databricks-serving"
+Provides-Extra: all
+Requires-Dist: structured-data-models-client[databricks,duckdb,lakebase,postgres,relational,s3,snowflake,sqlite]; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: requests-mock; extra == "test"
+Dynamic: license-file
+
+# structured-data-models-client
+
+One Python client for NVIDIA's structured-data foundation models. Ask a
+predictive question of one table, or of a whole relational schema, without
+training a model for each dataset.
+
+```bash
+pip install structured-data-models-client
+```
+
+Inference runs in a NIM, so this package downloads no weights and needs no GPU.
+
+```python
+import pandas as pd
+from sdm_client import KumoTabular, Request, SDMClient
+
+labelled = pd.DataFrame(
+    {
+        'age': [31.0, 44.5, 28.0, 51.0, 39.0],
+        'spend': [120.0, 430.0, 90.0, 510.0, 260.0],
+        'churn': [0, 1, 0, 1, 0],
+    }
+)
+to_score = pd.DataFrame({'age': [33.0, 47.0], 'spend': [150.0, 480.0]})
+
+request = Request(
+    context=labelled, predict=to_score, target='churn', task='classification'
+)
+
+with SDMClient(url='http://localhost:8000') as client:
+    print(client.predict(request, model=KumoTabular()).to_pandas())
+```
+
+The model is an argument, not a method name. For several related tables, ask in
+the Predictive Query Language and pass `KumoRelational()` instead; that needs
+`pip install 'structured-data-models-client[relational]'`.
+
+Documentation, the other four packages and the examples are in the repository:
+<https://github.com/NVIDIA/structured-data-models-client>
+
+Apache-2.0. Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES.

structured_data_models_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+sdm_client/__init__.py,sha256=80jgFI3qqu2vM6cPg2D_1_4wjGiOodQpMI1Lqh20ygA,2067
+sdm_client/_version.py,sha256=poqaNUKu0_Ul5ZFqMGv8evj9j4qgAD5x8P_Il9KxWOg,163
+sdm_client/base.py,sha256=YDrTAoLgxQQG4WrsdI08tt40fx7wkuqhEWT52X6BKgU,10959
+sdm_client/client.py,sha256=B4tVNTXOlrfBZVx1X814jt_BKymRP3ajEkapRZDvM-A,57548
+sdm_client/decompose.py,sha256=EfHHgQ9VEqkI1HHJD-je7kKFPpGQ9C8ZRdpLyoaZKOY,16976
+sdm_client/errors.py,sha256=-XsFUAnVuhNuG5vr21JNU72Esmn5SQSOU6H7WkAobJU,6474
+sdm_client/models.py,sha256=BbCi04Cw4f8uo2_CXAs93enaHnIxAFVQF_BZrFvisoA,9708
+sdm_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdm_client/query.py,sha256=8ArlBRQkN-HVodnZSkl7LFbgC6mtK5JNPt_zo_aqbKk,28438
+sdm_client/request.py,sha256=R5C5OUnpYeLN0aQu6xdy4JyJ6xXDeaggiLezCYjuv1Y,47310
+sdm_client/result.py,sha256=UQKeUQitF7Xql02CC_DRp-Y1SRgOfZO9j-R9FecAUkM,13917
+sdm_client/schema.py,sha256=v6b2YOMTrXJdnYpX2ofXUnXMZwuYKBykW8bckIbHDWM,134074
+sdm_client/adapters/__init__.py,sha256=2fRta-sa2gyep6ZWzsa56SczPXwusBKSzLBZBIgu1ro,275
+sdm_client/adapters/relational.py,sha256=aHW0DjhNzOk1NekRcoSNmGKTw8hgJ_3n1xIwDp_FMZc,35381
+sdm_client/adapters/tabular.py,sha256=KhqW7OOoik39-urT3jMWNkcJMKXR-IT5Jf_7ORqoDLs,23460
+sdm_client/core/__init__.py,sha256=dzFONzK2amcBi2mjeOZLTtsGl9v9zm5BlbbdiGFYWQI,201
+sdm_client/core/databricks_serving.py,sha256=rb7xxudzMZ-iAdNrSm7JXwTki-k-Ri9Z4xRoClf8BoA,23884
+sdm_client/core/databricks_user_agent.py,sha256=L2hfkeZKydT8aN9zYWzx17cIbwWcTpvjU4DkqKyxwfA,2969
+sdm_client/core/dates.py,sha256=0lrCfXS4PLQGi-rV7LoMXx9Ljg7zVGcInnCofZsFgIk,11393
+sdm_client/core/transport.py,sha256=JMnOvEOjjUNDmAUwxi1UvB0z455gVq-MbmltbcnNu7s,34658
+sdm_client/core/warnings.py,sha256=vWfjbTI3H7BsGJZCwKI3sVpgbfyROi8rVes6B_kiUx8,1693
+sdm_client/materializers/__init__.py,sha256=0LRVeZyFxJGvN71w01NKOo4IQ5PvU08P_APD9XlQR4Y,407
+sdm_client/materializers/relational.py,sha256=lJzFDBzFnUflZQWpdGhI3nwHFWMIIZ3giUgff8H93Jg,75385
+sdm_client/materializers/sources.py,sha256=oRcExP2eL4cNUTn2a8hMYpsP3CZUGrfPAOUCMwmWt2M,11492
+sdm_client/materializers/tabular.py,sha256=ExhK4HR6xdcTU4j1ysSY4RN_1h07IsYDcPL1CxpIItE,12463
+sdm_client/wire/__init__.py,sha256=6eIZ3kuYq-XKMvKiQWFgIhFXxMOWkQrMQaJusWayXyE,1333
+sdm_client/wire/answers.py,sha256=6v_91HuHB7OaAuHrbz77_Xmk94N83t-l1azp3SQ2rjU,3156
+sdm_client/wire/dtypes.py,sha256=hFhhjmlY-UDRoXgNiNHf-8xlAk0Tm_gSPiaxxveqX2I,28791
+sdm_client/wire/keys.py,sha256=mkuHX-Hfm6wiilwDTfxmjRjrN8x-8Dc7nLYqNkHK95o,14315
+sdm_client/wire/tables.py,sha256=YFBURW3v00X2rzmyeG5ebTTEnwwEv8WKKwjayWO1jEU,1822
+structured_data_models_client-1.0.0.dist-info/licenses/LICENSE,sha256=fM-2HkOnqT3X8X_O17f2oQGYvlXIdaMvdUYepurE32I,11432
+structured_data_models_client-1.0.0.dist-info/licenses/NOTICE,sha256=n-tTBUaxjlPv7qKQfp4g1JFKcB7nYalVQv4NjirI8b0,405
+structured_data_models_client-1.0.0.dist-info/METADATA,sha256=EPxCwaTW4zwAOGCxxvPt59puzYXck10T7TYQhlIWxIA,4111
+structured_data_models_client-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+structured_data_models_client-1.0.0.dist-info/top_level.txt,sha256=adIMKX4LMOb2GTCVOMWoHptnvE2vsHMY2glsW1zCphM,11
+structured_data_models_client-1.0.0.dist-info/RECORD,,

structured_data_models_client-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+