transit-python 0.8.174-__py2.7.egg → 0.8.240__py2.7.egg

EGG-INFO/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: transit-python
-Version: 0.8.174-
+Version: 0.8.240-
 Summary: Transit marshalling for Python
 Home-page: https://github.com/cognitect/transit-python
 Author: Cognitect

EGG-INFO/SOURCES.txt

@@ -1,10 +1,24 @@
 setup.cfg
 setup.py
+scratch/__init__.py
+scratch/bools.py
+scratch/cache-inconsistent.py
+scratch/dt.py
+scratch/emptyset.py
+scratch/frozendict.py
+scratch/int_issue.py
+scratch/issue.py
+scratch/mp_test.py
+scratch/msgpack_issue.py
+scratch/newline.py
+scratch/streamit.py
+scratch/testmprt.py
+scratch/unicodeme.py
 tests/__init__.py
 tests/exemplars_test.py
 tests/helpers.py
+tests/regression.py
 tests/seattle_benchmark.py
-tests/transit_types_test.py
 transit/__init__.py
 transit/class_hash.py
 transit/constants.py
@@ -13,6 +27,7 @@ transit/helpers.py
 transit/read_handlers.py
 transit/reader.py
 transit/rolling_cache.py
+transit/sosjson.py
 transit/transit_types.py
 transit/write_handlers.py
 transit/writer.py

EGG-INFO/requires.txt

@@ -1,2 +1,2 @@
 python-dateutil
-msgpack-python
+msgpack-python

EGG-INFO/top_level.txt

@@ -1,2 +1,3 @@
+scratch
 tests
 transit

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: