cortex-training 0.0.3__py3-none-any.whl

cortex_training/wire.py

@@ -0,0 +1,414 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Cortex Training binary wire protocol (DSSST1).
+
+This is the single source of truth for how Cortex Training serializes binary
+training payloads. ``ArcticRL`` imports
+this module, so all three sides share one implementation.
+The wire version and metadata keys below are server-defined protocol literals.
+
+It owns three concerns behind one small surface:
+
+1. Codec -- ``dumps`` / ``loads`` serialize a nested dict/list/tuple of tensors
+   and JSON-able data as a single **safetensors** blob. Pickle is never used, so
+   nothing can execute during decode (unlike ``torch.load``).
+
+2. Operation metadata -- ``dumps(obj, metadata=...)`` stores small control-plane
+   metadata (router replay, chunk descriptors) inside the safetensors
+   ``__metadata__`` header. ``read_metadata`` reads it back **without**
+   deserializing tensors. This replaces the old hand-rolled ``DSSMETA1`` byte
+   envelope -- there is now exactly one framing.
+
+3. Byte chunking -- ``encode_byte_chunks`` splits an oversized DSSST1 frame into
+   self-describing byte-range frames. ``decode_byte_chunks`` reassembles them.
+   The split/merge contract lives in one place so client and server cannot
+   drift.
+
+Wire layout of one frame is just a safetensors blob::
+
+    [ u64 header_len | JSON header (__metadata__: {dss: <structure>, op: <metadata>}) | tensor bytes ]
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+import torch
+from safetensors.torch import load as st_load
+from safetensors.torch import save as st_save
+
+WIRE_FORMAT_VERSION = "DSSST1"
+
+_STRUCT_KEY = "dss"  # structure skeleton (internal)
+_OP_KEY = "op"  # operation metadata (router_replay, request/result chunks, ...)
+_REQUEST_CHUNK_KEY = "request_chunk"
+_RESULT_CHUNK_KEY = "result_chunk"
+_PLACEHOLDER_KEY = "__dss_empty__"
+_ROOT_KEY = "__root__"
+_MAX_HEADER_BYTES = 64 * 1024 * 1024
+_CHUNK_PAYLOAD_KEY = "payload"
+_DEFAULT_CHUNK_OVERHEAD_BYTES = 8192
+
+_PICKLE_SIGNATURES = (b"\x80\x02", b"\x80\x03", b"\x80\x04", b"\x80\x05")
+_ZIP_SIGNATURE = b"PK\x03\x04"
+
+
+class WireError(ValueError):
+    """Raised for malformed or incompatible wire payloads."""
+
+
+def _is_tensor(obj: Any) -> bool:
+    return torch.is_tensor(obj)
+
+
+# ---------------------------------------------------------------------------
+# Codec
+# ---------------------------------------------------------------------------
+
+
+def _subtree_has_tensor(obj: Any) -> bool:
+    if _is_tensor(obj):
+        return True
+    if isinstance(obj, dict):
+        return any(_subtree_has_tensor(v) for v in obj.values())
+    if isinstance(obj, (list, tuple)):
+        return any(_subtree_has_tensor(v) for v in obj)
+    return False
+
+
+def _encode(obj: Any, tensors: dict, seen: set, path: str) -> list:
+    if _is_tensor(obj):
+        key = path or _ROOT_KEY
+        tensor = obj.detach().cpu().contiguous()
+        node: list = ["t", key]
+        if tensor.dim() == 0:
+            tensor = tensor.reshape(1)
+            node = ["t", key, {"scalar": True}]
+        # safetensors rejects tensors that share storage; clone on collision.
+        if tensor.data_ptr() in seen and tensor.numel() > 0:
+            tensor = tensor.clone()
+        seen.add(tensor.data_ptr())
+        tensors[key] = tensor
+        return node
+    if isinstance(obj, dict):
+        if not _subtree_has_tensor(obj):
+            return ["j", obj]
+        items = []
+        for raw_key, value in obj.items():
+            if not isinstance(raw_key, str):
+                raise WireError(f"DSSST1 dict keys must be strings, got {type(raw_key)!r}")
+            child_path = f"{path}.{raw_key}" if path else raw_key
+            items.append([raw_key, _encode(value, tensors, seen, child_path)])
+        return ["d", items]
+    if isinstance(obj, tuple):
+        return ["u", [_encode(v, tensors, seen, f"{path}.{i}" if path else str(i)) for i, v in enumerate(obj)]]
+    if isinstance(obj, list):
+        if not _subtree_has_tensor(obj):
+            return ["j", obj]
+        return ["l", [_encode(v, tensors, seen, f"{path}.{i}" if path else str(i)) for i, v in enumerate(obj)]]
+    return ["j", obj]
+
+
+def dumps(obj: Any, *, metadata: dict | None = None) -> bytes:
+    """Serialize ``obj`` to one safetensors frame, with optional op ``metadata``."""
+    tensors: dict = {}
+    tree = _encode(obj, tensors, set(), "")
+    if not tensors:
+        tensors[_PLACEHOLDER_KEY] = torch.zeros(1, dtype=torch.uint8)
+    header = {_STRUCT_KEY: json.dumps({"v": WIRE_FORMAT_VERSION, "tree": tree})}
+    if metadata:
+        header[_OP_KEY] = json.dumps(metadata)
+    return st_save(tensors, metadata=header)
+
+
+def _decode(node: list, tensors: dict) -> Any:
+    tag = node[0]
+    if tag == "t":
+        tensor = tensors[node[1]]
+        if len(node) > 2 and isinstance(node[2], dict) and node[2].get("scalar"):
+            return tensor.reshape(())
+        return tensor
+    if tag == "j":
+        return node[1]
+    if tag == "d":
+        return {key: _decode(child, tensors) for key, child in node[1]}
+    if tag == "l":
+        return [_decode(child, tensors) for child in node[1]]
+    if tag == "u":
+        return tuple(_decode(child, tensors) for child in node[1])
+    raise WireError(f"unknown DSSST1 node tag {tag!r}")
+
+
+def _read_header(data: bytes) -> dict:
+    if len(data) < 8:
+        raise WireError("payload too short to be a DSSST1 safetensors blob")
+    header_len = int.from_bytes(data[:8], "little")
+    if header_len <= 0 or 8 + header_len > len(data) or header_len > _MAX_HEADER_BYTES:
+        raise WireError("invalid DSSST1 safetensors header length")
+    header = json.loads(data[8 : 8 + header_len].decode("utf-8"))
+    return header.get("__metadata__", {}) or {}
+
+
+def loads(data: Any) -> Any:
+    """Deserialize a frame produced by :func:`dumps`.
+
+    Never invokes pickle/``torch.load``; a legacy pickle or ``torch.save``
+    payload is rejected with a clear error instead of being executed.
+    """
+    if not isinstance(data, (bytes, bytearray, memoryview)):
+        raise WireError("DSSST1 loads expects bytes")
+    data = bytes(data)
+    try:
+        tensors = st_load(data)
+        header = _read_header(data)
+    except Exception as exc:  # not safetensors -> never feed it to pickle
+        if data[:2] in _PICKLE_SIGNATURES or data[:4] == _ZIP_SIGNATURE:
+            raise WireError(
+                "refusing to deserialize a legacy pickle/torch.save payload; "
+                "the peer must use the DSSST1 safetensors wire protocol"
+            ) from exc
+        raise WireError(f"not a valid DSSST1 safetensors payload: {exc}") from exc
+
+    raw = header.get(_STRUCT_KEY)
+    if raw is None:
+        raise WireError("DSSST1 structure missing from safetensors header")
+    info = json.loads(raw)
+    if info.get("v") != WIRE_FORMAT_VERSION:
+        raise WireError(f"unsupported DSSST1 wire version {info.get('v')!r}")
+    tensors.pop(_PLACEHOLDER_KEY, None)
+    return _decode(info["tree"], tensors)
+
+
+def read_metadata(data: Any) -> dict:
+    """Return the operation metadata from a frame header without loading tensors.
+
+    This is a lenient peek: bytes that aren't a valid DSSST1 frame simply have no
+    operation metadata, so ``{}`` is returned. The authoritative (pickle-safe)
+    decode happens in :func:`loads`.
+    """
+    if not isinstance(data, (bytes, bytearray, memoryview)):
+        raise WireError("DSSST1 read_metadata expects bytes")
+    try:
+        raw = _read_header(bytes(data)).get(_OP_KEY)
+    except (WireError, ValueError):
+        return {}
+    return json.loads(raw) if raw else {}
+
+
+# ---------------------------------------------------------------------------
+# Byte chunking -- split and reassemble DSSST1 frames
+# ---------------------------------------------------------------------------
+
+
+def _chunk_key(kind: str) -> str:
+    if kind == "request":
+        return _REQUEST_CHUNK_KEY
+    if kind == "result":
+        return _RESULT_CHUNK_KEY
+    raise WireError(f"unknown byte chunk kind {kind!r}")
+
+
+def _bytes_to_tensor(data: bytes) -> torch.Tensor:
+    # bytearray makes the buffer writable; clone detaches from the temporary.
+    return torch.frombuffer(bytearray(data), dtype=torch.uint8).clone()
+
+
+def _tensor_to_bytes(tensor: Any) -> bytes:
+    if not torch.is_tensor(tensor):
+        raise WireError("byte chunk payload must be a tensor")
+    if tensor.dtype != torch.uint8:
+        raise WireError(f"byte chunk payload tensor must be uint8, got {tensor.dtype}")
+    if tensor.ndim != 1:
+        raise WireError(f"byte chunk payload tensor must be 1-D, got shape {tuple(tensor.shape)}")
+    return tensor.cpu().contiguous().numpy().tobytes()
+
+
+def _make_byte_chunk_frame(
+    frame: bytes,
+    *,
+    kind: str,
+    operation: str | None,
+    group_id: str | None,
+    chunk_idx: int,
+    total_chunks: int,
+    start: int,
+    end: int,
+) -> bytes:
+    key = _chunk_key(kind)
+    desc: dict[str, Any] = {
+        "chunk_idx": chunk_idx,
+        "total_chunks": total_chunks,
+        "frame_sha256": hashlib.sha256(frame).hexdigest(),
+        "frame_size_bytes": len(frame),
+    }
+    if group_id is not None:
+        desc["chunk_group_id"] = group_id
+    if operation is not None:
+        desc["operation"] = operation
+    return dumps({_CHUNK_PAYLOAD_KEY: _bytes_to_tensor(frame[start:end])}, metadata={key: desc})
+
+
+def encode_byte_chunks(
+    frame: bytes,
+    *,
+    kind: str,
+    operation: str | None = None,
+    max_bytes: int = 0,
+    chunk_group_id: str | None = None,
+    force_chunk: bool = False,
+) -> list[bytes]:
+    """Split a DSSST1 frame into byte-range DSSST1 chunk frames.
+
+    Returns ``[frame]`` when no chunking is needed unless ``force_chunk`` is
+    true. Chunk frames contain a 1-D uint8 ``payload`` tensor plus metadata
+    under ``request_chunk`` or ``result_chunk``.
+    """
+    if not isinstance(frame, (bytes, bytearray, memoryview)):
+        raise WireError("encode_byte_chunks expects frame bytes")
+    frame = bytes(frame)
+    if not force_chunk and (max_bytes <= 0 or len(frame) <= max_bytes):
+        return [frame]
+
+    group_id = chunk_group_id if kind == "request" else None
+    if kind == "request" and not group_id:
+        import uuid
+
+        group_id = str(uuid.uuid4())
+
+    if max_bytes <= 0:
+        return [
+            _make_byte_chunk_frame(
+                frame,
+                kind=kind,
+                operation=operation,
+                group_id=group_id,
+                chunk_idx=0,
+                total_chunks=1,
+                start=0,
+                end=len(frame),
+            )
+        ]
+
+    payload_size = max(1, max_bytes - _DEFAULT_CHUNK_OVERHEAD_BYTES)
+    while True:
+        ranges = [(start, min(start + payload_size, len(frame))) for start in range(0, len(frame), payload_size)] or [
+            (0, 0)
+        ]
+        total = len(ranges)
+        chunks = [
+            _make_byte_chunk_frame(
+                frame,
+                kind=kind,
+                operation=operation,
+                group_id=group_id,
+                chunk_idx=idx,
+                total_chunks=total,
+                start=start,
+                end=end,
+            )
+            for idx, (start, end) in enumerate(ranges)
+        ]
+        if all(len(chunk) <= max_bytes for chunk in chunks):
+            return chunks
+        if payload_size == 1:
+            raise WireError("max_bytes is too small to hold one DSSST1 byte chunk frame")
+        payload_size = max(1, payload_size // 2)
+
+
+def read_byte_chunk_metadata(frame: Any) -> dict | None:
+    """Return byte chunk metadata with ``kind`` included, or ``None``."""
+    metadata = read_metadata(frame)
+    if _REQUEST_CHUNK_KEY in metadata:
+        desc = dict(metadata[_REQUEST_CHUNK_KEY])
+        desc["kind"] = "request"
+        return desc
+    if _RESULT_CHUNK_KEY in metadata:
+        desc = dict(metadata[_RESULT_CHUNK_KEY])
+        desc["kind"] = "result"
+        return desc
+    return None
+
+
+def decode_byte_chunks(chunks: list[bytes], *, kind: str | None = None) -> bytes:
+    """Reassemble byte-range DSSST1 chunks into the original DSSST1 frame."""
+    if not chunks:
+        raise WireError("decode_byte_chunks requires at least one frame")
+    if len(chunks) == 1 and read_byte_chunk_metadata(chunks[0]) is None:
+        return bytes(chunks[0])
+
+    descriptors = [read_byte_chunk_metadata(chunk) for chunk in chunks]
+    if any(desc is None for desc in descriptors):
+        raise WireError("decode_byte_chunks received a frame without byte chunk metadata")
+    descriptors = [desc for desc in descriptors if desc is not None]
+    actual_kind = descriptors[0]["kind"]
+    if kind is not None and actual_kind != kind:
+        raise WireError(f"expected {kind} chunks, got {actual_kind} chunks")
+
+    total = int(descriptors[0].get("total_chunks"))
+    frame_sha256 = descriptors[0].get("frame_sha256")
+    frame_size_bytes = int(descriptors[0].get("frame_size_bytes"))
+    group_id = descriptors[0].get("chunk_group_id")
+    operation = descriptors[0].get("operation")
+
+    if len(chunks) != total:
+        raise WireError(f"expected {total} byte chunks, got {len(chunks)}")
+
+    seen: set[int] = set()
+    ordered: list[tuple[int, bytes]] = []
+    for chunk, desc in zip(chunks, descriptors):
+        if desc["kind"] != actual_kind:
+            raise WireError("mixed byte chunk kinds")
+        if int(desc.get("total_chunks")) != total:
+            raise WireError("byte chunk total_chunks differs across frames")
+        if desc.get("frame_sha256") != frame_sha256:
+            raise WireError("byte chunk frame_sha256 differs across frames")
+        if int(desc.get("frame_size_bytes")) != frame_size_bytes:
+            raise WireError("byte chunk frame_size_bytes differs across frames")
+        if desc.get("chunk_group_id") != group_id:
+            raise WireError("byte chunk chunk_group_id differs across frames")
+        if desc.get("operation") != operation:
+            raise WireError("byte chunk operation differs across frames")
+        idx = int(desc.get("chunk_idx"))
+        if idx < 0 or idx >= total:
+            raise WireError("byte chunk_idx out of range")
+        if idx in seen:
+            raise WireError("duplicate byte chunk_idx")
+        seen.add(idx)
+        payload = loads(chunk).get(_CHUNK_PAYLOAD_KEY)
+        ordered.append((idx, _tensor_to_bytes(payload)))
+
+    if seen != set(range(total)):
+        missing = sorted(set(range(total)) - seen)
+        raise WireError(f"missing byte chunks: {missing}")
+
+    frame = b"".join(payload for _, payload in sorted(ordered))
+    if len(frame) != frame_size_bytes:
+        raise WireError("reassembled frame size mismatch")
+    if hashlib.sha256(frame).hexdigest() != frame_sha256:
+        raise WireError("reassembled frame sha256 mismatch")
+    return frame
+
+
+def encode_result_chunks(result: Any, *, max_bytes: int = 0) -> list[bytes]:
+    """Serialize and optionally byte-chunk a result object."""
+    return encode_byte_chunks(dumps(result), kind="result", max_bytes=max_bytes)
+
+
+def decode_result_chunks(chunks: list[bytes]) -> Any:
+    """Decode a result object returned by :func:`encode_result_chunks`."""
+    return loads(decode_byte_chunks(chunks, kind="result"))

cortex_training-0.0.3.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: cortex-training
+Version: 0.0.3
+Summary: Python SDK and command-line tools for Cortex Training
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: tenacity>=8.2.0
+Requires-Dist: snowflake-connector-python>=3.15.0
+Requires-Dist: torch
+Requires-Dist: safetensors
+Requires-Dist: textual>=0.50
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.990; extra == "dev"
+Dynamic: license-file
+
+# Cortex Training Client
+
+Python SDK, command-line tools, runnable recipes, and documentation for the
+Cortex Training REST API.
+
+## Install
+
+Requires Python 3.10 or later and [uv](https://docs.astral.sh/uv/getting-started/installation/).
+Create an environment and install the client:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install git+https://github.com/snowflakedb/cortex-training.git
+```
+
+The package includes the CLI, log TUI, and Python SDK. `pip install` also works
+in place of `uv pip install` in an active Python environment.
+
+## Log In
+
+Create `~/cortex-training-config.json` using the
+[connection template](examples/config/connection.json.template). Set `host` to
+your Snowflake account hostname, `pat` to your programmatic access token, and
+`database` and `schema` to the location of your Cortex Training endpoint.
+Keep this file outside the repository and do not commit credentials.
+
+Login validates the config and remembers its path for future CLI commands:
+
+```bash
+cortex-training login ~/cortex-training-config.json
+```
+
+The equivalent `cortex-training login --config ~/cortex-training-config.json`
+form is also supported.
+
+`ct` is an alias for `cortex-training`: every CLI example also works with `ct`.
+See [connection setup](docs/getting-started/setup.md) for more detail.
+
+## Try the CLI
+
+```bash
+cortex-training capacity           # Check available GPU capacity
+cortex-training list               # List jobs
+cortex-training get JOB_ID         # Inspect a job from the list
+cortex-training tui                # Pick a job and view its logs
+```
+
+See the [CLI quick reference](docs/reference/cli.md#quick-reference) for
+submission, training, generation, checkpoints, and log downloads.
+
+## Run a Recipe
+
+Start with [Run a Quick SFT Job](docs/getting-started/first-sft-run.md), a short
+end-to-end supervised fine-tuning walkthrough.
+
+Recipes require a repository checkout; they are not included in the installed
+package:
+
+```bash
+git clone https://github.com/snowflakedb/cortex-training.git
+cd cortex-training
+```
+
+Install the [recipe dependencies](recipes/README.md#prerequisites), then run
+the chosen recipe's commands from the repository root. Recipes take an explicit
+`config=/path/to/config.json` argument; use the same connection file you logged
+in with.
+
+| Task | Recipe |
+|---|---|
+| Fine-tune a chat model with LoRA or full-parameter training | [Conversational SFT](recipes/sft/conversational/README.md) |
+| Train math reasoning with reinforcement learning | [Math GRPO](recipes/rl/math_grpo/README.md) |
+| Serve a model or checkpoint, generate responses, and evaluate | [Inference endpoint](recipes/inference/README.md) |
+
+Check `cortex-training capacity` and the recipe's GPU requirements before
+starting a run. Browse the [recipe index](recipes/README.md) for all workflows.
+
+## More Documentation
+
+- [Getting started and prerequisites](docs/getting-started/README.md)
+- [CLI commands and configuration](docs/reference/cli.md)
+- [Python SDK](docs/reference/python-sdk.md)
+- [REST API](docs/reference/rest-api.md)
+- [Model and training-method compatibility](docs/reference/model-compatibility.md)
+- [Job management and cluster status](docs/guides/operations/manage-jobs.md)
+
+## Development
+
+### Editable Install
+
+From a repository checkout, with your Python environment active:
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+### Build a Wheel
+
+With `uv` installed, run:
+
+```bash
+./scripts/build_wheel.sh
+```
+
+The script builds the package using `pyproject.toml` in an isolated build
+environment and writes the wheel to `dist/`. It can be invoked from any working
+directory and does not install the package's runtime dependencies.
+
+### Repository Map
+
+| Path | Purpose |
+|---|---|
+| `model-catalog/` | Supported models, context limits, and recommended job profiles |
+| `docs/` | Getting started material, concepts, guides, and reference |
+| `recipes/` | End-to-end training, sampling, and evaluation workflows |
+| `examples/api/` | Small JSON examples for individual API operations |
+| `examples/config/` | Connection configuration templates |
+| `src/cortex_training/` | Installable Python client |
+| `tests/` | Client and CLI tests |
+| `cluster-status.py` | Optional watch view of running jobs and GPU usage |

cortex_training-0.0.3.dist-info/RECORD

@@ -0,0 +1,19 @@
+cortex_training/__init__.py,sha256=W3uHGh4yGYvB3Ye-29NzWcmAuq4wvS03dmR0G6O5aB0,1547
+cortex_training/__main__.py,sha256=bADZ9swQotcDkWUIQ-opq-k_PJZh8yR1IcddxDXio6k,737
+cortex_training/_cli.py,sha256=r38HouCpYj0RR2MFSyzlZ82kaNd93g2LtOrGTc-rfy4,33590
+cortex_training/cli.py,sha256=5ecW-hKpRICUQHTDelL3xcZW1aLz-1UoGBl2DV6q5Ro,2842
+cortex_training/client.py,sha256=EF9pIE1LRuTycKwgL2dFX15uqAH7Tyf5ZU6cARCr55k,115150
+cortex_training/peft.py,sha256=dN0cDbckx6wcLil39hoD6JXrvmPQSN4WC0zFRC5npIQ,4555
+cortex_training/telemetry.py,sha256=n8sEay0umQFkhWPIw44YjcQHZJC23Un3qDuwjtVpmF4,19383
+cortex_training/wire.py,sha256=0jOxKzjdL9ym_b6G5UKlfhuwR6ZRXc0q4mSkYNhC6o8,15768
+cortex_training/tui/__init__.py,sha256=EuG2sQ4PJ4yIZnmSZ2j0SxZ2MHYFHNsBgRT7_N6M3Uo,946
+cortex_training/tui/__main__.py,sha256=_8sL3nktS4bpX-hmDw3wioD-9Ol7pC20MHS3PpRhywY,4365
+cortex_training/tui/app.py,sha256=p7qQxwfgCiMIrmqdMoGR2HbkaQ9r3bYBMGzwy7Cddv8,27040
+cortex_training/tui/format.py,sha256=e83sWcL14ybDq_3oMS7HlAD9vFGREKbN8SiiLx7b_Pg,12835
+cortex_training/tui/log_cache.py,sha256=J6tvefYorOPS-vCDGwLN7EA3Shq_UJtXV_k6S_mNv9g,14977
+cortex_training-0.0.3.dist-info/licenses/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+cortex_training-0.0.3.dist-info/METADATA,sha256=F7IkUp6ERAW02hSc_tW6i2qRXWSlKVorJMIkiKF1pEc,4930
+cortex_training-0.0.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cortex_training-0.0.3.dist-info/entry_points.txt,sha256=2_-x1gwFPTJpKb7hbNehYQxUc6h4phAz-NgDBXYRLBQ,91
+cortex_training-0.0.3.dist-info/top_level.txt,sha256=3vIEeuPa44fLTC3IRfhim4oUaPKPhxix7m8fgTHhRUs,16
+cortex_training-0.0.3.dist-info/RECORD,,

cortex_training-0.0.3.dist-info/WHEEL

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

cortex_training-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cortex-training = cortex_training.cli:main
+ct = cortex_training.cli:main