{ "info": { "author": "Ian Ogilvy", "author_email": "ian.ogilvy@saltmobile.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.2", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Utilities" ], "description": ".. ObjDict documentation master README file.\n\n=======\nObjDict\n=======\n\nUses_\n-----\n\nWhy 'objdict'? The reasons include:\n\n - All tools and Classes for simple and relable JSON for objects\n - `ObjDict: The ad-hoc structure/object 'swiss army knife' class`_.\n - `Struct: the leaner specialized object`_.\n - `OEnum: Base class for Enums with JSON send/recieve`_.\n - `Support for JSON message encoding and decoding`_.\n - `ObjDict in place of dictionaries as convenient ad-hoc data structures`_.\n - `Mutable equivalent to nametuple (or namedlist)`_.\n - `Adding JSON serialization to classes`_.\n - `OrderedDict alternative`_.\n\nBackground_\n-----------\n\n - `History and acknowledgements`_.\n - `JsonWeb alternative to ObjDict JSON processing`_.\n - `Multiple uses of dictionaries`_.\n - `Introducing the ObjDict`_.\n - `Multiple modes of dictionary use and JSON`_.\n - `ObjDict JSON general`_.\n - `ObjDict JSON load tools`_.\n - `ObjDict JSON dump tools`_.\n\nInstructions_\n-------------\n\n - `General notes and restrictions`_.\n - `Initialisation and JSON load`_.\n - `'str' and JSON dumps`_.\n - `Custom classes and JSON`_.\n - `Maintaining order with custom classes and defaults`_.\n\n_`Uses`\n-------\n\nObjDict: The ad-hoc structure/object 'swiss army knife' class\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\nAs described in this 'uses' section, the ObjDict class has many uses, and can\nbe used in place of :code:`namedtuples`, :code:`namedlists`, :code:`OrderedDict` objects, as\nwell as for processing JSON data. One single import gives this flexibility.\n\nThe one trade-off for this flexibility, compared to using the individual specialised\nclasses is performance. If you have performance critical code that is used in\nmassively iterative loops then, for example, namedtuples are far better, as long as\nnamedtuples provide all the functionality you require. But every last nanosecond\nis not of the essence and flexibility to adapt and simply code is desired, then\n'ObjDict' can be a replacement for several other classes, plus provide best tools\nfor working with JSON data.\n\nStruct: the leaner specialized object\n+++++++++++++++++++++++++++++++++++++\nA swiss army nife does everything, but sometimes a special purpose device \nis more elegant. The 'Struct' class provides the leaner, more elegant solution\nfor creating your own classes. ObjDict is perfect for decoding Json objects which\nmay be collections or maybe objects, but Struct is designed for building your own\nobject classes. A :code:`__json__` method is provided, as well as useful 'str' and 'repr'\ndefault methods. The json default method provides easy overrides, passing the \ndefault method a dictionary of the data to be included in json::\n\n def __json__(self, **kwargs):\n return super().__json__(, **kwargs)\n\n\nOEnum: Base class for Enums with JSON send/recieve\n++++++++++++++++++++++++++++++++++++++++++++++++++\nUsing the OEnum from this package, in place of Enum from enum package, adds\nJSON encoding and decoding to Enumerated data. Same as 'Enum', but codes to\nJSON and decodes back the the original type. Example::\n\n @objdict.from_json() #decorated require for decoding direct from json\n class MyEnum(objdict.OEnum):\n first = 1\n second = 2\n third = 3\n\n place = MyEnum(1)\n jsondata = { 'place': place }\n # as json '{ \"place\": { \"__type__\", \"MyEnum\", \"n\": \"first\"}}'\n\nNote, \"MyEnum\" will decode direct value from 'n' key (by name) or 'v' key\nby value.\n\n\n\nSupport for JSON message encoding and decoding\n++++++++++++++++++++++++++++++++++++++++++++++\n\nWhere an application has the need to build JSON data to save or transmit, or\nto decode and process JSON data loaded or received, the ObjDict structure provides all\nthe tools to achieve this, with clear object oriented code. This usage has different\nrequirements than JSON serialisation (as discussed below), as it is necessary\nto be able to produce not just a JSON representation of an object, but create\nobjects that can describe any required possible\narbitrary JSON data to produce or decode specific messages.\nFor example, the order of fields may be significant in a\nJSON message, although field order may not be significant for object\nserialisation. The ObjDict class has\nthe tools to produce exactly the JSON data required by any application, and to decode\nany possible incoming JSON messages for processing. It was for this usage that\nObjDict was initially developed.\n\nObjDict in place of dictionaries as convenient ad-hoc data structures\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\nSee the text below on 'multiple uses of dictionaries' for background.\nThere is a significant amount of code where dictionaries have been used for\nad-hoc structures. The use case often arises where it can become useful if\nthese data structure can have elements accessed in the simpler are many.\n\nMutable equivalent to nametuple (or namedlist)\n++++++++++++++++++++++++++++++++++++++++++++++\n\nThere are occasions where a 'namedtuple' cannot be used due to the need for\nmutable objects. The ObjDict also fulfills this need and can be initialised\nfrom list data. There are many other classes that also fill this need, but\nthe ObjDict combines this functionality with JSON processing, with dictionary\naccess to data and other functions.\n\nAdding JSON serialization to classes\n++++++++++++++++++++++++++++++++++++\n\nApplications that have a need to serialise objects in order to restore those\nobjects either within the same application, or in an application connected\nthrough a data-link, may desire JSON as the format for object storage or object\nmessage format. The ObjDict class and module provides the tools for this,\nserialising the state of an object in order for that state to be later\nloaded, either by an identical class, or a different class which has use\nfor some or all of the same 'object state' information.\n\nOrderedDict alternative\n+++++++++++++++++++++++\n\nOrderedDicts do everything dictionaries can, and in some applications it can\nbe useful to simply move to OrderedDict classes for all dictionaries. 'ObjDict'\nis another alternative, with a shorter name, even more flexibility and power,\nand a much more readable 'str' representation that can also be used for clearer\ninitialisation. See instructions for details on 'str' and initialisation\nflexibility.\n\n\n_`Background`\n-------------\n - `History and acknowledgements`_.\n - `JsonWeb alternative to ObjDict JSON processing`_.\n - `Multiple uses of dictionaries`_.\n - `Introducing the ObjDict`_.\n - `Multiple modes of dictionary use and JSON`_.\n - `ObjDict JSON general`_.\n - `ObjDict JSON load tools`_.\n - `ObjDict JSON dump tools`_.\n\nHistory and acknowledgements\n++++++++++++++++++++++++++++\n\nThe project emerged from a need for code to generate and decode JSON\nmessages. Originally the package `JsonWeb `_ was\nselected for the task, but it became clear the use case differed. 'JsonWeb' is\nideal for representing classes as JSON, and reloading classes from that JSON\nand provides validation and tests and schema that are not reproduced in ObjDict.\nHowever ObjDict provides specifically for classes created to generate or process\nJSON as data, as\nopposed to JSON as a representation of the class, and now the ObjDict and Struct\nclasses, with a wider range of uses. The whole issue of JSON data which ambiguously\nmay correspond to either a dictionary collection, or an object, arises from\ngeneral processing of JSON data and gives rise to the ObjDict. The ObjDict\nproject started out to add more control\nover JSON as a fork of JsonWeb, but evolved over time to the different use cases.\n\nA key result of the different use case is the JsonWeb focuses strongly on validation\nthat the JSON code exactly matches requirements, where as ObjDict takes the opposite\napproach of specially being designed to allow for communication between software \nsystems where one end of the link may be upgraded prior to the other end of the link,\nwhich requires JSON messages designed to permitt data from future message formats \nwithout generating errors. An 'upgrade tolerant' system.\n\nJsonWeb alternative to ObjDict JSON processing\n++++++++++++++++++++++++++++++++++++++++++++++\n\nThe project 'JsonWeb' overlaps is use cases with this project. The focus of\n'JsonWeb' is to provide for serializing python object structures and instancing\npython objects from the serialized form. ObjDict can be used for this role also,\nbut currently lacks the validation logic used by 'JsonWeb' to ensure JSON data\nmatches exactly the required format.\n\nIn fact, rather than an emphasis on validation, the original primary use case of\nObjDict is to allow maximum flexibility\nfor the JSON data representing an object. The ObjDict object itself is a generic\nobject to enable working with JSON data without having a matching object definition.\nBeyond the ObjDict\nclass, the entire ObjDict-JSON processing philosophy is to provide for\ninformation sent between\ncomputer systems with flexible, adaptable message handling.\nWhere, for example, the message specification may evolve from version to\nversion. This requires flexible interpretation of data, and the ability to\neasily ignore additional data that may have been added in later versions,\nproviding easy backward compatibility.\n\nThe structure for JSON dump and load is a very flexible framework, and any feature\nincluding more rigid validation could easily be added.\n\nMultiple uses of dictionaries\n+++++++++++++++++++++++++++++\n\nIn python, dictionaries are designed as 'collections' but are often used as\nad-hoc structures or objects. In a true collection, the key for an entry does\nnot indicate properties\nof the value associated with the key. For example, a collection of people,\nkeyed by names\nwould not normally infer the significance or type of data for each entry\n(or in this case person) by the key. The data has the same implications regardless\nof whether the key is 'bob' or 'jane'. The data associated with 'bob' or 'jane'\nis of the same type and is interpreted the same way.\nFor an 'ad-hoc' structure the keys **do** signal both the nature of the data and\neven the type of data.\nConsider for each entry for a person we have a full name and age.\nA dictionary could be used to hold this information, but this time it is an\nad-hoc structure. As a dictionary we always expect the same two keys, and each\nis specific to the information and different keys even have different types of data.\nThis is not a dictionary as a collection, but as an ad-hoc structure. These are two\nvery different uses of a dictionary, the collection the dictionary was designed for,\nand the ad-hoc structure or ad-hoc object as a second use.\n\nIntroducing the ObjDict\n+++++++++++++++++++++++\n\nAn ObjDict is a subclass of dictionary designed to support this second\n'ad-hoc object' mode of use. An ObjDict supports all normal dict operations, but\nadds support for accessing and setting entries as attributes.\n\nSo::\n\n bob['full_name'] = 'Robert Roberts'\n\nis equivalent to::\n\n bob.full_name = 'Robert Roberts'\n\nEither form can be used. ObjDicts also have further uses.\n\nMultiple modes of dictionary use and JSON\n+++++++++++++++++++++++++++++++++++++++++\n\nThe standard JSON dump and load map JSON 'objects' to python dictionaries.\nJSON objects even look like python dictionaries (using {}\nbraces and a ':'). In JavaScript, objects can also\nbe treated similarly to dictionaries in python. The reality is some JSON\nobjects are best represented in python as objects, yet others are best\nrepresented as dictionaries.\n\nConsider::\n\n { \"name\": {\"first\": \"fred\", \"last\": \"blogs\" }\n \"colour_codes\": {\"red\": 100, \"green\": 010, \"yellow\": 110, \"white\": 111 }\n }\n\nIn this data, the 'name' is really an object but 'color_codes' is a\ntrue dictionary. Name is not a true dictionary because it is not a collection\nof similar objects, but rather something with two specific properties.\nIterating through name does not really make sense, however iterating through\nour colours does make sense. Adding to the collection of colours and their\nbeing a variable number of colours in the collection is all consistent.\nTreating 'name' is not ideal as the 'keys' rather than being entries in a collections\neach have specific meaning. Keys should not really have meaning, and these keys\nare really 'attributes' of name, and name better represented as an object.\n\nSo two types of information are represented in the same way in JSON.\n\nAnother limitation of working with python dictionaries and JSON is that in messages,\norder can be significant but dictionaries are not ordered.\n\nThe solution provided here is to map JSON 'objects' to a new python ObjDict\n(Object Dictionaries). These act like OrderedDictionaries, but can also be treated\nas python objects.\n\nSo 'dump' or '__JSON__()' or 'str()' / '__str__()' of the 'names' and\n'colour_codes' example above produces an\nouter ObjDict containing two inner 'ObjDict's, 'name' and 'colour_codes'.\nAssume the outer ObjDict is assigned to a variable called 'data'.\nEach ObjDict can be treated as either an object or a dictionary, so all the code\nbelow is valid::\n\n data = ObjDict(string_from_above)\n name = data['name'] # works, but as 'data' is not a real 'dict' not ideal\n name = data.name # better\n first_name = data.name.first\n first_name = data[\"name\"][\"first\"] # works but again not ideal\n\n red_code = data.colour_codes[\"red\"]\n # as colour codes is a true collection it will be unlikely to set\n # members to individual variables, but the code is valid\n\nObjDict items also 'str' or 'dump' back to the original JSON as above.\nHowever if the original string was changed to::\n\n { \"name\": {\"first\": \"fred\", \"last\": \"blogs\", \"__type__\": \"Name\" }\n \"colour_codes\":{\"red\": 100, \"green\": 010, \"yellow\": 110, \"white\": 111 }\n }\n\nThe JSON 'load' used to load or initialise ObjDict uses an 'object_pairs_hook'\nthat checks a table of registered class names and corresponding classes.\n\nIf there is an entry in the table, then that class will be used for embedded objects.\nEntries with no :code:`__type__` result in ObjDict objects, and if the 'DefaultType' is\nset then a class derived from the default type, with the name from the value\nof '__type__' will be returned. If 'DefaultType' is None, then an exception will\nbe generated.\n\nSee the instructions section for further information.\n\nObjDict JSON general\n++++++++++++++++++++\n\nThe tools provided allow for dumping any class to JSON, and loading any class\nfrom JSON data. There is no requirement for the basing classes on the ObjDict\nclass. The main use of ObjDict is to decode JSON data which is **NOT** already\nidentified as matching a class within the application. The ObjDict provides the\ncatchall.\n\nThe main challenge is not the specific class being loaded or dumped, but the\nobjects **within** that class.\n\nConsider loading an object properties from JSON. A simple loop to use each JSON field\nto set each attribute, and the class to be set is simply one class. However, what if\nsome of those fields are themselves objects, and possibly fields within those\nagain objects? Within the single 'top-level' object, there may be many embedded\nobjects and identifying and processing these embedded objects is the actual challenge.\n\nIn general, handling embedded objects is achieved through the '__from_JSON__' class method\nwithin each class for the 'JSON.load', or the '__JSON__' method within each\nobject for the 'JSON.dump'.\n\nStandard routines to perform these methods are available, together with the tools\nto easily decorate classes and other utilities.\n\nObjDict JSON load tools\n+++++++++++++++++++++++\n\nThe three main tools for loading JSON objects are an 'object_pairs_hook' method to\nbe passed to the standard 'JSON.load' function, the '__from_JSON__' class method that\ncan be added to any class to control instancing the class from JSON and\nthe 'from_JSON' decorator.\n\nThe philosophy is the use of simple, flexible building blocks.\n\n:code:`object_pairs_hook`\n~~~~~~~~~~~~~~~~~~~~~~~~~\nA class within the objdict module, 'ObjPairHook', is a wrapper tool to provide\na function for the standard library JSON.load() function. Simply instance an ObjPairHook\nand pass the 'from_JSON' method to JSON_load(). eg::\n\n hook=ObjPairHook().from_JSON\n JSON.load(object_pairs_hook=hook)\n\n class ObjPairsHook()\n def __init__(classes_list=[],BaseHook=None,BaseType=None):\n\n\nThe 'from_JSON' method will check all JSON objects for a '__type__' entry, or use\n'default' processing. For objects with a '__type__', both the entries in the\n'classes_list' parameter and the default_classes_list maintained within\nthe objdict module and added to through\nthe 'from_JSON' decorator, can be instanced if there is a name match.\n\nFor objects with '__type__' entries but no name match with either source of classes\nthen the a dynamic class based on 'BaseClass' is generated and selected as the 'class'.\n\nFor objects with no '__type__' entry, then the 'BaseHook' is selected as the\n'class' (although in practice is it also\npossible to use a method rather than a class).\n\nOnce a class is selected, then if this class has a '__from_JSON__' attribute, then\nthis class method is called to instance an object, otherwise the normal init method\nfor the class is called.\n\n:code:`__from_JSON__` class method\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nProviding a '__from_JSON__' class method is called to instance an the object\nby the 'object_pairs_hook' if an attribute of this name is present.\n\n:code:`from_JSON` decorator\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe from_JSON decorator, when used to decorate a class, adds the class to\ndefault_class list used by the object_pairs_hook.\n\nObjDict JSON dump tools\n+++++++++++++++++++++++\n\nThe '__JSON__' method, JSONEncoder class, the :code:`@to_JSON` decorator and the\nJSON_registry of to_JSON converters are the main\ntools for encoding JSON. Whereas JsonWeb takes an approach of decorating classes\nwith configuration information to allow the encoder class to produce the JSON\noutput, ObjDict uses a JSONEncoder that delegates the encoding to '__JSON__'\nmethod within each object, or from a table of class/converter pairs.\n\nJSONEncoder class\n~~~~~~~~~~~~~~~~~\n\nThe JSON_encoder class does the actual encoding, and for each object it first\nchecks for a '__JSON__' method and class that method if present. For objects\ndefined outside of scope e.g. Decimal(), the encoder checks the encoder_table\nfor a matching entry and if present calls that encoder.\n\n:code:`to_JSON` decorator\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis decorator checks if the class has a '__JSON__' method, and if not, decorates\nthe class with a default '__JSON__' method. The '__JSON__' method itself is then\ndecorated with any configuration data.\n\n:code:`__JSON__` method\n~~~~~~~~~~~~~~~~~~~~~~~\n\nFor any object this is either a function or a bound method to be called with\nthe object to be encoded as a parameter. The method should return either a\nstring or a dictionary to be included included in the JSON output.\n\nJSON_registry\n~~~~~~~~~~~~~\n\nThis is an object which can be imported from the objdict module to access the\n'add_to' method (:code:`JSON_registry.add_to(,`). By default, the\ntable contains entries for Decimal, datetime.datetime and datetime.time.\nAny entry can be overwritten by simply adding new values for the same class.\n\n\n_`Instructions`\n---------------\n - `General notes and restrictions`_.\n - `Initialisation and JSON load`_.\n - `'str' and JSON dumps`_.\n - `Custom classes and JSON`_.\n - `Maintaining order with custom classes and defaults`_.\n\n\nGeneral notes and restrictions\n++++++++++++++++++++++++++++++\n\nSince valid keys for an ObjDict may not necessarily be valid attribute names (for example an\ninteger can be a dictionary key but not an attribute name, and dictionary keys\ncan contain spaces), not all\nkey entries can be accessed as attributes. Similarly, there are attributes\nwhich are not considered to be key data, and these attributes have an underscore\npreceding the name. Some attributes are part of the scaffolding of the ObjDict\nclass and these all have a leading underscore, as well as a trailing underscore.\nIt is recommended to use a leading underscore for all class 'scaffolding' added as\nextensions to the ObjDict class or to derived classes, where this scaffolding\nis not to be included as also dictionary data.\n\n\nInitialisation and JSON load\n++++++++++++++++++++++++++++\n\nObjDict can be initialised from lists, from JSON strings, from dictionaries,\nfrom parameter lists or from keyword parameter lists. Struct also provides \nintialisation from lists (with __keys__ or from keyword parameter lists.\n\nExamples::\n\n a = ObjDict('{\"a\": 1, \"b\": 2}')\n\n class XYZ(ObjDict):\n __keys__ = 'x y z'\n\n xyz = XYZ(10,20,30)\n xyz.y == 20\n\nInitialisation from lists or parameter lists\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nInitialisation from a list of key value pairs, as with OrderedDict class is\nsupported. Beyond key value pairs, there is also support for direct initialisation\nfrom lists. The '_keys__' parameter must be included for initialisation from lists.\nAlso, Classes\nderived from ObjDict or Struct can have '_keys__' as a class attribute, providing a similar\nuse pattern to the 'namedtuple'. '_keys__' can be either\na list of strings, or a string with space or comma separated values. When\ninitialising from a list or parameter list, the list size must match the number\nof keys created through '_keys__', however other items can be added after\ninitialisation.\n\nSo this code produces True::\n\n class XY(ObjDict):\n __keys__ = 'x y'\n\n sample = XY(1, 3)\n sample.x, sample.y == 1, 3\n\n\n class XYS(Struct):\n __keys__ = 'x y'\n\n sample2 = XYS(1, 3)\n sample2.x, sample2.y == 1, 3\n\nAlternatively the form to produce a similar result but with the SubClass would be::\n\n sample = ObjDict(1, 3, __keys__='x y')\n sample = Struct(1, 3 ,__keys__='x y')\n\nInitialisation from JSON strings\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor more complex initialisation, JSON strings can provide an ideal solution.\nThis allows for complex structures with nested/embedded 'ObjDict' or other objects.\n\nNote that initialising from either dictionaries or keyword parameters will result\nin the order being lost.\n\nFor example::\n\n >>> ObjDict(a=1, b=2, c=3)\n {\"c\": 3, \"b\": 2, \"a\": 1}\n\n >>> ObjDict({\"a\": 1, \"b\": 2, \"c\": 3})\n {\"a\": 1, \"b\": 2, \"c\": 3}\n\nSo initialisation from a JSON string is useful if key order is important.\n\nInitialisation from dict, OrderedDict, or key word arguments\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nAs discussed already, initialisation from dict or key word arguments will\nnot maintain order of keys, but if order is not important, such as when the data\nhas already been inserted into a dictionary.\n\n'str' and JSON dumps\n++++++++++++++++++++\n\nA limitation with OrderDict objects is that 'str' representation can be clumsy\nwhen the structure is nested.\n\nThe '__str__' method of ObjDict class calls the '__JSON__' method. '__str__' can\nbe overridden without disturbing the '__JSON__' method. To convert an ObjDict\nto JSON, simply call either of these methods.\n\nJsonEncoder and objdict.dumps\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor working with ObjDict objects or other objects using 'json.dumps' the\nobjdict module provides a 'JsonEncoder' object to use as a parameter to\n'json.dumps', and an alternative 'dumps' with the encoder as a default\nparameter::\n\n import json\n from objdict import JsonEncoder\n\n json.dumps(, cls=JsonEncoder)\n\n or\n\n import objDict\n\n objdict.dumps()\n\nAdditional Uses for the Encoder\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nSimple decorate other classes with the 'to_json' decorator and these will also\nthen encode using their __json__ method.\n\nAlso other classes, including classes already defined without a __json__\nmethod can register together with an appropriate method of function to produce\njson from those objects.\n\nCustom classes and JSON\n+++++++++++++++++++++++\n\nCustom classes allow for JSON data to result in instantiating objects other\nthan ObjDict from JSON data. These custom classes can be sub-classed from ObjDict\nor built simply using the :code:`@to_JSON()` and/or :code:`@from_JSON()` decorators.\n\nSub-classing ObjDict\n~~~~~~~~~~~~~~~~~~~~\n\nIf sub-classing from ObjDict, then your class should not need to be decorated\nwith either of the from/to decorators. Such class will make use of code in\nthe standard __init__ method of ObjDict and standard ObjDict json\nencoding/decoding method.\n\nThe reality is that ObjDict is best subclasses by JSON decode presented with classes \nthat are not declared, so it is not known if a collection or object is best.\n\nClasses created with JSON representation as a criteria are recommended to be based \non Struct, rather than ObjDict.\n\nNote that if subclassing objdict and defining an __init__ method, or adding\nspecialised instancing from json, then some steps are needed.\n\nThe ObjDict init method allows for an OrderedDictionary first parameter\nto effectively provide a set of key word values for the class. Either simply\ntest for first parameter being and ordered dictionary and bypass other intialisation\nor have custon initialisation::\n\n class MyClass(ObjDict):\n def __init__(a,b,c):\n if isinstance(a,dict):\n #instancing from json\n super().__init__(a)\n else:\n #regular init\n self.a = a\n self.b = b\n self.c = c\n\n # alternate code\n @from_json()\n class MyClass(ObjDict):\n def __init__(a,b,c):\n self.a = a\n self.b = b\n self.c = c\n\n @classmethod\n def __from_json__(cls,odict):\n return cls(odict.pop('a'),odict.pop('b'),odict.pop('c'))\n\n\nJSON.dumps from decorators\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe alternative to subclassing ObjDict avoids inheriting other properties of\nObjDict which may not be relevant to the application. The :code:`@to_JSON` decorator\ndecorates a class with a '__JSON__' method, and if JSON.dumps() is called as follows::\n\n from objdict import JSONEncoder\n import JSON\n\n JSON.dumps(my_object, cls = JSONEncoder)\n\nAlternate method using objdict.dumps::\n\n import objdict\n\n objdict.dumps(my_object)\n\nThen all decorated classes will be encoded using their '__JSON__' method, in\naddition to any classes in the JSON_registry.\n\nJSONEncoder and JSON_registry\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe JSONEncoder encodes all classes added to the JSON_registry, as well\nas any class with a '__JSON__' method. Classes such as datetime.date or\ndecimal.Decimal are standard library classes and it may not be convenient to\nsub-class these to have a '__JSON__' method. For these cases, calling the\nadd_to method of the JSON_registry allows adding these objects to be encoded.\n\nFor example::\n\n from objdict import JSON_registry\n\n JSON_registry.add_to(datetime.date, str)\n\nThis will ensure JSONEncoder will use the 'str' function to encode dates.\n\njson.loads from decorators\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe :code:`@from_json()` decorator adds the class to the class register internal to the\nobjdict module, to then be used by the 'object_hook_pair' function provided\nas a parameter to the json.loads function.\n\nEither call json.loads with the object_hook_pair= or use the objdict.loads\nfunction as follows::\n\n import json\n from objdict import make_pairs_hook, ObjDict\n\n classes = # use 'None' for default\n obj = json.loads(,\n object_hook_pairs=make_pairs_hook(classes,ObjDict,ObjDict)\n )\n\n # or alternate method\n import objdict\n\n obj = objdict.loads()\n\nfrom_json decorator\n~~~~~~~~~~~~~~~~~~~~\nThe from_json(type_name=None,use=None) can be supplied with a alternate name\nif desired to overide the class name for __type__ entries in the json text,\nplus a 'use ' setting which applies for cases where no '__from_json__ class\nmethod is present. The 'use' setting can specify a fuction to instantiate\nobjects. The method must take two parameters, a class, and an orderdictionary\nof values.\n\nAlternately, 'use' as None, will simply instantiate a class from the __init__\nmethod and supply all values from the json text as keyword arguments.\n\nSetting 'use' to True, will also use the __init__ method of the class, but\nsupply the data from json in a single OrderedDict parameter.\n\nAs follows::\n\n json_text = '{\"a\":1,\"b\":2,\"c\":3}'\n @from_json()\n class Test:\n def __init__(self,a=None,b=None,c=None,**kwargs):\n # note: if kwargs is not present, than any additional\n # fields in the json will create an exception\n self.a=a\n self.b=b\n self.c=c\n\n @from_json(use=True)\n class Test:\n def __init__(self,a,b=None,c=None):\n # if called from json, then all data will be in a dictionary a\n #parameter - then will preserve json data order\n if isinstance(a,dict):\n self.parms=a\n self.a = a.get('a')\n self.b = a.get('b')\n self.c = a.get('c')\n else:\n self.a = a\n self.b = b\n self.c = c\n\n\nObjPairHook().decode()\n~~~~~~~~~~~~~~~~~~~~~~\n\nTo call json.loads, instance an ObjPairHook object and then pass the decode\nmethod of that object to json.loads.\n\nThe decode method will, for all classes in the load_class_register, check if\nthe class has a '__from_JSON__' class method, and if present, call the '__from_JSON__'\nclass method will be called to instance an object from the set of key, value pairs.\n\nFor example, if you have::\n\n { \"name\":{\n \"first\": \"joe\",\n \"last\": \"foo\"\n }\n }\n\n # now code\n @objdict.from_JSON()\n class Name:\n def __init__(self, first=None, last=None, **kwargs):\n self.first = first\n self.last = last\n\n\nRead with::\n\n loads(string)\n\nthen convert the name\ndictionary into an object and put that object back in the original tree::\n\n tree = combiParse(string)\n tree['name'] = Name(**tree['name']) # kwargs!!! i.e. \"**\" required :-)\n\nThe result would be 'unParsed' ::\n\n { \"name\":{\n __type__: \"Name\"\n \"first\": \"joe\",\n \"last\": \"foo\"\n }\n }\n\n\nDecoding automatically to objects can then be added at a later time.\n\nMaintaining order with custom classes and defaults\n++++++++++++++++++++++++++++++++++++++++++++++++++\n\nObjDict classes and automatically created classes currently maintain key order,\nbut of course cannot provide for default values for attributes.\n\nCustom classes can specify default values for attributes, but currently custom\nclasses do not automatically maintain order, even if based on ObjDict classes.\n\nMaintaining order and supporting default values are available with an '__init__'\nmethod. Note, the order attributes are set will be their order in a message.\nClasses sub-classed from ObjDict will have '__type__' at the end of JSON output.\n\nIf a custom class is decorated with :code:`@decode.from_object(JSONSimpleHandler)`,\nthen all fields in the raw JSON will be sent in a single dict. Of course, as\na dict order is lost and also there are no default values.\nThe recommended code for the init is something like this::\n\n @objdict.from_JSON()\n class Custom(ObjDict):\n def __init__(self, *args, **kwargs):\n super(Custom,self).__init__()\n if args:\n arg0 = args[0]\n assert len(args) == 0, \"unexpected argument\"\n self.arg1 = arg0.pop('arg1', default)\n self.arg2 = arg0.pop('arg2', default)\n ........\n self.update(arg0)\n self.update(**kwargs)\n\nLife is much simpler with :code:`@decode.from_object()`, but at the expense of ignoring\nany unexpected arguments. Currently \\*\\*kwargs will always be empty in this case\nbut a future update will likely address this.\n\nExample::\n\n @decode.from_object()\n class Custom(ObjDict):\n def __init__(self,arg1=None, arg2=None ...., **kwargs):\n super(Custom,self).__init__()\n self.arg1 = arg1\n self.arg2 = arg1\n ........\n self.update(**kwargs) # currently kwargs is empty\n\n\nAll that is needed as imports is above.\n\nThis system supports both 'ObjDict' and custom classes. In JSON representation\na '__type__' field is used to indicate actual type. For your own classes use::\n\n @encode.to_object()\n @decode.from_object()\n class Sample:\n def __init(self, p1, p2, ...):\n self.p1 = p1\n self.p2 = p2\n ....\n\nto map between::\n\n { \"p1\": 1, \"p2\": 2, \"__type__\": \"Sample\"}\n\nand::\n\n Sample(1,2)\n\nHowever simple examples such as this could also use the default 'ObjDict' objects.\n\n\n", "description_content_type": null, "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://bitbucket.org/objdict/objdict", "keywords": "object dictionary tuples namedtuples namedlists JSON custom classes", "license": "LGPL", "maintainer": "", "maintainer_email": "", "name": "objdict", "package_url": "https://pypi.org/project/objdict/", "platform": "", "project_url": "https://pypi.org/project/objdict/", "project_urls": { "Homepage": "https://bitbucket.org/objdict/objdict" }, "release_url": "https://pypi.org/project/objdict/0.4.4/", "requires_dist": null, "requires_python": "", "summary": "The ObjDict class has many uses including: as a tool for processing and generating json information, for ad-hoc classes and mutable named tuples, or just as dictionaries that allow dot notation access.", "version": "0.4.4" }, "last_serial": 3139260, "releases": { "0.1.0.dev1": [ { "comment_text": "", "digests": { "md5": "f92f9a299e07a4682a525c6f8787cb76", "sha256": "364db42e52a4b4639feb5c7df85b11ca1e3cbdc1ae0bab5c6fa9336070c0be8c" }, "downloads": -1, "filename": "objdict-0.1.0.dev1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "f92f9a299e07a4682a525c6f8787cb76", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 33085, "upload_time": "2016-09-08T04:11:42", "url": "https://files.pythonhosted.org/packages/4d/21/6c7ad5b63c012196e163cf2da839d3d2894db5ae1c1d522c46dcd300b5c4/objdict-0.1.0.dev1-py2.py3-none-any.whl" } ], "0.1.0b1": [ { "comment_text": "", "digests": { "md5": "9da29f47163662965940af79aa93c1db", "sha256": "992a4c008ea60655f0f8f165dad381a028f67b433f9a04feacb4d5c2efcc6e95" }, "downloads": -1, "filename": "objdict-0.1.0b1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "9da29f47163662965940af79aa93c1db", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37013, "upload_time": "2016-09-09T05:05:18", "url": "https://files.pythonhosted.org/packages/85/20/decfa43b462e61121be93b7f74af8d1cac5900239d9ed2ad901921ffea4f/objdict-0.1.0b1-py2.py3-none-any.whl" } ], "0.1.0b2": [ { "comment_text": "", "digests": { "md5": "8e7ea7883b977468a1d93a89678d50a8", "sha256": "fbc1d298cfd9a228bd58556fe2f9c1a677ee6fac8ca9fa84ee93398cd6af98b1" }, "downloads": -1, "filename": "objdict-0.1.0b2-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "8e7ea7883b977468a1d93a89678d50a8", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 36961, "upload_time": "2016-09-09T05:15:11", "url": "https://files.pythonhosted.org/packages/1f/25/5d8f5726edeaebd3ba4b7009f359b0de3fb44eb83673aeb5b61ae337eab4/objdict-0.1.0b2-py2.py3-none-any.whl" } ], "0.1.0b3": [ { "comment_text": "", "digests": { "md5": "2141009530317ac06621090650d9f202", "sha256": "b213158232ae9b7174775510cead1d13e1bc1976e8160ed1373a01dded8445f9" }, "downloads": -1, "filename": "objdict-0.1.0b3-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "2141009530317ac06621090650d9f202", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37076, "upload_time": "2016-09-09T05:27:30", "url": "https://files.pythonhosted.org/packages/6e/72/568421e495cd9ac53d282ccdf811b34c504d8236b5b2329ba1232393c822/objdict-0.1.0b3-py2.py3-none-any.whl" } ], "0.1.0b4": [ { "comment_text": "", "digests": { "md5": "83ea598d7f41f5c163d8cabe135f7211", "sha256": "e6f945196238d72e96955c0d3ae3b06c6a90a314646f7ed24be869b7cca3fc31" }, "downloads": -1, "filename": "objdict-0.1.0b4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "83ea598d7f41f5c163d8cabe135f7211", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37057, "upload_time": "2016-09-09T06:23:21", "url": "https://files.pythonhosted.org/packages/8d/97/c48141b202db637ba06346137fd60a46f9edfbe839bfb2719c208374c3b2/objdict-0.1.0b4-py2.py3-none-any.whl" } ], "0.1.0b5": [ { "comment_text": "", "digests": { "md5": "3e6136128323c44f51277e5ea91f2b49", "sha256": "1cfb34df1efd445103cd86df77928973e95c477a761d2e5ea8274540d03a7ae1" }, "downloads": -1, "filename": "objdict-0.1.0b5-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "3e6136128323c44f51277e5ea91f2b49", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37483, "upload_time": "2016-09-12T00:11:57", "url": "https://files.pythonhosted.org/packages/d6/e9/166a1add5eeb0fe2d7c076089266df822820a82328888ecfd040d4d8d5fb/objdict-0.1.0b5-py2.py3-none-any.whl" } ], "0.2.0": [ { "comment_text": "", "digests": { "md5": "c5365d72a47353fc2d815343b2a5d153", "sha256": "a54521c75c3106a48adfe8ca3687be1ed24323069e20dce9df409a92efc59be9" }, "downloads": -1, "filename": "objdict-0.2.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "c5365d72a47353fc2d815343b2a5d153", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37498, "upload_time": "2016-09-12T09:55:23", "url": "https://files.pythonhosted.org/packages/7d/0f/911e28e646efb18b9892b31f3397e53a124a4d07def0726ee43cb4c2fcff/objdict-0.2.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3e17a81fda480d09967d6d6d9822b8e3", "sha256": "70807d3e0539693b9004711b2300473db54d42701eedacafa59f45d513f88bd7" }, "downloads": -1, "filename": "objdict-0.2.0.tar.gz", "has_sig": false, "md5_digest": "3e17a81fda480d09967d6d6d9822b8e3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 34521, "upload_time": "2016-09-12T09:55:37", "url": "https://files.pythonhosted.org/packages/e6/07/8f7e62ab6d562e159deabb694e65d848eb5d57e113e88978c9cb5ffd1be6/objdict-0.2.0.tar.gz" } ], "0.2.1": [ { "comment_text": "", "digests": { "md5": "55a6f87b248e03a2aa322205100c49e5", "sha256": "a8ce3aef551d972d213c6357d5fe56cb4fecf81f0a69bd2f3833d868564cc375" }, "downloads": -1, "filename": "objdict-0.2.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "55a6f87b248e03a2aa322205100c49e5", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 27426, "upload_time": "2016-09-12T12:54:54", "url": "https://files.pythonhosted.org/packages/01/fc/059f303fa116da786790575967b8437b4f67a36191f273eb91aa660a51f2/objdict-0.2.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "1f32850c366560c2304e1b9edf1ee098", "sha256": "69a25a8fe63d9fda2db806346ea34fe3eb8e4d82202458e61c031347178a5d97" }, "downloads": -1, "filename": "objdict-0.2.1.tar.gz", "has_sig": false, "md5_digest": "1f32850c366560c2304e1b9edf1ee098", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30444, "upload_time": "2016-09-12T12:55:06", "url": "https://files.pythonhosted.org/packages/ed/ff/a9fb4ee94ec5d5d6a16b428fabb8bc7c000d7daf763dc06e8d213ad7f585/objdict-0.2.1.tar.gz" } ], "0.2.2": [ { "comment_text": "", "digests": { "md5": "bbda1aac2a3c4ffc95480e77497728f7", "sha256": "37b9319231e595fd627a336b9c2e15890ae5863f9323b77f518b20dc62aeff3a" }, "downloads": -1, "filename": "objdict-0.2.2-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "bbda1aac2a3c4ffc95480e77497728f7", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 27439, "upload_time": "2016-09-12T13:15:02", "url": "https://files.pythonhosted.org/packages/67/17/3806d229e9f649c49c624b4c50dd66bc32e0f591189931213e5abd5615ef/objdict-0.2.2-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3bb51c6a0e3e4c06c93083a06033d594", "sha256": "4d5d60c94322f1f7f7905b92db3ebb7886caf2ee0a157067eaa00ea1c43d4610" }, "downloads": -1, "filename": "objdict-0.2.2.tar.gz", "has_sig": false, "md5_digest": "3bb51c6a0e3e4c06c93083a06033d594", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30467, "upload_time": "2016-09-12T13:15:18", "url": "https://files.pythonhosted.org/packages/b0/bb/a321af995d67ab289c66f29ca058b7c8a478f6ca1c7f87b97c21b688948f/objdict-0.2.2.tar.gz" } ], "0.2.3": [ { "comment_text": "", "digests": { "md5": "3453ade87375f8a0a24ef90546cdcf62", "sha256": "44016b5f27101333be587965e6aa5e50c0bd38445460fb693464e470e5ed63bf" }, "downloads": -1, "filename": "objdict-0.2.3-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "3453ade87375f8a0a24ef90546cdcf62", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 27450, "upload_time": "2016-09-12T13:18:08", "url": "https://files.pythonhosted.org/packages/76/b5/caa36489bd266c2b7cd79be68e98432b66f8aa66eebd6a17c54f28e617f8/objdict-0.2.3-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "ffabdf86a9f55b6fc1b142ec777c5135", "sha256": "5e5f6f2654a7a96aa1c92626b3fa2e119c106fa00c3d2bcb5654cbef17b9d026" }, "downloads": -1, "filename": "objdict-0.2.3.tar.gz", "has_sig": false, "md5_digest": "ffabdf86a9f55b6fc1b142ec777c5135", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30478, "upload_time": "2016-09-12T13:18:20", "url": "https://files.pythonhosted.org/packages/1b/3d/8f5e03af3a270d738a78d2ac2edc10a7a21f222e63b62dccc6bfd126a08d/objdict-0.2.3.tar.gz" } ], "0.2.4": [ { "comment_text": "", "digests": { "md5": "94ee36ac70011537512abfe7013706fc", "sha256": "c23378e4ccfe343aa21097fef89c3aaf692372197251599b34d019b3c7d77cdc" }, "downloads": -1, "filename": "objdict-0.2.4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "94ee36ac70011537512abfe7013706fc", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 31824, "upload_time": "2016-09-16T04:27:30", "url": "https://files.pythonhosted.org/packages/92/66/0a02edf2bdca7e70098d5e59287db5f24174abdc9a6ff73eaee1cdc58896/objdict-0.2.4-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "04dac27d51cb63af42276d786405a512", "sha256": "6b190240769416b2e0dd7b9a828b36cff00eb50f5f6b3f859f14793a46925d4f" }, "downloads": -1, "filename": "objdict-0.2.4.tar.gz", "has_sig": false, "md5_digest": "04dac27d51cb63af42276d786405a512", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 33891, "upload_time": "2016-09-16T04:27:44", "url": "https://files.pythonhosted.org/packages/bd/2c/56d5f2b163939d8e17f8d76cebc27e1a5b3c229a96045d5f403e445cd7ff/objdict-0.2.4.tar.gz" } ], "0.2.5": [ { "comment_text": "", "digests": { "md5": "5780b963a26719e259ac671358d85f26", "sha256": "b9b1c3f10d51a200262386ca30cdc8470c8c2f3ebe8272b1795cb361623df044" }, "downloads": -1, "filename": "objdict-0.2.5-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "5780b963a26719e259ac671358d85f26", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 31822, "upload_time": "2016-09-16T04:33:11", "url": "https://files.pythonhosted.org/packages/65/0f/7eefd1d9dcfc4220601ec263f7efdafd3875bb6b4adc360a266e2dd97aaa/objdict-0.2.5-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "029069b8bae232467c00c4229ab0bebd", "sha256": "30f5a137a6cc4dfad4121fe6fd37dc2d7c35d81b1dd077c6b07c5060d9a88232" }, "downloads": -1, "filename": "objdict-0.2.5.tar.gz", "has_sig": false, "md5_digest": "029069b8bae232467c00c4229ab0bebd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 33891, "upload_time": "2016-09-16T04:33:22", "url": "https://files.pythonhosted.org/packages/d4/0c/f196763d434208c3ab9d24fa2ff5aead0b752064f7f1eb6a55803ffd3039/objdict-0.2.5.tar.gz" } ], "0.2.6": [ { "comment_text": "", "digests": { "md5": "d9481d17bc153ebd20791d6d6337f2de", "sha256": "85b65cacbe1557664428ad44bfa1589b5e10b0a716a1c6907584b6f4c0bbb6f2" }, "downloads": -1, "filename": "objdict-0.2.6-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "d9481d17bc153ebd20791d6d6337f2de", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 32198, "upload_time": "2016-09-16T06:58:21", "url": "https://files.pythonhosted.org/packages/ef/ca/4d9880cfdb3bda71864b605e07d93eb61c03d5c458ca038e9f1b58803739/objdict-0.2.6-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "c5459d85ff199dfa8849bd999385c585", "sha256": "78377ad11a438151f1da9bcf1607ad68c2f530a14d15e5b6655e8387c053737e" }, "downloads": -1, "filename": "objdict-0.2.6.tar.gz", "has_sig": false, "md5_digest": "c5459d85ff199dfa8849bd999385c585", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 33366, "upload_time": "2016-09-16T07:02:38", "url": "https://files.pythonhosted.org/packages/5e/15/35a885500f3e25f575bf8c21be408d6b55d5f6b61a587b6191671564d950/objdict-0.2.6.tar.gz" } ], "0.2.7": [ { "comment_text": "", "digests": { "md5": "465e6feff7f42defc25b6a084dff3cf1", "sha256": "852a468903ff0a1e90881c131d1ac4da3b2e8f5b1eef006fd49d4c2009f1e324" }, "downloads": -1, "filename": "ObjDict-0.2.7-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "465e6feff7f42defc25b6a084dff3cf1", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 32226, "upload_time": "2016-09-16T08:37:56", "url": "https://files.pythonhosted.org/packages/9d/d9/4103f402c071a06f3681fc11d6e4830981a75d4b6db0da8cea735d790b0d/ObjDict-0.2.7-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "58f524fdce4ec4cd6542ee8ecee1a315", "sha256": "a763866782281a3dfb658478544d625a27c00a03a4ad2539bea5b869fb10c6e0" }, "downloads": -1, "filename": "ObjDict-0.2.7.tar.gz", "has_sig": false, "md5_digest": "58f524fdce4ec4cd6542ee8ecee1a315", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 33425, "upload_time": "2016-09-16T08:38:07", "url": "https://files.pythonhosted.org/packages/85/fa/93c8d21ae4f48b9ab42a330422a7fbcaccbe9ef126654c1fbc4be82237b1/ObjDict-0.2.7.tar.gz" } ], "0.2.8": [ { "comment_text": "", "digests": { "md5": "fe3bb2e61b4a12506a5959818f1b9bfe", "sha256": "936b6b5b915761b33d4da148cb58852f01576308174e1cf041d08df66275789f" }, "downloads": -1, "filename": "ObjDict-0.2.8-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "fe3bb2e61b4a12506a5959818f1b9bfe", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 32220, "upload_time": "2016-09-16T08:56:02", "url": "https://files.pythonhosted.org/packages/32/5e/7477c866efddece58c29f312c74e1f19f77f0e8014943858ffe02ef9e700/ObjDict-0.2.8-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "43afaa3a659275ad4837a14da88c6e8e", "sha256": "6bfd23f186989e6af5655255a15374524a1561fe96c047d04870899828aaab48" }, "downloads": -1, "filename": "ObjDict-0.2.8.tar.gz", "has_sig": false, "md5_digest": "43afaa3a659275ad4837a14da88c6e8e", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 33382, "upload_time": "2016-09-16T08:56:14", "url": "https://files.pythonhosted.org/packages/27/c6/f0336264f37a33c9cfa8696428cc3794563c9562f54709180ad829c175fb/ObjDict-0.2.8.tar.gz" } ], "0.2.9": [ { "comment_text": "", "digests": { "md5": "43a3202198325ea96ea4956de1dbe171", "sha256": "fb6b7d4af7a260dd8b45c330d8cb60c926975b08ec4244d9e2e958f3680382ed" }, "downloads": -1, "filename": "ObjDict-0.2.9-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "43a3202198325ea96ea4956de1dbe171", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 36774, "upload_time": "2016-09-19T02:01:30", "url": "https://files.pythonhosted.org/packages/21/77/4320b9ec7dbfdbcb80f6df0dfd2b51981d54115da821a22766b1af357edf/ObjDict-0.2.9-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "c23075b917e697e009cb0f7ba8b07060", "sha256": "fc9ac770fc175da296b4c592fee725fb4e2454105b3d666210b36aab55702b1c" }, "downloads": -1, "filename": "ObjDict-0.2.9.tar.gz", "has_sig": false, "md5_digest": "c23075b917e697e009cb0f7ba8b07060", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 37470, "upload_time": "2016-09-19T02:01:44", "url": "https://files.pythonhosted.org/packages/b4/e9/90c74d24308197eaa28f19096abf6ed0e31f5c962d631cd53386eb509867/ObjDict-0.2.9.tar.gz" } ], "0.3.0": [ { "comment_text": "", "digests": { "md5": "99eb26a9fccabff3a21a1d546127829d", "sha256": "c8cf6ea06928216885d36b15e747d212e6d3fbbba4c0739eb95dde66a212ef0c" }, "downloads": -1, "filename": "ObjDict-0.3.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "99eb26a9fccabff3a21a1d546127829d", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37861, "upload_time": "2016-09-22T04:03:32", "url": "https://files.pythonhosted.org/packages/72/23/93ffa82bd89dd4045ad4d8efa8817720898c07086ef9cb822c0f171d3895/ObjDict-0.3.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "e1625d694b9ab5cb66f40688259d3daf", "sha256": "c53ea82fab0f81fe94706d2a10f724f5ef4f8b33a1167102d06d45279a8e9abf" }, "downloads": -1, "filename": "ObjDict-0.3.0.tar.gz", "has_sig": false, "md5_digest": "e1625d694b9ab5cb66f40688259d3daf", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45149, "upload_time": "2016-09-22T04:03:44", "url": "https://files.pythonhosted.org/packages/3f/9f/677e473afebbe7b36b99099ae26d827741794579a7f5dfa53802ae19a443/ObjDict-0.3.0.tar.gz" } ], "0.3.1": [ { "comment_text": "", "digests": { "md5": "6284ab669fb7477321bcfaa7b0005a12", "sha256": "1a21e6a35223e7c60fb18089f3887188db33ce91a972c71901983038858de3e6" }, "downloads": -1, "filename": "ObjDict-0.3.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "6284ab669fb7477321bcfaa7b0005a12", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37866, "upload_time": "2016-09-26T02:26:30", "url": "https://files.pythonhosted.org/packages/88/bb/ac09b81024a9835a1b5f7c19d977dc65daa887f2f119cccf6b1939383bb9/ObjDict-0.3.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "1ffb458d0c3f70d45988fc6a2d039f27", "sha256": "1e4ec04e72cdfa8fa0cd34db738733645ab08c8ae8d9fe25948cd55af627769a" }, "downloads": -1, "filename": "ObjDict-0.3.1.tar.gz", "has_sig": false, "md5_digest": "1ffb458d0c3f70d45988fc6a2d039f27", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45169, "upload_time": "2016-09-26T02:28:18", "url": "https://files.pythonhosted.org/packages/f0/63/762ff86f517e3b5fdbbd1d0a172ed682835a1ae6ff62d584b8d78340e891/ObjDict-0.3.1.tar.gz" } ], "0.3.2": [ { "comment_text": "", "digests": { "md5": "6f882d2cb3bc4201265943c80e631984", "sha256": "af67c68681009938132f9e0c24e4d91967cc132d39626f8709d19d45fed8005d" }, "downloads": -1, "filename": "ObjDict-0.3.2-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "6f882d2cb3bc4201265943c80e631984", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 38054, "upload_time": "2016-09-28T04:47:10", "url": "https://files.pythonhosted.org/packages/85/ee/d5bf96379606be0d6803524614fe93efb32e9c43368883ccc09412e2459d/ObjDict-0.3.2-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "b7b7f3bcd4d63c6353ea3b682e6f75cb", "sha256": "14c85e8978010fc676a9b8e42a129e16561dbebb83f72fbb991ae7df891826a6" }, "downloads": -1, "filename": "ObjDict-0.3.2.tar.gz", "has_sig": false, "md5_digest": "b7b7f3bcd4d63c6353ea3b682e6f75cb", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45240, "upload_time": "2016-09-28T04:47:23", "url": "https://files.pythonhosted.org/packages/30/27/609eac94e3b8e6c0ff0f4b52fc12cb048cc0faee98a5911014264c03ec15/ObjDict-0.3.2.tar.gz" } ], "0.3.3": [ { "comment_text": "", "digests": { "md5": "79ccd219f54aab9f5e2be1c7fead2f7f", "sha256": "6bebb8142e3af2b4665cc5c6a470b4234a7865d0cd09bcef28ea72e12284aa52" }, "downloads": -1, "filename": "ObjDict-0.3.3-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "79ccd219f54aab9f5e2be1c7fead2f7f", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 35246, "upload_time": "2016-11-10T04:58:57", "url": "https://files.pythonhosted.org/packages/98/77/2c99061b1ca7fa17de3f7897102caa53029bbb35f0e23f4ce151726dce6d/ObjDict-0.3.3-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "4b1b866cceabbfbe03ced023ceee4944", "sha256": "a143ed36d24785c7dcbe607c17cfd4aabee04a17c7faf0b3e2b940e4e4c34820" }, "downloads": -1, "filename": "ObjDict-0.3.3.tar.gz", "has_sig": false, "md5_digest": "4b1b866cceabbfbe03ced023ceee4944", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 42917, "upload_time": "2016-11-10T04:59:09", "url": "https://files.pythonhosted.org/packages/6f/eb/e63f7795ae4ed62115005e0e8b4ae1ccdeb6c98324228c2af162cc99e585/ObjDict-0.3.3.tar.gz" } ], "0.3.4": [ { "comment_text": "", "digests": { "md5": "157003383c9cd60b8595a8f9cc2f8fff", "sha256": "8a8e7649db3183d0581677752e7757759df4f38ba061751abfb163f7f401c94b" }, "downloads": -1, "filename": "ObjDict-0.3.4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "157003383c9cd60b8595a8f9cc2f8fff", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 35448, "upload_time": "2016-11-17T05:35:33", "url": "https://files.pythonhosted.org/packages/a4/9b/645e3bdbc8a14f51f451f305b66749e88f02ba984368f8e91ac1dd6f839a/ObjDict-0.3.4-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "2c500775b70b1ffb65cee867333f87ea", "sha256": "04d24f2bd4a468cf5ead48a9208b00af4ec6422b83fb9607933f252a8fe3b7fb" }, "downloads": -1, "filename": "ObjDict-0.3.4.tar.gz", "has_sig": false, "md5_digest": "2c500775b70b1ffb65cee867333f87ea", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 43105, "upload_time": "2016-11-17T05:35:46", "url": "https://files.pythonhosted.org/packages/78/9f/1f3b3ad9484fb4735566fcb9568269070a027188f74e3a55901d10659318/ObjDict-0.3.4.tar.gz" } ], "0.3.5": [ { "comment_text": "", "digests": { "md5": "7f91fdead05462c210fdd839fa1fc1ef", "sha256": "b4c4bf338def50149430710bacf2594d9653dcd906838d4096214fa92b7a7462" }, "downloads": -1, "filename": "ObjDict-0.3.5-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "7f91fdead05462c210fdd839fa1fc1ef", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 35857, "upload_time": "2016-12-12T05:57:08", "url": "https://files.pythonhosted.org/packages/af/8b/4086f9bdfc34a2783efcde42938680a3ee064938fd374e84d3f05d1aab06/ObjDict-0.3.5-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "b09f20315ce24fbee76e1b0d0a0b6f62", "sha256": "caa4ab00ad1fa41825e70492aa0a61b4899c88a4c6816bef4801ef0d76d610e9" }, "downloads": -1, "filename": "ObjDict-0.3.5.tar.gz", "has_sig": false, "md5_digest": "b09f20315ce24fbee76e1b0d0a0b6f62", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 43552, "upload_time": "2016-12-12T05:57:22", "url": "https://files.pythonhosted.org/packages/9e/dd/ed9adde8b6f1e80baf38cfe39f3df5e9edb0cba8c22411b8abef57922818/ObjDict-0.3.5.tar.gz" } ], "0.3.6": [ { "comment_text": "", "digests": { "md5": "3071e2538adcb97fc5111a2ba3f88f65", "sha256": "51f2a62201099dab0d0396a9b9aef8df712e615472c5cdfc43eeeefee4214ada" }, "downloads": -1, "filename": "ObjDict-0.3.6-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "3071e2538adcb97fc5111a2ba3f88f65", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 35862, "upload_time": "2016-12-17T01:57:15", "url": "https://files.pythonhosted.org/packages/64/dd/5e4a755baeda6cd1369ce4fde7cfd96e11b64fb6ac727a7cba0b829dfbcc/ObjDict-0.3.6-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3ac5ab55364b88708d1ff946363b27fa", "sha256": "ef9b651d96549271e09869e165474be73131a7d8fade5c769cb912ac92fdd42f" }, "downloads": -1, "filename": "ObjDict-0.3.6.tar.gz", "has_sig": false, "md5_digest": "3ac5ab55364b88708d1ff946363b27fa", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 43552, "upload_time": "2016-12-17T01:57:27", "url": "https://files.pythonhosted.org/packages/41/8b/6b543eb08e6b6562216413e233ee25dcc0b5900b0c66cc5b994718464340/ObjDict-0.3.6.tar.gz" } ], "0.3.7": [ { "comment_text": "", "digests": { "md5": "31cfcd7f0d8cf9feef52ec2e2dc72dfd", "sha256": "3e9af909a3e0ed7c8f0ff5f6a74f8dc59d40c451cd9a7fe5f92498df97e0a188" }, "downloads": -1, "filename": "ObjDict-0.3.7-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "31cfcd7f0d8cf9feef52ec2e2dc72dfd", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 37106, "upload_time": "2017-04-04T01:51:15", "url": "https://files.pythonhosted.org/packages/9b/35/49cb15e1272bc120c786444c0c5d126860a790d8a5618eccb61a698ace61/ObjDict-0.3.7-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "36fe80968ec1b73e3a07b10de9b9d4de", "sha256": "bfabe6b7e61cee871147f2b3127d0f9c2b36ba699c8a64be8aa3422b94347746" }, "downloads": -1, "filename": "ObjDict-0.3.7.tar.gz", "has_sig": false, "md5_digest": "36fe80968ec1b73e3a07b10de9b9d4de", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 44585, "upload_time": "2017-04-04T01:50:48", "url": "https://files.pythonhosted.org/packages/62/d7/87704d2c1505d52ef7ae9f795559bdef4f9aed679b321bf9031110423e6d/ObjDict-0.3.7.tar.gz" } ], "0.3.8": [ { "comment_text": "", "digests": { "md5": "33dc26b49b3afe7e16f8aa812a0b3dc8", "sha256": "2fa85fec34ce334cf687329fd98d92f05237ac8eee1ce4eadb6be9c9a513798d" }, "downloads": -1, "filename": "ObjDict-0.3.8-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "33dc26b49b3afe7e16f8aa812a0b3dc8", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 38762, "upload_time": "2017-04-04T05:39:00", "url": "https://files.pythonhosted.org/packages/d8/dc/386ec478acb27c471768ca32df8ec4e4e39c32b8a3f0a6b62b87a037c77f/ObjDict-0.3.8-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3d239282a14df816025fa49cf035bfa5", "sha256": "d03f15eb58b59180d884fbd6bdd7f3865d50f6ed6e7c336ab8832f23a187a1cb" }, "downloads": -1, "filename": "ObjDict-0.3.8.tar.gz", "has_sig": false, "md5_digest": "3d239282a14df816025fa49cf035bfa5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45702, "upload_time": "2017-04-04T05:39:13", "url": "https://files.pythonhosted.org/packages/01/80/689b021be7e8580ec87065f32659c5c087842eb74027923b67abe7e158ff/ObjDict-0.3.8.tar.gz" } ], "0.3.9": [ { "comment_text": "", "digests": { "md5": "0f7f65c7fad59234ed787e4c774f9923", "sha256": "23daec147dd0fba6fb593b175ab715db6cf3911939e08ffe8ba8c77966669de6" }, "downloads": -1, "filename": "ObjDict-0.3.9-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "0f7f65c7fad59234ed787e4c774f9923", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 38904, "upload_time": "2017-04-27T03:07:12", "url": "https://files.pythonhosted.org/packages/a0/2f/2f9fd6a947b11c0ffba065f50621545004236d2cb0d632d00dda820c3c75/ObjDict-0.3.9-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "363a347a86b1c9910671d9bf0c69273f", "sha256": "18b3ba2e5b8d262387397269d5015a8ae59ace034e68427a6cc8c4e3df2ec049" }, "downloads": -1, "filename": "ObjDict-0.3.9.tar.gz", "has_sig": false, "md5_digest": "363a347a86b1c9910671d9bf0c69273f", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45816, "upload_time": "2017-04-27T03:07:21", "url": "https://files.pythonhosted.org/packages/50/e1/ff4a869c755ed5e2a5c9221415976dcf0409356c591f8824814663677fe5/ObjDict-0.3.9.tar.gz" } ], "0.4.0": [ { "comment_text": "", "digests": { "md5": "43cd41937d17f9dca55c1abdf003d4d0", "sha256": "8c4f794d83c665d28183371d4dcc7f7e1a589bfb51c84237f96c5f6fa00f754b" }, "downloads": -1, "filename": "ObjDict-0.4.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "43cd41937d17f9dca55c1abdf003d4d0", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 39979, "upload_time": "2017-04-30T23:23:50", "url": "https://files.pythonhosted.org/packages/3c/ec/9d3f85dfd9254632741080d8a1344272a58c0092ac9ee1d5268a8c1b91a3/ObjDict-0.4.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "a43a997adec403d049c6bf5ed26ab45d", "sha256": "83457da4180363aeb5dcb8e371b9cdd27410db6814dca65ad61858c8c3f87d83" }, "downloads": -1, "filename": "ObjDict-0.4.0.tar.gz", "has_sig": false, "md5_digest": "a43a997adec403d049c6bf5ed26ab45d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 47554, "upload_time": "2017-04-30T23:24:02", "url": "https://files.pythonhosted.org/packages/1d/3a/fddf72a57dfc0be3bc16dbe144de61ae1a1f1643387733663664ea61f22d/ObjDict-0.4.0.tar.gz" } ], "0.4.1": [ { "comment_text": "", "digests": { "md5": "1f436c953b863fa412466c103ede607e", "sha256": "d3eed21c0a5ccf5b61b92f4f829bdf30f6d58a1bf58491a162c56f53122b1922" }, "downloads": -1, "filename": "ObjDict-0.4.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "1f436c953b863fa412466c103ede607e", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 41361, "upload_time": "2017-05-09T04:35:56", "url": "https://files.pythonhosted.org/packages/c6/25/a2e3dea257f408fd7904032e6e1d8d2cda3df090016777f36f7e87a16978/ObjDict-0.4.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "1b5b504a2867c864689184da85b494e5", "sha256": "7a9cedb6486fe2f2958ce8f69b96b3ae1822a96c46b5c6e8a5f3b656a76b1e59" }, "downloads": -1, "filename": "ObjDict-0.4.1.tar.gz", "has_sig": false, "md5_digest": "1b5b504a2867c864689184da85b494e5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 49160, "upload_time": "2017-05-09T04:35:47", "url": "https://files.pythonhosted.org/packages/d2/af/e1c1059871bd872b8bef6457cf55a489079103409f2a893dccf9292cbf81/ObjDict-0.4.1.tar.gz" } ], "0.4.2": [ { "comment_text": "", "digests": { "md5": "023a95e9d5c3e1925132d45ee1420a8a", "sha256": "46412a830445bd9b471fe803f1d25bc796ce4bfbe83358743adde56ef34417f6" }, "downloads": -1, "filename": "ObjDict-0.4.2-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "023a95e9d5c3e1925132d45ee1420a8a", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 41684, "upload_time": "2017-05-22T05:04:55", "url": "https://files.pythonhosted.org/packages/fb/90/d8444ce2e1d60c2c4d3be0a8e71b3d734ecccef6024674bb761893dc7b6c/ObjDict-0.4.2-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "005d8033f2930253fec654783ad90a7e", "sha256": "4a4adca8316bb21f9962b8c75c78c5906b78a4471e70b340e40faaa17c774a87" }, "downloads": -1, "filename": "ObjDict-0.4.2.tar.gz", "has_sig": false, "md5_digest": "005d8033f2930253fec654783ad90a7e", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 49447, "upload_time": "2017-05-22T05:05:07", "url": "https://files.pythonhosted.org/packages/82/b2/8c708a5d282085ff50714c39701e24e9fe64d392a01914166fd330fb43a9/ObjDict-0.4.2.tar.gz" } ], "0.4.3": [ { "comment_text": "", "digests": { "md5": "775e1b4a4eae769bd348bcf511d319c5", "sha256": "8087fa5143153507a97faf8efb83fcbba86efd5a937109eca69b8ec594ba5aa1" }, "downloads": -1, "filename": "ObjDict-0.4.3-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "775e1b4a4eae769bd348bcf511d319c5", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 41780, "upload_time": "2017-06-26T01:26:09", "url": "https://files.pythonhosted.org/packages/1f/f5/0acfeef63db8078f048d63ab59b9938c732da8aaa9860c85b07009c3a29c/ObjDict-0.4.3-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "ffc5adfb7ffd6d1e93c42406a595434b", "sha256": "870e5ce6488e20b467dd84248cf0a4c50fff5f622eb88bc778d269bdf1c9c945" }, "downloads": -1, "filename": "ObjDict-0.4.3.tar.gz", "has_sig": false, "md5_digest": "ffc5adfb7ffd6d1e93c42406a595434b", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 49522, "upload_time": "2017-06-26T01:25:58", "url": "https://files.pythonhosted.org/packages/53/ad/3e5a61dbbb3d77984a06076bcd48fe46365d12329d2249002674dab794b8/ObjDict-0.4.3.tar.gz" } ], "0.4.4": [ { "comment_text": "", "digests": { "md5": "7b09eff833fd158c79c77f8aad3f2359", "sha256": "ccc17032a9f7c36b350a7ad2f6ac1879df3af9be6d1c9261a7e20b45fe7a7067" }, "downloads": -1, "filename": "ObjDict-0.4.4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "7b09eff833fd158c79c77f8aad3f2359", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 42155, "upload_time": "2017-09-01T01:27:13", "url": "https://files.pythonhosted.org/packages/e6/05/9966507c03728c8f33cd4cfaf84222624fbb3818455e140c855de128ae3e/ObjDict-0.4.4-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d38161eff83595c0de75686e1183b4ee", "sha256": "57ab56fa153f70d81736410c6428c9f5e028502cef9c9baa93c9ea43951983c5" }, "downloads": -1, "filename": "ObjDict-0.4.4.tar.gz", "has_sig": false, "md5_digest": "d38161eff83595c0de75686e1183b4ee", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 49906, "upload_time": "2017-09-01T01:28:20", "url": "https://files.pythonhosted.org/packages/f9/4a/10b6b72f60bbf47608b4be0cdb47929fdbd6e8d6000b6e56bb0c708c2a61/ObjDict-0.4.4.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "7b09eff833fd158c79c77f8aad3f2359", "sha256": "ccc17032a9f7c36b350a7ad2f6ac1879df3af9be6d1c9261a7e20b45fe7a7067" }, "downloads": -1, "filename": "ObjDict-0.4.4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "7b09eff833fd158c79c77f8aad3f2359", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 42155, "upload_time": "2017-09-01T01:27:13", "url": "https://files.pythonhosted.org/packages/e6/05/9966507c03728c8f33cd4cfaf84222624fbb3818455e140c855de128ae3e/ObjDict-0.4.4-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d38161eff83595c0de75686e1183b4ee", "sha256": "57ab56fa153f70d81736410c6428c9f5e028502cef9c9baa93c9ea43951983c5" }, "downloads": -1, "filename": "ObjDict-0.4.4.tar.gz", "has_sig": false, "md5_digest": "d38161eff83595c0de75686e1183b4ee", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 49906, "upload_time": "2017-09-01T01:28:20", "url": "https://files.pythonhosted.org/packages/f9/4a/10b6b72f60bbf47608b4be0cdb47929fdbd6e8d6000b6e56bb0c708c2a61/ObjDict-0.4.4.tar.gz" } ] }