| """Command-line tool for CBOR diagnostics and testing""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import decimal |
| import fractions |
| import io |
| import ipaddress |
| import json |
| import re |
| import sys |
| import uuid |
| from collections.abc import Callable, Collection, Iterable, Iterator |
| from contextlib import ExitStack |
| from datetime import datetime |
| from functools import partial |
| from typing import TYPE_CHECKING, Any, BinaryIO, TypeVar |
|
|
| from . import CBORDecoder, CBORSimpleValue, CBORTag, FrozenDict, load, undefined |
|
|
| if TYPE_CHECKING: |
| from typing import Literal, TypeAlias |
|
|
| T = TypeVar("T") |
| JSONValue: TypeAlias = "str | float | bool | None | list[JSONValue] | dict[str, JSONValue]" |
|
|
| default_encoders: dict[type, Callable[[Any], Any]] = { |
| bytes: lambda x: x.decode(encoding="utf-8", errors="backslashreplace"), |
| decimal.Decimal: str, |
| FrozenDict: lambda x: str(dict(x)), |
| CBORSimpleValue: lambda x: f"cbor_simple:{x.value:d}", |
| type(undefined): lambda x: "cbor:undef", |
| datetime: lambda x: x.isoformat(), |
| fractions.Fraction: str, |
| uuid.UUID: lambda x: x.urn, |
| CBORTag: lambda x: {f"CBORTag:{x.tag:d}": x.value}, |
| set: list, |
| re.compile("").__class__: lambda x: x.pattern, |
| ipaddress.IPv4Address: str, |
| ipaddress.IPv6Address: str, |
| ipaddress.IPv4Network: str, |
| ipaddress.IPv6Network: str, |
| } |
|
|
|
|
| def tag_hook(decoder: CBORDecoder, tag: CBORTag, ignore_tags: Collection[int] = ()) -> object: |
| if tag.tag in ignore_tags: |
| return tag.value |
|
|
| if tag.tag == 24: |
| return decoder.decode_from_bytes(tag.value) |
| elif decoder.immutable: |
| return f"CBORtag:{tag.tag}:{tag.value}" |
|
|
| return tag |
|
|
|
|
| class DefaultEncoder(json.JSONEncoder): |
| def default(self, v: Any) -> Any: |
| obj_type = v.__class__ |
| encoder = default_encoders.get(obj_type) |
| if encoder: |
| return encoder(v) |
|
|
| return json.JSONEncoder.default(self, v) |
|
|
|
|
| def iterdecode( |
| f: BinaryIO, |
| tag_hook: Callable[[CBORDecoder, CBORTag], Any] | None = None, |
| object_hook: Callable[[CBORDecoder, dict[Any, Any]], Any] | None = None, |
| str_errors: Literal["strict", "error", "replace"] = "strict", |
| ) -> Iterator[Any]: |
| decoder = CBORDecoder(f, tag_hook=tag_hook, object_hook=object_hook, str_errors=str_errors) |
| while True: |
| try: |
| yield decoder.decode() |
| except EOFError: |
| return |
|
|
|
|
| def key_to_str(d: T, dict_ids: set[int] | None = None) -> str | list[Any] | dict[str, Any] | T: |
| dict_ids = set(dict_ids or []) |
| rval: dict[str, Any] = {} |
| if not isinstance(d, dict): |
| if isinstance(d, CBORSimpleValue): |
| return f"cbor_simple:{d.value:d}" |
|
|
| if isinstance(d, (tuple, list, set)): |
| if id(d) in dict_ids: |
| raise ValueError("Cannot convert self-referential data to JSON") |
| else: |
| dict_ids.add(id(d)) |
|
|
| v = [key_to_str(x, dict_ids) for x in d] |
| dict_ids.remove(id(d)) |
| return v |
| else: |
| return d |
|
|
| if id(d) in dict_ids: |
| raise ValueError("Cannot convert self-referential data to JSON") |
| else: |
| dict_ids.add(id(d)) |
|
|
| for k, v in d.items(): |
| if isinstance(k, bytes): |
| k = k.decode(encoding="utf-8", errors="backslashreplace") |
| elif isinstance(k, CBORSimpleValue): |
| k = f"cbor_simple:{k.value:d}" |
| elif isinstance(k, (FrozenDict, frozenset, tuple)): |
| k = str(k) |
|
|
| if isinstance(v, dict): |
| v = key_to_str(v, dict_ids) |
| elif isinstance(v, (tuple, list, set)): |
| v = [key_to_str(x, dict_ids) for x in v] |
|
|
| rval[k] = v |
|
|
| return rval |
|
|
|
|
| def main() -> None: |
| prog = "python -m cbor2.tool" |
| description = ( |
| "A simple command line interface for cbor2 module " |
| "to validate and pretty-print CBOR objects." |
| ) |
| parser = argparse.ArgumentParser(prog=prog, description=description) |
| parser.add_argument("-o", "--outfile", type=str, help="output file", default="-") |
| parser.add_argument( |
| "infiles", |
| nargs="*", |
| default=["-"], |
| help="Collection of CBOR files to process or - for stdin", |
| ) |
| parser.add_argument( |
| "-k", |
| "--sort-keys", |
| action="store_true", |
| default=False, |
| help="sort the output of dictionaries alphabetically by key", |
| ) |
| parser.add_argument( |
| "-p", |
| "--pretty", |
| action="store_true", |
| default=False, |
| help="indent the output to look good", |
| ) |
| parser.add_argument( |
| "-s", |
| "--sequence", |
| action="store_true", |
| default=False, |
| help="Parse a sequence of concatenated CBOR items", |
| ) |
| parser.add_argument( |
| "-d", |
| "--decode", |
| action="store_true", |
| default=False, |
| help="CBOR data is base64 encoded (handy for stdin)", |
| ) |
| parser.add_argument( |
| "-i", |
| "--tag-ignore", |
| type=str, |
| default="", |
| help="Comma separated list of tags to ignore and only return the value", |
| ) |
| options = parser.parse_args() |
|
|
| if options.outfile == "-": |
| outfile = 1 |
| closefd = False |
| else: |
| outfile = options.outfile |
| closefd = True |
|
|
| ignore_s = options.tag_ignore.split(",") |
| droptags = {int(n) for n in ignore_s if (len(n) and n[0].isdigit())} |
| my_hook = partial(tag_hook, ignore_tags=droptags) |
|
|
| with open( |
| outfile, mode="w", encoding="utf-8", errors="backslashreplace", closefd=closefd |
| ) as outfp: |
| for path in options.infiles: |
| with ExitStack() as stack: |
| if path == "-": |
| infile: BinaryIO = sys.stdin.buffer |
| else: |
| infile = stack.enter_context(open(path, mode="rb")) |
|
|
| if options.decode: |
| infile = io.BytesIO(base64.b64decode(infile.read())) |
|
|
| try: |
| if options.sequence: |
| objs: Iterable[Any] = iterdecode(infile, tag_hook=my_hook) |
| else: |
| objs = (load(infile, tag_hook=my_hook),) |
|
|
| for obj in objs: |
| json.dump( |
| key_to_str(obj), |
| outfp, |
| sort_keys=options.sort_keys, |
| indent=(None, 4)[options.pretty], |
| cls=DefaultEncoder, |
| ensure_ascii=False, |
| ) |
| outfp.write("\n") |
| except (ValueError, EOFError) as e: |
| raise SystemExit(e) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
