telemetry-cli 1.0.0__py3-none-any.whl

telemetry_cli/tgen/runtime.py

@@ -0,0 +1,390 @@
+"""Generating records from a parsed command file.
+
+Each field of an item specification is Python code, evaluated for every
+record in one shared namespace. A field may hold several statements
+separated by semicolons; its value is that of the last one (an expression,
+or the value assigned by an assignment).
+
+The namespace provides:
+
+    I            the record counter
+    F            the fill byte: each read gives the fill value, or a new
+                 random byte when F is set to a string containing "ran"
+                 (as with the -r option)
+    X, O         set by seek_file
+    DEBUG        set true to trace evaluation on stderr
+    P            the items: P.name.value is the item's value for this record
+                 (or the last record, if it hasn't been evaluated yet), and
+                 P.name._value evaluates its value field again. Likewise for
+                 name, offset, trigger and type.
+    rand, srand  Perl-compatible random numbers (drand48)
+    subcom_file, file_lookup, seek_file
+                 read data from files
+    pmod         Perl's % (on the integer parts of its operands)
+    pand, por, pxor, pshl, pshr
+                 Perl's &, |, ^, << and >> (on unsigned 64-bit integers)
+    cat          Perl's . (join values as text; numbers as Perl prints them)
+    sprintf      Perl's sprintf
+    pi, sin, cos, tan, atan2, sqrt, exp, log, floor, ceil
+    stderr       for diagnostics (stdout is the data)
+"""
+
+from __future__ import annotations
+
+import ast
+import math
+import sys
+from collections.abc import Callable
+from typing import BinaryIO, TextIO
+
+from .. import _pack
+from .._perl import UV_MAX, numify, perl_str, sprintf, to_uv
+from .cmdfile import Item, Statement
+
+
+class TgenError(ValueError):
+    pass
+
+
+class Drand48:
+    """Perl's random number generator (Perl_drand48), so seeded runs match Perl's."""
+
+    A, C, M = 0x5DEECE66D, 0xB, 1 << 48
+
+    def __init__(self, seed: int | None = None):
+        if seed is None:
+            import os
+
+            seed = int.from_bytes(os.urandom(4), "little")
+        self.seed(seed)
+
+    def seed(self, seed: int) -> None:
+        self.x = ((int(seed) & 0xFFFFFFFF) << 16) + 0x330E
+
+    def random(self) -> float:
+        self.x = (self.A * self.x + self.C) % self.M
+        return self.x / self.M
+
+
+def perl_true(v) -> bool:
+    """Perl's truth of a field's value: undef, 0, "" and "0" are false."""
+    if v is None:
+        return False
+    if isinstance(v, str):
+        return v not in ("", "0")
+    if isinstance(v, (list, tuple, bytes)):
+        return True  # a reference, or a non-empty string of bytes
+    return bool(v)
+
+
+def pmod(a, b):
+    """Perl's a % b: both operands are truncated to integers first."""
+    a, b = int(numify(a)), int(numify(b))
+    if b == 0:
+        raise ZeroDivisionError("Illegal modulus zero")
+    return a % b
+
+
+def cat(*values) -> str:
+    """Perl's string concatenation."""
+    return "".join(perl_str(v) for v in values)
+
+
+class _FieldCode:
+    """A compiled field: statements, then the expression whose value is the field's."""
+
+    def __init__(self, src: str, where: str):
+        self.src, self.where = src, where
+        try:
+            tree = ast.parse(src.strip() or "None", mode="exec")
+        except SyntaxError as e:
+            raise TgenError(f"{where}: can't parse {src!r}: {e.msg}") from None
+        tree = _ReadFill().visit(tree)
+        body = tree.body
+        last = body[-1] if body else ast.Expr(ast.Constant(None))
+        if isinstance(last, ast.Expr):
+            result = last.value
+            body = body[:-1]
+        elif isinstance(last, (ast.Assign, ast.AugAssign, ast.AnnAssign)):
+            target = last.targets[-1] if isinstance(last, ast.Assign) else last.target
+            result = _loaded(target)
+        else:
+            result = ast.Constant(None)
+        self.stmts = compile(ast.fix_missing_locations(ast.Module(body, [])), where, "exec")
+        self.expr = compile(ast.fix_missing_locations(ast.Expression(result)), where, "eval")
+
+    def run(self, ns: dict):
+        try:
+            exec(self.stmts, ns)
+            return eval(self.expr, ns)
+        except TgenError:
+            raise
+        except Exception as e:
+            raise TgenError(f"{self.where}: {type(e).__name__}: {e}  (in {self.src!r})") from None
+
+
+def _loaded(target: ast.expr) -> ast.expr:
+    """An expression reading back an assignment target (with reads of F as reads)."""
+    node = ast.parse(ast.unparse(target), mode="eval").body
+    return _ReadFill().visit(node)
+
+
+class _ReadFill(ast.NodeTransformer):
+    """Turn each read of F into a call, so it can give a new random byte every time."""
+
+    def visit_Name(self, node: ast.Name):
+        if node.id == "F" and isinstance(node.ctx, ast.Load):
+            return ast.copy_location(ast.Call(ast.Name("_read_fill", ast.Load()), [], []), node)
+        return node
+
+
+class ItemValues:
+    """P.name: one item's current values, and its fields for re-evaluation."""
+
+    def __init__(self, gen: Generator, item: Item):
+        self._gen, self._item = gen, item
+        self.name = item.name
+        self._current: dict = {}
+
+    def _get(self, field: str):
+        # The Perl pasted $P{name}{field} into the code as text, so a float
+        # came back with 15 significant digits.
+        v = self._current.get(field)
+        return float(perl_str(v)) if isinstance(v, float) and math.isfinite(v) else v
+
+    offset = property(lambda self: self._get("offset"))
+    trigger = property(lambda self: self._get("trigger"))
+    type = property(lambda self: self._get("type"))
+    value = property(lambda self: self._get("value"))
+
+    @property
+    def _name(self):
+        return self._item.name
+
+    @property
+    def _offset(self):
+        return self._gen._code(self._item, "offset").run(self._gen.ns)
+
+    @property
+    def _trigger(self):
+        return self._gen._code(self._item, "trigger").run(self._gen.ns)
+
+    @property
+    def _type(self):
+        return self._gen._code(self._item, "type").run(self._gen.ns)
+
+    @property
+    def _value(self):
+        return self._gen._code(self._item, "value").run(self._gen.ns)
+
+    def __getitem__(self, key: str):
+        return getattr(self, key)
+
+
+class Items:
+    def __init__(self):
+        self._items: dict[str, ItemValues] = {}
+
+    def __getattr__(self, name: str) -> ItemValues:
+        try:
+            return self.__dict__["_items"][name]
+        except KeyError:
+            raise AttributeError(f"no item named {name!r}") from None
+
+    def __getitem__(self, name: str) -> ItemValues:
+        return self._items[name]
+
+
+class Generator:
+    def __init__(
+        self,
+        items: list[Item],
+        statements: list[Statement],
+        *,
+        fill="0",
+        seed: int | None = None,
+        stderr: TextIO | None = None,
+        source: str = "command file",
+    ):
+        self.items = items
+        self.source = source
+        self.stderr = stderr if stderr is not None else sys.stderr
+        self.rng = Drand48(seed)
+        self.files: dict[str, BinaryIO] = {}
+        self._compiled: dict[tuple[int, str], _FieldCode] = {}
+        self.P = Items()
+        for it in items:
+            self.P._items[it.name] = ItemValues(self, it)
+        self.ns: dict = self._namespace(fill)
+        for st in statements:
+            _FieldCode(st.code, f"{source}:{st.line}").run(self.ns)
+
+    # --- the namespace --------------------------------------------------------
+
+    def _namespace(self, fill) -> dict:
+        ns = {
+            "I": 0,
+            "F": fill,
+            "X": None,
+            "O": 0,
+            "DEBUG": 0,
+            "P": self.P,
+            "rand": self.rand,
+            "srand": self.srand,
+            "subcom_file": self.subcom_file,
+            "file_lookup": self.file_lookup,
+            "seek_file": self.seek_file,
+            "pmod": pmod,
+            "pand": lambda a, b: to_uv(a) & to_uv(b),
+            "por": lambda a, b: to_uv(a) | to_uv(b),
+            "pxor": lambda a, b: to_uv(a) ^ to_uv(b),
+            "pshl": lambda a, b: (to_uv(a) << to_uv(b)) & UV_MAX if to_uv(b) < 64 else 0,
+            "pshr": lambda a, b: to_uv(a) >> to_uv(b) if to_uv(b) < 64 else 0,
+            "cat": cat,
+            "sprintf": sprintf,
+            "stderr": self.stderr,
+            "_read_fill": self.read_fill,
+        }
+        for name in ("pi", "sin", "cos", "tan", "atan2", "sqrt", "exp", "log", "floor", "ceil"):
+            ns[name] = getattr(math, name)
+        return ns
+
+    def rand(self, n=1):
+        """Perl's rand: a float in [0, n); rand(0) is rand(1)."""
+        n = numify(n) or 1
+        return self.rng.random() * n
+
+    def srand(self, seed=0):
+        self.rng.seed(int(numify(seed)))
+        return seed
+
+    def read_fill(self):
+        """The value of F: the fill, or a random byte if the fill is "random"."""
+        mode = self.ns["F"]
+        if isinstance(mode, str) and "ran" in mode:
+            return int(self.rng.random() * 256)
+        return mode
+
+    # --- file helpers (each file is opened once) ------------------------------
+
+    def _file(self, name) -> BinaryIO:
+        name = str(name)
+        if name not in self.files:
+            try:
+                self.files[name] = open(name, "rb")  # noqa: SIM115
+            except OSError as e:
+                raise TgenError(f"Can't read from {name}:  {e.strerror}") from None
+        return self.files[name]
+
+    def _read(self, name, offset, nbytes) -> bytes | None:
+        f = self._file(name)
+        offset = int(numify(offset))
+        if offset < 0:
+            return None
+        f.seek(offset)
+        return f.read(max(int(numify(nbytes)), 0))
+
+    def subcom_file(self, file, offset, nbytes):
+        """nbytes of file starting at offset, as a byte string."""
+        data = self._read(file, offset, nbytes)
+        return b"" if data is None else data
+
+    def file_lookup(self, file, offset, nbytes, unpack_type):
+        """The first value unpacked from nbytes of file at offset (0 if they can't be read)."""
+        nbytes = int(numify(nbytes))
+        data = self._read(file, offset, nbytes)
+        if data is None or len(data) != nbytes:
+            return 0
+        values = _pack.unpack(str(unpack_type), data)
+        return values[0] if values else None
+
+    def seek_file(self, file, offset, nbytes, unpack_type, cond):
+        """Read nbytes at offset (evaluated with O = 0, 1, 2, ...) until cond is true.
+
+        offset and cond are code, as strings; X holds the value just read.
+        Returns the offset that satisfied cond, or -1 at the end of the file.
+        """
+        offset_code = _FieldCode(str(offset), "seek_file offset")
+        cond_code = _FieldCode(str(cond), "seek_file condition")
+        nbytes = int(numify(nbytes))
+        self.ns["O"] = 0
+        while True:
+            at = offset_code.run(self.ns)
+            data = self._read(file, at, nbytes)
+            if data is None or len(data) != nbytes:
+                return -1
+            values = _pack.unpack(str(unpack_type), data)
+            self.ns["X"] = values[0] if values else None
+            if self.ns.get("DEBUG"):
+                print(f"o={self.ns['O']}; seek_value={self.ns['X']}", file=self.stderr)
+            self.ns["O"] += 1
+            if perl_true(cond_code.run(self.ns)):
+                return at
+
+    # --- generating -------------------------------------------------------------
+
+    def _code(self, item: Item, field: str) -> _FieldCode:
+        key = (id(item), field)
+        if key not in self._compiled:
+            self._compiled[key] = _FieldCode(
+                getattr(item, field), f"{self.source}:{item.line} ({item.name}, {field})"
+            )
+        return self._compiled[key]
+
+    def _eval(self, item: Item, field: str):
+        value = self._code(item, field).run(self.ns)
+        if self.ns.get("DEBUG"):
+            print(f"{item.name}.{field}: {getattr(item, field)!r} -> {value!r}", file=self.stderr)
+        return value
+
+    def frame(self) -> bytes:
+        frame: list[int | None] = []
+        for item in self.items:
+            cur = self.P._items[item.name]._current
+            cur["offset"] = offset = self._eval(item, "offset")
+            cur["trigger"] = trigger = self._eval(item, "trigger")
+            if not perl_true(trigger):
+                continue
+            if numify(offset) < 0:  # a calculation only: evaluate the value, don't pack
+                cur["value"] = self._eval(item, "value")
+                continue
+            cur["type"] = type_ = self._eval(item, "type")
+            cur["value"] = value = self._eval(item, "value")
+            values = list(value) if isinstance(value, (list, tuple)) else [value]
+            try:
+                packed = _pack.pack(str(type_), *values)
+            except _pack.PackError as e:
+                raise TgenError(f"{self.source}:{item.line} ({item.name}): {e}") from None
+            start = int(numify(offset))
+            end = start + len(packed)
+            if end > len(frame):
+                frame.extend([None] * (end - len(frame)))
+            frame[start:end] = packed
+        out = bytearray()
+        for b in frame:
+            if b is None:
+                out.append(int(numify(self.read_fill())) & 0xFF)
+            else:
+                out.append(b)
+        return bytes(out)
+
+    def run(
+        self,
+        out: BinaryIO,
+        nframes: int,
+        first: int,
+        *,
+        notify: int = 100,
+        quiet: bool = False,
+        progress: Callable[[str], None] | None = None,
+    ) -> None:
+        last = first + nframes - 1
+        self.ns["I"] = first
+        while numify(self.ns["I"]) <= last:
+            out.write(self.frame())
+            i = int(numify(self.ns["I"]))
+            if not quiet and not (i + 1) % notify and progress:
+                progress(f"{i}/{last}")
+            self.ns["I"] = self.ns["I"] + 1
+        for f in self.files.values():
+            f.close()

