tallipoika 2024.1.3__tar.gz

tallipoika-2024.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stefan Hagen
+
+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.

tallipoika-2024.1.3/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

tallipoika-2024.1.3/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: tallipoika
+Version: 2024.1.3
+Summary: Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation.
+Author-email: Stefan Hagen <stefan@hagen.link>
+Maintainer-email: Stefan Hagen <stefan@hagen.link>
+Project-URL: Homepage, https://git.sr.ht/~sthagen/tallipoika
+Project-URL: Bug-Tracker, https://todo.sr.ht/~sthagen/tallipoika
+Project-URL: Documentation, https://codes.dilettant.life/docs/tallipoika
+Project-URL: Source-Code, https://git.sr.ht/~sthagen/tallipoika
+Project-URL: Test-Coverage, https://codes.dilettant.life/coverage/tallipoika
+Keywords: developer-tools,devops
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-flake8; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Tallipoika
+
+Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation.
+
+[![License](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/license-spdx-mit.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/LICENSE)
+[![Country of Origin](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/country-of-origin-name-switzerland-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/COUNTRY-OF-ORIGIN)
+[![Export Classification Control Number (ECCN)](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/export-control-classification-number_eccn-ear99-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/EXPORT-CONTROL-CLASSIFICATION-NUMBER)
+[![Configuration](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/configuration-sbom.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/docs/third-party/README.md)
+
+[![Version](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/latest-release.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Downloads](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/downloads-per-month.svg)](https://pepy.tech/project/tallipoika)
+[![Python](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/python-versions.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Maintenance Status](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/commits-per-year.svg)](https://git.sr.ht/~sthagen/tallipoika/log)
+
+## Documentation
+
+User and developer [documentation of tallipoika](https://codes.dilettant.life/docs/tallipoika).
+
+## Bug Tracker
+
+Any feature requests or bug reports shall go to the [todos of tallipoika](https://todo.sr.ht/~sthagen/tallipoika).
+
+## Primary Source repository
+
+The main source of `tallipoika` is on a mountain in central Switzerland.
+We use distributed version control (git).
+There is no central hub.
+Every clone can become a new source for the benefit of all.
+The preferred public clone of `tallipoika` is:
+
+* [at sourcehut](https://git.sr.ht/~sthagen/tallipoika) - a collection of tools useful for software development.
+
+## Contributions
+
+Please do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
+If you like to share small changes under the repositories license please kindly do so by sending a patchset.
+You can either send such a patchset per email using [git send-email](https://git-send-email.io) or
+if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork at [sourcehut](https://git.sr.ht/).
+
+## Support
+
+Please kindly submit issues at https://todo.sr.ht/~sthagen/tallipoika or write plain text email to ~sthagen/tallipoika@lists.sr.ht to submit patches and request support. Thanks.
+
+## Thanks also to
+
+This implementation is based on the [original implementation of the JSON Canonicalization Scheme (JCS)](https://github.com/cyberphone/json-canonicalization) gently provided under the APACHE-2.0 license by Anders Rundgren.
+The initial implementation of `tallipoika` is kept similar to show the identical functioning of both implementation.
+Also, the input and output JSON tests are provided within this repository as a service for validators.
+
+# Status
+
+Experimental.
+
+**Note**: The default branch is `default`.

tallipoika-2024.1.3/README.md

@@ -0,0 +1,54 @@
+# Tallipoika
+
+Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation.
+
+[![License](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/license-spdx-mit.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/LICENSE)
+[![Country of Origin](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/country-of-origin-name-switzerland-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/COUNTRY-OF-ORIGIN)
+[![Export Classification Control Number (ECCN)](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/export-control-classification-number_eccn-ear99-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/EXPORT-CONTROL-CLASSIFICATION-NUMBER)
+[![Configuration](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/configuration-sbom.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/docs/third-party/README.md)
+
+[![Version](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/latest-release.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Downloads](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/downloads-per-month.svg)](https://pepy.tech/project/tallipoika)
+[![Python](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/python-versions.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Maintenance Status](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/commits-per-year.svg)](https://git.sr.ht/~sthagen/tallipoika/log)
+
+## Documentation
+
+User and developer [documentation of tallipoika](https://codes.dilettant.life/docs/tallipoika).
+
+## Bug Tracker
+
+Any feature requests or bug reports shall go to the [todos of tallipoika](https://todo.sr.ht/~sthagen/tallipoika).
+
+## Primary Source repository
+
+The main source of `tallipoika` is on a mountain in central Switzerland.
+We use distributed version control (git).
+There is no central hub.
+Every clone can become a new source for the benefit of all.
+The preferred public clone of `tallipoika` is:
+
+* [at sourcehut](https://git.sr.ht/~sthagen/tallipoika) - a collection of tools useful for software development.
+
+## Contributions
+
+Please do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
+If you like to share small changes under the repositories license please kindly do so by sending a patchset.
+You can either send such a patchset per email using [git send-email](https://git-send-email.io) or
+if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork at [sourcehut](https://git.sr.ht/).
+
+## Support
+
+Please kindly submit issues at https://todo.sr.ht/~sthagen/tallipoika or write plain text email to ~sthagen/tallipoika@lists.sr.ht to submit patches and request support. Thanks.
+
+## Thanks also to
+
+This implementation is based on the [original implementation of the JSON Canonicalization Scheme (JCS)](https://github.com/cyberphone/json-canonicalization) gently provided under the APACHE-2.0 license by Anders Rundgren.
+The initial implementation of `tallipoika` is kept similar to show the identical functioning of both implementation.
+Also, the input and output JSON tests are provided within this repository as a service for validators.
+
+# Status
+
+Experimental.
+
+**Note**: The default branch is `default`.

tallipoika-2024.1.3/pyproject.toml

@@ -0,0 +1,116 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tallipoika"
+version = "2024.1.3"
+description = "Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation."
+readme = "README.md"
+authors = [{ name = "Stefan Hagen", email = "stefan@hagen.link" }]
+maintainers = [{ name = "Stefan Hagen", email = "stefan@hagen.link" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.9",
+]
+keywords = ["developer-tools", "devops"]
+dependencies = [
+  "typer",
+]
+requires-python = ">=3.9"
+
+[project.optional-dependencies]
+dev = ["black", "coverage", "hypothesis", "mypy", "pytest", "pytest-cov", "pytest-flake8", "ruff"]
+
+[project.urls]
+Homepage = "https://git.sr.ht/~sthagen/tallipoika"
+Bug-Tracker = "https://todo.sr.ht/~sthagen/tallipoika"
+Documentation = "https://codes.dilettant.life/docs/tallipoika"
+Source-Code = "https://git.sr.ht/~sthagen/tallipoika"
+Test-Coverage = "https://codes.dilettant.life/coverage/tallipoika"
+
+[project.scripts]
+tallipoika = "tallipoika.cli:app"
+
+[tool.setuptools.packages.find]
+include = ["tallipoika"]
+exclude = ["test*"]
+
+[tool.black]
+line-length = 120
+skip-string-normalization = true
+target-version = ["py39", "py310", "py311", "py312"]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+precision = 2
+exclude_lines = [
+    "pragma: no cover",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+    "@overload",
+]
+omit = [
+    "*/__main__.py",
+]
+
+[tool.ruff]
+line-length = 120
+select = ["E", "F", "Q"]
+ignore = []
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+target-version = "py310"
+unfixable = ["F401"]
+
+[tool.ruff.flake8-quotes]
+docstring-quotes = "double"
+inline-quotes = "single"
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["E402"]
+
+[tool.ruff.flake8-import-conventions.aliases]
+altair = "alt"
+"matplotlib.pyplot" = "plt"
+numpy = "np"
+pandas = "pd"
+seaborn = "sns"
+
+[tool.ruff.mccabe]
+max-complexity = 42  # default is 10
+
+[tool.mypy]
+strict = true
+implicit_reexport = true
+
+[tool.pytest]
+testpaths = "test"
+filterwarnings = "error"

tallipoika-2024.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tallipoika-2024.1.3/tallipoika/__init__.py

@@ -0,0 +1,78 @@
+"""Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation."""
+import datetime as dti
+import logging
+import os
+import pathlib
+from typing import List, no_type_check
+
+# [[[fill git_describe()]]]
+__version__ = '2024.1.3+parent.2e105da5'
+# [[[end]]] (checksum: 74ad8c59fd85ec37e5170a11f7e6a7a4)
+__version_info__ = tuple(
+    e if '-' not in e else e.split('-')[0] for part in __version__.split('+') for e in part.split('.') if e != 'parent'
+)
+
+APP_ALIAS = str(pathlib.Path(__file__).parent.name)
+APP_ENV = APP_ALIAS.upper()
+APP_NAME = locals()['__doc__']
+DEBUG = bool(os.getenv(f'{APP_ENV}_DEBUG', ''))
+VERBOSE = bool(os.getenv(f'{APP_ENV}_VERBOSE', ''))
+QUIET = False
+STRICT = bool(os.getenv(f'{APP_ENV}_STRICT', ''))
+ENCODING = 'utf-8'
+ENCODING_ERRORS_POLICY = 'ignore'
+DEFAULT_CONFIG_NAME = f'.{APP_ALIAS}.json'
+DEFAULT_LF_ONLY = 'YES'
+DEFAULT_STRUCTURE_NAME = 'structure.yml'
+DEFAULT_STRUCTURES_NAME = 'structures.yml'
+log = logging.getLogger()  # Module level logger is sufficient
+LOG_FOLDER = pathlib.Path('logs')
+LOG_FILE = f'{APP_ALIAS}.log'
+LOG_PATH = pathlib.Path(LOG_FOLDER, LOG_FILE) if LOG_FOLDER.is_dir() else pathlib.Path(LOG_FILE)
+LOG_LEVEL = logging.INFO
+VERSION = __version__
+VERSION_DOTTED_TRIPLE = '.'.join(__version_info__[:3])
+TS_FORMAT_LOG = '%Y-%m-%dT%H:%M:%S'
+TS_FORMAT_PAYLOADS = '%Y-%m-%d %H:%M:%S.%f UTC'
+TS_FORMAT_GENERATOR = '%Y-%m-%d %H:%M:%S.%f +00:00'
+
+__all__: List[str] = [
+    'APP_ALIAS',
+    'APP_ENV',
+    'APP_NAME',
+    'DEBUG',
+    'DEFAULT_CONFIG_NAME',
+    'DEFAULT_STRUCTURE_NAME',
+    'DEFAULT_STRUCTURES_NAME',
+    'ENCODING',
+    'TS_FORMAT_GENERATOR',
+    'VERSION',
+    'VERSION_DOTTED_TRIPLE',
+    'log',
+]
+
+
+@no_type_check
+def formatTime_RFC3339(self, record, datefmt=None):  # noqa
+    """HACK A DID ACK we could inject .astimezone() to localize ..."""
+    return dti.datetime.fromtimestamp(record.created, dti.timezone.utc).isoformat()  # pragma: no cover
+
+
+@no_type_check
+def init_logger(name=None, level=None):
+    """Initialize module level logger"""
+    global log  # pylint: disable=global-statement
+
+    log_format = {
+        'format': '%(asctime)s %(levelname)s [%(name)s]: %(message)s',
+        'datefmt': TS_FORMAT_LOG,
+        # 'filename': LOG_PATH,
+        'level': LOG_LEVEL if level is None else level,
+    }
+    logging.Formatter.formatTime = formatTime_RFC3339
+    logging.basicConfig(**log_format)
+    log = logging.getLogger(APP_ENV if name is None else name)
+    log.propagate = True
+
+
+init_logger(name=APP_ENV, level=logging.DEBUG if DEBUG else None)

tallipoika-2024.1.3/tallipoika/api.py

@@ -0,0 +1,473 @@
+"""JSON Canonicalization Scheme (JCS) serializer."""
+import re
+from typing import no_type_check
+
+import tallipoika.py2es6 as py2es6
+
+try:
+    from _json import encode_basestring_ascii as c_encode_basestring_ascii
+except ImportError:
+    c_encode_basestring_ascii = None  # type: ignore
+try:
+    from _json import encode_basestring as c_encode_basestring  # type: ignore
+except ImportError:
+    c_encode_basestring = None
+try:
+    from _json import make_encoder as c_make_encoder
+except ImportError:
+    c_make_encoder = None  # type: ignore
+
+COLON = ':'
+COMMA = ','
+SPACE = ' '
+OPEN_SB = '['
+CLOSE_SB = ']'
+EMPTY_ARRAY_REP = f'{OPEN_SB}{CLOSE_SB}'
+OPEN_CB = '{'
+CLOSE_CB = '}'
+EMPTY_OBJECT_REP = f'{OPEN_CB}{CLOSE_CB}'
+NL = '\n'
+
+JSON_FALSE_REP = 'false'
+JSON_NULL_REP = 'null'
+JSON_TRUE_REP = 'true'
+
+ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+HAS_UTF8 = re.compile(b'[\x80-\xff]')
+ESCAPE_DCT = {
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+for i in range(0x20):
+    ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
+
+INFINITY = float('inf')
+
+
+@no_type_check
+def py_encode_basestring(s):
+    """Return a JSON representation of a Python string."""
+
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+
+    return f'"{ESCAPE.sub(replace, s)}"'
+
+
+encode_basestring = c_encode_basestring or py_encode_basestring
+
+
+@no_type_check
+def py_encode_basestring_ascii(s):
+    """Return an ASCII-only JSON representation of a Python string."""
+
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                return '\\u{0:04x}'.format(n)
+            else:
+                # surrogate pair
+                n -= 0x10000
+                s1 = 0xD800 | ((n >> 10) & 0x3FF)
+                s2 = 0xDC00 | (n & 0x3FF)
+                return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)
+
+    return f'"{ESCAPE_ASCII.sub(replace, s)}"'
+
+
+encode_basestring_ascii = c_encode_basestring_ascii or py_encode_basestring_ascii  # type: ignore
+
+
+@no_type_check
+class JSONEncoder(object):
+    """JSON encoder for typical Python data structures.
+
+    Encodes the following nine Python types as the following 7 JSON types:
+
+    - Python `dict` -> JSON object
+    - Python `list` and `tuple` -> JSON array
+    - Python `str` -> JSON string
+    - Python `float` and `int` -> JSON number
+    - Python `True` ->JSON true
+    - Python `False` -> JSON false
+    - Python `None` -> JSON null
+
+    To extend recognition to other objects, subclass and implement a `.default()` method that returns a serializable
+    object for `o` if possible, otherwise it should call the superclass implementation (to raise `TypeError`).
+    """
+
+    item_separator = f'{COMMA}{SPACE}'
+    key_separator = f'{COLON}{SPACE}'
+
+    @no_type_check
+    def __init__(
+        self,
+        *,
+        skipkeys=False,
+        ensure_ascii=False,
+        check_circular=True,
+        allow_nan=True,
+        sort_keys=True,
+        indent=None,
+        separators=(COMMA, COLON),
+        default=None,
+    ):
+        """Constructor for JSONEncoder, with sensible defaults.
+
+        If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None.
+        If skipkeys is True, such items are simply skipped.
+
+        If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters
+        escaped.  If ensure_ascii is false, the output can contain non-ASCII characters.
+
+        If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references
+        during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check
+        takes place.
+
+        If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such.  This behavior is not JSON
+        specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will
+        be a ValueError to encode such floats.
+
+        If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests
+        to ensure that JSON serializations can be compared on a day-to-day basis.
+
+        If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with
+        that indent level.  An indent level of 0 will only insert newlines. None is the most compact representation.
+
+        If specified, separators should be an (item_separator, key_separator) tuple.  The default is
+        (', ', ': ') if *indent* is ``None`` and(',', ': ') otherwise.  To get the most compact JSON representation,
+        you should specify (',', ':') to eliminate whitespace.
+
+        If specified, default is a function that gets called for objects that can't otherwise be serialized.  It should
+        return a JSON encodable version of the object or raise a ``TypeError``.
+
+        """
+
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.allow_nan = allow_nan
+        self.sort_keys = sort_keys
+        self.indent = indent
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        elif indent is not None:
+            self.item_separator = COMMA
+        if default is not None:
+            self.default = default
+
+    @no_type_check
+    def default(self, o):
+        """Implement this method in a subclass such that it returns a serializable object for o.
+
+        For example, to support arbitrary iterators, you could implement default like this::
+
+            def default(self, o):
+                try:
+                    iterable = iter(o)
+                except TypeError:
+                    pass
+                else:
+                    return list(iterable)
+                return JSONEncoder.default(self, o) # Let the base class default method raise the TypeError
+
+        """
+        raise TypeError(f"Object of type '{o.__class__.__name__}' is not JSON serializable")
+
+    @no_type_check
+    def encode(self, o):
+        """Return a JSON string representation of a Python data structure.
+
+        >>> from json.encoder import JSONEncoder
+        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+        '{"foo": ["bar", "baz"]}'
+
+        """
+        # This is for extremely simple cases and benchmarks.
+        if isinstance(o, str):
+            if self.ensure_ascii:
+                return encode_basestring_ascii(o)
+            else:
+                return encode_basestring(o)
+        # This doesn't pass the iterator directly to ''.join() because the exceptions aren't as detailed.
+        # The list call should be roughly equivalent to the PySequence_Fast that ''.join() would do.
+        chunks = self.iterencode(o, _one_shot=False)
+        if not isinstance(chunks, (list, tuple)):
+            chunks = list(chunks)
+        return ''.join(chunks)
+
+    @no_type_check
+    def iterencode(self, o, _one_shot=False):
+        """Encode the given object and yield each string representation as available.
+
+        For example::
+
+            for chunk in JSONEncoder().iterencode(bigobject):
+                mysocket.write(chunk)
+
+        """
+        if self.check_circular:
+            markers = {}
+        else:
+            markers = None
+        if self.ensure_ascii:
+            _encoder = encode_basestring_ascii
+        else:
+            _encoder = encode_basestring
+
+        def floatstr(o, allow_nan=self.allow_nan, _repr=float.__repr__, _inf=INFINITY, _neginf=-INFINITY):
+            """Check for specials.
+
+            Note that this type of test is processor and platform-specific, so tests shall not rely on the internals.
+            """
+
+            if o != o:
+                text = 'NaN'
+            elif o == _inf:
+                text = 'Infinity'
+            elif o == _neginf:
+                text = '-Infinity'
+            else:
+                return _repr(o)
+
+            if not allow_nan:
+                raise ValueError(f'out of range float value {repr(o)} is not JSON compliant')
+
+            return text
+
+        if _one_shot and c_make_encoder is not None and self.indent is None:
+            _iterencode = c_make_encoder(
+                markers,
+                self.default,
+                _encoder,
+                self.indent,
+                self.key_separator,
+                self.item_separator,
+                self.sort_keys,
+                self.skipkeys,
+                self.allow_nan,
+            )
+        else:
+            _iterencode = _make_iterencode(
+                markers,
+                self.default,
+                _encoder,
+                self.indent,
+                floatstr,
+                self.key_separator,
+                self.item_separator,
+                self.sort_keys,
+                self.skipkeys,
+                _one_shot,
+            )
+        return _iterencode(o, 0)
+
+
+@no_type_check
+def _make_iterencode(
+    markers,
+    _default,
+    _encoder,
+    _indent,
+    _floatstr,
+    _key_separator,
+    _item_separator,
+    _sort_keys,
+    _skipkeys,
+    _one_shot,
+    # HACK: hand-optimized bytecode; turn globals into locals
+    ValueError=ValueError,
+    dict=dict,
+    float=float,
+    id=id,
+    int=int,
+    isinstance=isinstance,
+    list=list,
+    str=str,
+    tuple=tuple,
+    _intstr=int.__str__,
+):
+    if _indent is not None and not isinstance(_indent, str):
+        _indent = SPACE * _indent
+
+    @no_type_check
+    def _iterencode_list(lst, _current_indent_level):
+        if not lst:
+            yield EMPTY_ARRAY_REP
+            return
+        if markers is not None:
+            markerid = id(lst)
+            if markerid in markers:
+                raise ValueError('circular reference detected for sequence')
+            markers[markerid] = lst
+        buf = OPEN_SB
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = NL + _indent * _current_indent_level
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        else:
+            newline_indent = None
+            separator = _item_separator
+        first = True
+        for value in lst:
+            if first:
+                first = False
+            else:
+                buf = separator
+            if isinstance(value, str):
+                yield buf + _encoder(value)
+            elif value is None:
+                yield buf + JSON_NULL_REP
+            elif value is True:
+                yield buf + JSON_TRUE_REP
+            elif value is False:
+                yield buf + JSON_FALSE_REP
+            elif isinstance(value, (float, int)):
+                # Subclasses of float and int may override __str__, but should still serialize as numbers in JSON.
+                # One example within the standard library is IntEnum.
+                yield buf + py2es6.serialize(value)
+            else:
+                yield buf
+                if isinstance(value, (list, tuple)):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                elif isinstance(value, dict):
+                    chunks = _iterencode_dict(value, _current_indent_level)
+                else:
+                    chunks = _iterencode(value, _current_indent_level)
+                yield from chunks
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield NL + _indent * _current_indent_level
+        yield CLOSE_SB
+        if markers is not None:
+            del markers[markerid]
+
+    @no_type_check
+    def _iterencode_dict(dct, _current_indent_level):
+        if not dct:
+            yield EMPTY_OBJECT_REP
+            return
+        if markers is not None:
+            markerid = id(dct)
+            if markerid in markers:
+                raise ValueError('circular reference detected for dict')
+            markers[markerid] = dct
+        yield OPEN_CB
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = '\n' + _indent * _current_indent_level
+            item_separator = _item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            item_separator = _item_separator
+        first = True
+        if _sort_keys:
+            items = sorted(dct.items(), key=lambda kv: kv[0].encode('utf-16_be'))
+        else:
+            items = dct.items()
+        for key, value in items:
+            if isinstance(key, str):
+                pass
+            # JavaScript is weakly typed for these, so it makes sense to
+            # also allow them.  Many encoders seem to do something like this.
+            elif isinstance(key, (float, int)):
+                # see comment for float/int in _make_iterencode
+                key = py2es6.serialize(key)
+            elif key is True:
+                key = 'true'
+            elif key is False:
+                key = 'false'
+            elif key is None:
+                key = 'null'
+            elif _skipkeys:
+                continue
+            else:
+                raise TypeError(f'key {repr(key)} is not a string')
+            if first:
+                first = False
+            else:
+                yield item_separator
+            yield _encoder(key)
+            yield _key_separator
+            if isinstance(value, str):
+                yield _encoder(value)
+            elif value is None:
+                yield JSON_NULL_REP
+            elif value is True:
+                yield JSON_TRUE_REP
+            elif value is False:
+                yield JSON_FALSE_REP
+            elif isinstance(value, (float, int)):
+                # see comment for int/float in _make_iterencode
+                yield py2es6.serialize(value)
+            else:
+                if isinstance(value, (list, tuple)):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                elif isinstance(value, dict):
+                    chunks = _iterencode_dict(value, _current_indent_level)
+                else:
+                    chunks = _iterencode(value, _current_indent_level)
+                yield from chunks
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield NL + _indent * _current_indent_level
+        yield CLOSE_CB
+        if markers is not None:
+            del markers[markerid]
+
+    @no_type_check
+    def _iterencode(o, _current_indent_level):
+        if isinstance(o, str):
+            yield _encoder(o)
+        elif o is None:
+            yield JSON_NULL_REP
+        elif o is True:
+            yield JSON_TRUE_REP
+        elif o is False:
+            yield JSON_FALSE_REP
+        elif isinstance(o, (float, int)):
+            # see comment for float/int in _make_iterencode
+            yield py2es6.serialize(o)
+        elif isinstance(o, (list, tuple)):
+            yield from _iterencode_list(o, _current_indent_level)
+        elif isinstance(o, dict):
+            yield from _iterencode_dict(o, _current_indent_level)
+        else:
+            if markers is not None:
+                markerid = id(o)
+                if markerid in markers:
+                    raise ValueError('circular reference detected')
+                markers[markerid] = o
+            o = _default(o)
+            yield from _iterencode(o, _current_indent_level)
+            if markers is not None:
+                del markers[markerid]
+
+    return _iterencode
+
+
+@no_type_check
+def ensure_encoding(text: str, utf8: bool) -> str:
+    return text.encode() if utf8 else text
+
+
+@no_type_check
+def canonicalize(obj, utf8=True):
+    return ensure_encoding(JSONEncoder(sort_keys=True).encode(obj), utf8=utf8)
+
+
+@no_type_check
+def serialize(obj, utf8=True):
+    return ensure_encoding(JSONEncoder(sort_keys=False).encode(obj), utf8=utf8)

tallipoika-2024.1.3/tallipoika/py2es6.py

@@ -0,0 +1,82 @@
+"""Serialize a Python numerical value as an ECMAScript v6 or later string."""
+import math
+from typing import Union, no_type_check
+
+DASH = '-'
+DECIMAL_POINT = '.'
+DIGIT_ZERO = '0'
+MIN_INTEGER_DIGITS = 0
+MAX_INTEGER_DIGITS = 21
+REPR_SWITCH_ABOVE = -7
+
+
+@no_type_check
+def serialize(number: Union[float, int]) -> str:
+    """Serialize a Python builtin number as an ECMAScript v6 or later string.
+
+    Implementation Note(s):
+
+    - (builtin) numbers are for now int and float but may be extended to other types
+      that can be mapped to JSON numbers
+    - separate into the components:
+      + sign
+      + integral part
+      + decimal point
+      + fractional part
+      + exponent part
+    - return the concatenation of the components (some components may be empty)
+
+    """
+    if not math.isfinite(number):
+        raise ValueError(f'invalid number ({number})')
+
+    as_float = float(number)
+
+    if as_float == 0:
+        return DIGIT_ZERO
+
+    as_text = str(as_float)
+
+    sign = DASH if as_text[0] == DASH else ''
+    magnitude = as_text[1:] if sign else as_text
+
+    mantissa = magnitude
+    exponent = ''
+    exponent_number = 0
+    if (fndx := magnitude.find('e')) > 0:
+        mantissa, exponent = magnitude[0:fndx], magnitude[fndx:]
+        if exponent[2:3] == '0':  # Suppress leading zero on exponents
+            exponent = exponent[:2] + exponent[3:]
+        exponent_number = int(exponent[1:])
+
+    integral = mantissa
+    decimal_point = ''
+    fractional = ''
+    if (fndx := mantissa.find(DECIMAL_POINT)) > 0:
+        decimal_point = DECIMAL_POINT
+        integral, fractional = mantissa[:fndx], mantissa[fndx + 1 :]
+
+    if fractional == DIGIT_ZERO:  # x.0 -> x
+        decimal_point = ''
+        fractional = ''
+
+    if MIN_INTEGER_DIGITS < exponent_number < MAX_INTEGER_DIGITS:
+        integral += fractional
+        fractional = ''
+        decimal_point = ''
+        exponent = ''
+        n = exponent_number - len(integral)
+        while n >= 0:
+            n -= 1
+            integral += DIGIT_ZERO
+    elif REPR_SWITCH_ABOVE < exponent_number < 0:
+        fractional = integral + fractional
+        integral = DIGIT_ZERO
+        decimal_point = DECIMAL_POINT
+        exponent = ''
+        n = exponent_number
+        while n < -1:
+            n += 1
+            fractional = DIGIT_ZERO + fractional
+
+    return f'{sign}{integral}{decimal_point}{fractional}{exponent}'

tallipoika-2024.1.3/tallipoika.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: tallipoika
+Version: 2024.1.3
+Summary: Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation.
+Author-email: Stefan Hagen <stefan@hagen.link>
+Maintainer-email: Stefan Hagen <stefan@hagen.link>
+Project-URL: Homepage, https://git.sr.ht/~sthagen/tallipoika
+Project-URL: Bug-Tracker, https://todo.sr.ht/~sthagen/tallipoika
+Project-URL: Documentation, https://codes.dilettant.life/docs/tallipoika
+Project-URL: Source-Code, https://git.sr.ht/~sthagen/tallipoika
+Project-URL: Test-Coverage, https://codes.dilettant.life/coverage/tallipoika
+Keywords: developer-tools,devops
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-flake8; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Tallipoika
+
+Stableson (Finnish: tallipoika) - a JSON Canonicalization Scheme (JCS) implementation.
+
+[![License](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/license-spdx-mit.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/LICENSE)
+[![Country of Origin](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/country-of-origin-name-switzerland-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/COUNTRY-OF-ORIGIN)
+[![Export Classification Control Number (ECCN)](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/export-control-classification-number_eccn-ear99-neutral.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/EXPORT-CONTROL-CLASSIFICATION-NUMBER)
+[![Configuration](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/configuration-sbom.svg)](https://git.sr.ht/~sthagen/tallipoika/tree/default/item/docs/third-party/README.md)
+
+[![Version](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/latest-release.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Downloads](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/downloads-per-month.svg)](https://pepy.tech/project/tallipoika)
+[![Python](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/python-versions.svg)](https://pypi.python.org/pypi/tallipoika/)
+[![Maintenance Status](https://git.sr.ht/~sthagen/tallipoika/blob/default/docs/badges/commits-per-year.svg)](https://git.sr.ht/~sthagen/tallipoika/log)
+
+## Documentation
+
+User and developer [documentation of tallipoika](https://codes.dilettant.life/docs/tallipoika).
+
+## Bug Tracker
+
+Any feature requests or bug reports shall go to the [todos of tallipoika](https://todo.sr.ht/~sthagen/tallipoika).
+
+## Primary Source repository
+
+The main source of `tallipoika` is on a mountain in central Switzerland.
+We use distributed version control (git).
+There is no central hub.
+Every clone can become a new source for the benefit of all.
+The preferred public clone of `tallipoika` is:
+
+* [at sourcehut](https://git.sr.ht/~sthagen/tallipoika) - a collection of tools useful for software development.
+
+## Contributions
+
+Please do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
+If you like to share small changes under the repositories license please kindly do so by sending a patchset.
+You can either send such a patchset per email using [git send-email](https://git-send-email.io) or
+if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork at [sourcehut](https://git.sr.ht/).
+
+## Support
+
+Please kindly submit issues at https://todo.sr.ht/~sthagen/tallipoika or write plain text email to ~sthagen/tallipoika@lists.sr.ht to submit patches and request support. Thanks.
+
+## Thanks also to
+
+This implementation is based on the [original implementation of the JSON Canonicalization Scheme (JCS)](https://github.com/cyberphone/json-canonicalization) gently provided under the APACHE-2.0 license by Anders Rundgren.
+The initial implementation of `tallipoika` is kept similar to show the identical functioning of both implementation.
+Also, the input and output JSON tests are provided within this repository as a service for validators.
+
+# Status
+
+Experimental.
+
+**Note**: The default branch is `default`.

tallipoika-2024.1.3/tallipoika.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+tallipoika/__init__.py
+tallipoika/api.py
+tallipoika/py2es6.py
+tallipoika.egg-info/PKG-INFO
+tallipoika.egg-info/SOURCES.txt
+tallipoika.egg-info/dependency_links.txt
+tallipoika.egg-info/entry_points.txt
+tallipoika.egg-info/requires.txt
+tallipoika.egg-info/top_level.txt
+test/test_api.py
+test/test_py2es6.py

tallipoika-2024.1.3/tallipoika.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tallipoika-2024.1.3/tallipoika.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tallipoika = tallipoika.cli:app

tallipoika-2024.1.3/tallipoika.egg-info/requires.txt

@@ -0,0 +1,11 @@
+typer
+
+[dev]
+black
+coverage
+hypothesis
+mypy
+pytest
+pytest-cov
+pytest-flake8
+ruff

tallipoika-2024.1.3/tallipoika.egg-info/top_level.txt

@@ -0,0 +1 @@
+tallipoika

tallipoika-2024.1.3/test/test_api.py

@@ -0,0 +1,26 @@
+import json
+import pathlib
+
+from tallipoika.api import canonicalize
+
+ENCODING = 'utf-8'
+NL = '\n'
+test_data_root: pathlib.Path = pathlib.Path('test') / 'fixtures'
+input_data_root: pathlib.Path = test_data_root / 'reference_upstream_input'
+output_data_root: pathlib.Path = test_data_root / 'reference_upstream_output'
+
+
+def test_upstream():
+    for case in sorted(input_data_root.glob('*.json')):
+        file_name = case.name
+        with open(output_data_root / file_name, 'r', encoding=ENCODING) as sink:
+            expected = sink.read().encode()
+
+        with open(input_data_root / file_name, 'r', encoding=ENCODING) as source:
+            loaded = source.read()
+
+        actual = canonicalize(json.loads(loaded))
+        recycled = canonicalize(json.loads(actual.decode(ENCODING, 'strict')))
+
+        assert actual == expected
+        assert actual == recycled

tallipoika-2024.1.3/test/test_py2es6.py

@@ -0,0 +1,48 @@
+import binascii
+import pathlib
+import struct
+
+import tallipoika.py2es6 as py2es6
+
+COMMA = ','
+INVALID_NUMBER = 'null'
+UPSTREAM_REF_TEST_DATA = pathlib.Path('test') / 'fixtures' / 'es6testfile100m.txt'
+
+
+def verify(ieee_hex, expected) -> None:
+    """Test program using a 100 million value file formatted as follows:
+    value in ieee hex representation (1-16 digits) + ',' + correct ES6 format + '\n'
+    """
+    while len(ieee_hex) < 16:
+        ieee_hex = '0' + ieee_hex
+    value = struct.unpack('>d', binascii.a2b_hex(ieee_hex))[0]
+    try:
+        serialized = py2es6.serialize(value)
+    except ValueError:
+        if expected == INVALID_NUMBER:
+            return
+    if serialized == expected and value == float(serialized) and repr(value) == str(value):
+        return
+    raise ValueError('IEEE:   ' + ieee_hex + '\nPython: ' + serialized + '\nExpected: ' + expected)
+
+
+def test_corners():
+    assert verify('4340000000000001', '9007199254740994') is None
+    assert verify('4340000000000002', '9007199254740996') is None
+    assert verify('444b1ae4d6e2ef50', '1e+21') is None
+    assert verify('3eb0c6f7a0b5ed8d', '0.000001') is None
+    assert verify('3eb0c6f7a0b5ed8c', '9.999999999999997e-7') is None
+    assert verify('8000000000000000', '0') is None
+    assert verify('7fffffffffffffff', INVALID_NUMBER) is None
+    assert verify('7ff0000000000000', INVALID_NUMBER) is None
+    assert verify('fff0000000000000', INVALID_NUMBER) is None
+
+
+def test_reference():
+    with open(UPSTREAM_REF_TEST_DATA, 'r') as line_source:
+        for count, line in enumerate(line_source):
+            if line:
+                i = line.find(COMMA)
+                if i <= 0 or i >= len(line) - 1:
+                    raise ValueError(f'bad line ({line}) at {count}')
+                assert verify(line[:i], line[i + 1 : len(line) - 1]) is None