transit package

Submodules

transit.class_hash module

class transit.class_hash.ClassDict(*args, **kwargs)

Bases: _abcoll.MutableMapping

A dictionary that looks up class/type keys with inheritance.

transit.constants module

transit.decoder module

class transit.decoder.Decoder(options={})

Bases: object

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.

decode(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.

decode_hash(hash, cache, as_map_key)

decode_list(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.

decode_string(string, cache, as_map_key)

Decode a string - arguments follow the same convention as the top-level ‘decode’ function.

decode_tag(tag, rep)

parse_string(string, cache, as_map_key)

register(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.

class transit.decoder.Tag(tag)

Bases: object

transit.helpers module

transit.helpers.mapcat(f, i)

transit.helpers.pairs(i)

transit.helpers.take(n, i)

transit.read_handlers module

class transit.read_handlers.BigDecimalHandler

Bases: object

static from_rep(v)

class transit.read_handlers.BigIntegerHandler

Bases: object

static from_rep(d)

class transit.read_handlers.BooleanHandler

Bases: object

static from_rep(x)

class transit.read_handlers.CmapHandler

Bases: object

static from_rep(cmap)

class transit.read_handlers.DateHandler

Bases: object

static from_rep(d)

class transit.read_handlers.DefaultHandler

Bases: object

static from_rep(t, v)

class transit.read_handlers.FloatHandler

Bases: object

static from_rep(v)

class transit.read_handlers.IdentityHandler

Bases: object

static from_rep(i)

class transit.read_handlers.IntHandler

Bases: object

static from_rep(v)

class transit.read_handlers.KeywordHandler

Bases: object

static from_rep(v)

class transit.read_handlers.LinkHandler

Bases: object

static from_rep(l)

class transit.read_handlers.ListHandler

Bases: object

static from_rep(l)

class transit.read_handlers.NoneHandler

Bases: object

static from_rep(_)

class transit.read_handlers.SetHandler

Bases: object

static from_rep(s)

class transit.read_handlers.SpecialNumbersHandler

Bases: object

static from_rep(z)

class transit.read_handlers.SymbolHandler

Bases: object

static from_rep(v)

class transit.read_handlers.UriHandler

Bases: object

static from_rep(u)

class transit.read_handlers.UuidHandler

Bases: object

static from_rep(u)

Given a string, return a UUID object.

transit.reader module

class transit.reader.JsonUnmarshaler

Bases: object

The top-level Unmarshaler used by the Reader for JSON payloads. While you may use this directly, it is strongly discouraged.

load(stream)

loadeach(stream)

class transit.reader.MsgPackUnmarshaler

Bases: object

The top-level Unmarshaler used by the Reader for MsgPack payloads. While you may use this directly, it is strongly discouraged.

load(stream)

loadeach(stream)

class transit.reader.Reader(protocol='json')

Bases: object

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.

read(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.

readeach(stream, **kwargs)

Temporary hook for API while streaming reads are in experimental phase. Read each object from stream as available with generator. JSON blocks indefinitely waiting on JSON entities to arrive. MsgPack requires unpacker property to be fed stream using unpacker.feed() method.

register(key_or_tag, f_val)

Register a custom transit tag and decoder/parser function for use during reads.

transit.rolling_cache module

class transit.rolling_cache.RollingCache

Bases: object

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.

clear()

decode(name, as_map_key=False)

Always returns the name

encache(name)

encode(name, as_map_key=False)

Returns the name the first time and the key after that

is_cache_full()

size()

transit.rolling_cache.decode_key(s)

transit.rolling_cache.encode_key(i)

transit.rolling_cache.is_cache_key(name)

transit.rolling_cache.is_cacheable(string, as_map_key=False)

transit.transit_types module

class transit.transit_types.Array(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.Boolean(name)

Bases: object

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.

class transit.transit_types.CMap(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.Keyword(value)

Bases: transit.transit_types.Named

class transit.transit_types.Link(href=None, rel=None, name=None, render=None, prompt=None)

Bases: object

HREF = u'href'

IMAGE = u'image'

LINK = u'link'

NAME = u'name'

PROMPT = u'prompt'

REL = u'rel'

RENDER = u'render'

as_array

as_map

href

name

prompt

rel

render

class transit.transit_types.List(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.Named

Bases: object

name

namespace

class transit.transit_types.Set(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.Symbol(value)

Bases: transit.transit_types.Named

class transit.transit_types.TaggedValue(tag, rep)

Bases: object

class transit.transit_types.URI(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.Vector(rep)

Bases: transit.transit_types.TaggedValue

class transit.transit_types.frozendict(*args, **kwargs)

Bases: _abcoll.Mapping, _abcoll.Hashable

transit.transit_types.kws

transit.write_handlers module

class transit.write_handlers.ArrayHandler

Bases: object

static rep(a)

static string_rep(a)

static tag(a)

class transit.write_handlers.BigDecimalHandler

Bases: object

static rep(n)

static string_rep(n)

static tag(_)

class transit.write_handlers.BigIntHandler

Bases: object

static rep(n)

static string_rep(n)

static tag(_)

class transit.write_handlers.BooleanHandler

Bases: object

static rep(b)

static string_rep(b)

static tag(_)

class transit.write_handlers.DateTimeHandler

Bases: object

epoch = datetime.datetime(1970, 1, 1, 0, 0, tzinfo=tzutc())

static rep(d)

static string_rep(d)

static tag(_)

static verbose_handler()

class transit.write_handlers.FloatHandler

Bases: object

static rep(f)

static string_rep(f)

static tag(f)

class transit.write_handlers.IntHandler

Bases: object

static rep(i)

static string_rep(i)

static tag(i)

class transit.write_handlers.KeywordHandler

Bases: object

static rep(k)

static string_rep(k)

static tag(k)

class transit.write_handlers.LinkHandler

Bases: object

static rep(l)

static string_rep(_)

static tag(_)

class transit.write_handlers.MapHandler

Bases: object

static rep(m)

static string_rep(m)

static tag(m)

class transit.write_handlers.NoneHandler

Bases: object

static rep(_)

static string_rep(n)

static tag(_)

class transit.write_handlers.SetHandler

Bases: object

static rep(s)

static string_rep(_)

static tag(_)

class transit.write_handlers.StringHandler

Bases: object

static rep(s)

static string_rep(s)

static tag(s)

class transit.write_handlers.SymbolHandler

Bases: object

static rep(s)

static string_rep(s)

static tag(s)

class transit.write_handlers.TaggedMap(tag, rep, str)

Bases: object

rep()

string_rep()

tag()

class transit.write_handlers.TaggedValueHandler

Bases: object

static rep(tv)

static string_rep(_)

static tag(tv)

class transit.write_handlers.UriHandler

Bases: object

static rep(u)

static string_rep(u)

static tag(_)

class transit.write_handlers.UuidHandler

Bases: object

static rep(u)

static string_rep(u)

static tag(_)

class transit.write_handlers.VerboseDateTimeHandler

Bases: object

static rep(d)

static string_rep(d)

static tag(_)

class transit.write_handlers.WriteHandler

Bases: transit.class_hash.ClassDict

This is the master handler for encoding/writing Python data into Transit data, based on its type. The Handler itself is a dispatch map, that resolves on full type/object inheritance.

These handlers can be overriden during the creation of a Transit Writer.

transit.writer module

class transit.writer.JsonMarshaler(io, opts={})

Bases: transit.writer.Marshaler

The Marshaler tailor to JSON. To use this Marshaler, specify the ‘json’ protocol when creating a Writer.

JSON_MAX_INT = 9007199254740991

JSON_MIN_INT = -9007199254740991

default_opts = {'min_int': -9007199254740991, 'max_int': 9007199254740991, 'prefer_strings': True}

emit_array_end()

emit_array_start(size)

emit_map(m, _, cache)

Emits array as per default JSON spec.

emit_map_end()

emit_map_start(size)

emit_object(obj, as_map_key=False)

pop_level()

push_level()

push_map()

write_sep()

class transit.writer.Marshaler(opts={})

Bases: object

The base Marshaler from which all Marshalers inherit.

The Marshaler specifies how to emit Transit data given encodeable Python objects. The end of this process is specialized by other Marshalers to covert the final result into an on-the-wire payload (JSON or MsgPack).

are_stringable_keys(m)

Test whether the keys within a map are stringable - a simple map, that can be optimized and whose keys can be cached

dispatch_map(rep, as_map_key, cache)

Used to determine and dipatch the writing of a map - a simple map with strings as keys, or a complex map, whose keys are also compound types.

emit_array(a, _, cache)

emit_boolean(b, as_map_key, cache)

emit_cmap(m, _, cache)

emit_double(d, as_map_key, cache)

emit_encoded(tag, handler, obj, as_map_key, cache)

emit_int(tag, i, as_map_key, cache)

emit_map(m, _, cache)

emit_nil(_, as_map_key, cache)

emit_string(prefix, tag, string, as_map_key, cache)

emit_tagged(tag, rep, cache)

marshal(obj, as_map_key, cache)

Marshal an individual obj, potentially as part of another container object (like a list/dictionary/etc). Specify if this object is a key to a map/dict, and pass in the current cache being used. This method should only be called by a top-level marshalling call and should not be considered an entry-point for integration.

marshal_top(obj, cache=None)

Given a complete object that needs to be marshaled into Transit data, and optionally a cache, dispatch accordingly, and flush the data directly into the IO stream.

register(obj_type, handler_class)

Register custom converters for object types present in your application. This allows you to extend Transit to encode new types. You must specify the obj type to be encoded, and the handler class that should be used by this marshaller.

class transit.writer.MsgPackMarshaler(io, opts={})

Bases: transit.writer.Marshaler

The Marshaler tailor to MsgPack. To use this Marshaler, specify the ‘msgpack’ protocol when creating a Writer.

MSGPACK_MAX_INT = 9223372036854775807L

MSGPACK_MIN_INT = -9223372036854775808L

default_opts = {'min_int': -9223372036854775808L, 'max_int': 9223372036854775807L, 'prefer_strings': False}

emit_array_end()

emit_array_start(size)

emit_map_end()

emit_map_start(size)

emit_object(obj, as_map_key=False)

flush()

class transit.writer.VerboseJsonMarshaler(io, opts={})

Bases: transit.writer.VerboseSettings, transit.writer.JsonMarshaler

JsonMarshaler class with VerboseSettings mixin.

class transit.writer.VerboseSettings

Bases: object

Mixin for JsonMarshaler that adds support for Verbose output/input. Verbosity is only suggest for debuging/inspecting purposes.

emit_map(m, _, cache)

emit_string(prefix, tag, string, as_map_key, cache)

emit_tagged(tag, rep, cache)

class transit.writer.Writer(io, protocol='json', opts={'cache_enabled': True})

Bases: object

The top-level object for writing out Python objects and converting them to Transit data. During initialization, you must specify the protocol used for marshalling the data- json or msgpack. You must also specify the io source used for writing (a file descriptor). You may optionally pass in an options dictionary that will be forwarded onto the Marshaler. The cache is enabled by default.

register(obj_type, handler_class)

Register custom converters for object types present in your application. This allows you to extend Transit to encode new types. You must specify the obj type to be encoded, and the handler class that should be used by the Marshaler during write-time.

write(obj)

Given a Python object, marshal it into Transit data and write it to the ‘io’ source.

transit.writer.escape(s)

transit.writer.flatten_map(m)

Expand a dictionary’s items into a flat list

transit.writer.is_escapable(value)

transit.writer.re_fn(pat)

Module contents