transit-python 0.8.174-__py2-none-any.whl → 0.8.240__py2-none-any.whl

scratch/__init__.py

@@ -0,0 +1 @@
+# empty

scratch/bools.py

@@ -0,0 +1,15 @@
+from transit.transit_types import true, false
+                                    
+
+if true:
+    print("ok")
+if not true:
+    print("not ok")
+if false:
+    print("not ok")
+if not false:
+    print("ok")
+if true and false:
+    print("not ok")
+if true or false:
+    print("ok")

scratch/cache-inconsistent.py

@@ -0,0 +1,10 @@
+from StringIO import StringIO
+from transit.writer import Writer
+from transit.reader import Reader
+from transit.transit_types import Symbol
+r = Reader('json')
+io = StringIO()
+w = Writer(io,'json')
+w.write([{"Problem?":True},Symbol("Here"),Symbol("Here")])
+print(io.getvalue())
+print(r.read(StringIO(io.getvalue())))

scratch/dt.py

@@ -0,0 +1,7 @@
+from transit.writer import Writer
+from StringIO import StringIO
+import datetime as dt
+
+io = StringIO()
+writer = Writer(io, "json")
+writer.write({"date": dt.datetime.utcnow()})

scratch/emptyset.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from transit.writer import Writer
+from transit.reader import Reader
+from transit.transit_types import URI
+from StringIO import StringIO
+import sys
+
+io = StringIO()
+
+x = set()
+print(x)
+
+writer = Writer(io, protocol="json")
+writer.write(x)
+reader = Reader(protocol="json")
+print io.getvalue()
+io.seek(0)
+outcome = reader.read(io)
+print(outcome)

scratch/frozendict.py

@@ -0,0 +1,14 @@
+from transit.writer import Writer
+from transit.reader import Reader
+import StringIO
+
+a={"a":1}
+b={"a":1,"b":2}
+
+io = StringIO.StringIO()
+w = Writer(io, protocol="msgpack")
+
+w.write([a,b])
+r = Reader(protocol="msgpack")
+result = r.read(StringIO.StringIO(io.getvalue()))
+print result

scratch/int_issue.py

@@ -0,0 +1,10 @@
+from transit.writer import Writer
+from StringIO import StringIO
+
+io = StringIO()
+
+writer = Writer(io, "json")
+writer.write([2**53+100, 2**63+100])
+
+s = io.getvalue()
+print s

scratch/issue.py

@@ -0,0 +1,44 @@
+from transit.reader import Reader
+from transit.writer import Writer
+from StringIO import StringIO
+import datetime
+
+
+class DateHandler(object):
+    @staticmethod
+    def tag(d):
+        return 'p'
+
+    @staticmethod
+    def rep(d):
+        return str(d)
+
+    @staticmethod
+    def string_rep(d):
+        return str(d)
+
+    @staticmethod
+    def from_rep(d):
+        return datetime.datetime.strptime(d, '%Y-%m-%d').date()
+
+
+my_data = {
+    'start_date': datetime.date(2014, 9, 9),
+    'end_date': datetime.date(2014, 10, 10)
+}
+
+io = StringIO()
+writer = Writer(io, "json")
+writer.register(datetime.date, DateHandler)
+writer.write(my_data)
+output = io.getvalue()
+io.close()
+
+
+reader = Reader()
+reader.register('p', DateHandler)
+parsed = reader.read(StringIO(output))
+
+assert parsed['start_date'] == my_data['start_date']  # Should be fine
+assert parsed['end_date'] == my_data['end_date']  # Error here - actual value of parsed['end_date'] is (u'start_date', u'2014-10-10')
+print(parsed)

scratch/mp_test.py

@@ -0,0 +1,22 @@
+import transit.writer as twriter
+import transit.reader as treader
+from io import BytesIO
+from StringIO import StringIO
+from datetime import datetime
+import dateutil.tz
+from uuid import UUID
+
+b = BytesIO()
+#b = StringIO()
+r = treader.Reader(protocol="msgpack")
+w = twriter.Writer(b, protocol="msgpack")
+
+UUIDS = (UUID('5a2cbea3-e8c6-428b-b525-21239370dd55'),
+         UUID('d1dc64fa-da79-444b-9fa4-d4412f427289'),
+         UUID('501a978e-3a3e-4060-b3be-1cf2bd4b1a38'),
+         UUID('b3ba141a-a776-48e4-9fae-a28ea8571f58'))
+
+w.write(UUIDS)
+print(b.getvalue())
+b.seek(0)
+print r.read(b)

scratch/msgpack_issue.py

@@ -0,0 +1,19 @@
+from transit.reader import Reader
+from transit.writer import Writer
+from StringIO import StringIO
+
+#json = "{\"~#set\":[{\"~#set\":[1,3,2]},{\"~#set\":[null,0,2.0,\"~~eight\",1,true,\"five\",false,\"~$seven\",\"~:six\"]}]}\n"
+#mpcode = "94a37e6360a37e637ea37e635ea37e6323".decode("hex")
+
+json = "{\"~#set\":[1,true]}"
+io = StringIO()
+io.write(json)
+io.seek(0)
+r = Reader(protocol="json")
+correct = r.read(io)
+out = StringIO()
+w = Writer(out, protocol="json")
+w.write(correct)
+print(json)
+print(out.getvalue())
+

scratch/newline.py

@@ -0,0 +1,14 @@
+from transit.reader import Reader
+from transit.writer import Writer
+from StringIO import StringIO
+
+s = 'a\nb'
+
+io = StringIO()
+writer = Writer(io, 'json')
+writer.write(s)
+output = io.getvalue()
+io.close()
+
+reader = Reader()
+assert s == reader.read(StringIO(output))

scratch/streamit.py

@@ -0,0 +1,56 @@
+from StringIO import StringIO
+from copy import copy
+import json
+
+DELIMS = {"{" : "}",
+          "[" : "]",
+          "\"": "\""}
+
+SKIP = [" ", "\n", "\t"]
+
+ESCAPE = "\\"
+
+def read_chunk(stream):
+    """Ignore whitespace outside of strings.
+    """
+    chunk = stream.read(1)
+    while chunk in SKIP:
+        chunk = stream.read(1)
+    if chunk == "\"":
+        chunk += stream.read(1)
+        while not chunk.endswith("\""):
+            if chunk[-1] == ESCAPE:
+                chunk += stream.read(2)
+            else:
+                chunk += stream.read(1)
+    return chunk
+
+def yield_json(stream):
+    buff = u""
+    arr_count = 0
+    obj_count = 0
+    while True:
+        buff += read_chunk(stream)
+
+        if buff.endswith('{'):
+            obj_count += 1
+        if buff.endswith('['):
+            arr_count += 1
+        if buff.endswith(']'):
+            arr_count -= 1
+            if obj_count == arr_count == 0:
+                json_item = copy(buff)
+                buff = u""
+                yield json_item
+        if buff.endswith('}'):
+            obj_count -= 1
+            if obj_count == arr_count == 0:
+                json_item = copy(buff)
+                buff = u""
+                yield json_item
+
+if __name__ == "__main__":
+    x = StringIO("""[\"^ \",\"~:key0000\",0,\"~:key0001\",1,\"~:key0002\",2,\"~:key0003\",3,\"~:key0004\",4,\"~:key0005\",5,\"~:key0006\",6,\"~:key0007\",7,\"~:key0008\",8,\"~:key0009\",9]\n""")
+#    x = StringIO("""{\"~#'\":false}\n""")
+    for a in yield_json(x):
+        print(a)

scratch/testmprt.py

@@ -0,0 +1,15 @@
+from transit import reader, writer
+from StringIO import StringIO
+
+for fmt in ("msgpack", "json"):
+    io = StringIO()
+    w = writer.Writer(io, fmt)
+
+    for item in [0, 1, 1902382]:
+        w.write(item)
+
+    io.seek(0)
+    r = reader.Reader(fmt, io)
+
+    for item in r.read():
+        print(item)

