JMESPath is a query language for JSON.

Overview

JMESPath

https://travis-ci.org/jmespath/jmespath.py.svg?branch=develop https://codecov.io/github/jmespath/jmespath.py/coverage.svg?branch=develop

JMESPath (pronounced "james path") allows you to declaratively specify how to extract elements from a JSON document.

For example, given this document:

{"foo": {"bar": "baz"}}

The jmespath expression foo.bar will return "baz".

JMESPath also supports:

Referencing elements in a list. Given the data:

{"foo": {"bar": ["one", "two"]}}

The expression: foo.bar[0] will return "one". You can also reference all the items in a list using the * syntax:

{"foo": {"bar": [{"name": "one"}, {"name": "two"}]}}

The expression: foo.bar[*].name will return ["one", "two"]. Negative indexing is also supported (-1 refers to the last element in the list). Given the data above, the expression foo.bar[-1].name will return "two".

The * can also be used for hash types:

{"foo": {"bar": {"name": "one"}, "baz": {"name": "two"}}}

The expression: foo.*.name will return ["one", "two"].

Installation

You can install JMESPath from pypi with:

pip install jmespath

API

The jmespath.py library has two functions that operate on python data structures. You can use search and give it the jmespath expression and the data:

>>> import jmespath
>>> path = jmespath.search('foo.bar', {'foo': {'bar': 'baz'}})
'baz'

Similar to the re module, you can use the compile function to compile the JMESPath expression and use this parsed expression to perform repeated searches:

>>> import jmespath
>>> expression = jmespath.compile('foo.bar')
>>> expression.search({'foo': {'bar': 'baz'}})
'baz'
>>> expression.search({'foo': {'bar': 'other'}})
'other'

This is useful if you're going to use the same jmespath expression to search multiple documents. This avoids having to reparse the JMESPath expression each time you search a new document.

Options

You can provide an instance of jmespath.Options to control how a JMESPath expression is evaluated. The most common scenario for using an Options instance is if you want to have ordered output of your dict keys. To do this you can use either of these options:

>>> import jmespath
>>> jmespath.search('{a: a, b: b}',
...                 mydata,
...                 jmespath.Options(dict_cls=collections.OrderedDict))


>>> import jmespath
>>> parsed = jmespath.compile('{a: a, b: b}')
>>> parsed.search(mydata,
...               jmespath.Options(dict_cls=collections.OrderedDict))

Custom Functions

The JMESPath language has numerous built-in functions, but it is also possible to add your own custom functions. Keep in mind that custom function support in jmespath.py is experimental and the API may change based on feedback.

If you have a custom function that you've found useful, consider submitting it to jmespath.site and propose that it be added to the JMESPath language. You can submit proposals here.

To create custom functions:

  • Create a subclass of jmespath.functions.Functions.
  • Create a method with the name _func_<your function name>.
  • Apply the jmespath.functions.signature decorator that indicates the expected types of the function arguments.
  • Provide an instance of your subclass in a jmespath.Options object.

Below are a few examples:

import jmespath
from jmespath import functions

# 1. Create a subclass of functions.Functions.
#    The function.Functions base class has logic
#    that introspects all of its methods and automatically
#    registers your custom functions in its function table.
class CustomFunctions(functions.Functions):

    # 2 and 3.  Create a function that starts with _func_
    # and decorate it with @signature which indicates its
    # expected types.
    # In this example, we're creating a jmespath function
    # called "unique_letters" that accepts a single argument
    # with an expected type "string".
    @functions.signature({'types': ['string']})
    def _func_unique_letters(self, s):
        # Given a string s, return a sorted
        # string of unique letters: 'ccbbadd' ->  'abcd'
        return ''.join(sorted(set(s)))

    # Here's another example.  This is creating
    # a jmespath function called "my_add" that expects
    # two arguments, both of which should be of type number.
    @functions.signature({'types': ['number']}, {'types': ['number']})
    def _func_my_add(self, x, y):
        return x + y

# 4. Provide an instance of your subclass in a Options object.
options = jmespath.Options(custom_functions=CustomFunctions())

# Provide this value to jmespath.search:
# This will print 3
print(
    jmespath.search(
        'my_add(`1`, `2`)', {}, options=options)
)

