boxes-client 0.1.1__py3-none-any.whl

boxes_client/decode_util.py

@@ -0,0 +1,106 @@
+"""Best-effort decoding of Envelope data values — the *legacy auto* path.
+
+Boxes send heavy payloads as raw ``bytes``. The old client *guessed* the
+encoding; that guessing is kept only as a **legacy fallback** so
+un-migrated boxes keep working. The documented path is the box-declared
+``"encoding"`` keyword decoded by the named codecs in
+:mod:`boxes_client.codec` (see ``CODECS.md``): when a field has a declared
+codec, :mod:`boxes_client.result` uses :func:`codec.decode_with` directly
+and this guessing never runs.
+
+Guess chain (legacy): JSON (if it looks like JSON) -> torch (if installed)
+-> numpy (if 4-byte aligned and not an image) -> raw ``bytes``. Nothing here
+raises: the client always returns *something*.
+
+.. note::
+    The guessing is imperfect: the numpy branch fires on *any*
+    4-byte-aligned blob and can return a plausible-looking but wrong float
+    array. If you control the box, declare ``"encoding"`` in its response
+    config instead of relying on guessing.
+
+The codec *bodies* live once in :mod:`boxes_client.codec`; this module
+wraps them with the legacy "try it, or fall through" behaviour.
+"""
+
+from .codec import _decode_json, _decode_numpy, _decode_torch  # noqa: F401  (shared bodies / back-compat)
+
+
+def _try_numpy(buf: bytes):
+    try:
+        return _decode_numpy(buf)
+    except Exception:
+        pass
+    try:
+        # legacy extra: the uint8 fallback kept for pre-declaration behaviour
+        import numpy as np
+        arr = np.frombuffer(buf, dtype=np.uint8)
+        if arr.nbytes == 0:
+            return None
+        return arr
+    except Exception:
+        return None
+
+
+def _try_torch(buf: bytes):
+    """Legacy: only accepts a plain Tensor payload (the original contract);
+    dict-of-tensors go through the declared ``torch`` codec instead."""
+    try:
+        import torch
+    except ImportError:
+        return None
+    try:
+        obj = _decode_torch(buf)
+        if isinstance(obj, torch.Tensor):
+            return obj
+    except Exception:
+        pass
+    return None
+
+
+def _try_json(buf: bytes):
+    try:
+        s = buf.decode("utf-8")
+    except Exception:
+        return None
+    if not s or s[0] not in "{[":
+        return None
+    try:
+        return _decode_json(buf)
+    except Exception:
+        return None
+
+
+def decode_payload(buf):
+    """Return the decoded value of ``buf``.
+
+    Order (legacy fallback only — boxes are expected to declare
+    ``"encoding"`` in the response config instead):
+    JSON (if it looks like it) -> torch (tapnext / vggt) -> numpy
+    (opencv_box ``np_to_bytes``) -> raw ``bytes``.
+    Nothing raises: the client always returns *something*.
+    """
+    if buf is None:
+        return None
+    if not isinstance(buf, (bytes, bytearray, memoryview)):
+        return buf
+    buf = bytes(buf)
+
+    # JSON first: a JSON document is never a valid torch/numpy buffer.
+    # _try_json only fires when the first byte is '{' or '[' — cheap and safe.
+    j = _try_json(buf)
+    if j is not None:
+        return j
+
+    # torch next — tapnext / vggt use torch.save.
+    t = _try_torch(buf)
+    if t is not None:
+        return t
+
+    # numpy next — opencv_box uses np_to_bytes; only attempt when the size is
+    # at least one element and not clearly a JPEG.
+    if len(buf) >= 4 and len(buf) % 4 == 0 and buf[:2] not in (b"\xff\xd8", b"\x89P"):
+        arr = _try_numpy(buf)
+        if arr is not None:
+            return arr
+
+    return buf

boxes_client/envelope.py

