transit-python 0.8.321__cp310-abi3-win_amd64.whl

transit/__init__.py

@@ -0,0 +1,16 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+__version__ = "0.8.321"

transit/_accel.py

@@ -0,0 +1,27 @@
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+# The optional native extension (transit._native, built from transit-format-c).
+# Reader and Writer use it when it's available, unless TRANSIT_PUREPYTHON is
+# set; otherwise, or for anything it doesn't handle, they use pure Python.
+import os
+
+native = None
+if not os.environ.get("TRANSIT_PUREPYTHON"):
+    try:
+        from transit import _native as native
+    except ImportError:
+        native = None
+
+FORMATS = {"json": 0, "json_verbose": 1, "msgpack": 2}

transit/class_hash.py

@@ -0,0 +1,52 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+from collections.abc import MutableMapping
+
+
+class ClassDict(MutableMapping):
+    """A dictionary that looks up class/type keys with inheritance."""
+
+    def __init__(self, *args, **kwargs):
+        self.store = dict()
+        self.update(dict(*args, **kwargs))
+
+    def __getitem__(self, key):
+        key = key if isinstance(key, type) else type(key)
+        if key in self.store:
+            return self.store[key]
+        else:
+            for t in key.__bases__:
+                value = t in self.store and self.store[t]
+                if value:
+                    return value
+            # only use mro if __bases__ doesn't work to
+            # avoid its perf overhead.
+            for t in key.mro():
+                value = t in self.store and self.store[t]
+                if value:
+                    return value
+            raise KeyError("No handler found for: " + str(key))
+
+    def __setitem__(self, key, value):
+        self.store[key] = value
+
+    def __delitem__(self, key):
+        del self.store[key]
+
+    def __iter__(self):
+        return iter(self.store)
+
+    def __len__(self):
+        return len(self.store)

transit/constants.py

@@ -0,0 +1,23 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+# These are constants used throughout the source code.
+# They refer to Tag codes used when reading and wrting transit.
+
+ESC = "~"
+SUB = "^"
+RES = "`"
+TAG = "~#"
+QUOTE = "'"
+MAP_AS_ARR = "^ "

transit/decoder.py

