transit-python 0.8.321__cp310-abi3-win_amd64.whl

transit/rolling_cache.py

@@ -0,0 +1,104 @@
+## 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.constants import SUB, MAP_AS_ARR
+
+FIRST_ORD = 48
+CACHE_CODE_DIGITS = 44
+CACHE_SIZE = CACHE_CODE_DIGITS * CACHE_CODE_DIGITS
+MIN_SIZE_CACHEABLE = 4
+
+
+def is_cache_key(name):
+    return len(name) > 0 and name[0] == SUB and name != MAP_AS_ARR
+
+
+def encode_key(i):
+    lo = i % CACHE_CODE_DIGITS
+    hi = i // CACHE_CODE_DIGITS
+    if hi == 0:
+        return "^" + chr(lo + FIRST_ORD)
+    return "^" + chr(hi + FIRST_ORD) + chr(lo + FIRST_ORD)
+
+
+def decode_key(s):
+    sz = len(s)
+    if sz == 2:
+        return ord(s[1]) - FIRST_ORD
+    return (ord(s[2]) - FIRST_ORD) + \
+           (CACHE_CODE_DIGITS * (ord(s[1]) - FIRST_ORD))
+
+
+def is_cacheable(string, as_map_key=False):
+    return len(string) >= MIN_SIZE_CACHEABLE \
+        and (as_map_key or string[:2] in ("~#", "~$", "~:"))
+
+
+class RollingCache:
+    """This is the internal cache used by python-transit for cacheing and
+    expanding map keys during writing and reading.  The cache enables transit
+    to minimize the amount of duplicate data sent over the wire, effectively
+    compressing down the overall payload size.  The cache is not intended to
+    be used directly.
+
+    Readers and writers must agree on cache codes, so this follows the
+    transit spec (and transit-java): codes are assigned in order from "^0",
+    and once CACHE_SIZE entries are in use the cache starts over from "^0".
+    """
+    def __init__(self):
+        self.key_to_value = {}
+        self.value_to_key = {}
+        self.index = 0
+
+    def decode(self, name, as_map_key=False):
+        """Reading: expand a cache code, or remember a cacheable value.
+        Always returns the (uncached) name.
+        """
+        if is_cache_key(name):
+            try:
+                return self.key_to_value[name]
+            except KeyError:
+                raise ValueError("Unknown cache code: " + name) from None
+        if is_cacheable(name, as_map_key):
+            self.encache(name)
+        return name
+
+    def encode(self, name, as_map_key=False):
+        """Writing: returns the name the first time and the code after that."""
+        if name in self.value_to_key:
+            return self.value_to_key[name]
+        if is_cacheable(name, as_map_key):
+            self.encache(name)
+        return name
+
+    def size(self):
+        return len(self.key_to_value)
+
+    def is_cache_full(self):
+        return self.index >= CACHE_SIZE
+
+    def encache(self, name):
+        if self.is_cache_full():
+            self.clear()
+        key = encode_key(self.index)
+        self.index += 1
+        self.key_to_value[key] = name
+        self.value_to_key[name] = key
+        return name
+
+    def clear(self):
+        self.key_to_value = {}
+        self.value_to_key = {}
+        self.index = 0

transit/sosjson.py

