sci-protocol 0.2.0__py3-none-any.whl

pysci/zipformat.py

@@ -0,0 +1,400 @@
+"""The canonical single-file bundle ZIP (protocol §2.2).
+
+:func:`parse_zip_layout` checks every structural rule of §2.2 except CRC-32
+values and entry ordering against the manifest (those need entry data and
+the manifest; see :mod:`pysci.bundle`). It reads only the end record, the
+central directory, and each local header, checking bounds before every read,
+and verifies that headers and data account for every byte.
+
+:func:`write_canonical_zip` produces the exact bytes defined by §2.2 and
+:func:`canonical_zip_size` evaluates the §2.1 size formula.
+"""
+
+from __future__ import annotations
+
+import struct
+import zlib
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from typing import Final, Protocol
+
+from .errors import Incomplete, Invalid, Issue, Outcome
+from .source import ByteSource, iter_chunks
+
+__all__ = [
+    "BASELINE_ZIP_LIMIT",
+    "SupportsWrite",
+    "ZipEntry",
+    "canonical_zip_size",
+    "crc32_of",
+    "parse_zip_layout",
+    "write_canonical_zip",
+]
+
+BASELINE_ZIP_LIMIT: Final = 64 * 1024 * 1024
+
+_LOCAL_SIG: Final = 0x04034B50
+_CENTRAL_SIG: Final = 0x02014B50
+_EOCD_SIG: Final = 0x06054B50
+_LOCAL: Final = struct.Struct("<IHHHHHIIIHH")
+_CENTRAL: Final = struct.Struct("<IHHHHHHIIIHHHHHII")
+_EOCD: Final = struct.Struct("<IHHHHIIH")
+_VERSION: Final = 10  # version 1.0
+_MADE_BY: Final = 0x000A  # MS-DOS host, version 1.0
+_DOS_DATE: Final = 0x0021  # 1980-01-01
+_DOS_TIME: Final = 0x0000
+_MAX_U16: Final = 0xFFFF
+_MAX_U32: Final = 0xFFFFFFFF
+ENTRY_OVERHEAD: Final = _LOCAL.size + _CENTRAL.size  # 76 bytes, plus 2 * path length
+EOCD_SIZE: Final = _EOCD.size  # 22
+
+
+@dataclass(frozen=True, slots=True)
+class ZipEntry:
+    """Location of one stored entry inside a structurally valid ZIP."""
+
+    name: bytes
+    local_offset: int
+    data_offset: int
+    size: int
+    crc32: int
+
+    @property
+    def path(self) -> str:
+        """The entry name decoded as ASCII (validated by the parser)."""
+        return self.name.decode("ascii")
+
+
+def _invalid(code: str, requirement: str, observed: object = None) -> Invalid:
+    return Invalid(
+        Issue(
+            code,
+            requirement,
+            section="2.2",
+            file="bundle.zip",
+            observed=None if observed is None else str(observed),
+        )
+    )
+
+
+def parse_zip_layout(
+    source: ByteSource,
+    *,
+    max_entries: int = _MAX_U16 - 1,
+    max_central_bytes: int = 64 * 1024 * 1024,
+) -> list[ZipEntry]:
+    """Parse and check the §2.2 layout without reading entry data.
+
+    Raises:
+        Invalid: any layout, field, or consistency violation.
+        Incomplete: the central directory exceeds a local limit.
+    """
+    size = source.size
+    if size < EOCD_SIZE:
+        raise _invalid(
+            "zip_truncated",
+            "a ZIP ends with a 22-byte end-of-central-directory record",
+            f"{size} bytes",
+        )
+    eocd_offset = size - EOCD_SIZE
+    sig, disk, cd_disk, count_disk, count_total, cd_size, cd_offset, comment_len = _EOCD.unpack(
+        source.read_at(eocd_offset, EOCD_SIZE)
+    )
+    if sig != _EOCD_SIG:
+        raise _invalid(
+            "zip_end_record",
+            "one end-of-central-directory record must end at the last byte, with an empty comment",
+        )
+    if comment_len != 0:
+        raise _invalid("zip_comment", "the archive comment must be empty", comment_len)
+    if disk != 0 or cd_disk != 0:
+        raise _invalid("zip_disk_number", "all disk-number fields must be zero")
+    if _MAX_U16 in (count_disk, count_total) or _MAX_U32 in (cd_size, cd_offset):
+        raise _invalid("zip64", "ZIP64 records and sentinel values are prohibited")
+    if count_disk != count_total:
+        raise _invalid(
+            "zip_entry_count",
+            "both entry-count fields must give the actual count",
+            f"{count_disk} != {count_total}",
+        )
+    if cd_offset > eocd_offset or cd_size != eocd_offset - cd_offset:
+        raise _invalid(
+            "zip_central_extent",
+            "the central directory must lie between the last "
+            "entry data and the end record, with its stated offset and length",
+        )
+    if count_total > max_entries:
+        raise Incomplete(
+            Issue(
+                "zip_entry_limit",
+                "ZIP entry count exceeds the local limit",
+                section="6",
+                file="bundle.zip",
+                observed=str(count_total),
+                outcome=Outcome.INCOMPLETE,
+            )
+        )
+    if cd_size > max_central_bytes:
+        raise Incomplete(
+            Issue(
+                "zip_central_limit",
+                "central directory exceeds the local limit",
+                section="6",
+                file="bundle.zip",
+                observed=str(cd_size),
+                outcome=Outcome.INCOMPLETE,
+            )
+        )
+    central = source.read_at(cd_offset, cd_size)
+    records = _parse_central(central, count_total)
+    return _check_locals(source, records, cd_offset)
+
+
+@dataclass(frozen=True, slots=True)
+class _Central:
+    name: bytes
+    crc32: int
+    size: int
+    offset: int
+    fields: tuple[int, ...]  # version needed .. uncompressed size, shared with local header
+
+
+def _parse_central(central: bytes, count: int) -> list[_Central]:
+    records: list[_Central] = []
+    position = 0
+    for index in range(count):
+        if len(central) - position < _CENTRAL.size:
+            raise _invalid(
+                "zip_central_truncated",
+                "central directory must contain one header per entry",
+                f"entry {index}",
+            )
+        (
+            sig,
+            made_by,
+            needed,
+            flags,
+            method,
+            mtime,
+            mdate,
+            crc,
+            csize,
+            usize,
+            name_len,
+            extra_len,
+            comment_len,
+            disk_start,
+            internal,
+            external,
+            offset,
+        ) = _CENTRAL.unpack_from(central, position)
+        if sig != _CENTRAL_SIG:
+            raise _invalid(
+                "zip_central_signature", "central file header signature expected", f"entry {index}"
+            )
+        _check_common(index, needed, flags, method, mtime, mdate, csize, usize)
+        if made_by != _MADE_BY:
+            raise _invalid(
+                "zip_version_made_by", "version made by must be 0x000A", f"0x{made_by:04X}"
+            )
+        if extra_len != 0 or comment_len != 0:
+            raise _invalid(
+                "zip_extra_field", "extra fields and file comments must be empty", f"entry {index}"
+            )
+        if disk_start != 0:
+            raise _invalid("zip_disk_number", "all disk-number fields must be zero")
+        if internal != 0 or external != 0:
+            raise _invalid(
+                "zip_attributes",
+                "internal and external file attributes must be zero",
+                f"entry {index}",
+            )
+        if offset == _MAX_U32:
+            raise _invalid("zip64", "ZIP64 sentinel values are prohibited")
+        start = position + _CENTRAL.size
+        if name_len > len(central) - start:
+            raise _invalid(
+                "zip_central_truncated", "file name exceeds the central directory", f"entry {index}"
+            )
+        name = central[start : start + name_len]
+        records.append(
+            _Central(
+                name,
+                crc,
+                usize,
+                offset,
+                (needed, flags, method, mtime, mdate, crc, csize, usize, name_len, extra_len),
+            )
+        )
+        position = start + name_len
+    if position != len(central):
+        raise _invalid(
+            "zip_unaccounted_bytes",
+            "central directory length must match its headers exactly",
+            f"{len(central) - position} extra bytes",
+        )
+    return records
+
+
+def _check_common(
+    index: int, needed: int, flags: int, method: int, mtime: int, mdate: int, csize: int, usize: int
+) -> None:
+    if needed != _VERSION:
+        raise _invalid("zip_version_needed", "version needed to extract must be 1.0 (10)", needed)
+    if flags != 0:
+        raise _invalid(
+            "zip_flags",
+            "general-purpose flags must be zero (no data descriptors)",
+            f"0x{flags:04X}",
+        )
+    if method != 0:
+        raise _invalid("zip_method", "compression method must be 0 (stored)", method)
+    if mtime != _DOS_TIME:
+        raise _invalid("zip_mod_time", "last-modification time must be 0x0000", f"0x{mtime:04X}")
+    if mdate != _DOS_DATE:
+        raise _invalid("zip_mod_date", "last-modification date must be 0x0021", f"0x{mdate:04X}")
+    if _MAX_U32 in (csize, usize):
+        raise _invalid("zip64", "ZIP64 sentinel values are prohibited")
+    if csize != usize:
+        raise _invalid(
+            "zip_size_mismatch",
+            "stored entries have equal compressed and uncompressed sizes",
+            f"entry {index}",
+        )
+
+
+def _check_locals(
+    source: ByteSource, records: Sequence[_Central], cd_offset: int
+) -> list[ZipEntry]:
+    entries: list[ZipEntry] = []
+    position = 0
+    for index, record in enumerate(records):
+        if record.offset != position:
+            raise _invalid(
+                "zip_local_offset",
+                "each central entry must point to its local "
+                "header, stored consecutively from byte zero",
+                f"entry {index}: offset {record.offset}, expected {position}",
+            )
+        if cd_offset - position < _LOCAL.size:
+            raise _invalid(
+                "zip_local_truncated", "local header exceeds the entry region", f"entry {index}"
+            )
+        (sig, *fields) = _LOCAL.unpack(source.read_at(position, _LOCAL.size))
+        if sig != _LOCAL_SIG:
+            raise _invalid(
+                "zip_local_signature", "local file header signature expected", f"entry {index}"
+            )
+        needed, flags, method, mtime, mdate, _crc, csize, usize, _nlen, _xlen = fields
+        _check_common(index, needed, flags, method, mtime, mdate, csize, usize)
+        if tuple(fields) != record.fields:
+            raise _invalid(
+                "zip_header_mismatch",
+                "fields shared by local and central headers must agree byte for byte",
+                f"entry {index}",
+            )
+        name_start = position + _LOCAL.size
+        name_len = len(record.name)
+        if name_len > cd_offset - name_start:
+            raise _invalid(
+                "zip_local_truncated", "file name exceeds the entry region", f"entry {index}"
+            )
+        if source.read_at(name_start, name_len) != record.name:
+            raise _invalid(
+                "zip_header_mismatch", "local and central file names must agree", f"entry {index}"
+            )
+        data_offset = name_start + name_len
+        if record.size > cd_offset - data_offset:
+            raise _invalid(
+                "zip_data_truncated",
+                "entry data must end before the central directory",
+                f"entry {index}",
+            )
+        if not record.name.isascii():
+            raise _invalid("zip_name", "entry names must be ASCII paths", record.name)
+        entries.append(ZipEntry(record.name, position, data_offset, record.size, record.crc32))
+        position = data_offset + record.size
+    if position != cd_offset:
+        raise _invalid(
+            "zip_unaccounted_bytes",
+            "local headers and data must account for every byte before the central directory",
+            f"{cd_offset - position} unaccounted bytes",
+        )
+    return entries
+
+
+def crc32_of(source: ByteSource) -> int:
+    """CRC-32 of a whole source, streamed."""
+    crc = 0
+    for chunk in iter_chunks(source):
+        crc = zlib.crc32(chunk, crc)
+    return crc
+
+
+class SupportsWrite(Protocol):
+    def write(self, data: bytes, /) -> object: ...
+
+
+def canonical_zip_size(entries: Iterable[tuple[str, int]]) -> int:
+    """Exact canonical ZIP length: ``22 + sum(file_bytes + 76 + 2 * path_bytes)`` (§2.1).
+
+    ``entries`` must include ``manifest.json`` and ``manifest.json.sig``.
+    """
+    return EOCD_SIZE + sum(
+        size + ENTRY_OVERHEAD + 2 * len(path.encode("utf-8")) for path, size in entries
+    )
+
+
+def write_canonical_zip(sink: SupportsWrite, entries: Sequence[tuple[str, ByteSource]]) -> int:
+    """Write the canonical ZIP for entries already in §2.2 order; return its length.
+
+    Each source is read twice (CRC pass, then copy) in bounded chunks. The
+    caller is responsible for the entry order (manifest, signature, then
+    listed paths in ascending ASCII order); see
+    :func:`pysci.bundle.canonical_entries`.
+
+    Raises:
+        ValueError: the entries cannot be represented in classic ZIP.
+    """
+    if len(entries) >= _MAX_U16:
+        raise ValueError("too many entries for classic ZIP")
+    central = bytearray()
+    position = 0
+    for name, source in entries:
+        name_bytes = name.encode("ascii")
+        size = source.size
+        if size >= _MAX_U32 or len(name_bytes) > _MAX_U16:
+            raise ValueError(f"entry {name!r} cannot be represented without ZIP64")
+        crc = crc32_of(source)
+        header = _LOCAL.pack(
+            _LOCAL_SIG, _VERSION, 0, 0, _DOS_TIME, _DOS_DATE, crc, size, size, len(name_bytes), 0
+        )
+        sink.write(header + name_bytes)
+        for chunk in iter_chunks(source):
+            sink.write(chunk)
+        central += _CENTRAL.pack(
+            _CENTRAL_SIG,
+            _MADE_BY,
+            _VERSION,
+            0,
+            0,
+            _DOS_TIME,
+            _DOS_DATE,
+            crc,
+            size,
+            size,
+            len(name_bytes),
+            0,
+            0,
+            0,
+            0,
+            0,
+            position,
+        )
+        central += name_bytes
+        position += _LOCAL.size + len(name_bytes) + size
+        if position >= _MAX_U32:
+            raise ValueError("archive too large for classic ZIP")
+    sink.write(bytes(central))
+    sink.write(_EOCD.pack(_EOCD_SIG, 0, 0, len(entries), len(entries), len(central), position, 0))
+    return position + len(central) + EOCD_SIZE