@@ -0,0 +1,185 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+from transit import transit_types
+from transit import read_handlers as rh
+from transit.constants import MAP_AS_ARR, ESC, SUB, RES
+from transit.helpers import pairs
+from transit.rolling_cache import RollingCache
+from transit.transit_types import true, false
+
+
+class Tag:
+    def __init__(self, tag):
+        self.tag = tag
+
+default_options = {"decoders": {"_": rh.NoneHandler,
+                                ":": rh.KeywordHandler,
+                                "$": rh.SymbolHandler,
+                                "?": rh.BooleanHandler,
+                                "i": rh.IntHandler,
+                                "d": rh.FloatHandler,
+                                "f": rh.BigDecimalHandler,
+                                "u": rh.UuidHandler,
+                                "r": rh.UriHandler,
+                                "t": rh.DateHandler,
+                                "m": rh.DateHandler,
+                                "n": rh.BigIntegerHandler,
+                                "z": rh.SpecialNumbersHandler,
+                                "link": rh.LinkHandler,
+                                "list": rh.ListHandler,
+                                "set": rh.SetHandler,
+                                "cmap": rh.CmapHandler,
+                                "'": rh.IdentityHandler},
+                   "default_decoder": rh.DefaultHandler}
+
+ground_decoders = {"_": rh.NoneHandler,
+                   "?": rh.BooleanHandler,
+                   "i": rh.IntHandler,
+                   "'": rh.IdentityHandler}
+
+
+class Decoder:
+    """The Decoder is the lowest level entry point for parsing, decoding, and
+    fully converting Transit data into Python objects.
+
+    During the creation of a Decoder object, you can specify custom options
+    in a dictionary.  One such option is 'decoders'.  Note that while you
+    can specify your own decoders and override many of the built in decoders,
+    some decoders are silently enforced and cannot be overriden.  These are
+    known as Ground Decoders, and are needed to maintain bottom-tier
+    compatibility.
+    """
+    def __init__(self, options=None):
+        self.options = default_options.copy()
+        self.options.update(options or {})
+
+        # Copy so that registering decoders on one Decoder doesn't leak into
+        # default_options (and so every other Decoder).
+        self.decoders = dict(self.options["decoders"])
+        # Always ensure we control the ground decoders
+        self.decoders.update(ground_decoders)
+
+    def decode(self, node, cache=None, as_map_key=False):
+        """Given a node of data (any supported decodeable obj - string, dict,
+        list), return the decoded object.  Optionally set the current decode
+        cache [None].  If None, a new RollingCache is instantiated and used.
+        You may also hit to the decoder that this node is to be treated as a
+        map key [False].  This is used internally.
+        """
+        if not cache:
+            cache = RollingCache()
+        return self._decode(node, cache, as_map_key)
+
+    def _decode(self, node, cache, as_map_key):
+        if isinstance(node, str):
+            return self.decode_string(node, cache, as_map_key)
+        elif isinstance(node, bytes):
+            return self.decode_string(node.decode("utf-8"), cache, as_map_key)
+        elif isinstance(node, dict):
+            return self.decode_hash(node, cache, as_map_key)
+        elif isinstance(node, list):
+            return self.decode_list(node, cache, as_map_key)
+        elif isinstance(node, bool):
+            return true if node else false
+        return node
+
+    def decode_list(self, node, cache, as_map_key):
+        """Special case decodes map-as-array.
+        Otherwise lists are treated as Python lists.
+
+        Arguments follow the same convention as the top-level 'decode'
+        function.
+        """
+        if node:
+            if node[0] == MAP_AS_ARR:
+                # key must be decoded before value for caching to work.
+                returned_dict = {}
+                for k, v in pairs(node[1:]):
+                    key = self._decode(k, cache, True)
+                    val = self._decode(v, cache, as_map_key)
+                    returned_dict[key] = val
+                return transit_types.frozendict(returned_dict)
+
+            # Each element must be decoded exactly once, in order, to keep
+            # the cache in step with the writer.
+            decoded = self._decode(node[0], cache, as_map_key)
+            if isinstance(decoded, Tag):
+                return self.decode_tag(decoded.tag,
+                                       self._decode(node[1], cache, as_map_key))
+            return (decoded,) + tuple(self._decode(x, cache, as_map_key)
+                                      for x in node[1:])
+        return ()
+
+    def decode_string(self, string, cache, as_map_key):
+        """Decode a string - arguments follow the same convention as the
+        top-level 'decode' function.
+        """
+        return self.parse_string(cache.decode(string, as_map_key),
+                                 cache, as_map_key)
+
+    def decode_tag(self, tag, rep):
+        decoder = self.decoders.get(tag, None)
+        if decoder:
+            return decoder.from_rep(rep)
+        else:
+            return self.options["default_decoder"].from_rep(tag, rep)
+
+    def decode_hash(self, hash, cache, as_map_key):
+        if len(hash) != 1:
+            h = {}
+            for k, v in hash.items():
+                # crude/verbose implementation, but this is only version that
+                # plays nice w/cache for both msgpack and json thus far.
+                # -- e.g., we have to specify encode/decode order for key/val
+                # -- explicitly, all implicit ordering has broken in corner
+                # -- cases, thus these extraneous seeming assignments
+                key = self._decode(k, cache, True)
+                val = self._decode(v, cache, False)
+                h[key] = val
+            return transit_types.frozendict(h)
+        else:
+            key = list(hash)[0]
+            value = hash[key]
+            key = self._decode(key, cache, True)
+            if isinstance(key, Tag):
+                return self.decode_tag(key.tag,
+                                       self._decode(value, cache, as_map_key))
+        return transit_types.frozendict({key: self._decode(value, cache, False)})
+
+    def parse_string(self, string, cache, as_map_key):
+        if string.startswith(ESC):
+            m = string[1]
+            if m in self.decoders:
+                return self.decoders[m].from_rep(string[2:])
+            elif m == ESC or m == SUB or m == RES:
+                return string[1:]
+            elif m == "#":
+                return Tag(string[2:])
+            else:
+                return self.options["default_decoder"].from_rep(string[1],
+                                                                string[2:])
+        return string
+
+    def register(self, key_or_tag, obj):
+        """Register a custom Transit tag and new parsing function with the
+        decoder.  Also, you can optionally set the 'default_decoder' with
+        this function.  Your new tag and parse/decode function will be added
+        to the interal dictionary of decoders for this Decoder object.
+        """
+        if key_or_tag == "default_decoder":
+            self.options["default_decoder"] = obj
+        else:
+            self.decoders[key_or_tag] = obj

transit/helpers.py

@@ -0,0 +1,41 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+import itertools
+
+
+def mapcat(f, i):
+    return itertools.chain.from_iterable(map(f, i))
+
+
+def pairs(i):
+    return zip(*[iter(i)] * 2)
+
+
+cycle = itertools.cycle
+
+
+def take(n, i):
+    return itertools.islice(i, 0, n)
+
+
+def require_msgpack():
+    """Import msgpack, which is only needed for the msgpack protocol."""
+    try:
+        import msgpack
+    except ImportError as e:
+        raise ImportError("The msgpack protocol requires the msgpack package; "
+                          "install it with: pip install 'transit-python[msgpack]'") from e
+    return msgpack

