File: PKG-INFO

package info (click to toggle)
py-ubjson 0.16.1-5
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 464 kB
  • sloc: ansic: 1,992; python: 1,408; sh: 6; makefile: 5
file content (116 lines) | stat: -rw-r--r-- 4,857 bytes parent folder | download | duplicates (8)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
Metadata-Version: 2.1
Name: py-ubjson
Version: 0.16.1
Summary: Universal Binary JSON encoder/decoder
Home-page: https://github.com/Iotic-Labs/py-ubjson
Author: Iotic Labs Ltd
Author-email: info@iotic-labs.com
Maintainer: Iotic Labs Ltd
Maintainer-email: vilnis.termanis@iotic-labs.com
License: Apache License 2.0
Description: # Overview
        
        This is a Python v3.2+ (and 2.7+) [Universal Binary JSON](http://ubjson.org) encoder/decoder based on the [draft-12](UBJSON-Specification.md) specification.
        
        
        # Installing / packaging
        ```shell
        # To get from PyPI
        pip3 install py-ubjson
        
        # To only build extension modules inline (e.g. in repository)
        python3 setup.py build_ext -i
        
        # To build & install globally
        python3 setup.py install
        
        # To skip building of extensions when installing (or building)
        PYUBJSON_NO_EXTENSION=1 python3 setup.py install
        ```
        **Notes**
        
        - The extension module is not required but provide a significant speed boost.
        - The above can also be run with v2.7+
        - This module is also available via [Anaconda (conda-forge)](https://anaconda.org/conda-forge/py-ubjson)
        - PyPI releases are signed with the [Iotic Labs Software release signing key](https://developer.iotic-labs.com/iotic-labs.com.asc)
        - At run time, one can check whether compiled version is in use via the _ubjson.EXTENSION_ENABLED_ boolean
        
        
        # Usage
        It's meant to behave very much like Python's built-in [JSON module](https://docs.python.org/3/library/json.html), e.g.:
        ```python
        import ubjson
        
        encoded = ubjson.dumpb({u'a': 1})
        
        decoded = ubjson.loadb(encoded)
        ```
        **Note**: Only unicode strings in Python 2 will be encoded as strings, plain *str* will be encoded as a byte array.
        
        
        # Documentation
        ```python
        import ubsjon
        help(ubjson.dump)
        help(ubjson.load)
        ```
        
        # Command-line utility
        This converts between JSON and UBJSON formats:
        ```shell
        python3 -mubjson
        USAGE: ubjson (fromjson|tojson) (INFILE|-) [OUTFILE]
        ```
        
        
        # Tests
        
        ## Static
        This library has been checked using [flake8](https://pypi.python.org/pypi/flake8) and [pylint](http://www.pylint.org), using a modified configuration - see _pylint.rc_ and _flake8.cfg_.
        
        ## Unit
        ```shell
        python3 -mvenv py
        . py/bin/activate
        pip install -U pip setuptools
        pip install -e .[dev]
        
        ./coverage_test.sh
        ```
        **Note**: See `coverage_test.sh` for additional requirements.
        
        
        # Limitations
        - The **No-Op** type is only supported by the decoder. (This should arguably be a protocol-level rather than serialisation-level option.) Specifically, it is **only** allowed to occur at the start or between elements of a container and **only** inside un-typed containers. (In a typed container it is impossible to tell the difference between an encoded element and a No-Op.)
        - Strongly-typed containers are only supported by the decoder (apart from for **bytes**/**bytearray**) and not for No-Op.
        - Encoder/decoder extensions are not supported at this time.
        
        
        # Why?
        The only existing implementation I was aware of at the time of writing ([simpleubjson](https://github.com/brainwater/simpleubjson)) had the following limitations:
        
        - Does not support efficient binary encoding
        - Only supports draft-9
        - Only supports individual Python types rather than anything implementing an interface (e.g. _Mapping_)
        - Does not decode nested arrays or objects in expected form
        - Lacks C extension speed-up
        
Keywords: ubjson,ubj
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: C
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Description-Content-Type: text/markdown
Provides-Extra: dev