@@ -0,0 +1,129 @@
+## 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.
+# Streaming reads of a sequence of JSON texts (as sent over a pipe or socket),
+# yielding each top level value as soon as it has fully arrived.
+#
+# Rather than scanning a character at a time, whatever data is available is
+# read in one go and a regex skips ahead to the characters that matter for
+# finding the end of a value (brackets, quotes and escapes). Each complete
+# value is then handed to json.loads.
+import codecs
+import json
+import re
+
+CHUNK_SIZE = 64 * 1024
+
+_NON_WS = re.compile(r"[^ \t\n\r]")
+_STRUCTURAL = re.compile(r'[\[\]{}"]')
+_IN_STRING = re.compile(r'["\\]')
+
+
+def read_available(stream, size=CHUNK_SIZE):
+    """Return a function that reads whatever data is available from stream,
+    blocking only until there is some. Returns an empty value at EOF.
+    """
+    buffer = getattr(stream, "buffer", None)
+    if buffer is not None and hasattr(buffer, "read1"):
+        # A text wrapper (e.g. sys.stdin); read(n) on it blocks until n
+        # characters arrive, so read bytes from the underlying buffer.
+        return lambda: buffer.read1(size)
+    if hasattr(stream, "read1"):
+        return lambda: stream.read1(size)
+    return lambda: stream.read(size)
+
+
+def chunks_raw(stream):
+    """Yield data from stream as it becomes available, until EOF."""
+    read = read_available(stream)
+    while True:
+        data = read()
+        if not data:
+            return
+        yield data
+
+
+def chunks(stream):
+    """Yield text from stream as it becomes available, decoding bytes as UTF-8."""
+    decoder = codecs.getincrementaldecoder("utf-8")()
+    for data in chunks_raw(stream):
+        text = data if isinstance(data, str) else decoder.decode(data)
+        if text:
+            yield text
+    decoder.decode(b"", final=True)  # raises on truncated UTF-8
+
+
+def yield_json(stream):
+    """Yield the text of each top level JSON array, object or string in stream."""
+    buf = ""
+    pos = 0          # where to resume scanning in buf
+    start = None     # start of the value being read, None between values
+    depth = 0
+    in_string = False
+    for text in chunks(stream):
+        buf += text
+        while True:
+            if start is None:
+                m = _NON_WS.search(buf, pos)
+                if not m:
+                    buf, pos = "", 0
+                    break
+                start = m.start()
+                c = buf[start]
+                pos = start + 1
+                if c == '"':
+                    in_string = True
+                elif c in "[{":
+                    depth = 1
+                else:
+                    raise ValueError("Expected a JSON array, object or string, "
+                                     "found: " + repr(buf[start:start + 20]))
+            elif in_string:
+                m = _IN_STRING.search(buf, pos)
+                if not m:
+                    pos = len(buf)
+                    break
+                if m.group() == "\\":
+                    if m.end() == len(buf):
+                        # escaped character hasn't arrived yet
+                        pos = m.start()
+                        break
+                    pos = m.end() + 1
+                    continue
+                pos = m.end()
+                in_string = False
+            else:
+                m = _STRUCTURAL.search(buf, pos)
+                if not m:
+                    pos = len(buf)
+                    break
+                c = m.group()
+                pos = m.end()
+                if c == '"':
+                    in_string = True
+                    continue
+                depth += 1 if c in "[{" else -1
+            if depth == 0 and not in_string:
+                yield buf[start:pos]
+                buf, pos, start = buf[pos:], 0, None
+    if start is not None:
+        raise ValueError("Stream ended in the middle of a JSON value")
+
+
+def items(stream, **kwargs):
+    """Yield each top level JSON value in stream as soon as it is available.
+    Keyword arguments are passed to json.loads (e.g. object_pairs_hook).
+    """
+    for s in yield_json(stream):
+        yield json.loads(s, **kwargs)

transit/transit_types.py