@@ -0,0 +1,115 @@
+"""Envelope builders for the shared ``pipeline.PipelineService`` boxes.
+
+Every box in the *envelope family* (tapnext, yolo, vggt, opencv_box, lang_segm,
+...) speaks::
+
+    service PipelineService {
+      rpc <Method>( Envelope ) returns ( Envelope );   # Process, DetectSequence, ...
+    }
+
+``build()`` turns a flat Python ``data`` dict + a ``config`` dict into an
+``Envelope`` message. It intentionally makes **no assumption about field names
+or payload types** -- ``data={"images": ...}``, ``data={"sentences": ...}``
+or any other keys are all the same shape to the client. Value types pick the
+``Value`` oneof via ``aux.wrap_value``.
+
+Value coercion (applied to each data value, and to each list element):
+
+    bytes / bytearray / memoryview   -> bytes          binary payload (e.g. an image)
+    pathlib.Path                     -> read file      serializes a local file to bytes
+    int                              -> float          (proto ``f`` is a float)
+    str                              -> literal string a *text* value, NOT a file path
+    list of the above (homogeneous)  -> BytesList / StringList / FloatList
+
+So: to ship a *file* use ``bytes`` or ``pathlib.Path`` (or :func:`load`); to send a
+*literal string* use ``str``.
+"""
+
+import json
+import pathlib
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from ._pb_loader import get as _get_pb
+
+
+def load(path: Union[str, "pathlib.PurePath"]) -> bytes:
+    """Read a local file into ``bytes`` so it can be shipped to a (possibly
+    remote) box. Equivalent to ``pathlib.Path(path).read_bytes()``."""
+    return pathlib.Path(path).read_bytes()
+
+
+def _coerce_item(v: Any) -> Any:
+    """Coerce one scalar into something ``aux.wrap_value`` can wrap."""
+    if isinstance(v, pathlib.PurePath):
+        return v.read_bytes()
+    if isinstance(v, (bytearray, memoryview)):
+        return bytes(v)
+    if type(v) is int:
+        return float(v)
+    return v
+
+
+def _coerce_value(v: Any) -> Any:
+    """Coerce a value or a homogeneous list of values."""
+    if isinstance(v, (list, tuple)):
+        return [_coerce_item(x) for x in v]
+    return _coerce_item(v)
+
+
+def build(data: Optional[Dict[str, Any]] = None,
+          config: Optional[Dict[str, Any]] = None):
+    """Build an ``Envelope`` request.
+
+    Parameters
+    ----------
+    data:
+        ``{field_name: value}`` mapped into ``Envelope.data``. Values follow the
+        coercion rules in the module docstring.
+    config:
+        Arbitrary dict serialized to ``Envelope.config_json`` (the box-specific
+        control payload; shape depends on the box).
+    """
+    pb2, _grpc, aux = _get_pb()
+    env = pb2.Envelope(config_json=json.dumps(config or {}))
+    for k, v in (data or {}).items():
+        env.data[k].CopyFrom(aux.wrap_value(_coerce_value(v)))
+    return env
+
+
+def _load_images(images: Union[str, bytes, Sequence]) -> List[bytes]:
+    """Normalize an ``images`` argument into a list of bytes.
+
+    Used by the image-box conveniences (:mod:`boxes_client.conveniences`), so a
+    bare ``str`` here is treated as a **local file path** to serialize (distinct
+    from the generic ``run`` contract where ``str`` means a literal string).
+    Accepts:
+
+    * a single path (str) or preencoded bytes
+    * a list of paths / preencoded bytes
+    * :class:`pathlib.Path` objects
+    """
+    if images is None:
+        return []
+    if isinstance(images, (str, bytes, bytearray, pathlib.PurePath)):
+        images = [images]
+    out: List[bytes] = []
+    for item in images:
+        if isinstance(item, (bytes, bytearray, memoryview)):
+            out.append(bytes(item))
+        elif isinstance(item, (str, pathlib.PurePath)):
+            out.append(pathlib.Path(item).read_bytes())
+        else:
+            raise TypeError(
+                f"Unsupported image element: {type(item)!r}. "
+                "Pass a path (str/pathlib.Path), pre-encoded bytes, or a list of those."
+            )
+    return out
+
+
+def reset_envelope(config_key: str):
+    """Build a config-only ``Process`` request that clears server-side state.
+
+    ``config_key`` names the box's config section (e.g. ``"tapnext"``,
+    ``"clip"``); the caller decides -- the core has no default and names no box.
+    """
+    return build(config={config_key: {"command": "reset"}})

boxes_client/result.py