# This will print "abcd"
print(
    jmespath.search(
        'foo.bar | unique_letters(@)',
        {'foo': {'bar': 'ccbbadd'}},
        options=options)
)

Again, if you come up with useful functions that you think make sense in the JMESPath language (and make sense to implement in all JMESPath libraries, not just python), please let us know at jmespath.site.

Specification

If you'd like to learn more about the JMESPath language, you can check out the JMESPath tutorial. Also check out the JMESPath examples page for examples of more complex jmespath queries.

The grammar is specified using ABNF, as described in RFC4234. You can find the most up to date grammar for JMESPath here.

You can read the full JMESPath specification here.

Testing

In addition to the unit tests for the jmespath modules, there is a tests/compliance directory that contains .json files with test cases. This allows other implementations to verify they are producing the correct output. Each json file is grouped by feature.

Discuss

Join us on our Gitter channel if you want to chat or if you have any questions.

Comments
  • Fix wildcard projection bug

    Fix wildcard projection bug

    Don't project a None (null) value, project an empty list if we receive a None value.

    This was previously generating an uncaught exception because we try to extend a list with a None value.

    opened by jamesls 10
  • Deprecate Python 2.6 and 3.3 before removal

    Deprecate Python 2.6 and 3.3 before removal

    It's a good idea to deprecate before removal (https://github.com/jmespath/jmespath.py/pull/166), to give downstream dependencies a heads up.

    How would you like to deprecate?

    Here's some ideas. Let me know if you want any of them removing or changing. I assumed JMESPath 1.0 would be the version they'll be dropped in, but that of course can be changed.

    Warn when importing

    • Pro: deprecation is visible
    • Con: maybe too visible

    Warn when installing

    • Pro: gets the message across, not too often
    • Con: maybe you don't want any warning

    Document in CHANGELOG

    • The minimum needed

    Also added python_requires for the current versions (2.6+, 3.3+). This would be useful whatever is decided.

    opened by hugovk 8
  • Drop support for EOL Python 2.6 and 3.3

    Drop support for EOL Python 2.6 and 3.3

    Python 2.6 and 3.3 are EOL (2.6 in 2013 and 3.3 in 2017) and no longer receiving security updates (or any updates) from the core Python team. They're also relatively little used.

    Here's the pip installs for JMESPath from PyPI for July 2018:

    | python_version | percent | download_count | | -------------- | ------: | -------------: | | 2.7 | 84.97% | 6,859,760 | | 3.6 | 8.74% | 705,206 | | 3.5 | 3.93% | 317,543 | | 3.4 | 1.45% | 117,063 | | 3.7 | 0.48% | 38,496 | | 2.6 | 0.43% | 34,353 | | 3.3 | 0.00% | 381 | | 3.8 | 0.00% | 12 | | None | 0.00% | 2 | | 3.2 | 0.00% | 1 | | Total | | 8,072,817 |

    Source: pypinfo --start-date 2018-07-01 --end-date 2018-07-31 --percent --markdown jmespath pyversion

    This PR:

    • Drops support for EOL Python 2.6 (same as https://github.com/jmespath/jmespath.py/pull/114)
    • Drops support for EOL Python 3.3
    • Upgrades Python syntax with https://github.com/asottile/pyupgrade
    • Fixes some code inspection warnings
    • Adds python_requires to help pip: https://packaging.python.org/guides/dropping-older-python-versions/
    pending 
    opened by hugovk 7
  • Fix race condition in cache eviction

    Fix race condition in cache eviction

    Class attributes are more likely to be shared between threads. There is a race if two threads try to evict the same cache entry. Due to the random sampling the race only occurs if the cache is big or there are many threads.

    Re the change to setup.py, I think it is good practice to always set the version to a pre-release in between actual releases.

    opened by hannes-ucsc 7
  • Custom functions

    Custom functions

    What are your thoughts about adding a method to register custom functions directly into RuntimeFunctions class in functions.py?

    JMESPath is almost good enough to use as a domain specific language for general language transforming objects. You can sneak in literals in the multi-select hash. You can filter for values, and transform them to booleans using <=, == operators. There's some support for making sure values are numbers.

    However I don't see anyway to do something like "if value is x, return y" where you show a literal if a condition matches. There's no way to convert conditions to an arbitrary literal - if a value in a multi-select hash is going to be a literal, it has to be of the same value no matter what.

    I can see a possible workaround if custom functions on JMESPath. E.g. if I implement the "if" function for use, I can do something like:

    search("if(bar==`1`, `hello`, `world`)", {'bar': '1'})
    

    This would return the literal hello if the bar key is 1, otherwise it returns world. The only issue is the current python implementation means its going to be hacky to do this. You have to override multiple classes, in functions.py and override the TreeInterpreter and the ParsedResult classes as well.

    I think if custom functions were desired, it would be much more elegant if there is a method to register them directly into the RuntimeFunctions in functions.py, rather than either forcing a fork or overriding a litany of classes.

    What do you think?

    feature-request 
    opened by meric 7
  • Added

    Added "current index" support for projections

    It is sometimes useful when in a projection to be able to know which element of the thing being projected you are evaluating. When projecting on an array, the index would be the current index of the array (starting at 0), and when projecting an object, the index would be the current key of the array. I would suggest adding a new token to the grammar to represent the "current_node". The character I would suggest is #.

    I can flesh this out with more details and a JEP if there's interest in something like this.

    opened by mtdowling 7
  • Jep 3

    Jep 3

    Implement JEP-3, latest spec is https://github.com/jamesls/jmespath/blob/mtdowling-functions/docs/proposals/functions.rst

    I need to update the specification.rst with the docs from the JEP linked above, but I'd like to kick off the code review now.

    cc @toastdriven @mtdowling @danielgtaylor

    opened by jamesls 6
  • Problems installing jmespath in Ubuntu 20.04 LTS

    Problems installing jmespath in Ubuntu 20.04 LTS

    I'm running Ubuntu 20.04 LTS in a VirtualBox VM and I just tried to install ansible with the following command line:

    sudo apt-get install ansible -y

    One of the dependencies that it installed was jmespath and I saw the following output from apt-get:

    Setting up python3-jmespath (0.9.4-2) ... /usr/lib/python3/dist-packages/jmespath/visitor.py:32: SyntaxWarning: "is" with a literal. Did you mean "=="? if x is 0 or x is 1: /usr/lib/python3/dist-packages/jmespath/visitor.py:32: SyntaxWarning: "is" with a literal. Did you mean "=="? if x is 0 or x is 1: /usr/lib/python3/dist-packages/jmespath/visitor.py:34: SyntaxWarning: "is" with a literal. Did you mean "=="? elif y is 0 or y is 1: /usr/lib/python3/dist-packages/jmespath/visitor.py:34: SyntaxWarning: "is" with a literal. Did you mean "=="? elif y is 0 or y is 1: /usr/lib/python3/dist-packages/jmespath/visitor.py:260: SyntaxWarning: "is" with a literal. Did you mean "=="? if original_result is 0:

    I'm guessing that this is not the result you expected. Is there any additional information that I can provide you?

    I've attached a text file with all of the apt-get output. apt-get output.txt

    opened by Tomasthanes 5
  • Python 3.8 raises a SyntaxWarning

    Python 3.8 raises a SyntaxWarning

    https://github.com/jmespath/jmespath.py/blob/develop/jmespath/visitor.py#L32

    SyntaxWarning: "is" with a literal. Did you mean "=="?  if x is 0 or x is 1:
    if x is 0 or x is 1:
    

    I noticed this error when installing boto3 (requires jmespath 0.9.4) with Python 3.8. The warning was not present in Python 3.7.x

    Lines 32, 34, 260 are affected.

    opened by mneil 5
  • Can't flatten sub-sub-lists?

    Can't flatten sub-sub-lists?

    Let's say I have this list: [[1, 2, 3, [4]], [5, 6, 7, [8, 9]]

    I want to extract this output: [[1, 2, 3, 4], [5, 6, 7, 8, 9]]

    It seems like this query should work: [*][], i.e., "project the input into a list, and flatten each element of the outer list" but it doesn't work. I get [1, 2, 3, [4], 5, 6, 7, [8, 9]], which is the same as if I had just passed in []. Oddly, [*][0] does return what I would expect, [1, 5] which the first element of each element of the outer list. Why is it that in the [*][0] expression the [0] operates on each element of the top-level list, while in [*][] the [] seems to operate on the list as a whole? I would expect that behavior out of [*] | []. Similarly, [0][] returns [1, 2, 3, 4] and [1][] returns [5, 6, 7, 8, 9].

    I see the same behavior both on the released 0.7.1 and the current develop branch.

    Thanks!

    --Joel

    enhancement 
    opened by joelthompson 5
  • Add starts_with, ends_with, reverse functions

    Add starts_with, ends_with, reverse functions

    I think these functions would be useful, but am open to hearing suggestions. I know that some of these can be accomplished with the array slicing JEP, but these arguably provide a more convenient way to do this (foo[::-1] vs. reverse(foo)).

    opened by jamesls 5
  • Bump wheel from 0.24.0 to 0.38.1

    Bump wheel from 0.24.0 to 0.38.1

    Bumps wheel from 0.24.0 to 0.38.1.

    Changelog

    Sourced from wheel's changelog.

    Release Notes

    UNRELEASED

    • Updated vendored packaging to 22.0

    0.38.4 (2022-11-09)

    • Fixed PKG-INFO conversion in bdist_wheel mangling UTF-8 header values in METADATA (PR by Anderson Bravalheri)

    0.38.3 (2022-11-08)

    • Fixed install failure when used with --no-binary, reported on Ubuntu 20.04, by removing setup_requires from setup.cfg

    0.38.2 (2022-11-05)

    • Fixed regression introduced in v0.38.1 which broke parsing of wheel file names with multiple platform tags

    0.38.1 (2022-11-04)

    • Removed install dependency on setuptools
    • The future-proof fix in 0.36.0 for converting PyPy's SOABI into a abi tag was faulty. Fixed so that future changes in the SOABI will not change the tag.

    0.38.0 (2022-10-21)

    • Dropped support for Python < 3.7
    • Updated vendored packaging to 21.3
    • Replaced all uses of distutils with setuptools
    • The handling of license_files (including glob patterns and default values) is now delegated to setuptools>=57.0.0 (#466). The package dependencies were updated to reflect this change.
    • Fixed potential DoS attack via the WHEEL_INFO_RE regular expression
    • Fixed ValueError: ZIP does not support timestamps before 1980 when using SOURCE_DATE_EPOCH=0 or when on-disk timestamps are earlier than 1980-01-01. Such timestamps are now changed to the minimum value before packaging.

    0.37.1 (2021-12-22)

    • Fixed wheel pack duplicating the WHEEL contents when the build number has changed (#415)
    • Fixed parsing of file names containing commas in RECORD (PR by Hood Chatham)

    0.37.0 (2021-08-09)

    • Added official Python 3.10 support
    • Updated vendored packaging library to v20.9

    ... (truncated)

    Commits
    • 6f1608d Created a new release
    • cf8f5ef Moved news item from PR #484 to its proper place
    • 9ec2016 Removed install dependency on setuptools (#483)
    • 747e1f6 Fixed PyPy SOABI parsing (#484)
    • 7627548 [pre-commit.ci] pre-commit autoupdate (#480)
    • 7b9e8e1 Test on Python 3.11 final
    • a04dfef Updated the pypi-publish action
    • 94bb62c Fixed docs not building due to code style changes
    • d635664 Updated the codecov action to the latest version
    • fcb94cd Updated version to match the release
    • Additional commits viewable in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • Usage Questions

    Usage Questions

    Sorry for perhaps a basic question but have structure as follows :

    jsonData = """{ "products" : { "1" : { "sku" : "a", "attributes" : { "location" : "there", "time": ""500". "planet" : "earth" } }, "2" : { "sku" : "b", "something" : "1", "attributes" : { "location" : "here", "time": ""500". "planet" : "Mars" } }, "3" : { "sku" : "c", "something" : "3", "attributes" : { "location" : "there", "time": ""300". "planet" : "earth" } } } }"""

    I'm trying to return all time values where planet = "earth". I've tried a few things and reviewed the excellent examples in your documentation but i'm still stuck. Any pointers would be really appreciated.

    opened by AkikoOrenji 1
  • JEP-19 Evaluation of Pipe Expressions

    JEP-19 Evaluation of Pipe Expressions

    Sub Expression

    The specification for sub-expression outlines how it should behave in pseudocode:

    left-evaluation = search(left-expression, original-json-document)
    result = search(right-expression, left-evaluation)
    

    However, this is incorrect, as many compliance tests expect the result to be null when the left-hand-side evaluates to  null. So, the real pseudocode shoud in fact be:

    left-evaluation = search(left-expression, original-json-document)
    if left-evaluation is `null` then result = `null`
    else result = search(right-expression, left-evaluation)
    

    Pipe Expression

    However, it seems intuitive for pipe-expression to behave as is specified by the pseudocode above.

    left-evaluation = search(left-expression, original-json-document)
    result = search(right-expression, left-evaluation)
    

    Which means that the evaluation should still happens if the left-hand-side is null.

    Summary

    This PR introduces a new compliance test that outlines the following expression: search ( `null` | [@], {} ) -> [ null ] in the hope to standardize the exact behaviour of pipe expressions.

    opened by springcomp 0
  • `TreeInterpreter` creates reference cycle, causing GC pressure

    `TreeInterpreter` creates reference cycle, causing GC pressure

    We recently noticed that a heavy JMESpath workload was triggering a large number of garbage collection runs. We are using jmespath.compile(), and we tracked this down to the jmespath.visitor.TreeInterpreter that is created on every call to `ParsedResult.search(): https://github.com/jmespath/jmespath.py/blob/bbe7300c60056f52413603cf3e2bcd0b6afeda3d/jmespath/parser.py#L508

    It appears that TreeInterpreter creates a reference cycle, which leads to the GC being triggered frequently to clean up the cycles. As far as I can tell, the problem comes from the Visitor._method_cache: https://github.com/jmespath/jmespath.py/blob/bbe7300c60056f52413603cf3e2bcd0b6afeda3d/jmespath/visitor.py#L91-L93

    ...which store references to methods that are bound to self in a member of self.

    Possible solution

    We worked around the problem by monkey patching ParsedResult so that it (1) caches a default_interpreter for use when options=None, and (2) uses it in search(). If I understand correctly, we could go further and use a global TreeInterpreter for all ParsedResult instances. The TreeInterpreter seems to be stateless apart from self._method_cache and that implementation seems to be thread-safe (with only the risk of multiple lookups for the same method in a multithreaded case).

    I'd be happy to contribute a PR for either version if this would be welcome.

    How to reproduce

    The following reproducer shows the problem:

    import jmespath
    
    import gc
    gc.set_debug(gc.DEBUG_COLLECTABLE)
    
    pattern = jmespath.compile("foo")
    value = {"foo": "bar"}
    
    for _ in range(1000000):
        pattern.search(value)
    

    ...where the output contains one million repetitions of something like:

    gc: collectable <TreeInterpreter 0x10f634fa0>
    gc: collectable <dict 0x10f63e780>
    gc: collectable <Options 0x10f634520>
    gc: collectable <Functions 0x10f6345b0>
    gc: collectable <method 0x10f63ee80>
    gc: collectable <dict 0x10f63eb00>
    
    opened by mrry 1
  • Remove uneeded cast to `float` in `avg` function

    Remove uneeded cast to `float` in `avg` function

    Python3 implemented PEP-238 which changes the way the division operator is applyied. In Python3 is not needed a float casting to get the result of a "true division" rather than the previous "floor division". As I can see, jmespath.py does not support Python2 so this cast can be removed.

    opened by mondeja 0
the project for the most brutal and effective language learning technique

- "The project for the most brutal and effective language learning technique" (c) Alex Kay The langflow project was created especially for language le

Alexander Kaigorodov 7 Dec 26, 2021
Python-samples - This project is to help someone need some practices when learning python language

Python-samples - This project is to help someone need some practices when learning python language

Gui Chen 0 Feb 14, 2022
jmespath.rs Python binding

rjmespath-py jmespath.rs Python binding.

messense 3 Dec 14, 2022
PyPika is a python SQL query builder that exposes the full richness of the SQL language using a syntax that reflects the resulting query. PyPika excels at all sorts of SQL queries but is especially useful for data analysis.

PyPika - Python Query Builder Abstract What is PyPika? PyPika is a Python API for building SQL queries. The motivation behind PyPika is to provide a s

KAYAK 1.9k Jan 4, 2023
Continuous Query Decomposition for Complex Query Answering in Incomplete Knowledge Graphs

Continuous Query Decomposition This repository contains the official implementation for our ICLR 2021 (Oral) paper, Complex Query Answering with Neura

UCL Natural Language Processing 71 Dec 29, 2022
Code for ACL 21: Generating Query Focused Summaries from Query-Free Resources

marge This repository releases the code for Generating Query Focused Summaries from Query-Free Resources. Please cite the following paper [bib] if you

Yumo Xu 28 Nov 10, 2022
A python framework to transform natural language questions to queries in a database query language.

__ _ _ _ ___ _ __ _ _ / _` | | | |/ _ \ '_ \| | | | | (_| | |_| | __/ |_) | |_| | \__, |\__,_|\___| .__/ \__, | |_| |_| |___/

Machinalis 1.2k Dec 18, 2022
Python library for serializing any arbitrary object graph into JSON. It can take almost any Python object and turn the object into JSON. Additionally, it can reconstitute the object back into Python.

jsonpickle jsonpickle is a library for the two-way conversion of complex Python objects and JSON. jsonpickle builds upon the existing JSON encoders, s

null 1.1k Jan 2, 2023
Creates fake JSON files from a JSON schema

Use jsf along with fake data generators to provide consistent and meaningful fake data for your system.

Andy Challis 86 Jan 3, 2023
Json utils is a python module that you can use when working with json files.

Json-utils Json utils is a python module that you can use when working with json files. it comes packed with a lot of featrues Features Converting jso

Advik 4 Apr 24, 2022
Random JSON Key:Pair Json Generator

Random JSON Key:Value Pair Generator This simple script take an engish dictionary of words and and makes random key value pairs. The dictionary has ap

Chris Edwards 1 Oct 14, 2021
With the help of json txt you can use your txt file as a json file in a very simple way

json txt With the help of json txt you can use your txt file as a json file in a very simple way Dependencies re filemod pip install filemod Installat

Kshitij 1 Dec 14, 2022
Same as json.dumps or json.loads, feapson support feapson.dumps and feapson.loads

Same as json.dumps or json.loads, feapson support feapson.dumps and feapson.loads

boris 5 Dec 1, 2021
Fast subdomain scanner, Takes arguments from a Json file ("args.json") and outputs the subdomains.

Fast subdomain scanner, Takes arguments from a Json file ("args.json") and outputs the subdomains. File Structure core/ colors.py db/ wordlist.txt REA

whoami security 4 Jul 2, 2022
Get important strings inside [Info.plist] & and Binary file also all output of result it will be saved in [app_binary].json , [app_plist_file].json file

Get important strings inside [Info.plist] & and Binary file also all output of result it will be saved in [app_binary].json , [app_plist_file].json file

null 12 Sep 28, 2022
🐍 A hyper-fast Python module for reading/writing JSON data using Rust's serde-json.

A hyper-fast, safe Python module to read and write JSON data. Works as a drop-in replacement for Python's built-in json module. This is alpha software

Matthias 479 Jan 1, 2023
Django-gmailapi-json-backend - Email backend for Django which sends email via the Gmail API through a JSON credential

django-gmailapi-json-backend Email backend for Django which sends email via the

Innove 1 Sep 9, 2022
Ibmi-json-beautify - Beautify json string with python

Ibmi-json-beautify - Beautify json string with python

Jefferson Vaughn 3 Feb 2, 2022
A Python command-line utility for validating that the outputs of a given Declarative Form Azure Portal UI JSON template map to the input parameters of a given ARM Deployment Template JSON template

A Python command-line utility for validating that the outputs of a given Declarative Form Azure Portal UI JSON template map to the input parameters of a given ARM Deployment Template JSON template

Glenn Musa 1 Feb 3, 2022
GraphQL is a query language and execution engine tied to any backend service.

GraphQL The GraphQL specification is edited in the markdown files found in /spec the latest release of which is published at https://graphql.github.io

GraphQL 14k Jan 1, 2023