jtoken 0.1.0__py3-none-any.whl

jtoken/__init__.py

@@ -0,0 +1,28 @@
+"""jtoken — Compress JSON for LLM prompts with ~30% fewer tokens."""
+
+from ._codec import decode, encode
+from .exceptions import JPackDecodeError, JPackEncodeError, JPackError
+from .tokens import TokenCountError, TokenSavings, count_tokens, token_savings
+
+__version__ = "0.1.0"
+__author__ = "Hermann Samimi"
+
+# json-style aliases
+dumps = encode
+loads = decode
+
+__all__ = [
+    "encode",
+    "decode",
+    "dumps",
+    "loads",
+    "count_tokens",
+    "token_savings",
+    "TokenSavings",
+    "JPackError",
+    "JPackEncodeError",
+    "JPackDecodeError",
+    "TokenCountError",
+    "__version__",
+    "__author__",
+]

jtoken/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

jtoken/_codec.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .exceptions import JPackDecodeError, JPackEncodeError
+
+_SEP = ": "
+_NULLS_KEY = "nulls"
+_TRUES_KEY = "trues"
+_FALSES_KEY = "falses"
+_RESERVED = {_NULLS_KEY, _TRUES_KEY, _FALSES_KEY}
+
+
+def encode(data: dict[str, Any]) -> str:
+    """Compress a JSON-like dict into jtoken format.
+
+    Strips JSON syntax and collapses all null, true, and false fields each into
+    a single summary line. Nested dicts are flattened with dot notation.
+    The result is lossless: decode(encode(data)) == data.
+    """
+    if not isinstance(data, dict):
+        raise JPackEncodeError(f"Expected dict, got {type(data).__name__}")
+
+    flat = _flatten(data)
+
+    null_keys: list[str] = []
+    true_keys: list[str] = []
+    false_keys: list[str] = []
+    lines: list[str] = []
+
+    for k, v in flat.items():
+        if v is None:
+            null_keys.append(k)
+        elif v is True:
+            true_keys.append(k)
+        elif v is False:
+            false_keys.append(k)
+        elif isinstance(v, (int, float)):
+            lines.append(f"{k}{_SEP}{v}")
+        elif isinstance(v, str):
+            val = f'"{v}"' if _is_ambiguous(v) else v
+            lines.append(f"{k}{_SEP}{val}")
+        else:
+            raise JPackEncodeError(
+                f"Unsupported value type for key {k!r}: {type(v).__name__}. "
+                "Supported types: str, int, float, bool, None."
+            )
+
+    if true_keys:
+        lines.append(f"{_TRUES_KEY}{_SEP}{','.join(true_keys)}")
+    if false_keys:
+        lines.append(f"{_FALSES_KEY}{_SEP}{','.join(false_keys)}")
+    if null_keys:
+        lines.append(f"{_NULLS_KEY}{_SEP}{','.join(null_keys)}")
+
+    return "\n".join(lines)
+
+
+def decode(text: str) -> dict[str, Any]:
+    """Reconstruct a dict from a jtoken-compressed string."""
+    if not isinstance(text, str):
+        raise JPackDecodeError(f"Expected str, got {type(text).__name__}")
+
+    flat: dict[str, Any] = {}
+
+    for lineno, line in enumerate(text.strip().splitlines(), 1):
+        if not line.strip():
+            continue
+        if _SEP not in line:
+            raise JPackDecodeError(
+                f"Invalid format on line {lineno}: missing {_SEP!r} separator"
+            )
+
+        key, _, value = line.partition(_SEP)
+
+        if key == _NULLS_KEY:
+            for k in value.split(","):
+                flat[k.strip()] = None
+        elif key == _TRUES_KEY:
+            for k in value.split(","):
+                flat[k.strip()] = True
+        elif key == _FALSES_KEY:
+            for k in value.split(","):
+                flat[k.strip()] = False
+        elif _is_quoted(value):
+            flat[key] = value[1:-1]
+        elif value.lower() == "true":
+            flat[key] = True   # backward-compat with inline key: true
+        elif value.lower() == "false":
+            flat[key] = False  # backward-compat with inline key: false
+        else:
+            try:
+                flat[key] = int(value)
+            except ValueError:
+                try:
+                    flat[key] = float(value)
+                except ValueError:
+                    flat[key] = value
+
+    return _unflatten(flat)
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _flatten(data: dict[str, Any], prefix: str = "") -> dict[str, Any]:
+    """Recursively flatten a nested dict using dot-notation keys."""
+    result: dict[str, Any] = {}
+    for k, v in data.items():
+        k_str = str(k)
+        if "." in k_str:
+            raise JPackEncodeError(
+                f"Key {k_str!r} contains '.' which is reserved for nested paths"
+            )
+        if _SEP in k_str:
+            raise JPackEncodeError(f"Key cannot contain {_SEP!r}: {k_str!r}")
+        if not prefix and k_str in _RESERVED:
+            raise JPackEncodeError(f"Key '{k_str}' is reserved")
+        key = f"{prefix}.{k_str}" if prefix else k_str
+        if isinstance(v, dict):
+            result.update(_flatten(v, key))
+        else:
+            result[key] = v
+    return result
+
+
+def _unflatten(flat: dict[str, Any]) -> dict[str, Any]:
+    """Reconstruct a nested dict from dot-notation keys."""
+    result: dict[str, Any] = {}
+    for dotted_key, value in flat.items():
+        parts = dotted_key.split(".")
+        d = result
+        for part in parts[:-1]:
+            if part not in d or not isinstance(d[part], dict):
+                d[part] = {}
+            d = d[part]
+        d[parts[-1]] = value
+    return result
+
+
+def _is_ambiguous(v: str) -> bool:
+    """True if this string would be mistyped as a number or bool on decode."""
+    if not v:
+        return True
+    if v.lower() in ("true", "false"):
+        return True
+    try:
+        int(v)
+        return True
+    except ValueError:
+        pass
+    try:
+        float(v)
+        return True
+    except ValueError:
+        pass
+    return False
+
+
+def _is_quoted(v: str) -> bool:
+    return len(v) >= 2 and v[0] == '"' and v[-1] == '"'