sci_protocol-0.2.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: sci-protocol
+Version: 0.2.0
+Summary: Python library and sci CLI for SCI research publications.
+Project-URL: Repository, https://github.com/azaho/sci
+Project-URL: Documentation, https://github.com/azaho/sci/blob/main/README.md
+Author: SCI contributors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: asn1crypto>=1.5.1
+Requires-Dist: cryptography>=46.0.3
+Requires-Dist: idna>=3.11
+Description-Content-Type: text/markdown
+
+<h1 align="center">sci</h1>
+
+<p align="center">Signed, verifiable research publications for agents and humans.</p>
+
+<p align="center">
+  <a href="https://github.com/azaho/sci/actions/workflows/checks.yml"><img src="https://github.com/azaho/sci/actions/workflows/checks.yml/badge.svg?branch=main" alt="Checks"></a>
+  <a href="https://github.com/azaho/sci/actions/workflows/test-vectors.yml"><img src="https://github.com/azaho/sci/actions/workflows/test-vectors.yml/badge.svg?branch=main" alt="Test vectors"></a>
+  <a href="pyproject.toml"><img src="https://img.shields.io/badge/Python-3.11%2B-blue?logo=python&logoColor=white" alt="Python 3.11+"></a>
+  <a href="protocol/README.md"><img src="https://img.shields.io/badge/Protocol-0.1_draft-orange" alt="Protocol 0.1 draft"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache_2.0-blue" alt="Software license: Apache 2.0"></a>
+</p>
+
+SCI is an open, decentralized publication system. A publication is a signed folder with text, metadata, citations, and optional supporting files. Its ID is the SHA-256 hash of its signed manifest. Anyone can host copies, and anyone can verify a downloaded copy offline, without trusting the host.
+
+| Component | Contents |
+| --- | --- |
+| [`protocol/`](protocol/README.md) | Protocol specification (draft 0.1), baseline publication license, and the shared conformance corpus |
+| [CLI guide](cli/README.md) | The `sci` command: prepare, sign, verify, publish, submit, search, and retrieve publications |
+| [`python/`](python/README.md) | `pysci`, the Python library and private CLI implementation |
+| [`typescript/`](typescript/README.md) | TypeScript protocol library for browsers, Deno, Workers, and Node |
+
+Both implementations use the shared 680-case [conformance corpus](protocol/test-vectors/README.md).
+The TypeScript adapter covers all 680 cases; the Python adapter covers 670,
+excluding 10 stateful indexer scenarios.
+
+## Install
+
+Requires Python 3.11 or later. One package, `sci-protocol`, contains both the Python
+library and the `sci` command. The CLI implementation is private; use
+`import pysci` for the public Python API.
+
+After the first PyPI release, install the standalone command with:
+
+```sh
+uv tool install sci-protocol
+```
+
+Or install both the library and command in a project virtual environment:
+
+```sh
+pip install sci-protocol
+```
+
+`uv tool install` isolates the command; it does not add `pysci` to your
+project or notebook environment.
+
+Until the PyPI release, install from this checkout at the repository root:
+
+```sh
+uv tool install .
+# Or, inside a project virtual environment:
+pip install .
+```
+
+For development, use `uv sync` and `uv run sci --help`. Package version 0.2.0
+introduces this unified distribution; the SCI protocol remains at draft 0.1.
+
+## First workflow
+
+Prepare a draft folder:
+
+```text
+draft/
+├── sci.json      # required: {"title": "...", "abstract": "...", "citations": [...]}
+├── README.md     # required: main text in UTF-8 Markdown
+└── files/        # optional: code, data, and figures
+```
+
+Sign it, verify it, and keep the bundle in a local campaign folder:
+
+```sh
+sci keygen                                          # create a signing key in ~/.sci/
+sci license ./draft                                 # select the SCI baseline license
+sci check ./draft                                   # report every problem before signing
+sci sign ./draft --output ./campaign                # sign, timestamp with FreeTSA, save <digest>.zip
+sci verify ./campaign/<digest>.zip                  # complete offline verification
+sci search "neural decoding" --in ./campaign        # search verified local bundles
+```
+
+Host the bundles in a public archive and register them with an index:
+
+```sh
+sci publish ./campaign --to https://github.com/lab/research --create
+sci submit ./campaign --to https://sciscape.io \
+  --archive https://github.com/lab/research
+sci pull sha256:<digest> --in https://sciscape.io   # retrieve and verify from any registered host
+```
+
+See the [CLI instructions](cli/README.md) for every command, and [CONTRIBUTING.md](CONTRIBUTING.md) for development.
+
+## License
+
+Software in this repository is licensed under the [Apache License, Version 2.0](LICENSE). Publications keep their own licenses; the [SCI baseline publication license](protocol/sci-baseline-LICENSE.txt) is CC BY 4.0 for text, figures, and data and MIT for code.