scratch/unicodeme.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+from transit.writer import Writer
+from transit.reader import Reader
+from transit.transit_types import URI
+from StringIO import StringIO
+import sys
+
+io = StringIO()
+
+x = URI(u'http://www.詹姆斯.com/')
+print(x)
+
+writer = Writer(io, protocol="json-verbose")
+writer.write(x)
+reader = Reader(protocol="json-verbose")
+print io.getvalue()
+io.seek(0)
+outcome = reader.read(io)
+print(outcome)
+
+

tests/exemplars_test.py

@@ -14,26 +14,24 @@
 ## limitations under the License.
 import unittest
 
-# get parent directory into python path
-import sys, os
-sys.path.append(os.path.abspath(os.path.dirname(__file__) + os.path.sep + os.path.pardir))
-
 # then import transit stuff
 from transit.reader import Reader, JsonUnmarshaler, MsgPackUnmarshaler
 from transit.writer import Writer
-from transit.transit_types import Keyword, Symbol, URI, frozendict, TaggedValue, Link
+from transit.transit_types import Keyword, Symbol, URI, frozendict, TaggedValue, Link, true, false
 from StringIO import StringIO
 from transit.helpers import mapcat
 from helpers import ints_centered_on, hash_of_size, array_of_symbools
 from uuid import UUID
 from datetime import datetime
 import dateutil.tz
+from math import isnan
 
 class ExemplarBaseTest(unittest.TestCase):
     pass
 
 def exemplar(name, val):
     class ExemplarTest(ExemplarBaseTest):
+
         def test_json(self):
             with open("../transit-format/examples/0.8/simple/" + name + ".json", 'r') as stream:
                 data = Reader(protocol="json").read(stream)
@@ -87,13 +85,18 @@ def exemplar(name, val):
             try:
                 return unittest.TestCase.assertEqual(self, val, data)
             except AssertionError as e:
-                e.args += (name, "failed")
-                raise
+                if not False in [isnan(v) and isnan(d) or isnan(v) == isnan(d)
+                                 for v, d in zip (val, data)]:
+                    return unittest.TestCase.assertEqual(self, filter(lambda x: not isnan(x), val),
+                                                               filter(lambda x: not isnan(x), data))
+                else:
+                    e.args += (name, "failed")
+                    raise
 
     globals()["test_" + name + "_json"] = ExemplarTest
 
 ARRAY_SIMPLE = (1, 2, 3)
-ARRAY_MIXED = (0, 1, 2.0, True, False, 'five', Keyword("six"), Symbol("seven"), '~eight', None)
+ARRAY_MIXED = (0, 1, 2.0, true, false, 'five', Keyword("six"), Symbol("seven"), '~eight', None)
 ARRAY_NESTED = (ARRAY_SIMPLE, ARRAY_MIXED)
 SMALL_STRINGS = ("", "a", "ab", "abc", "abcd", "abcde", "abcdef")
 POWERS_OF_TWO = tuple(map(lambda x: pow(2, x), range(66)))
@@ -128,14 +131,14 @@ MAP_SIMPLE = frozendict({Keyword("a"): 1,
 
 MAP_MIXED = frozendict({Keyword("a"): 1,
                         Keyword("b"): u"a string",
-                        Keyword("c"): True})
+                        Keyword("c"): true})
 
 MAP_NESTED = frozendict({Keyword("simple"): MAP_SIMPLE,
                          Keyword("mixed"): MAP_MIXED})
 
 exemplar("nil", None)
-exemplar("true", True)
-exemplar("false", False)
+exemplar("true", true)
+exemplar("false", false)
 exemplar("zero", 0)
 exemplar("one", 1)
 exemplar("one_string", "hello")