@@ -0,0 +1,146 @@
+"""Result object returned from ``Box`` calls."""
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+from .codec import decode_with
+from .decode_util import decode_payload
+
+
+def _is_numeric_array(v):
+    try:
+        import numpy as np
+    except ImportError:
+        return False
+    return isinstance(v, np.ndarray)
+
+
+def _find_encoding(config):
+    """Locate the box's declared ``"encoding"`` contract key.
+
+    Scans the parsed config top-level, then each one-level section (first hit
+    wins). Returns the declared value — a codec-name ``str`` that applies to
+    every ``bytes`` field, or a ``{field_name: codec_name}`` map for mixed
+    responses — or ``None`` (undeclared: legacy auto-decode applies).
+    ``encoding`` is a generic contract keyword, not a box name.
+    """
+    if not isinstance(config, dict):
+        return None
+    if "encoding" in config:
+        return config["encoding"]
+    for section in config.values():
+        if isinstance(section, dict) and "encoding" in section:
+            return section["encoding"]
+    return None
+
+
+def _codec_for(enc, field_name):
+    """Resolve the declared codec name for one field (or ``None``)."""
+    if enc is None:
+        return None
+    if isinstance(enc, str):
+        return enc
+    if isinstance(enc, dict):
+        return enc.get(field_name)
+    # A declared but unrecognized shape (e.g. a list) -> ignore, use legacy.
+    return None
+
+
+def _decode_any(buf, codec_name=None):
+    """Decode a single Envelope Value payload.
+
+    - list of byte payloads: decode each element
+    - list of strings/floats: pass through
+    - bytes: declared codec if given (never raises), else the legacy guess chain
+    - scalars (str/float/int): pass through
+    """
+    if isinstance(buf, (list, tuple)):
+        items = list(buf)
+        if items and all(isinstance(x, (bytes, bytearray, memoryview)) for x in items):
+            if codec_name is not None:
+                return [decode_with(x, codec_name) for x in items]
+            return [decode_payload(x) for x in items]
+        return items
+    if isinstance(buf, (bytes, bytearray, memoryview)):
+        if codec_name is not None:
+            return decode_with(buf, codec_name)
+        return decode_payload(buf)
+    return buf
+
+
+@dataclass
+class Result:
+    """A decoded response from a box.
+
+    ``fields`` maps every Envelope data field to its decoded value: the
+    box-declared ``"encoding"`` codec when the box declares one
+    (:mod:`boxes_client.codec`), else the legacy auto-decode
+    (:mod:`boxes_client.decode_util`). Use ``raw`` for the undecoded Envelope.
+    Field values can also be read directly, e.g. ``res.tracks``.
+    """
+
+    raw: Any = None
+    config: Any = None
+    fields: Dict[str, Any] = field(default_factory=dict)
+    #: The box's declared payload encoding, exactly as found in the response
+    #: config: a codec-name ``str``, a ``{field: codec}`` map, or ``None``
+    #: (undeclared → legacy auto-decode). Exposed so callers can see *why*
+    #: a field came back decoded or raw.
+    encoding: Any = None
+
+    @classmethod
+    def from_envelope(cls, envelope):
+        config = envelope.config_json
+        if config:
+            try:
+                config = json.loads(config)
+            except (ValueError, TypeError):
+                pass
+
+        # Declared payload encoding (generic contract keyword, not a box name).
+        # ``None`` → behaviour is identical to before the codecs landed.
+        enc = _find_encoding(config)
+
+        fields = {}
+        for name, val in envelope.data.items():
+            kind = val.WhichOneof("kind") if hasattr(val, "WhichOneof") else None
+            if kind == "b":
+                buf = val.b
+            elif kind == "bb":
+                buf = list(val.bb.values)
+            elif kind == "ss":
+                buf = list(val.ss.values)
+            elif kind == "ff":
+                buf = list(val.ff.values)
+            elif kind == "f":
+                buf = val.f
+            elif kind == "s":
+                buf = val.s
+            else:
+                buf = val
+            fields[name] = _decode_any(buf, codec_name=_codec_for(enc, name))
+        return cls(raw=envelope, config=config, fields=fields, encoding=enc)
+
+    def __getattr__(self, name):
+        if name.startswith("_") or name in ("raw", "config", "fields"):
+            raise AttributeError(name)
+        d = self.__dict__.get("fields") or {}
+        if name in d:
+            return d[name]
+        raise AttributeError(
+            f"Result has no field {name!r}; available: {sorted(d)}"
+        )
+
+    def as_dict(self):
+        return {
+            "config": self.config,
+            "fields": {
+                k: (v.tolist() if _is_numeric_array(v) else v)
+                for k, v in self.fields.items()
+            },
+        }
+
+    def __repr__(self):
+        cfg = self.config if isinstance(self.config, dict) else "<str>"
+        return f"<Result fields=[{', '.join(sorted(self.fields))}] config={cfg}>"

