# JData for Python - lightweight and serializable data annotations for Python
- Copyright: (C) Qianqian Fang (2019-2024) <q.fang at neu.edu>
- License: Apache License, Version 2.0
- Version: 0.6.0
- URL: https://github.com/NeuroJSON/pyjdata
- Acknowledgement: This project is supported by US National Institute of Health (NIH)
grant [U24-NS124027](https://reporter.nih.gov/project-details/10308329)
The [JData Specification](https://github.com/NeuroJSON/jdata/) defines a lightweight
language-independent data annotation interface enabling easy storing
and sharing of complex data structures across different programming
languages such as MATLAB, JavaScript, Python etc. Using JData formats, a
complex Python data structure, including numpy objects, can be encoded
as a simple `dict` object that is easily serialized as a JSON/binary JSON
file and share such data between programs of different languages.
Since 2021, the development of PyJData module and the underlying data format specificaitons
[JData](https://neurojson.org/jdata/draft3) and [BJData](https://neurojson.org/bjdata/draft2)
have been funded by the US National Institute of Health (NIH) as
part of the NeuroJSON project (https://neurojson.org and https://neurojson.io).
The goal of the NeuroJSON project is to develop scalable, searchable, and
reusable neuroimaging data formats and data sharing platforms. All data
produced from the NeuroJSON project will be using JSON/Binary JData formats as the
underlying serialization standards and the lightweight JData specification as
language-independent data annotation standard.
## How to install
* Github: download from https://github.com/NeuroJSON/pyjdata
* PIP: run `pip install jdata` see https://pypi.org/project/jdata/
This package can also be installed on Ubuntu 21.04 or Debian Bullseye via
```
sudo apt-get install python3-jdata
```
On older Ubuntu or Debian releases, you may install jdata via the below PPA:
```
sudo add-apt-repository ppa:fangq/ppa
sudo apt-get update
sudo apt-get install python3-jdata
```
Dependencies:
* **numpy**: PIP: run `pip install numpy` or `sudo apt-get install python3-numpy`
* (optional) **bjdata**: PIP: run `pip install bjdata` or `sudo apt-get install python3-bjdata`, see https://pypi.org/project/bjdata/, only needed to read/write BJData/UBJSON files
* (optional) **lz4**: PIP: run `pip install lz4`, only needed when encoding/decoding lz4-compressed data
* (optional) **backports.lzma**: PIP: run `sudo apt-get install liblzma-dev` and `pip install backports.lzma` (needed for Python 2.7), only needed when encoding/decoding lzma-compressed data
* (optional) **blosc2**: PIP: run `pip install blosc2`, only needed when encoding/decoding blosc2-compressed data
Replacing `pip` by `pip3` if you are using Python 3.x. If either `pip` or `pip3`
does not exist on your system, please run
```
sudo apt-get install python3-pip
```
Please note that in some OS releases (such as Ubuntu 20.04), python2.x and python-pip
are no longer supported.
One can also install this module from the source code. To do this, you first
check out a copy of the latest code from Github by
```
git clone https://github.com/NeuroJSON/pyjdata.git
cd pyjdata
```
then install the module to your local user folder by
```
python3 setup.py install --user
```
or, if you prefer, install to the system folder for all users by
```
sudo python3 setup.py install
```
Please replace `python` by `python3` if you want to install it for Python 3.x instead of 2.x.
Instead of installing the module, you can also import the jdata module directly from
your local copy by cd the root folder of the unzipped pyjdata package, and run
```
import jdata as jd
```
## How to use
The PyJData module is easy to use. You can use the `encode()/decode()` functions to
encode Python data into JData annotation format, or decode JData structures into
native Python data, for example
```
import jdata as jd
import numpy as np
a={'str':'test','num':1.2,'list':[1.1,[2.1]],'nan':float('nan'),'np':np.arange(1,5,dtype=np.uint8)}
jd.encode(a)
jd.decode(jd.encode(a))
d1=jd.encode(a,{'compression':'zlib','base64':1})
d1
jd.decode(d1,{'base64':1})
```
One can further save the JData annotated data into JSON or binary JSON (UBJSON) files using
the `jdata.save` function, or loading JData-formatted data to Python using `jdata.load`
```
import jdata as jd
import numpy as np
a={'str':'test','num':1.2,'list':[1.1,[2.1]],'nan':float('nan'),'np':np.arange(1,5,dtype=np.uint8)}
jd.save(a,'test.json')
newdata=jd.load('test.json')
newdata
```
One can use `loadt` or `savet` to read/write JSON-based data files and `loadb` and `saveb` to
read/write binary-JSON based data files. By default, JData annotations are automatically decoded
after loading and encoded before saving. One can set `{'encode': False}` in the save functions
or `{'decode': False}` in the load functions as the `opt` to disable further processing of JData
annotations. We also provide `loadts` and `loadbs` for parsing a string-buffer made of text-based
JSON or binary JSON stream.
PyJData supports multiple N-D array data compression/decompression methods (i.e. codecs), similar
to HDF5 filters. Currently supported codecs include `zlib`, `gzip`, `lz4`, `lzma`, `base64` and various
`blosc2` compression methods, including `blosc2blosclz`, `blosc2lz4`, `blosc2lz4hc`, `blosc2zlib`,
`blosc2zstd`. To apply a selected compression method, one simply set `{'compression':'method'}` as
the option to `jdata.encode` or `jdata.save` function; `jdata.load` or `jdata.decode` automatically
decompress the data based on the `_ArrayZipType_` annotation present in the data. Only `blosc2`
compression methods support multi-threading. To set the thread number, one should define an `nthread`
value in the option (`opt`) for both encoding and decoding.
## Reading JSON via REST-API
If a REST-API (URL) is given as the first input of `load`, it reads the JSON data directly
from the URL and parse the content to native Python data structures. To avoid repetitive download,
`load` automatically cache the downloaded file so that future calls directly load the
locally cached file. If one prefers to always load from the URL without local cache, one should
use `loadurl()` instead. Here is an example
```
import jdata as jd
data = jd.load('https://neurojson.io:7777/openneuro/ds000001');
data.keys()
```
## Using JSONPath to access and query complex datasets
Starting from v0.6.0, PyJData provides a lightweight implementation [JSONPath](https://goessner.net/articles/JsonPath/),
a widely used format for query and access a hierarchical dict/list structure, such as those
parsed by `load` or `loadurl`. Here is an example
```
import jdata as jd
data = jd.loadurl('https://raw.githubusercontent.com/fangq/jsonlab/master/examples/example1.json');
jd.jsonpath(data, '$.age')
jd.jsonpath(data, '$.address.city')
jd.jsonpath(data, '$.phoneNumber')
jd.jsonpath(data, '$.phoneNumber[0]')
jd.jsonpath(data, '$.phoneNumber[0].type')
jd.jsonpath(data, '$.phoneNumber[-1]')
jd.jsonpath(data, '$.phoneNumber..number')
jd.jsonpath(data, '$[phoneNumber][type]')
jd.jsonpath(data, '$[phoneNumber][type][1]')
```
The `jd.jsonpath` function does not support all JSONPath features. If more complex JSONPath
queries are needed, one should install `jsonpath_ng` or other more advanced JSONPath support.
Here is an example using `jsonpath_ng`
```
import jdata as jd
from jsonpath_ng.ext import parse
data = jd.loadurl('https://raw.githubusercontent.com/fangq/jsonlab/master/examples/example1.json');
val = [match.value for match in parse('$.address.city').find(data)]
val = [match.value for match in parse('$.phoneNumber').find(data)]
```
## Downloading and caching `_DataLink_` referenced external data files
Similarly to [JSONLab](https://github.com/fangq/jsonlab?tab=readme-ov-file#jsoncachem),
PyJData also provides similar external data file downloading/caching capability.
The `_DataLink_` annotation in the JData specification permits linking of external data files
in a JSON file - to make downloading/parsing externally linked data files efficient, such as
processing large neuroimaging datasets hosted on http://neurojson.io, we have developed a system
to download files on-demand and cache those locally. jsoncache.m is responsible of searching
the local cache folders, if found the requested file, it returns the path to the local cache;
if not found, it returns a SHA-256 hash of the URL as the file name, and the possible cache folders
When loading a file from URL, below is the order of cache file search paths, ranking in search order
```
global-variable NEUROJSON_CACHE | if defined, this path will be searched first
[pwd '/.neurojson'] | on all OSes
/home/USERNAME/.neurojson | on all OSes (per-user)
/home/USERNAME/.cache/neurojson | if on Linux (per-user)
/var/cache/neurojson | if on Linux (system wide)
/home/USERNAME/Library/neurojson| if on MacOS (per-user)
/Library/neurojson | if on MacOS (system wide)
C:\ProgramData\neurojson | if on Windows (system wide)
```
When saving a file from a URL, under the root cache folder, subfolders can be created;
if the URL is one of a standard NeuroJSON.io URLs as below
```
https://neurojson.org/io/stat.cgi?action=get&db=DBNAME&doc=DOCNAME&file=sub-01/anat/datafile.nii.gz
https://neurojson.io:7777/DBNAME/DOCNAME
https://neurojson.io:7777/DBNAME/DOCNAME/datafile.suffix
```
the file datafile.nii.gz will be downloaded to /home/USERNAME/.neurojson/io/DBNAME/DOCNAME/sub-01/anat/ folder
if a URL does not follow the neurojson.io format, the cache folder has the below form
```
CACHEFOLDER{i}/domainname.com/XX/YY/XXYYZZZZ...
```
where XXYYZZZZ.. is the SHA-256 hash of the full URL, XX is the first two digit, YY is the 3-4 digits
In PyJData, we provide `jdata.jdlink()` function to dynamically download and locally cache
externally linked data files. `jdata.jdlink()` only parse files with JSON/binary JSON suffixes that
`load` supports. Here is a example
```
import jdata as jd
data = jd.load('https://neurojson.io:7777/openneuro/ds000001');
extlinks = jd.jsonpath(data, '$..anat.._DataLink_') # deep-scan of all anatomical folders and find all linked NIfTI files
jd.jdlink(extlinks, {'regex': 'sub-0[12]_.*nii'}) # download only the nii files for sub-01 and sub-02
jd.jdlink(extlinks) # download all links
```
## Utility
One can convert from JSON based data files (`.json, .jdt, .jnii, .jmsh, .jnirs`) to binary-JData
based binary files (`.bjd, .jdb, .bnii, .bmsh, .bnirs`) and vice versa using command
```
python3 -mjdata /path/to/text/json/file.json # convert to /path/to/text/json/file.jdb
python3 -mjdata /path/to/text/json/file.jdb # convert to /path/to/text/json/file.json
python3 -mjdata -h # show help info
```
## Test
To see additional data type support, please run the built-in test using below command
```
python3 -m unittest discover -v test
```
Raw data
{
"_id": null,
"home_page": "https://github.com/NeuroJSON/pyjdata",
"name": "jdata",
"maintainer": "Qianqian Fang",
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": "JSON, JData, UBJSON, BJData, OpenJData, NeuroJSON, JNIfTI, JMesh, Encoder, Decoder",
"author": "Qianqian Fang",
"author_email": "fangqq@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/62/d1/8f03bab6d5b6377a84d0fc456b495b0e5e2a3f24d86ed957cc43f3bae72e/jdata-0.6.0.tar.gz",
"platform": "any",
"description": "\n\n# JData for Python - lightweight and serializable data annotations for Python\n\n- Copyright: (C) Qianqian Fang (2019-2024) <q.fang at neu.edu>\n- License: Apache License, Version 2.0\n- Version: 0.6.0\n- URL: https://github.com/NeuroJSON/pyjdata\n- Acknowledgement: This project is supported by US National Institute of Health (NIH)\n grant [U24-NS124027](https://reporter.nih.gov/project-details/10308329)\n\n\n\nThe [JData Specification](https://github.com/NeuroJSON/jdata/) defines a lightweight \nlanguage-independent data annotation interface enabling easy storing\nand sharing of complex data structures across different programming\nlanguages such as MATLAB, JavaScript, Python etc. Using JData formats, a \ncomplex Python data structure, including numpy objects, can be encoded\nas a simple `dict` object that is easily serialized as a JSON/binary JSON\nfile and share such data between programs of different languages.\n\nSince 2021, the development of PyJData module and the underlying data format specificaitons\n[JData](https://neurojson.org/jdata/draft3) and [BJData](https://neurojson.org/bjdata/draft2)\nhave been funded by the US National Institute of Health (NIH) as\npart of the NeuroJSON project (https://neurojson.org and https://neurojson.io).\n\nThe goal of the NeuroJSON project is to develop scalable, searchable, and\nreusable neuroimaging data formats and data sharing platforms. All data\nproduced from the NeuroJSON project will be using JSON/Binary JData formats as the\nunderlying serialization standards and the lightweight JData specification as\nlanguage-independent data annotation standard.\n\n## How to install\n\n* Github: download from https://github.com/NeuroJSON/pyjdata\n* PIP: run `pip install jdata` see https://pypi.org/project/jdata/\n\nThis package can also be installed on Ubuntu 21.04 or Debian Bullseye via\n```\nsudo apt-get install python3-jdata\n```\n\nOn older Ubuntu or Debian releases, you may install jdata via the below PPA:\n```\nsudo add-apt-repository ppa:fangq/ppa\nsudo apt-get update\nsudo apt-get install python3-jdata\n```\n\nDependencies:\n* **numpy**: PIP: run `pip install numpy` or `sudo apt-get install python3-numpy`\n* (optional) **bjdata**: PIP: run `pip install bjdata` or `sudo apt-get install python3-bjdata`, see https://pypi.org/project/bjdata/, only needed to read/write BJData/UBJSON files\n* (optional) **lz4**: PIP: run `pip install lz4`, only needed when encoding/decoding lz4-compressed data\n* (optional) **backports.lzma**: PIP: run `sudo apt-get install liblzma-dev` and `pip install backports.lzma` (needed for Python 2.7), only needed when encoding/decoding lzma-compressed data\n* (optional) **blosc2**: PIP: run `pip install blosc2`, only needed when encoding/decoding blosc2-compressed data\n\nReplacing `pip` by `pip3` if you are using Python 3.x. If either `pip` or `pip3` \ndoes not exist on your system, please run\n```\n sudo apt-get install python3-pip\n```\nPlease note that in some OS releases (such as Ubuntu 20.04), python2.x and python-pip \nare no longer supported.\n\nOne can also install this module from the source code. To do this, you first\ncheck out a copy of the latest code from Github by\n```\n git clone https://github.com/NeuroJSON/pyjdata.git\n cd pyjdata\n```\nthen install the module to your local user folder by\n```\n python3 setup.py install --user\n```\nor, if you prefer, install to the system folder for all users by\n```\n sudo python3 setup.py install\n```\nPlease replace `python` by `python3` if you want to install it for Python 3.x instead of 2.x.\n\nInstead of installing the module, you can also import the jdata module directly from \nyour local copy by cd the root folder of the unzipped pyjdata package, and run\n```\n import jdata as jd\n```\n\n## How to use\n\nThe PyJData module is easy to use. You can use the `encode()/decode()` functions to\nencode Python data into JData annotation format, or decode JData structures into\nnative Python data, for example\n\n```\nimport jdata as jd\nimport numpy as np\n\na={'str':'test','num':1.2,'list':[1.1,[2.1]],'nan':float('nan'),'np':np.arange(1,5,dtype=np.uint8)}\njd.encode(a)\njd.decode(jd.encode(a))\nd1=jd.encode(a,{'compression':'zlib','base64':1})\nd1\njd.decode(d1,{'base64':1})\n```\n\nOne can further save the JData annotated data into JSON or binary JSON (UBJSON) files using\nthe `jdata.save` function, or loading JData-formatted data to Python using `jdata.load`\n\n```\nimport jdata as jd\nimport numpy as np\n\na={'str':'test','num':1.2,'list':[1.1,[2.1]],'nan':float('nan'),'np':np.arange(1,5,dtype=np.uint8)}\njd.save(a,'test.json')\nnewdata=jd.load('test.json')\nnewdata\n```\n\nOne can use `loadt` or `savet` to read/write JSON-based data files and `loadb` and `saveb` to\nread/write binary-JSON based data files. By default, JData annotations are automatically decoded\nafter loading and encoded before saving. One can set `{'encode': False}` in the save functions\nor `{'decode': False}` in the load functions as the `opt` to disable further processing of JData\nannotations. We also provide `loadts` and `loadbs` for parsing a string-buffer made of text-based\nJSON or binary JSON stream.\n\nPyJData supports multiple N-D array data compression/decompression methods (i.e. codecs), similar\nto HDF5 filters. Currently supported codecs include `zlib`, `gzip`, `lz4`, `lzma`, `base64` and various\n`blosc2` compression methods, including `blosc2blosclz`, `blosc2lz4`, `blosc2lz4hc`, `blosc2zlib`,\n`blosc2zstd`. To apply a selected compression method, one simply set `{'compression':'method'}` as\nthe option to `jdata.encode` or `jdata.save` function; `jdata.load` or `jdata.decode` automatically\ndecompress the data based on the `_ArrayZipType_` annotation present in the data. Only `blosc2`\ncompression methods support multi-threading. To set the thread number, one should define an `nthread`\nvalue in the option (`opt`) for both encoding and decoding.\n\n## Reading JSON via REST-API\n\nIf a REST-API (URL) is given as the first input of `load`, it reads the JSON data directly\nfrom the URL and parse the content to native Python data structures. To avoid repetitive download,\n`load` automatically cache the downloaded file so that future calls directly load the\nlocally cached file. If one prefers to always load from the URL without local cache, one should\nuse `loadurl()` instead. Here is an example\n\n```\nimport jdata as jd\ndata = jd.load('https://neurojson.io:7777/openneuro/ds000001');\ndata.keys()\n```\n\n## Using JSONPath to access and query complex datasets\n\nStarting from v0.6.0, PyJData provides a lightweight implementation [JSONPath](https://goessner.net/articles/JsonPath/),\na widely used format for query and access a hierarchical dict/list structure, such as those\nparsed by `load` or `loadurl`. Here is an example\n\n```\nimport jdata as jd\n\ndata = jd.loadurl('https://raw.githubusercontent.com/fangq/jsonlab/master/examples/example1.json');\njd.jsonpath(data, '$.age')\njd.jsonpath(data, '$.address.city')\njd.jsonpath(data, '$.phoneNumber')\njd.jsonpath(data, '$.phoneNumber[0]')\njd.jsonpath(data, '$.phoneNumber[0].type')\njd.jsonpath(data, '$.phoneNumber[-1]')\njd.jsonpath(data, '$.phoneNumber..number')\njd.jsonpath(data, '$[phoneNumber][type]')\njd.jsonpath(data, '$[phoneNumber][type][1]')\n```\n\nThe `jd.jsonpath` function does not support all JSONPath features. If more complex JSONPath\nqueries are needed, one should install `jsonpath_ng` or other more advanced JSONPath support.\nHere is an example using `jsonpath_ng`\n\n```\nimport jdata as jd\nfrom jsonpath_ng.ext import parse\n\ndata = jd.loadurl('https://raw.githubusercontent.com/fangq/jsonlab/master/examples/example1.json');\n\nval = [match.value for match in parse('$.address.city').find(data)]\nval = [match.value for match in parse('$.phoneNumber').find(data)]\n```\n\n## Downloading and caching `_DataLink_` referenced external data files\n\nSimilarly to [JSONLab](https://github.com/fangq/jsonlab?tab=readme-ov-file#jsoncachem),\nPyJData also provides similar external data file downloading/caching capability.\n\nThe `_DataLink_` annotation in the JData specification permits linking of external data files\nin a JSON file - to make downloading/parsing externally linked data files efficient, such as\nprocessing large neuroimaging datasets hosted on http://neurojson.io, we have developed a system\nto download files on-demand and cache those locally. jsoncache.m is responsible of searching\nthe local cache folders, if found the requested file, it returns the path to the local cache;\nif not found, it returns a SHA-256 hash of the URL as the file name, and the possible cache folders\n\nWhen loading a file from URL, below is the order of cache file search paths, ranking in search order\n```\n global-variable NEUROJSON_CACHE | if defined, this path will be searched first\n [pwd '/.neurojson'] \t | on all OSes\n /home/USERNAME/.neurojson\t | on all OSes (per-user)\n /home/USERNAME/.cache/neurojson | if on Linux (per-user)\n /var/cache/neurojson \t | if on Linux (system wide)\n /home/USERNAME/Library/neurojson| if on MacOS (per-user)\n /Library/neurojson\t\t | if on MacOS (system wide)\n C:\\ProgramData\\neurojson\t | if on Windows (system wide)\n```\nWhen saving a file from a URL, under the root cache folder, subfolders can be created;\nif the URL is one of a standard NeuroJSON.io URLs as below\n```\n https://neurojson.org/io/stat.cgi?action=get&db=DBNAME&doc=DOCNAME&file=sub-01/anat/datafile.nii.gz\n https://neurojson.io:7777/DBNAME/DOCNAME\n https://neurojson.io:7777/DBNAME/DOCNAME/datafile.suffix\n```\nthe file datafile.nii.gz will be downloaded to /home/USERNAME/.neurojson/io/DBNAME/DOCNAME/sub-01/anat/ folder\nif a URL does not follow the neurojson.io format, the cache folder has the below form\n```\n CACHEFOLDER{i}/domainname.com/XX/YY/XXYYZZZZ...\n```\nwhere XXYYZZZZ.. is the SHA-256 hash of the full URL, XX is the first two digit, YY is the 3-4 digits\n\nIn PyJData, we provide `jdata.jdlink()` function to dynamically download and locally cache\nexternally linked data files. `jdata.jdlink()` only parse files with JSON/binary JSON suffixes that\n`load` supports. Here is a example\n\n```\nimport jdata as jd\n\ndata = jd.load('https://neurojson.io:7777/openneuro/ds000001');\nextlinks = jd.jsonpath(data, '$..anat.._DataLink_') # deep-scan of all anatomical folders and find all linked NIfTI files\njd.jdlink(extlinks, {'regex': 'sub-0[12]_.*nii'}) # download only the nii files for sub-01 and sub-02\njd.jdlink(extlinks) # download all links\n```\n\n## Utility\n\nOne can convert from JSON based data files (`.json, .jdt, .jnii, .jmsh, .jnirs`) to binary-JData\nbased binary files (`.bjd, .jdb, .bnii, .bmsh, .bnirs`) and vice versa using command\n```\npython3 -mjdata /path/to/text/json/file.json # convert to /path/to/text/json/file.jdb\npython3 -mjdata /path/to/text/json/file.jdb # convert to /path/to/text/json/file.json\npython3 -mjdata -h # show help info\n```\n\n## Test\n\nTo see additional data type support, please run the built-in test using below command\n\n```\npython3 -m unittest discover -v test\n```\n",
"bugtrack_url": null,
"license": "Apache license 2.0",
"summary": "Encoding and decoding Python data structrues using portable JData-annotated formats",
"version": "0.6.0",
"project_urls": {
"Download": "https://github.com/NeuroJSON/pyjdata/archive/v0.6.0.tar.gz",
"Homepage": "https://github.com/NeuroJSON/pyjdata"
},
"split_keywords": [
"json",
" jdata",
" ubjson",
" bjdata",
" openjdata",
" neurojson",
" jnifti",
" jmesh",
" encoder",
" decoder"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "55e0e194ce0358ed3e00b006eb155561de862d45cd1e74f4d66e9a5cba9298f4",
"md5": "b8a79705b186295f9bc48c1e8a3e3c0c",
"sha256": "f2f7d8d39cfa3911a161a9c46be79dc8e8ba0197f0a492fe1e28b1826bd3e495"
},
"downloads": -1,
"filename": "jdata-0.6.0-py2.py3-none-any.whl",
"has_sig": false,
"md5_digest": "b8a79705b186295f9bc48c1e8a3e3c0c",
"packagetype": "bdist_wheel",
"python_version": "py2.py3",
"requires_python": null,
"size": 20377,
"upload_time": "2024-04-01T05:50:14",
"upload_time_iso_8601": "2024-04-01T05:50:14.114421Z",
"url": "https://files.pythonhosted.org/packages/55/e0/e194ce0358ed3e00b006eb155561de862d45cd1e74f4d66e9a5cba9298f4/jdata-0.6.0-py2.py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "62d18f03bab6d5b6377a84d0fc456b495b0e5e2a3f24d86ed957cc43f3bae72e",
"md5": "54083475f53d2dbab604587c52575d0c",
"sha256": "5b27138c1355d306df6b38857879b26cddc5d27ce887160d1c567442a46d7ad4"
},
"downloads": -1,
"filename": "jdata-0.6.0.tar.gz",
"has_sig": false,
"md5_digest": "54083475f53d2dbab604587c52575d0c",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 25396,
"upload_time": "2024-04-01T05:50:16",
"upload_time_iso_8601": "2024-04-01T05:50:16.702484Z",
"url": "https://files.pythonhosted.org/packages/62/d1/8f03bab6d5b6377a84d0fc456b495b0e5e2a3f24d86ed957cc43f3bae72e/jdata-0.6.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-01 05:50:16",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "NeuroJSON",
"github_project": "pyjdata",
"travis_ci": true,
"coveralls": false,
"github_actions": true,
"lcname": "jdata"
}
JSON