@@ -215,6 +218,8 @@ exemplar("maps_four_char_string_keys", ({"aaaa": 1, "bbbb": 2},
 exemplar("maps_unrecognized_keys", (TaggedValue("abcde", Keyword("anything")),
                                    TaggedValue("fghij", Keyword("anything-else")),))
 
+exemplar("vector_special_numbers", (float("nan"), float("inf"), float("-inf")))
+
 # Doesn't exist in simple examples but gave me tests to verify Link.
 #exemplar("link", Link("http://www.blah.com", "test", "test", "link", "test"))
 

tests/regression.py

@@ -0,0 +1,80 @@
+## 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.
+
+# This test suite verifies that issues corrected remain corrected.
+import unittest
+
+from transit.reader import Reader
+from transit.writer import Writer
+from transit.transit_types import Symbol, frozendict, true, false
+from StringIO import StringIO
+
+class RegressionBaseTest(unittest.TestCase):
+    pass
+
+def regression(name, value):
+    class RegressionTest(RegressionBaseTest):
+
+        def test_roundtrip(self):
+            in_data = value
+            io = StringIO()
+            w = Writer(io, "json")
+            w.write(in_data)
+            r = Reader("json")
+            out_data = r.read(StringIO(io.getvalue()))
+            self.assertEqual(in_data, out_data)
+
+    globals()["test_" + name + "_json"] = RegressionTest
+
+regression("cache_consistency", ({"Problem?":true},
+                                  Symbol("Here"),
+                                  Symbol("Here")))
+regression("one_pair_frozendict", frozendict({"a":1}))
+regression("json_int_max", (2**53+100, 2**63+100))
+regression("newline_in_string", "a\nb")
+
+class BooleanTest(unittest.TestCase):
+    """Even though we're roundtripping transit_types.true and
+    transit_types.false now, make sure we can still write Python bools.
+
+    Additionally, make sure we can still do basic logical evaluation on transit
+    Boolean values.
+    """
+    def test_write_bool(self):
+        for protocol in ("json", "json-verbose", "msgpack"):
+            io = StringIO()
+            w = Writer(io, protocol)
+            w.write((True, False))
+            r = Reader(protocol)
+            io.seek(0)
+            out_data = r.read(io)
+            assert out_data[0] == true
+            assert out_data[1] == false
+
+    def test_basic_eval(self):
+        assert true
+        assert not false
+
+    def test_or(self):
+        assert true or false
+        assert not (false or false)
+        assert true or true
+
+    def test_and(self):
+        assert not (true and false)
+        assert true and true
+        assert not (false and false)
+
+if __name__ == '__main__':
+    unittest.main()

transit/class_hash.py

@@ -16,14 +16,14 @@
 import collections
 
 class ClassDict(collections.MutableMapping):
-    """ A dictionary that looks up class/type keys with inheritance"""
+    """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 = isinstance(key, type) and key or type(key)
+        key = key if isinstance(key, type) else type(key)
         if key in self.store:
             return self.store[key]
         else:

transit/decoder.py

@@ -18,6 +18,7 @@ from collections import OrderedDict
 from helpers import pairs
 import read_handlers as rh
 from rolling_cache import RollingCache, is_cacheable, is_cache_key
+from transit_types import true, false
 
 class Tag(object):
     def __init__(self, tag):
@@ -34,6 +35,7 @@ default_options = {"decoders": {"_": rh.NoneHandler,
                                 "t": rh.DateHandler,
                                 "m": rh.DateHandler,
                                 "n": rh.BigIntegerHandler,
+                                "z": rh.SpecialNumbersHandler,
                                 "link": rh.LinkHandler,
                                 "list": rh.ListHandler,
                                 "set": rh.SetHandler,
@@ -47,7 +49,7 @@ ground_decoders = {"_": rh.NoneHandler,
                    "'": rh.IdentityHandler}
 
 class Decoder(object):
-    """ The Decoder is the lowest level entry point for parsing, decoding, and
+    """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
@@ -55,7 +57,8 @@ class Decoder(object):
     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."""
+    compatibility.
+    """
 
     def __init__(self, options={}):
         self.options = default_options.copy()
@@ -66,11 +69,12 @@ class Decoder(object):
         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,
+        """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."""
+        map key [False].  This is used internally.
+        """
         if not cache:
             cache = RollingCache()
         return self._decode(node, cache, as_map_key)
@@ -85,18 +89,19 @@ class Decoder(object):
             return self.decode_list(node, cache, as_map_key)
         elif tp is str:
             return self.decode_string(unicode(node, "utf-8"), cache, as_map_key)
-        else:
-            return node
+        elif tp is bool:
+            return true if node else false
+        return node
 
     def decode_list(self, node, cache, as_map_key):
-        """ Special case decodes map-as-array.
+        """Special case decodes map-as-array.
         Otherwise lists are treated as Python lists.
 
         Arguments follow the same convention as the top-level 'decode'
-        function"""
+        function.
+        """
         if node:
-            decoded = self._decode(node[0], cache, as_map_key)
-            if decoded == MAP_AS_ARR:
+            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:]):
@@ -104,16 +109,16 @@ class Decoder(object):
                     val = self._decode(v, cache, as_map_key)
                     returned_dict[key] = val
                 return returned_dict