jtoken/cli.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any
+
+from . import decode, encode, count_tokens, token_savings
+from .exceptions import JPackDecodeError, JPackEncodeError, JPackError
+from .tokens import TokenCountError
+
+
+def _read_input(path: str | None) -> str:
+    if path:
+        with open(path, encoding="utf-8") as handle:
+            return handle.read()
+    return sys.stdin.read()
+
+
+def _load_json_object(text: str) -> dict[str, Any]:
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"Invalid JSON input: {exc}") from exc
+    if not isinstance(data, dict):
+        raise SystemExit("JSON input must be an object")
+    return data
+
+
+def _load_json_or_jtoken(text: str) -> dict[str, Any] | str:
+    stripped = text.strip()
+    if not stripped:
+        raise SystemExit("Input is empty")
+    if stripped[0] in "{[":
+        return _load_json_object(text)
+    return stripped
+
+
+def _handle_errors(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (JPackError, TokenCountError) as exc:
+            print(exc, file=sys.stderr)
+            raise SystemExit(1) from exc
+
+    return wrapper
+
+
+@_handle_errors
+def _cmd_encode(args: argparse.Namespace) -> None:
+    data = _load_json_object(_read_input(args.file))
+    sys.stdout.write(encode(data))
+
+
+@_handle_errors
+def _cmd_decode(args: argparse.Namespace) -> None:
+    text = _read_input(args.file)
+    data = decode(text)
+    json.dump(data, sys.stdout, indent=2, sort_keys=True)
+    sys.stdout.write("\n")
+
+
+@_handle_errors
+def _cmd_stats(args: argparse.Namespace) -> None:
+    payload = _load_json_or_jtoken(_read_input(args.file))
+    stats = token_savings(payload, model=args.model, backend=args.backend)
+    print(stats)
+
+
+@_handle_errors
+def _cmd_count(args: argparse.Namespace) -> None:
+    payload = _load_json_or_jtoken(_read_input(args.file))
+    print(count_tokens(payload, model=args.model, backend=args.backend))
+
+
+def _add_token_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--model",
+        default="cl100k_base",
+        help="tiktoken model or encoding name (default: cl100k_base)",
+    )
+    parser.add_argument(
+        "--backend",
+        choices=("auto", "tiktoken", "estimate"),
+        default="auto",
+        help="token counting backend (default: auto)",
+    )
+
+
+def _add_input_file(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-f",
+        "--file",
+        help="read input from a file instead of stdin",
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="jtoken", description="jtoken CLI")
+    input_parent = argparse.ArgumentParser(add_help=False)
+    _add_input_file(input_parent)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser(
+        "encode",
+        parents=[input_parent],
+        help="encode JSON to jtoken",
+    ).set_defaults(func=_cmd_encode)
+    subparsers.add_parser(
+        "decode",
+        parents=[input_parent],
+        help="decode jtoken to JSON",
+    ).set_defaults(func=_cmd_decode)
+    stats_parser = subparsers.add_parser(
+        "stats",
+        parents=[input_parent],
+        help="compare jtoken vs JSON token usage",
+    )
+    _add_token_flags(stats_parser)
+    stats_parser.set_defaults(func=_cmd_stats)
+
+    count_parser = subparsers.add_parser(
+        "count",
+        parents=[input_parent],
+        help="count jtoken tokens",
+    )
+    _add_token_flags(count_parser)
+    count_parser.set_defaults(func=_cmd_count)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