boxes_client-0.1.1.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: boxes-client
+Version: 0.1.1
+Summary: Thin Python client to call deployed AI 'boxes' (gRPC services) by IP:port
+Author: Manuel Ferreira
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/manel-ferreira-01/boxes
+Project-URL: Repository, https://github.com/manel-ferreira-01/boxes
+Project-URL: Issues, https://github.com/manel-ferreira-01/boxes/issues
+Keywords: grpc,grpc-client,inference-serving,ai-fleet,pipeline,zstandard,codec
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio>=1.50
+Requires-Dist: protobuf>=7.35.1
+Requires-Dist: grpcio-reflection>=1.50
+Requires-Dist: numpy>=1.21
+Requires-Dist: zstandard>=0.18
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Dynamic: license-file
+
+# boxes-client
+
+A thin Python client for calling deployed AI **"boxes"** by `IP:port`.
+
+A *box* is one of the gRPC services in [`/images/`](../images/) built to the
+shared
+
+```protobuf
+service PipelineService {
+  rpc Process( Envelope ) returns ( Envelope );
+}
+```
+
+interface. Point this client at **any one box** and send an `Envelope`:
+
+```python
+from boxes_client import Box
+
+b = Box("localhost:8061")                 # a local box
+# b = Box("10.0.0.5:8061")                # ...or a remote one
+
+res = b.run(data={"images": ["frame.jpg"]},
+            config={"my_box": {"command": "do_thing", "parameters": {}}})
+print(res.fields)     # decoded payload, whatever the box returned
+print(res.config)     # parsed config_json
+```
+
+Box-specific one-liners live in an *optional* convenience layer, e.g. the
+tapnext tracker:
+
+```python
+from boxes_client import trace
+res = trace(b, images=["frame.jpg"], grid_size=30)
+```
+
+No registry, no central server — the client connects directly to the box, so
+local and remote boxes are the same call. Boxes stay independent, addressable,
+composable units (the *client* does the calling, preserving the distributed
+nature of the fleet).
+
+## Install
+
+```bash
+pip install boxes-client
+# optional, to decode tapnext/vggt tensor payloads to numpy:
+pip install "boxes-client[torch]"
+```
+
+(From a repo checkout, instead: `pip install -e boxes_client`.)
+
+`zstandard` is a base dependency (the `zstd_pickle` codec needs it); `torch`
+stays optional. Without the codec's library, declared payloads degrade to raw
+`bytes` with a warning (still usable — e.g.
+`torch.load(BytesIO(res.tracks), weights_only=False)`).
+
+The full design of the declared-encoding contract lives in
+[docs/CODECS.md](../docs/CODECS.md).
+
+## Core API (box-agnostic) + optional conveniences
+
+`Box` is deliberately box-agnostic: it builds and sends an `Envelope` and reads
+a `Result` back, and knows **no box, field, or model**. Per-box sugar lives in a
+separate convenience layer, so adding one never touches the core.
+
+### 1. Generic — `Box.run(data, config, method, reset_first)`
+The workhorse. No assumption about field names or payload types:
+
+```python
+b.run(
+    data    = {"images":    [img1, img2]},           # any field names; any types
+    config  = {"my_box":    {"command": "do_thing", "parameters": {...}}},
+    method  = "Process",                              # default; e.g. "similarity_check"
+)
+```
+
+`data` is a dict of `field_name -> value`. Values are coerced per the rules
+below and wrapped into the shared `Value` oneof via the vendored `aux.wrap_value`.
+
+### 2. Convenience — `trace(box, images, grid_size=None, reset_first=True)`
+An **optional** one-liner for the *tapnext* box, living in
+`boxes_client.conveniences` (not the core). It reads image files (or accepts
+pre-encoded bytes) and just calls `Box.run()` with the right shape:
+
+```python
+b = Box("localhost:8061")
+res = trace(b, images=["f1.jpg", "f2.jpg", "f3.jpg"], grid_size=30)
+np.save("tracks.npy", res.tracks.numpy())
+```
+
+The core `Box` knows nothing about tapnext — `trace` *is* the only tapnext
+knowledge, and it's safe to delete without touching the generic client. Add a
+sibling convenience (`segment`, `embed`, `detect`, …) for other boxes the same
+way; never put a box name in `box.py`.
+
+### `Box.reset(config_key=None)`
+Sends `{config_key: {"command": "reset"}}` on `Process`. `config_key` is the
+box's section name (or the one from the constructor). Stateful boxes clear
+state; stateless boxes typically ignore it. Pass the box name explicitly, or
+construct with `Box(host, config_key="tapnext")`.
+
+### `Box.info()`
+Asks the box (via gRPC reflection) whether it serves `pipeline.PipelineService`.
+Useful to check box reachability and shape before committing to a call.
+
+## Value coercion (for `Box.run` / convenience `data` values)
+
+| You pass | What's sent |
+|---|---|
+| `bytes` / `bytearray` / `memoryview` | `b` (single bytes) or `bb` (list) — for pre-encoded binary payloads (images, tensors, etc.) |
+| `pathlib.Path` | file bytes (read locally, sent as `b`) |
+| `str` | **literal string** (NOT a file path) — sent as `s` |
+| `int` | coerced to `float` (proto `f` is a float) |
+| list of the above (homogeneous) | corresponding list: `BytesList` / `StringList` / `FloatList` |
+
+That's why a *file* has to be passed as `pathlib.Path` (or a `bytes` you loaded
+yourself) — the client serializes it and ships it. A *literal string* is just
+`str` — no confusion.
+
+```python
+import pathlib
+# file:
+b.run(data={"images": [pathlib.Path("frame.jpg")]}, config={...})
+
+# preencoded:
+b.run(data={"images": [open("frame.jpg","rb").read()]}, config={...})
+
+# literal text (e.g. a hypothetical text-only envelope box):
+b.run(data={"sentences": ["hello", "world"]}, config={...})
+
+# list of floats:
+b.run(data={"vals": [1, 2, 3]}, config={...})       # -> FloatList
+```
+
+## Result object
+
+`Result` wraps the raw response `Envelope`:
+
+- `fields` — dict of `field_name -> decoded value`
+- `.tracks`, `.visibles`, … — direct field access via `__getattr__`
+- `config` — parsed `config_json`
+- `encoding` — the box's **declared** payload encoding (codec-name string,
+  `{field: codec}` map, or `None`), so you can see *why* a field is decoded
+  or raw
+- `raw` — the undecoded `Envelope` proto
+- `as_dict()` — JSON-friendly version (numpy arrays -> `tolist`)
+
+### Decoding: declared first, legacy guess as fallback
+
+The authoritative path is the box's **declaration**: the response `config_json`
+carries a generic `"encoding"` key — a codec name for all `bytes` fields, or a
+`{field_name: codec_name}` map:
+
+```json
+{ "lang_sam": { "status": "done", "encoding": "zstd_pickle" } }
+```
+
+``encoding`` scans the parsed config top-level, then each section (first hit
+wins). Named codecs (`[src/boxes_client/codec.py](src/boxes_client/codec.py)`,
+registry `CODECS` / `decode_with`, full design in [docs/CODECS.md](../docs/CODECS.md)):
+
+| name          | payload                               | decoded to              |
+|---------------|---------------------------------------|-------------------------|
+| `identity`    | raw bytes (the default)              | `bytes` unchanged       |
+| `json`        | UTF-8 JSON                            | `list`/`dict`           |
+| `torch`       | `torch.save()` tensor / dict          | `Tensor` / `dict`       |
+| `numpy`       | raw float32 buffer                    | `np.ndarray`            |
+| `zstd_pickle` | `zstd.compress(pickle.dumps(obj))`    | decoded Python          |
+
+Unknown names or a missing codec library degrade to **raw bytes + a
+warning** — never an exception.
+
+The legacy guess chain
+(`[src/boxes_client/decode_util.py](src/boxes_client/decode_util.py)`):
+**JSON → torch (if installed) → numpy → raw bytes**, kept only for boxes that
+declared nothing. Guessing is approximate (the numpy branch will happily
+reinterpret any 4-byte-aligned blob); boxes are expected to declare.
+
+## What's supported
+
+| Box | In scope | Notes |
+|-----|----------|-------|
+| tapnext (`Process`) | ✅ | v1 target; `trace(box, ...)` convenience over `Box.run` |
+| vggt, yolo, opencv_box, lang_segm, clip (`Process`) | ✅ envelope shape | call via `Box.run(...)` with the box-specific `config`; extras like yolo `DetectSequence` / opencv `similarity_check` need the box's own proto for `method=` |
+| cotracker, textEmbedding (`Forward`) | ⏸ pending | use `Box.run` after they're migrated to the shared envelope (client needs no changes) |
+
+### Method dispatch caveat
+
+`Box.run(..., method=...)` resolves to a method on the **client-stub**, which is
+built from the shared `pipeline.proto`. Today the shared proto defines only
+`Process`, so `method=` is currently useful only for `Process`. Boxes that add
+extra `PipelineService` RPCs (e.g. opencv's `similarity_check`, yolo's
+`DetectSequence`/`TrackSequence`/`AllProcessing`) will need either (a) to also
+be migrated to a *single* `Process` with a `command` field (the tapnext pattern),
+or (b) to have their own proto vendored into the client. This is the only
+remaining "per-box" knowledge in the client — everything else (field names,
+payload types, config shape) is fully generic.
+
+## Run the tests
+
+```bash
+# in-process fake box (no GPU, no real box needed)
+python boxes_client/tests/fake_box_smoke.py
+
+# real tapnext box at BOX_HOST:PORT
+BOX_HOST=localhost:8061 python boxes_client/tests/live_tapnext.py
+```
+
+## Notes / design
+
+- **Client-side only.** The box stays a box: independent, restartable,
+  composable. Distribution is preserved because the *client* dials the box
+  directly, so "local box" and "remote box" are the same call.
+- **Auto-protocol.** `Box.info()` uses gRPC reflection to confirm the box
+  serves `pipeline.PipelineService`. If the box does not serve reflection,
+  calls still work — `info()` just reports `reflection: False`.
+- **Declared-first decoding.** Boxes declare `"encoding"` in the response
+  config; the named codec decodes it. Undeclared payloads fall back to the
+  legacy JSON → torch → numpy → raw-bytes guess chain. Nothing raises; you
+  always get a `Result` (unknown codec / missing library → raw bytes +
+  warning).
+- **Forward boxes deferred.** cotracker / textEmbedding use bespoke
+  `Forward` messages; they will work through this client with no changes once
+  migrated to the shared envelope (clip is already migrated).