@@ -0,0 +1,267 @@
+## 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 Hashable, Mapping
+
+
+class Named:
+    def _parse(self):
+        p = self.str.split('/', 1)
+        if len(p) == 1:
+            self._name = self.str
+            self._namespace = None
+        else:
+            self._namespace = p[0] or None
+            self._name = p[1] or "/"
+        return self._name, self._namespace
+
+    @property
+    def name(self):
+        return self._name if hasattr(self, "_name") else self._parse()[0]
+
+    @property
+    def namespace(self):
+        return self._namespace if hasattr(self, "_namespace") \
+                               else self._parse()[1]
+
+
+class Keyword(Named):
+    def __init__(self, value):
+        assert isinstance(value, str)
+        self.str = value
+        self.hv = value.__hash__()
+
+    def __hash__(self):
+        return self.hv
+
+    def __eq__(self, other):
+        return isinstance(other, Keyword) and self.str == other.str
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __call__(self, mp):
+        return mp[self]
+
+    def __repr__(self):
+        return "<Keyword " + self.str + ">"
+
+    def __str__(self):
+        return self.str
+
+
+class Symbol(Named):
+    def __init__(self, value):
+        assert isinstance(value, str)
+        self.str = value
+        self.hv = value.__hash__()
+
+    def __hash__(self):
+        return self.hv
+
+    def __eq__(self, other):
+        return isinstance(other, Symbol) and self.str == other.str
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __call__(self, mp):
+        return mp[self]
+
+    def __repr__(self):
+        return self.str
+
+    def __str__(self):
+        return self.str
+
+kw_cache = {}
+
+
+class _KWS:
+    def __getattr__(self, item):
+        value = self(item)
+        setattr(self, item, value)
+        return value
+
+    def __call__(self, str):
+        if str in kw_cache:
+            return kw_cache[str]
+        else:
+            kw_cache[str] = Keyword(str)
+            return kw_cache[str]
+
+kws = _KWS()
+
+
+class TaggedValue:
+    def __init__(self, tag, rep):
+        self.tag = tag
+        self.rep = rep
+
+    def __eq__(self, other):
+        if isinstance(other, TaggedValue):
+            return self.tag == other.tag and \
+                   self.rep == other.rep
+        return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        if isinstance(self.rep, list):
+            return hash(tuple(self.rep))
+        return hash(self.rep)
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        return self.tag + " " + repr(self.rep)
+
+
+class Set(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "set", rep)
+
+
+class CMap(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "cmap", rep)
+
+
+class Vector(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "vector", rep)
+
+
+class Array(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "array", rep)
+
+
+class List(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "list", rep)
+
+
+class URI(TaggedValue):
+    def __init__(self, rep):
+        TaggedValue.__init__(self, "uri", rep)
+
+
+class frozendict(Mapping, Hashable):
+    def __init__(self, *args, **kwargs):
+        self._dict = dict(*args, **kwargs)
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __iter__(self):
+        return iter(self._dict)
+
+    def __getitem__(self, key):
+        return self._dict[key]
+
+    def __hash__(self):
+        return hash(frozenset(self._dict.items()))
+
+    def __repr__(self):
+        return 'frozendict(%r)' % (self._dict,)
+
+
+class Link:
+    # Class property constants for rendering types
+    LINK = "link"
+    IMAGE = "image"
+
+    # Class property constants for keywords/obj properties.
+    HREF = "href"
+    REL = "rel"
+    PROMPT = "prompt"
+    NAME = "name"
+    RENDER = "render"
+
+    def __init__(self, href=None, rel=None, name=None, render=None,
+                 prompt=None):
+        self._dict = frozendict()
+        assert href and rel
+        if render:
+            assert render.lower() in [Link.LINK, Link.IMAGE]
+        self._dict = {Link.HREF: href,
+                      Link.REL: rel,
+                      Link.NAME: name,
+                      Link.RENDER: render,
+                      Link.PROMPT: prompt}
+
+    def __eq__(self, other):
+        return self._dict == other._dict
+
+    def __ne__(self, other):
+        return self._dict != other._dict
+
+    @property
+    def href(self):
+        return self._dict[Link.HREF]
+
+    @property
+    def rel(self):
+        return self._dict[Link.REL]
+
+    @property
+    def prompt(self):
+        return self._dict[Link.PROMPT]
+
+    @property
+    def name(self):
+        return self._dict[Link.NAME]
+
+    @property
+    def render(self):
+        return self._dict[Link.RENDER]
+
+    @property
+    def as_map(self):
+        return self._dict
+
+    @property
+    def as_array(self):
+        return [self.href, self.rel, self.name, self.render, self.prompt]
+
+
+class Boolean:
+    """To allow a separate t/f that won't hash as 1/0. Don't call directly,
+    instead use true and false as singleton objects. Can use with type check.
+
+    Note that the Booleans are for preserving hash/set bools that duplicate 1/0
+    and not designed for use in Python outside logical evaluation (don't treat
+    as an int, they're not). You can get a Python bool using bool(x)
+    where x is a true or false Boolean.
+    """
+    def __init__(self, name):
+        self.v = True if name == "true" else False
+        self.name = name
+
+    def __bool__(self):
+        return self.v
+
+    def __repr__(self):
+        return self.name
+
+    def __str__(self):
+        return self.name
+
+# lowercase rep matches java/clojure
+
+false = Boolean("false")
+true = Boolean("true")