telemetry_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.5
+Name: telemetry-cli
+Version: 1.0.0
+Summary: Command-line tools for binary telemetry: decode, extract, measure and generate records
+Project-URL: Repository, https://github.com/donalgrant/telemetry-cli
+Project-URL: Documentation, https://github.com/donalgrant/telemetry-cli/tree/main/docs
+Project-URL: Changelog, https://github.com/donalgrant/telemetry-cli/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/donalgrant/telemetry-cli/issues
+Author: David A. Imel
+License-Expression: MIT
+License-File: LICENSE
+Keywords: binary,cli,decoding,pcm,records,telemetry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+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
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.23
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: pytest-cov>=4; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: tomli>=2; (python_version < '3.11') and extra == 'dev'
+Description-Content-Type: text/markdown
+
+# telemetry-cli
+
+Command-line tools for binary telemetry, built for Unix pipelines:
+
+- **pick** decodes fields from fixed-length binary records: integers, floats,
+  complex numbers, characters and bit fields, in any byte order
+  ([manual](https://github.com/donalgrant/telemetry-cli/blob/main/docs/pick.md)).
+- **recs** extracts records from a byte stream by their start (and end)
+  markers ([manual](https://github.com/donalgrant/telemetry-cli/blob/main/docs/recs.md)).
+- **recl** estimates the record length of a binary file
+  ([manual](https://github.com/donalgrant/telemetry-cli/blob/main/docs/recl.md)).
+- **tgen** generates synthetic telemetry from a command file describing each
+  record ([manual](https://github.com/donalgrant/telemetry-cli/blob/main/docs/tgen.md)).
+
+```console
+$ printf '\x00\x00\x00\x01\xff\xfeHi\x00\x00\x00\x02\x00\x07ok' > demo.bin
+$ pick demo.bin 8 -q order=big u s 2S
+1 -2 Hi
+2 7 ok
+$ pick demo.bin 8 -q order=big -n u0x w2b
+0 00 00 00 01  1111 1111 1111 1110
+1 00 00 00 02  0000 0000 0000 0111
+```
+
+Together: tgen makes a stream, recs pulls the frames out of it, recl finds
+their length, and pick decodes them. See
+[Using the tools together](https://github.com/donalgrant/telemetry-cli/blob/main/docs/pipelines.md).
+
+## Install
+
+Requires Python 3.10 or later. The package is `telemetry-cli` on PyPI, and is
+best installed as an isolated command-line tool:
+
+```text
+pipx install telemetry-cli
+# or
+uv tool install telemetry-cli
+```
+
+Either installs the commands `pick`, `recs`, `recl` and `tgen`. You can also
+`pip install telemetry-cli` in a virtual environment.
+
+## History
+
+These are Python ports of tools written at JPL. pick and recl began together
+as C++ tools, for a project whose telemetry arrived with no documentation of
+its structure: recl to find the length of the records, and pick to take them
+apart and work out what was in them. (A bit reminiscent of the film
+*Contact*.) Both were later rewritten in Perl (pick by 2000), and tgen (2003)
+and recs joined them.
+
+The command lines are the same, and so is the output, apart from fixes listed
+in the [CHANGELOG](https://github.com/donalgrant/telemetry-cli/blob/main/CHANGELOG.md):
+chiefly pick's byte-order handling on little-endian machines, and recl's
+measurement. tgen's command files are now Python; `tgen --convert` translates
+the old Perl ones. The Perl originals, with their history, are in
+[legacy/](https://github.com/donalgrant/telemetry-cli/tree/main/legacy).
+
+## Development
+
+```text
+python -m venv .venv && .venv/bin/pip install -e '.[dev]'
+.venv/bin/pytest
+```
+
+The tests compare each tool with its Perl original. `tests/golden/` holds the
+Perl's output for large tables of command lines (about 2,200 for pick, 700
+for recs), and the tests check that the Python version reproduces it byte for
+byte. Where it deliberately differs, the case names the CHANGELOG entry that
+explains why. With perl installed, further tests run random command lines
+through both versions and compare them (`HYPOTHESIS_PROFILE=deep pytest` for
+a longer search), and `python tools/make_golden.py --check` confirms the saved
+output is current. The examples in the documentation run as tests too.

telemetry_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+telemetry_cli/__init__.py,sha256=eb6NP89vHLTizc4DECIfkXYph1MHAVG3lP6xRh9PZDw,281
+telemetry_cli/_cli.py,sha256=Toez71kX-dZeAlgN1WxqujmG2htv_FXHrWeGjVJLH-U,508
+telemetry_cli/_getopt.py,sha256=v8DxS0bz0pbGcYqZTebQEle0Xkji-Ue8CE0KM9ixKUs,3800
+telemetry_cli/_msg.py,sha256=HEpnPAtRBIpA41DULrwMcMlJGVzNV9LM9AoJ7vqRZvM,1239
+telemetry_cli/_pack.py,sha256=DkoGgN_15gntl3GMZkiVl2GkiHyVGTljQOnaT6diLSY,6205
+telemetry_cli/_perl.py,sha256=VV7g_48MCtnAvmmpgGYJjsvXUhDsvmPjQ7tdt1JsmGI,5841
+telemetry_cli/pick/__init__.py,sha256=tf-fMfkUVpW4nhWQu6D8ctDkl3o8-9AIc-yM2UvKs60,71
+telemetry_cli/pick/__main__.py,sha256=R3wrnWRPRBDHCRIznlmRsnZ-nnDdJN7Lgo-Gnj8PgAE,99
+telemetry_cli/pick/cli.py,sha256=sGWx6I-e-GZa7tNrzsNtR2HK_XKfk21PEh0GXMP1suQ,5178
+telemetry_cli/pick/commandline.py,sha256=4rE0ADiJ0yeSN-WFQozy-PegkQPAtMPVOTXwLjDEy78,7725
+telemetry_cli/pick/fields.py,sha256=UtZoAotrkYSWP37SRjslysesuVelu8pXVH9iUT1clHM,5842
+telemetry_cli/pick/formats.py,sha256=rveagoksyngGNJgTvMm3lDM6A-3X3fH20K0tjzfeCTk,6908
+telemetry_cli/pick/help.py,sha256=Iie7L72JDWnNedb9dogOi02VcZd6AJqzPgsfk2tqeYI,18548
+telemetry_cli/pick/symbols/airmoc,sha256=vHkLQrkCCGhYDaPsKiAzoz5IfUXXiNSZ7GRW-y5MbGI,366
+telemetry_cli/pick/symbols/aux,sha256=wZ4rdl5XJiPL3ojuHiA3rmYaYkfgoBuNT1Bd-JxjBRc,409
+telemetry_cli/pick/symbols/corr,sha256=MCAFjE-hbWVwgj1LwFnOSLRDZWoeSNPFXiwDc8RkXCg,623
+telemetry_cli/pick/symbols/corrOld,sha256=E3fF8GL8XNJsoHfE1Z6KfXyyXuuc40du5YbCKC-YhbU,599
+telemetry_cli/pick/symbols/hw,sha256=statq5EeYbWwOXy4EC8BzveTyhGaxxVydJyMTbF4ltE,190
+telemetry_cli/pick/symbols/moc,sha256=MFj0nYy-o-YDa8C8iaztFASj4rqCterlVKAIJtJhEVs,664
+telemetry_cli/pick/symbols/subcom,sha256=GxSFJjxwZSeg5LlXyNVRS1vW0Q2ZD5uPkhKMp_1ERq8,2446
+telemetry_cli/pick/symbols/subcom_2002,sha256=sAjEgc6qwwLXwXzd9aq1wXQnMEGKXI1juBYO4A8WH98,2823
+telemetry_cli/recl/__init__.py,sha256=z4QFTEsk7RwgQHQCwjODqE5YSO0AnE30i0REjhAAX2A,57
+telemetry_cli/recl/__main__.py,sha256=30MLg92M0QF-x99qm1OapckDppgFkSgurwxg_Ne8GTI,99
+telemetry_cli/recl/cli.py,sha256=y2xdUzbHojbrT_AEacmPjB3S0hFs4wUnyd7cdBalMoc,7257
+telemetry_cli/recl/corr.py,sha256=z_fxBFrBw0gILJ8-7ZWQgYDSJWcFKvti4RsX28jxtFw,3536
+telemetry_cli/recs/__init__.py,sha256=E_nQYAX3sjrMia2Wk-x_HOZIgIWcWarJE3km7XGGLXw,82
+telemetry_cli/recs/__main__.py,sha256=KwNEOVw9Po2oqwSLDAqwyq7S2XSfMTGOoWNLs3vO4zE,99
+telemetry_cli/recs/cli.py,sha256=flmY1LRg-JRnagMAVyRCLLuvvWmUpUtjfYGXeJQIbIo,5886
+telemetry_cli/recs/extract.py,sha256=ggGsB5c6wfHaC6sjuC0Npv1csr9dFZIMoLs1NSOnptg,13854
+telemetry_cli/tgen/__init__.py,sha256=1mvMJA14vBGpCXT07p07xuY8nQAS-ulJZCJXdyXYrJY,60
+telemetry_cli/tgen/__main__.py,sha256=os93C6HnHnoAE5JGHRQHog0Z0Ai76-LpU9O8Zu5_w-s,99
+telemetry_cli/tgen/cli.py,sha256=csAJMRESnff07BpXGnXo9PIe9zSCquovo-5cs8132CU,4198
+telemetry_cli/tgen/cmdfile.py,sha256=07iLI_Ldm9MNLerAF4mPMr-1h2cr6-SgXBcu3314vMY,1725
+telemetry_cli/tgen/convert.py,sha256=x_BhnLNZLih1PX5QxKPWht1wDiLhmkEtQZdF5vV-mCE,9479
+telemetry_cli/tgen/runtime.py,sha256=Q0bHzqDeTP7-IypT85AOimvPnDW7WvWJs78QWZwxk94,13959
+telemetry_cli/tgen/examples/arb_data.tgen,sha256=ZV_EHPJWEzzwd5U6l4_3JZxtZvedBy8XyY4x2_hAjJ0,554
+telemetry_cli/tgen/examples/calsweep.tgen,sha256=zG29oFJ3ieTT-h4yi1HA4uMAElhpmi6b8P8JWtnYGuU,955
+telemetry_cli/tgen/examples/cond_fill.tgen,sha256=ddShQz4dn40xwfpCra6h3iag6aBmrJAOakN7N2tqjAw,487
+telemetry_cli/tgen/examples/counter.tgen,sha256=5LoP-S2hbGUfNdcoHsktCSTZNiro8vvT8QTGIp1LnoI,262
+telemetry_cli/tgen/examples/null_data.tgen,sha256=GKomAS3eyyBf_AXm5wezKdV-98QN-1k80lpFL4fWIhk,319
+telemetry_cli/tgen/examples/random_size.tgen,sha256=9t_6ir51jVbjKM8TR6cw6qWUWyyY6gQhEKicnM1ENUs,655
+telemetry_cli/tgen/examples/subcom.tgen,sha256=Hw3OACp9ueA4hsQimYT4R3w6U8DvAhd3zMlq0O_YvYM,436
+telemetry_cli/tgen/examples/valueV_value.tgen,sha256=ZnFGtF-trqeEHowmTghYW8JNR0SXMnOovXVXyL-Vdcg,674
+telemetry_cli-1.0.0.dist-info/METADATA,sha256=PT8DdJr04W51n4jQErEuBh51tclxgjr53AnuEfc-pas,4640
+telemetry_cli-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+telemetry_cli-1.0.0.dist-info/entry_points.txt,sha256=sOtbf_d1OIyGvm9DPBSUddoTjWZmMXePZNl69TzqZKA,158
+telemetry_cli-1.0.0.dist-info/licenses/LICENSE,sha256=PiTqw42Wp1U8DisYmUyCMgJny4s3Hd-0_hMWUciTX-k,1075
+telemetry_cli-1.0.0.dist-info/RECORD,,

telemetry_cli-1.0.0.dist-info/WHEEL

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

telemetry_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pick = telemetry_cli.pick.cli:main
+recl = telemetry_cli.recl.cli:main
+recs = telemetry_cli.recs.cli:main
+tgen = telemetry_cli.tgen.cli:main

telemetry_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2000-2026 David A. Imel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.