transit/read_handlers.py

@@ -0,0 +1,183 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+import datetime
+import re
+import uuid
+from decimal import Decimal
+
+from transit import transit_types
+from transit.helpers import pairs
+
+## Read handlers are used by the decoder when parsing/reading in Transit
+## data and returning Python objects
+
+EPOCH = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
+
+_RFC3339 = re.compile(r"(\d{4}-\d\d-\d\d)[Tt ](\d\d:\d\d:\d\d)(?:\.(\d+))?"
+                      r"([Zz]|[+-]\d\d:\d\d)?$")
+
+
+def parse_rfc3339(s):
+    """Parse an RFC 3339 timestamp into a UTC datetime, to the millisecond
+    (transit times are points in time, with millisecond precision, as they
+    are for the other transit implementations).
+
+    Normalizes what datetime.fromisoformat can't handle on every supported
+    Python ("Z", fractional seconds that aren't 3 or 6 digits). A missing
+    offset is taken to be UTC.
+    """
+    m = _RFC3339.match(s)
+    if not m:
+        d = datetime.datetime.fromisoformat(s)
+    else:
+        date, time, frac, offset = m.groups()
+        if frac:
+            time += "." + frac[:6].ljust(6, "0")
+        if offset is None or offset in "Zz":
+            offset = "+00:00"
+        d = datetime.datetime.fromisoformat(date + "T" + time + offset)
+    if d.tzinfo is None:
+        d = d.replace(tzinfo=datetime.timezone.utc)
+    d = d.astimezone(datetime.timezone.utc)
+    return d.replace(microsecond=d.microsecond // 1000 * 1000)
+
+
+class DefaultHandler:
+    @staticmethod
+    def from_rep(t, v):
+        return transit_types.TaggedValue(t, v)
+
+
+class NoneHandler:
+    @staticmethod
+    def from_rep(_):
+        return None
+
+
+class KeywordHandler:
+    @staticmethod
+    def from_rep(v):
+        return transit_types.Keyword(v)
+
+
+class SymbolHandler:
+    @staticmethod
+    def from_rep(v):
+        return transit_types.Symbol(v)
+
+
+class BigDecimalHandler:
+    @staticmethod
+    def from_rep(v):
+        return Decimal(v)
+
+
+class BooleanHandler:
+    @staticmethod
+    def from_rep(x):
+        return transit_types.true if x == "t" else transit_types.false
+
+
+class IntHandler:
+    @staticmethod
+    def from_rep(v):
+        return int(v)
+
+
+class FloatHandler:
+    @staticmethod
+    def from_rep(v):
+        return float(v)
+
+
+class UuidHandler:
+    @staticmethod
+    def from_rep(u):
+        """Given a string, or a pair of signed 64 bit ints (most significant
+        first), return a UUID object."""
+        if isinstance(u, str):
+            return uuid.UUID(u)
+        mask = (1 << 64) - 1
+        return uuid.UUID(int=(u[0] & mask) << 64 | (u[1] & mask))
+
+
+class UriHandler:
+    @staticmethod
+    def from_rep(u):
+        return transit_types.URI(u)
+
+
+class DateHandler:
+    @staticmethod
+    def from_rep(d):
+        if isinstance(d, int):
+            return DateHandler._convert_timestamp(d)
+        if "T" in d:
+            return parse_rfc3339(d)
+        return DateHandler._convert_timestamp(int(d))
+
+    @staticmethod
+    def _convert_timestamp(ms):
+        """Given a timestamp in ms, return a DateTime object."""
+        return EPOCH + datetime.timedelta(milliseconds=ms)
+
+
+class BigIntegerHandler:
+    @staticmethod
+    def from_rep(d):
+        return int(d)
+
+
+class LinkHandler:
+    @staticmethod
+    def from_rep(l):
+        return transit_types.Link(**l)
+
+
+class ListHandler:
+    @staticmethod
+    def from_rep(l):
+        return l
+
+
+class SetHandler:
+    @staticmethod
+    def from_rep(s):
+        return frozenset(s)
+
+
+class CmapHandler:
+    @staticmethod
+    def from_rep(cmap):
+        return transit_types.frozendict(pairs(cmap))
+
+
+class IdentityHandler:
+    @staticmethod
+    def from_rep(i):
+        return i
+
+
+class SpecialNumbersHandler:
+    @staticmethod
+    def from_rep(z):
+        if z == 'NaN':
+            return float('Nan')
+        if z == 'INF':
+            return float('Inf')
+        if z == '-INF':
+            return float('-Inf')
+        raise ValueError("Don't know how to handle: " + str(z) + " as \"z\"")

transit/reader.py

@@ -0,0 +1,137 @@
+## Copyright 2014 Cognitect. All Rights Reserved.
+## Copyright 2026 Vendekagon Labs LLC.
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS-IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+import json
+
+from transit import sosjson
+from transit._accel import FORMATS, native
+from transit.decoder import Decoder
+from transit.helpers import require_msgpack
+
+
+class Reader:
+    """The top-level object for reading in Transit data and converting it to
+    Python objects.  During initialization, you must specify the protocol used
+    for unmarshalling the data- json or msgpack. The msgpack protocol requires
+    the msgpack package (pip install 'transit-python[msgpack]').
+    """
+    def __init__(self, protocol="json"):
+        self.protocol = protocol
+        self.customized = False
+        if protocol in ("json", "json_verbose"):
+            self.reader = JsonUnmarshaler()
+        elif protocol == "msgpack":
+            try:
+                self.reader = MsgPackUnmarshaler()
+                self.unpacker = self.reader.unpacker
+            except ImportError:
+                # the native extension reads msgpack without the package
+                if native is None:
+                    raise
+                self.reader = None
+        else:
+            raise ValueError("'" + protocol + "' is not a supported. " +
+                             "Protocol must be:" +
+                             "'json', 'json_verbose', or 'msgpack'.")
+
+    def read(self, stream):
+        """Given a readable file descriptor object (something `load`able by
+        msgpack or json), read the data, and return the Python representation
+        of the contents. One-shot reader.
+        """
+        if native is not None and not self.customized:
+            return native.loads(stream.read(), FORMATS[self.protocol])
+        return self.reader.load(stream)
+
+    def register(self, key_or_tag, f_val):
+        """Register a custom transit tag and decoder/parser function for use
+        during reads.
+        """
+        self.customized = True
+        self.reader.decoder.register(key_or_tag, f_val)
+
+    def readeach(self, stream, **kwargs):
+        """Read each object from stream as it becomes available, as a
+        generator. Stops at the end of the stream.
+
+        Data is read from stream as it arrives rather than waiting for a full
+        buffer, so this works over pipes and sockets. For text streams wrapping
+        a binary buffer (like sys.stdin), the underlying buffer is read.
+
+        For msgpack, stream may be None, in which case the objects are taken
+        from data fed to the `unpacker` property with `unpacker.feed()`.
+        """
+        if native is not None and not self.customized and stream is not None:
+            yield from self._native_readeach(stream)
+            return
+        if self.reader is None:
+            require_msgpack()
+        for o in self.reader.loadeach(stream):
+            yield o
+
+
+    def _native_readeach(self, stream):
+        s = native.stream_new(FORMATS[self.protocol])
+        for chunk in sosjson.chunks_raw(stream):
+            native.stream_feed(s, chunk)
+            while True:
+                found, value = native.stream_read(s)
+                if not found:
+                    break
+                yield value
+        native.stream_end(s)
+        while True:
+            found, value = native.stream_read(s)
+            if not found:
+                return
+            yield value
+
+
+class JsonUnmarshaler:
+    """The top-level Unmarshaler used by the Reader for JSON payloads.  While
+    you may use this directly, it is strongly discouraged.
+    """
+    def __init__(self):
+        self.decoder = Decoder()
+
+    def load(self, stream):
+        return self.decoder.decode(json.load(stream))
+
+    def loadeach(self, stream):
+        for o in sosjson.items(stream):
+            yield self.decoder.decode(o)
+
+
+class MsgPackUnmarshaler:
+    """The top-level Unmarshaler used by the Reader for MsgPack payloads.
+    While you may use this directly, it is strongly discouraged.
+    """
+    def __init__(self):
+        self.msgpack = require_msgpack()
+        self.decoder = Decoder()
+        self.unpacker = self.msgpack.Unpacker(strict_map_key=False)
+
+    def load(self, stream):
+        return self.decoder.decode(self.msgpack.unpack(stream, strict_map_key=False))
+
+    def loadeach(self, stream):
+        for o in self.unpacker:
+            yield self.decoder.decode(o)
+        if stream is None:
+            return
+        for data in sosjson.chunks_raw(stream):
+            self.unpacker.feed(data)
+            for o in self.unpacker:
+                yield self.decoder.decode(o)