boxes_client-0.1.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+boxes_client/__init__.py,sha256=wy6l-AHmwOeCDE_EgJGRiQg5YlxrD6Lim9W6DVht7wQ,1624
+boxes_client/_pb_loader.py,sha256=F-n3WaxCZbx_1lSk6YFaPoWc-oSr1MgdGDEehcoPDAM,642
+boxes_client/box.py,sha256=YkgPp0RTeAG1VWdKjpJCanatAFkRLLD8F_5a0gsl9Aw,8259
+boxes_client/codec.py,sha256=FTm6V52yytiIlz5jnQ8dqOwOwSfkyEoyL-cvXhboa_M,4081
+boxes_client/conveniences.py,sha256=KNWqMvdoTc0xwSCmmNwVY5YA5JSjOgG7aENkfaztgYs,3648
+boxes_client/decode_util.py,sha256=C06620qHpmLQsv0PUg5k4q3ZcpB8IZ5AU4FbDPYG9n0,3439
+boxes_client/envelope.py,sha256=buU46Sixg8leKwFhKG4orCrX6slGWxN2mhM9IBJb0v0,4282
+boxes_client/result.py,sha256=jlk6czEJpv9EQODc3n9B881YVDwT8SxiyqNFWsXZs-k,5030
+boxes_client/_pb/__init__.py,sha256=5bIZkZk_hY8DdZmlsQ0oxLTryZ9iPXCUHfbSRa_PpH0,270
+boxes_client/_pb/aux.py,sha256=xlEh38o2CpIoRujHkn1HehIV3ebUeRrHkPqrb3AS7Xg,1263
+boxes_client/_pb/pipeline_pb2.py,sha256=7fdu73F2FXQPhIMiT2K5hdG71-6SaxQOxxkLufLnvxs,2803
+boxes_client/_pb/pipeline_pb2_grpc.py,sha256=LFcIJzebgNSZKwjRPGXdnieWxHWAhOb-ACSUGVGzQfM,3300
+boxes_client-0.1.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+boxes_client-0.1.1.dist-info/METADATA,sha256=A59Qx3tzjffoGm0FlvlJbjiRLBCMjYiSpTbqIeooKQw,10794
+boxes_client-0.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+boxes_client-0.1.1.dist-info/top_level.txt,sha256=Oxf7b8trFFSP25ms2Na4b7O1aHD0rROV5RhO5X6jBlM,13
+boxes_client-0.1.1.dist-info/RECORD,,

boxes_client-0.1.1.dist-info/WHEEL

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