-#                return {self._decode(k, cache, True):
-#                        self._decode(v, cache, as_map_key)
-#                        for k,v in pairs(node[1:])}
-            elif isinstance(decoded, Tag):
+
+            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 tuple(self._decode(x, cache, as_map_key) for x in node)
 
     def decode_string(self, string, cache, as_map_key):
-        """ Decode a string - arguments follow the same convention as the
-        top-level 'decode' function"""
+        """Decode a string - arguments follow the same convention as the
+        top-level 'decode' function.
+        """
         if is_cache_key(string):
             return self.parse_string(cache.decode(string, as_map_key), cache, as_map_key)
         if is_cacheable(string, as_map_key):
@@ -131,7 +136,14 @@ class Decoder(object):
         if len(hash) != 1:
             h = {}
             for k, v in hash.items():
-                h[self._decode(k, cache, True)] = self._decode(v, cache, False)
+                # 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,value = hash.items()[0]
@@ -139,7 +151,7 @@ class Decoder(object):
             if isinstance(key, Tag):
                 return self.decode_tag(key.tag, self._decode(value, cache, as_map_key))
             else:
-                return {key: self._decode(value, cache, False)}
+                return transit_types.frozendict({key: self._decode(value, cache, False)})
 
     def parse_string(self, string, cache, as_map_key):
         if string.startswith(ESC):
@@ -155,10 +167,11 @@ class Decoder(object):
         return string
 
     def register(self, key_or_tag, obj):
-        """ Register a custom Transit tag and new parsing function with the
+        """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"""
+        to the interal dictionary of decoders for this Decoder object.
+        """
         if key_or_tag == "default_decoder":
             self.options["default_decoder"] = obj
         else:

transit/read_handlers.py

@@ -47,7 +47,7 @@ class SymbolHandler(object):
 class BooleanHandler(object):
     @staticmethod
     def from_rep(x):
-        return x == "t"
+        return transit_types.true if x == "t" else transit_types.false
 
 class IntHandler(object):
     @staticmethod
@@ -62,7 +62,7 @@ class FloatHandler(object):
 class UuidHandler(object):
     @staticmethod
     def from_rep(u):
-        """ Given a string, return a UUID object"""
+        """Given a string, return a UUID object."""
         if isinstance(u, basestring):
             return uuid.UUID(u)
 
@@ -87,7 +87,7 @@ class DateHandler(object):
         return DateHandler._convert_timestamp(long(d))
     @staticmethod
     def _convert_timestamp(ms):
-        """ Given a timestamp in ms, return a DateTime object"""
+        """Given a timestamp in ms, return a DateTime object."""
         return datetime.datetime.fromtimestamp(ms/1000.0, dateutil.tz.tzutc())
 
 class BigIntegerHandler(object):
@@ -120,3 +120,13 @@ class IdentityHandler(object):
     def from_rep(i):
         return i
 
+class SpecialNumbersHandler(object):
+    @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\"")