jtoken/exceptions.py

@@ -0,0 +1,10 @@
+class JPackError(Exception):
+    """Base exception for all jtoken errors."""
+
+
+class JPackEncodeError(JPackError):
+    """Raised when encoding a dict fails."""
+
+
+class JPackDecodeError(JPackError):
+    """Raised when decoding a jtoken string fails."""

jtoken/tokens.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Union
+
+from ._codec import decode, encode
+from .exceptions import JPackError
+
+try:
+    import tiktoken as _tiktoken
+
+    _TIKTOKEN_AVAILABLE = True
+except ImportError:
+    _TIKTOKEN_AVAILABLE = False
+
+
+class TokenCountError(JPackError):
+    """Raised when token counting cannot be completed."""
+
+
+@dataclass
+class TokenSavings:
+    """Token comparison between jtoken and JSON representations."""
+
+    jtoken_tokens: int
+    json_tokens: int
+
+    @property
+    def saved(self) -> int:
+        return self.json_tokens - self.jtoken_tokens
+
+    @property
+    def percent(self) -> float:
+        if self.json_tokens == 0:
+            return 0.0
+        return self.saved / self.json_tokens * 100
+
+    def __str__(self) -> str:
+        return (
+            f"jtoken: {self.jtoken_tokens} tokens | "
+            f"json: {self.json_tokens} tokens | "
+            f"saved: {self.saved} ({self.percent:.1f}%)"
+        )
+
+
+def count_tokens(
+    data: Union[dict[str, Any], str],
+    *,
+    model: str = "cl100k_base",
+    backend: str = "auto",
+) -> int:
+    """Count the LLM tokens in jtoken-encoded data.
+
+    Args:
+        data:    A dict (auto-encoded to jtoken) or an already-encoded jtoken string.
+        model:   tiktoken encoding or model name (default: cl100k_base, used by
+                 GPT-4 and a close approximation for Claude).
+                 Accepts encoding names ("cl100k_base", "o200k_base") or
+                 OpenAI model names ("gpt-4", "gpt-4o").
+        backend: "auto"     — tiktoken if installed, otherwise estimates.
+                 "tiktoken" — tiktoken required; raises TokenCountError if absent.
+                 "estimate" — always uses the ~4 chars/token heuristic.
+
+    Returns:
+        Integer token count for the jtoken representation.
+    """
+    text = encode(data) if isinstance(data, dict) else data
+    return _count(text, model=model, backend=backend)
+
+
+def token_savings(
+    data: Union[dict[str, Any], str],
+    *,
+    model: str = "cl100k_base",
+    backend: str = "auto",
+) -> TokenSavings:
+    """Compare token usage between jtoken and JSON for the same data.
+
+    Args:
+        data:    A dict or an already-encoded jtoken string.
+        model:   tiktoken encoding or model name (see count_tokens).
+        backend: counting backend (see count_tokens).
+
+    Returns:
+        TokenSavings with jtoken_tokens, json_tokens, saved, and percent.
+
+    Example::
+
+        stats = jtoken.token_savings({"name": "Alice", "age": 30, "active": True})
+        print(stats)
+        # jtoken: 8 tokens | json: 12 tokens | saved: 4 (33.3%)
+    """
+    if isinstance(data, str):
+        source_dict = decode(data)
+        jtoken_text = data
+    else:
+        source_dict = data
+        jtoken_text = encode(data)
+
+    json_text = json.dumps(source_dict)
+
+    jtoken_n = _count(jtoken_text, model=model, backend=backend)
+    json_n = _count(json_text, model=model, backend=backend)
+
+    return TokenSavings(jtoken_tokens=jtoken_n, json_tokens=json_n)
+
+
+def _count(text: str, *, model: str, backend: str) -> int:
+    if backend == "estimate":
+        return _estimate(text)
+
+    if backend == "tiktoken" and not _TIKTOKEN_AVAILABLE:
+        raise TokenCountError(
+            "tiktoken is not installed. Run: pip install jtoken[tiktoken]"
+        )
+
+    if _TIKTOKEN_AVAILABLE and backend in ("auto", "tiktoken"):
+        try:
+            enc = _tiktoken.encoding_for_model(model)
+        except KeyError:
+            try:
+                enc = _tiktoken.get_encoding(model)
+            except Exception as exc:
+                if backend == "tiktoken":
+                    raise TokenCountError(
+                        f"Unknown tiktoken model/encoding: {model!r}"
+                    ) from exc
+                return _estimate(text)
+        return len(enc.encode(text))
+
+    return _estimate(text)
+
+
+def _estimate(text: str) -> int:
+    """~4 characters per token heuristic."""
+    return max(1, (len(text) + 3) // 4) if text else 0

jtoken-0.1.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: jtoken
+Version: 0.1.0
+Summary: A lightweight, human-readable key-value serialization format
+Project-URL: Homepage, https://github.com/hermannsamimi/jtoken
+Project-URL: Repository, https://github.com/hermannsamimi/jtoken
+Project-URL: Issues, https://github.com/hermannsamimi/jtoken/issues
+Author-email: Hermann Samimi <hermannsamimi@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: encoding,format,key-value,llm,serialization,text,tokens
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: tiktoken>=0.5; extra == 'dev'
+Provides-Extra: tiktoken
+Requires-Dist: tiktoken>=0.5; extra == 'tiktoken'
+Description-Content-Type: text/markdown
+
+# jtoken
+
+Compress JSON for LLM prompts — same data, fewer tokens.
+
+## What it does
+
+jtoken strips the syntactic noise from JSON (`"`, `{}`, `,`) and collapses all
+`null`, `true`, and `false` fields each into a single summary line. Nested dicts
+are flattened with dot notation so the same collapse applies at every level.
+The result is a compact format an LLM reads just as well as JSON.
+
+**JSON (30 tokens):**
+```json
+{"name": "Alice", "age": 30, "active": true, "verified": false, "ref": null}
+```
+
+**jtoken (21 tokens):**
+```
+name: Alice
+age: 30
+trues: active
+falses: verified
+nulls: ref
+```
+
+The round-trip is lossless: `decode(encode(data)) == data` for all supported types.
+
+## Installation
+
+```bash
+# Core — no external dependencies
+pip install jtoken
+
+# With accurate LLM token counting
+pip install jtoken[tiktoken]
+```
+
+## Quick start
+
+```python
+import jtoken
+
+data = {
+    "user": "alice",
+    "age": 30,
+    "premium": True,
+    "verified": True,
+    "is_remote": False,
+    "trial": False,
+    "score": 9.5,
+    "referral": None,
+    "last_login": None,
+}
+
+text = jtoken.encode(data)
+# user: alice
+# age: 30
+# score: 9.5
+# trues: premium,verified
+# falses: is_remote,trial
+# nulls: referral,last_login
+
+original = jtoken.decode(text)
+assert original == data
+```
+
+`dumps` / `loads` are available as `json`-style aliases.
+
+## CLI
+
+```bash
+echo '{"name": "Alice", "active": true}' | jtoken encode
+echo 'name: Alice\ntrues: active' | jtoken decode
+echo '{"name": "Alice", "active": true}' | jtoken stats
+echo '{"name": "Alice", "active": true}' | jtoken count
+```
+
+Use `-f/--file` to read from a file instead of stdin. `stats` and `count` accept
+`--model` and `--backend` (`auto`, `tiktoken`, `estimate`).
+
+## Nested documents
+
+Nested dicts are flattened with dot notation. Booleans and nulls at any depth
+are collapsed into the same summary lines.
+
+```python
+data = {
+    "title": "Engineer",
+    "metadata": {
+        "verified": True,
+        "sponsored": False,
+        "score": None,
+        "source": {
+            "crawled": True,
+            "enriched": None,
+        },
+    },
+}
+
+print(jtoken.encode(data))
+# title: Engineer
+# trues: metadata.verified,metadata.source.crawled
+# falses: metadata.sponsored
+# nulls: metadata.score,metadata.source.enriched
+```
+
+Decode reconstructs the full nested structure:
+
+```python
+assert jtoken.decode(jtoken.encode(data)) == data  # ✓
+```
+
+**Limitation:** keys cannot contain `.` (reserved for nesting) or `": "`.
+Arrays are not supported.
+
+## Token savings
+
+```python
+import jtoken
+
+stats = jtoken.token_savings(data)
+print(stats)
+# jtoken: 22 tokens | json: 36 tokens | saved: 14 (38.9%)
+
+n = jtoken.count_tokens(data)  # count jtoken tokens only
+```
+
+Savings are compared against `json.dumps(data)` — the standard representation
+you'd paste into a prompt. Savings are highest when a document has many `null`
+or boolean fields.
+
+```python
+# Specify model or encoding
+stats = jtoken.token_savings(data, model="gpt-4o")
+stats = jtoken.token_savings(data, model="o200k_base")
+
+# No tiktoken dependency
+stats = jtoken.token_savings(data, backend="estimate")
+```
+
+## API
+
+### `encode(data: dict) -> str`
+
+Compresses a dict into jtoken. Supported value types: `str`, `int`, `float`,
+`bool`, `None`, nested `dict`.
+
+**Summary lines (always at the end):**
+
+| line | contains |
+|---|---|
+| `trues: k1,k2,...` | all keys whose value is `True` |
+| `falses: k1,k2,...` | all keys whose value is `False` |
+| `nulls: k1,k2,...` | all keys whose value is `None` |
+
+String values that would decode ambiguously (look like a number or boolean)
+keep their quotes:
+
+```python
+jtoken.encode({"zip": "90210"})  # → 'zip: "90210"'   (string, quotes kept)
+jtoken.encode({"zip":  90210})   # → 'zip: 90210'      (int, no quotes)
+jtoken.encode({"ok": "true"})    # → 'ok: "true"'      (string, quotes kept)
+jtoken.encode({"ok": True})      # → 'trues: ok'       (bool, collapsed)
+```
+
+Raises `JPackEncodeError` for unsupported types, dots or `": "` in keys, or
+reserved key names (`nulls`, `trues`, `falses`).
+
+### `decode(text: str) -> dict`
+
+Reconstructs the original dict, including nested structure from dot-notation
+keys. Type inference for scalar values:
+
+| value | decoded as |
+|---|---|
+| `"quoted"` | `str` (always) |
+| key in `trues:` line | `True` |
+| key in `falses:` line | `False` |
+| key in `nulls:` line | `None` |
+| integer literal, e.g. `42` | `int` |
+| float literal, e.g. `3.14` | `float` |
+| anything else | `str` |
+
+Raises `JPackDecodeError` for invalid input.
+
+### `token_savings(data, *, model, backend) -> TokenSavings`
+
+Compares jtoken vs `json.dumps` token usage.
+
+```python
+stats.jtoken_tokens   # int
+stats.json_tokens    # int
+stats.saved          # int
+stats.percent        # float
+str(stats)           # "jtoken: 22 tokens | json: 36 tokens | saved: 14 (38.9%)"
+```
+
+### `count_tokens(data, *, model, backend) -> int`
+
+Counts LLM tokens in the jtoken representation. Accepts a dict or an
+already-encoded jtoken string.
+
+**`backend` options:**
+
+| value | behaviour |
+|---|---|
+| `"auto"` (default) | tiktoken if installed, otherwise estimates |
+| `"tiktoken"` | requires tiktoken; raises `TokenCountError` if absent |
+| `"estimate"` | ~4 chars/token heuristic, no extra dependency |
+
+## Exceptions
+
+```
+JPackError
+├── JPackEncodeError
+├── JPackDecodeError
+└── TokenCountError
+```
+
+## Development
+
+```bash
+git clone https://github.com/hermannsamimi/jtoken
+cd jtoken
+pip install -e ".[dev]"
+pytest
+pytest --cov=jtoken --cov-report=term-missing
+```
+
+## License
+
+MIT — © 2026 Hermann Samimi

jtoken-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+jtoken/__init__.py,sha256=KeGDSIUyUn51_cjdOLyQmpy1o4RiQswrYE1-L-WaZUA,618
+jtoken/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+jtoken/_codec.py,sha256=2j9i-pjjEUgEdu_VkddUMZBX_0mnrizhJJU5bzjo09w,5107
+jtoken/cli.py,sha256=1fMEvO_a5iM-Fp9IxF8PHhHAKj_95zM_f1UfPVMcIDI,3859
+jtoken/exceptions.py,sha256=-B11CECC_BEHVMm39Ub4CPBfF_usR-Bs4EDq9w6MHWw,252
+jtoken/tokens.py,sha256=HGr4R1jeGSm9D_3UFjRys_EE1axwCbHKlEkwHOcRERE,4077
+jtoken-0.1.0.dist-info/METADATA,sha256=hHxFwTqdLEl6EtYrnkrwMmU_FNn2Oj6rqY2-5qouQZ4,6965
+jtoken-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+jtoken-0.1.0.dist-info/entry_points.txt,sha256=hUIc42NM-4aqDuGlYffU3cmJaqs7GG_UzggmTneDwfY,43
+jtoken-0.1.0.dist-info/licenses/LICENSE,sha256=06gleizuefVN7pyIwD4F1-bHnBkKPkQTuYABA6fHWH4,1071
+jtoken-0.1.0.dist-info/RECORD,,

jtoken-0.1.0.dist-info/WHEEL

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

jtoken-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jtoken = jtoken.cli:main

jtoken-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hermann Samimi
+
+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.