sci_protocol-0.2.0.dist-info/RECORD

@@ -0,0 +1,80 @@
+pysci/__init__.py,sha256=6iAWMgbVnvk85K4xjfujSyaYih_fZiCVCyVu9nzTgYg,2232
+pysci/__main__.py,sha256=0wXYxQ_bSRnD7NvHIB139Pw9xn5RrNdaUZ4PeDddSKw,172
+pysci/accounts.py,sha256=gBPJyVmYqxs6KRBvXzNFkUwHx2SnK2JeM99oVBP6KHk,4697
+pysci/baseline.py,sha256=lXeEXFhVAVoAoO621fCUDMViHcZO-yEoIMhz2F6QD1Q,4841
+pysci/bundle.py,sha256=0A5GHVa3tluN7CmYJEaHMvKm6Tm6HQ4QMGLPDoxnSN0,30701
+pysci/citations.py,sha256=nWkbWt4_lona6-1O_JnogorAjEaPRse0HcCaeDokXpU,8241
+pysci/der.py,sha256=0fllx-VtUMVP_AaOTbDJp8GbFl3znJhtDz0HQBV0lCo,4758
+pysci/discovery.py,sha256=2vTCbRPjWtI7riXT08MfR-PUvFDzjE1c6g8-3-EVxUc,15545
+pysci/draft.py,sha256=L4Lj9qXjIpyvdYRHcpx6Jd2-ALDwjPwPBBPpsQzmRh0,13680
+pysci/ed25519.py,sha256=9Uu5TdsGEwYFdmUPFtCvEFXOXQ2L-OLEL87YdoqogKc,5297
+pysci/errors.py,sha256=xvv0FoLeI4hB4LYH9AqprILtjCr4_4OgJvkrUZn5N-8,6081
+pysci/ids.py,sha256=W7r3ZMJvnUFmggmqZ1nlAjQJztepwiOrtPGxwi-PFgY,1971
+pysci/jsonstrict.py,sha256=FHBCagb-LnQSNVhtfOfnoQ_ztaW5PYFUfgaUzrQ4_xA,6832
+pysci/keys.py,sha256=2Ja2o0CDwbD2bO4NZ2KJaWnlyNSyl3B8McYTqG-_ag4,7785
+pysci/manifest.py,sha256=tP7pAG0xeRU25P-u4PqgOO29AZMitOouKN_x733Cfbc,10745
+pysci/metadata.py,sha256=_YxvH1e2tXImDRGfo0jNQlctdgymyukl3gtrfkbaGEE,13729
+pysci/paths.py,sha256=bOnqOZL8drUpt8Vr9srGw3yhDzY0g6ZEuMZJsHnUi6w,4660
+pysci/png.py,sha256=Ef9NYvbFu_aZ00LTLeAp2PrbyhJwSUP4nB5GyQRJOvk,8329
+pysci/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysci/records.py,sha256=RrDMPYNGkNUdJmodiK1WpKh6-oya72ECkfCDgQ6fO-g,12866
+pysci/rfc3339.py,sha256=n0VrVeI8XdxFyic8txOLeRUWggteFwhuGICFftVbJ6g,2535
+pysci/schemas.py,sha256=LHeLns0CgJMqV3J0qSjbh_P7bccJksf9gDcOVFpsgFU,2259
+pysci/source.py,sha256=MErNuSO5V9_FXY9swwv8HzyzFt6eFGAz9NoP10BFp0I,5189
+pysci/specification.py,sha256=83lSZPXb0jTMSoRufwNWD0JulWrZvJg6mkJL1ihWChE,2147
+pysci/submission.py,sha256=I8ypqxM38WDGI0aXrMF0cK51SVKiLqzMQc4Sl58M9sY,7867
+pysci/templates.py,sha256=OGbePyPlLDzLOwEIGUsttdRbdtMH7ymmNcS4oOPt9so,4502
+pysci/text.py,sha256=IH12DJSr0XfRvjEWHzFKwJbSYQGyyMktCutWzsFgIKE,7601
+pysci/timestamps.py,sha256=sN4YzcvC54uSKLpksnDw0Euhsc5N4oq_BxDP2-y0CY0,33031
+pysci/zipformat.py,sha256=mI3QFLh-3isORPbFMkr1KAig2IuYScjWnUhC3xXLt5c,14168
+pysci/_cli/__init__.py,sha256=izaso6Nx_amnnDox2STr3CbZuwn6QQotopadF7qiHdA,148
+pysci/_cli/checks.py,sha256=XlKTAo_t89kIoRGcjCcEsOtzyL6cwlPv40ksDD479Ec,6647
+pysci/_cli/config.py,sha256=9z92ixo_8bLYq8MjjWynz0wpNwGvqBFq_PNcqd3cUs4,8011
+pysci/_cli/context.py,sha256=d8A0UxlBdNVoQj0fsgYHYYfEYAiIOx8SqJMWBSop-WA,2638
+pysci/_cli/destinations.py,sha256=Ugn8oOS0RELZ8GV0hID5eyqJ_5sBU6FkKg4jarWNuAM,5569
+pysci/_cli/errors.py,sha256=W-zF6-lOmPFXw7zh3GgRAH7fv8P1gUrcJGzSXENtwTE,5273
+pysci/_cli/main.py,sha256=peLjTx_vcHkYMxJDCOE-8tnt7nC4UXaH-0Uf8oW6O3U,9498
+pysci/_cli/output.py,sha256=rM-trm5DKrNYWde91TKYMNdctx5aoXOQSrwGt5Pmt5I,2706
+pysci/_cli/retrieval.py,sha256=cOprG0-O_VyZ3Y4SzlPPmEz9vbVx1yrjz-hplnNGAAE,1551
+pysci/_cli/spec.py,sha256=aSe8f9Z2TvjAZZcLloG8MCDZ_-PTW1xs5xVTvzNLBF0,3915
+pysci/_cli/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysci/_cli/clients/archive.py,sha256=7_Qgu8iUFjrm98WwHQJaJEzhjO8CUxTP0sa1mmFd6rM,17249
+pysci/_cli/clients/credentials.py,sha256=cB2jIUBUTz97tLlpUFToNSLX78xO3RI3Q7kymQNSUy0,1780
+pysci/_cli/clients/github.py,sha256=tyGEwR_6ccaKl7Cf5F1_ZUMZB_oeM2hkjfZArbrD9M4,28519
+pysci/_cli/clients/hosting.py,sha256=5iTeZqnrksilOSg5NwlIVuo_k8QVbL7xtM_hqSSZkB0,7753
+pysci/_cli/clients/http.py,sha256=f0K6KMeZeu0z5XG7mFHoiAOqKJb2TTdYkGT35Fh8Fhw,16730
+pysci/_cli/clients/huggingface.py,sha256=5qRVigeru4WkHbdSHvSC72iAFi7sHsZxtyBwhgn20WI,19202
+pysci/_cli/clients/index.py,sha256=nit0vIasrmHFzsYec3YWumonnr44MeX0p1weKNv_kdY,16624
+pysci/_cli/clients/tsa.py,sha256=Gkywequh62h1p_M5I_xapCCZlwVwGnWruZ7An5Z9EMs,7180
+pysci/_cli/commands/__init__.py,sha256=-C7eOIBhzHcp_jjaa1OuU9xVAvmmYsmKHn9grfcfMpQ,692
+pysci/_cli/commands/check.py,sha256=0-_sQYm_86mAkLXEkcCKkYADgXIcGUOQ-4w08257dm0,4600
+pysci/_cli/commands/claim.py,sha256=nS_sYXo3jnOaAfEeUCKMwa1NlwsjfuRAY0eY2WMNLH8,7415
+pysci/_cli/commands/common.py,sha256=C4Nvy3hWJsTt9CMrMSa2PTsjud5aCsufrGG-YCd8AA4,2895
+pysci/_cli/commands/folders.py,sha256=ciTc_joMLo5t4rQu_ik9PK__PUc-XwsZBLK6WqkEwV8,3284
+pysci/_cli/commands/index.py,sha256=EKDkmk9mjpL5waCuVFGGcBCgWMUzqB985uGgksytLz8,1808
+pysci/_cli/commands/keygen.py,sha256=QqbzyHkpF_gzuBuPlodaYuq8I9J0byDrlsDKdZXPQEo,2071
+pysci/_cli/commands/license.py,sha256=XP0_7lWtAGgVHntjyUszsFhx78qR1Br8UHd6Vn5mbWA,2928
+pysci/_cli/commands/protocol.py,sha256=6of-D8M-doJY0CqEbgbVr6Iz8ZtZp8Ny2g2ijw7vrvc,2694
+pysci/_cli/commands/publish.py,sha256=Owmx9v6nhrxYDLXrH7ai9gMEmAAsYVinBe0gdhpnHSs,12075
+pysci/_cli/commands/pull.py,sha256=ZNvftjI87D9wvSQb75smsfWf4qSspV33sNtduaf25-U,14207
+pysci/_cli/commands/read.py,sha256=YUpe0Rh6lU5N0yO8hQBa_UGEM8w7n6l_gSGv4ezX5Pk,14885
+pysci/_cli/commands/revoke.py,sha256=hFPqUZO9TPr2kTCLtIcNcC0NtU-rVT6Y6jP-D3OPhDk,8988
+pysci/_cli/commands/search.py,sha256=KXPIW_NiRNgNMOg6U0nzEkFcANHiaLcE1sYB82JE_2Q,15593
+pysci/_cli/commands/sign.py,sha256=nYsil1CV52fsMGYZsTsQEdsReEso3U87iRMZXlToKz0,12241
+pysci/_cli/commands/submit.py,sha256=x5wwpaw1v7uKdq8niQlgkl4wXwgvg5OePLw_Fh7PMy8,6756
+pysci/_cli/commands/timestamp.py,sha256=y0miNXKGhlYgwkxq7lPXVR18HeHB5F82w9jFu_9ojb0,8573
+pysci/_cli/commands/verify.py,sha256=HSnmytpaFXwAJAxPn2nAFe3luC9bKSBZTBClWR4l4kg,6336
+pysci/_cli/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysci/_cli/storage/catalog.py,sha256=xDFyTGSoM-bLz6mgUhc3ysYb01OofG7FRI-EmgLDsyU,13540
+pysci/_cli/storage/files.py,sha256=Sd_TwFZGdK4zThQLpfU25arKxob_GChPLKFuruGGPzQ,8381
+pysci/_cli/storage/inputs.py,sha256=UgNP4LsJQwMD4pXh6QhDvmgeBPtuc4VhBMVV1JZjTWQ,7382
+pysci/_cli/storage/keys.py,sha256=roa-HOky4PxlZBmMVXeJ2PSxlNDRfLjpVLsjO-Ys-9c,4442
+pysci/_cli/storage/local_publish.py,sha256=YtcQ2veSTsMeqHdbjjzfQ83WiS4FgNyy6uGUAOWrksU,3422
+pysci/data/freetsa-cacert.pem,sha256=IVG2ETf_qGv2ZGkbpn59oLGfmMdY49Io1djr8n4ERDg,2833
+pysci/data/sci-baseline-LICENSE.txt,sha256=jM_V_aqT5ecdyIEr8R4KcZi9ClNPpkuJcP0t5Y5sJHg,22183
+pysci/data/sci-protocol.md,sha256=MR5AcgOSVwk4_uP_Z9U-bO-TORayKGU9Enmpw_Uq_A0,39097
+sci_protocol-0.2.0.dist-info/METADATA,sha256=ANCHYOdOVmmqO3SZX7-9228fZ2It8812zJqt76V5QFU,5061
+sci_protocol-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+sci_protocol-0.2.0.dist-info/entry_points.txt,sha256=bgSpT-ID776Fyzmv4GU3C82Y1v43Ca_dD0xAsO17C4c,45
+sci_protocol-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+sci_protocol-0.2.0.dist-info/RECORD,,

sci_protocol-0.2.0.dist-info/WHEEL

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

sci_protocol-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sci = pysci._cli.main:main