| # pyjson5 | |
| A Python implementation of the JSON5 data format. | |
| [JSON5](https://json5.org) extends the | |
| [JSON](http://www.json.org) data interchange format to make it | |
| slightly more usable as a configuration language: | |
| * JavaScript-style comments (both single and multi-line) are legal. | |
| * Object keys may be unquoted if they are legal ECMAScript identifiers | |
| * Objects and arrays may end with trailing commas. | |
| * Strings can be single-quoted, and multi-line string literals are allowed. | |
| There are a few other more minor extensions to JSON; see the above page for | |
| the full details. | |
| This project implements a reader and writer implementation for Python; | |
| where possible, it mirrors the | |
| [standard Python JSON API](https://docs.python.org/library/json.html) | |
| package for ease of use. | |
| There is one notable difference from the JSON api: the `load()` and | |
| `loads()` methods support optionally checking for (and rejecting) duplicate | |
| object keys; pass `allow_duplicate_keys=False` to do so (duplicates are | |
| allowed by default). | |
| This is an early release. It has been reasonably well-tested, but it is | |
| **SLOW**. It can be 1000-6000x slower than the C-optimized JSON module, | |
| and is 200x slower (or more) than the pure Python JSON module. | |
| **Please Note:** This library only handles JSON5 documents, it does not | |
| allow you to read arbitrary JavaScript. For example, bare integers can | |
| be legal object keys in JavaScript, but they aren't in JSON5. | |
| ***One more note:*** It's long past time to declare this a 1.0 stable | |
| product and move on, so I am preparing to do so. If the latest version | |
| proves to be stable (e.g., no bug reports for a month or so), I plan to | |
| switch the directory layout to move `json5` under a `src` directory | |
| (i.e., use a src-layout to avoid accidentally importing an unpackaged | |
| version of the code), bake that for a month or so as well, and then | |
| release this as 1.0. | |
| ## Known issues | |
| * Did I mention that it is **SLOW**? | |
| * `load()` reads the entire remaining stream into memory, including when | |
| `consume_trailing=False`. That option ignores trailing content during | |
| parsing; it does not preserve unread stream data for a later `load()`. | |
| To read successive values, read the input into a string once and use | |
| `parse(..., consume_trailing=False)`, passing its returned position as | |
| the next `start`. Positions refer to decoded characters, not byte offsets | |
| or file seek positions. The `parse()` docstring includes an example. | |
| * The implementation is based on recursive descent parsing and relies on the | |
| runtime stack for recursion; this means that really deeply nested data | |
| might trigger a `RecursionError`, but this doesn't seem to be a problem in | |
| normal practice. If it is, please report it and I can raise the priority | |
| of fixing this properly :). | |
| * The implementation follows Python3's `json` implementation where | |
| possible. This means that the `encoding` method to `dump()` is | |
| ignored, and unicode strings are always returned. There is a slight | |
| difference to the `strict` argument to `load()`/`loads()` in order | |
| to be JSON5-compliant. | |
| * The `cls` keyword argument that `json.load()`/`json.loads()` accepts | |
| to specify a custom subclass of ``JSONDecoder`` is not and will not be | |
| supported, because this implementation uses a completely different | |
| approach to parsing strings and doesn't have anything like the | |
| `JSONDecoder` class. | |
| * The `cls` keyword argument that `json.dump()`/`json.dumps()` accepts | |
| is also not supported, for consistency with `json5.load()`. The `default` | |
| keyword *is* supported, though, and might be able to serve as a | |
| workaround. | |
| ## Contributing: | |
| `json5` has no runtime dependencies and it is supported on Python version | |
| **3.8** or later. | |
| However, in order to develop, test, build and publish the package you need a | |
| bunch of extra tools that are only supported on **3.11** or newer; on older | |
| versions, you can run the test, but not do anything else. | |
| When changing the code, do not add anything that only runs on 3.9 or later | |
| versions, and do not rely on `from __future__ import annotations`. | |
| Use a 79-character line and prefer single quotes to double; otherwise follow | |
| PEP-8 and the normal `ruff format` coding style. Write tests using | |
| `doctest` or `unittest`; for more on this see below. | |
| See [below](#ai-contribution-policy) for the policy on using AI to help | |
| make changes (in short, it's allowed but be careful). | |
| ### Testing | |
| Write tests using either the `unittest` or `doctest` modules from the | |
| standard library. Do not use `pytest` or any other package that needs | |
| to be installed; the tests and code are expected to be able to run in | |
| an environment with only the standard library (and this package) installed. | |
| Aim for 100% line coverage when writing tests. There's really no reason | |
| you can't get it for this package given how straightforward it is, and | |
| given Python's dynamic nature it is too easy for an uncovered line of | |
| code to actually be buggy (though type checkers and other tools have made | |
| this problem better over the years). If possible, feel free to shoot for | |
| 100% branch coverage. | |
| There aren't great guidelines in Python tests for how many tests to include | |
| in a given test case, and when to split things out. Don't necessarily put | |
| all of your tests into a single test case, but don't necessarily put each | |
| combination of things into a separate case either. | |
| Do not go overboard when writing tests. Try to cover the interesting | |
| cases of each type or parameter, and if you think the interaction between two | |
| parameters definitely matters or have a good argument for why it might matter, | |
| do test it. However, do not just exhaustively try to cover every | |
| possible combination of every parameter "just in case". That slows down | |
| the tests unnecessarily and can make it harder to understand the logic | |
| of what each test is doing (i.e., which things are important and which aren't). | |
| Definitely try to see if a given code path is already covered by the | |
| test suite before you write a new test for it. There's not *that* many tests | |
| in the suite, so this shouldn't be too hard to do. | |
| ### AI contribution policy | |
| Patches made with the help of AI are welcome, but contributors are expected | |
| to do their own work to review the changes and be willing and able to | |
| support and justify them. Do not have agents upload changes that you have not | |
| reviewed and vetted yourself. | |
| Changes are expected to match the style and philosophy of the project as much | |
| as possible. In particular, pay close attention to any tests that an AI tool | |
| may generate, and make sure you are not testing things that are already covered | |
| by other tests. | |
| You may disclose that the patch was made "with the help of AI" but don't | |
| have to. However, please don't mention which models or tools you used. It's | |
| not necessary, and at this time I think it's an inappropriate form of | |
| advertising (this stance may change in the future if it turns out that | |
| knowing which tool was used is actually important). | |
| If you used some sort of non-AI based tool to help with your change | |
| like a typechecker, a model checker, or a mutation tester, feel free to | |
| mention which one as it can help with validating and reproducing the changes. | |
| Do not include agents as "co-authors". You are expected to be the author | |
| of your change. If you had help from some other person, disclosing that | |
| is fine, however. | |
| ### On Mac | |
| The easiest thing to do is to install [`uv`](https://docs.astral.sh/uv) and | |
| use `uv` and the `//run` script to develop things. See `./run --help` for | |
| the various commands that are supported. | |
| ``` | |
| $ brew install uv | |
| $ git clone https://github.com/dpranke/pyjson5 | |
| $ cd pyjson5 | |
| $ source $(./run devenv) # To activate a venv w/ all the needed dev tools. | |
| ``` | |
| ### On other platforms | |
| Install `uv` via whatever mechanism is appropriate. | |
| ### Creating a venv | |
| You do not have to create a venv to do anything, if you use the `run` | |
| script, but if you want to invoke tools like `ruff` directly, you | |
| can do so as follows: | |
| ``` | |
| $ ./run devenv # which really just calls `uv sync`. | |
| $ source .venv/bin/activate | |
| ``` | |
| The code is currently written to expect to be executed in an environment | |
| where the package is actually installed, and not just a bunch of source | |
| files in a directory. The latter probably works with enough care taken, | |
| but that configuration is not tested nor guaranteed to work. | |
| ### Run tests and other checks | |
| ``` | |
| $ ./run presubmit | |
| ``` | |
| `//run` supports a number of other commands: | |
| * `regen` will regenerate the parser when the grammar is updated; in order | |
| to run this you need `glop` to be available as described above. | |
| * `format` will format all the code using `ruff format` for the Python code | |
| and `pyproject-fmt` for the `pyproject.toml` file; `format --check` will | |
| report whether the code is formatted properly without actually changing | |
| anything. It checks for the coding style described above. | |
| * `checks` checks the code for problems without actually executing the code. | |
| It runs: | |
| * `ruff check` | |
| * `pylint` | |
| * `mypy` | |
| * `tests` runs all of the tests. See [Testing](#testing) above for how | |
| to write tests for this package. | |
| * `coverage` runs all of the tests using the `coverage` tool in order to | |
| collect code coverage. You can pass `-b/--branch` to collect branch | |
| coverage. | |
| * `build` builds the package to get it ready to publish | |
| * `publish` tries to publish the package. You must specify `--dev` or `--prod` | |
| to indicate which PyPI repository you want to publish to; explicitly having | |
| to mention one or the other helps ensure that you don't try to publish | |
| something by accident. You can run `publish --check` in order to ensure | |
| that the package is built correctly without actually trying to publish it. | |
| You can only actually publish the package if you have permission to do so, | |
| of course. | |
| `presubmit` just runs all of the above commands at once (though not `regen` | |
| at the moment, because you might not have `glop` installed; this'll change | |
| when `glop` is properly packaged and installed in the venv. | |
| Other `run` commands: | |
| * `devenv` creates a virtual environ using `uv` and echoes the command needed | |
| to activate it. | |
| * `clean` will remove any unversioned files from the repo. | |
| * `help` prints usage. | |
| ## Releasing a new version: | |
| 1. Update the version in `json5/version.py` to $VERSION, which should be | |
| of the form X.Y.Z, where X, Y, and Z are numbers. Use | |
| [semantic versioning](https://semver.org/) when increasing the numbers: | |
| * X increases only when making backwards-incompatible or other very | |
| significant changes. Try very hard to avoid this. | |
| * Y increases when adding functionality in a backwards-compatible way. | |
| * Z increases when you are fixing bugs in a backwards-compatible way. | |
| In between releases, the version *may* be set to `X.Y.Z.dev0' to indicate | |
| that this is not an officially released version. | |
| 2. `./run presubmit` once more and make sure everything passes. | |
| 3. `git commit -a -m "Bump the version to $VERSION"` | |
| 4. `git tag "v$VERSION"` | |
| 5. `git push origin` | |
| 6. `git push --tags origin` | |
| 7. `./run publish --prod` (which will build the package if need be first) | |
| (Assuming you have upload privileges to PyPI and the GitHub repo, of course.) | |
| ## Version History / Release Notes: | |
| * Unreleased | |
| * Preserve duck-typed mapping contents without testing their truth value. | |
| * Preserve duck-typed array contents without testing their truth value. | |
| * Honor explicit false-valued callable parsing hooks and default encoders | |
| without testing their truth value. | |
| * Match the standard library's concrete collection encoding by default, | |
| including Python 3.15's built-in `frozendict`; add | |
| `use_duck_typing=True` to retain structural mapping and sequence | |
| detection. | |
| * v0.17.3 (2026-10-09) | |
| * Bump the indirect dependency on `urllib3` to 2.8.0 to pick up a | |
| security fix. | |
| * v0.17.2 (2026-10-09) | |
| * Commit, then release :(. | |
| * v0.17.1 (2026-10-09) | |
| * I screwed up the release and published a package from my dev | |
| fork rather than the main repo as v0.17.0; the package should be | |
| fine, but for reproducibility purposes I needed to redo it and | |
| get the tags right. | |
| * v0.17.0 (2026-10-09) | |
| * Use a packaged version of `glop`, rather than relying on it | |
| being checked out alongside this repo. This should make the | |
| package properly self-contained, and now we can enforce that | |
| the grammar is up-to-date in presubmit. | |
| * Rework the project dependencies. As before, the module still has | |
| no runtime dependencies. However, we will now only support doing | |
| most development on Python 3.11 or newer; older versions will only | |
| support running the tests. This means the `dev` venv config will | |
| only install the dev packages in that newer environment; this | |
| should make Dependabot happier. | |
| * Rework how the `//run` script works; | |
| the previous `pylint` and `mypy` checks have been moved into | |
| the `checks` command, which will now run all of the static | |
| analyzers, not just `ruff check`. The script also now consistently | |
| supports `-f/--failfast` across the commands, not just during `tests`. | |
| * There are no code changes in this release other than bumping the | |
| version numbers. | |
| * v0.16.0 (2026-10-07) | |
| * Document the `RecursionError` issue. | |
| * Fix an issue w/ spec compliance where \u2028 and \u2029 were not | |
| being allowed in string literals. | |
| * "Fix" an issue w/ spec compliance in how control characters | |
| (\x00 - 0x1f) were being handled in string literals; in JSON, | |
| they are not allowed, and the Python library has the `strict=False` | |
| option to allow them. In JSON5, they *are* allowed (except for \r | |
| and \n). json5 also has the `strict` option, and was initially | |
| supposed to match json here (I think), but due to a bug only \r and | |
| \n were being disallowed. However, this behavior is actually correct | |
| (they should always be allowed), and now `strict=False` will just | |
| control whether \r and \n will be allowed. This isn't a behavior | |
| change, but it might change what you expected the behavior to be. | |
| I've updated the docs. | |
| * Fix an issue where `start` wasn't being handled properly in the | |
| `load`() call. | |
| * Fix an issue where the error message was misformatted for illegal | |
| NaN values. | |
| * [Fix #92](https://github.com/dpranke/pyjson5/issues/92) and | |
| [#115](https://github.com/dpranke/pyjson5/pull/115), and update | |
| the type declarations for `load()` and `loads() to reflect that either | |
| bytes or strings might be passed in. | |
| * Updated all the dev dependencies and fixed all of the issues raised | |
| by newer versions of `ruff lint` and `pylint`. | |
| * v0.15.0 (2026-06-19) | |
| * [Fix #113](https://github.com/dpranke/pyjson5/issues/113), where parsing | |
| of signed hexadecimal literals such as `-0x1f` and `+0xff` was raising | |
| a ValueError instead of being allowed. | |
| * [Fix #111](https://github.com/dpranke/pyjson5/issues/111), with a slight | |
| docstring typo fix/improvement. | |
| * upgraded package dependences to their "latest" versions (without changing | |
| any direct dependencies and not pulling in anything newer than 30 days | |
| old). This resolves some potential security issues in a dev environment | |
| that Dependabot was warning about; no effect on the production code | |
| since the production library has no dependencies. | |
| * v0.14.0 (2026-03-27) | |
| This is really just a dependency bump release. | |
| * No (non-test) code changes. | |
| * Upgraded to latest packages for dev dependencies | |
| * Silenced a couple of warnings from the latest pylint where it | |
| can't deal with both unreachable code and a bad return value. | |
| * v0.13.0 (2026-01-01) | |
| * No code changes. | |
| * Add Python 3.14 to supported version, project config, dependencies | |
| * Update dependencies to latest stuff < 2025-12-01 | |
| * This relaxes the versions specified in pyproject.toml to just | |
| use 'newer than' rather than exact matches. | |
| * Sets 'uv.tool.exclude-newer' in pyproject.toml to tell uv not | |
| to look at packages published within the past 30 days; this will | |
| hopefully help prevent dependencies on compromised projects. | |
| * Switch to using dependency-groups for 'dev' group. | |
| * v0.12.1 (2025-08-12) | |
| * Fix [#94](https://github.com/dpranke/pyjson5/issues/94), where objects | |
| returned from a custom encoder were not being indented properly. | |
| * v0.12.0 (2025-04-03) | |
| * Roll back pyproject.toml change for licensing so that we can still | |
| build the package on 3.8. | |
| * Upgrade devenv package dependencies to latest versions; they now need | |
| Python 3.9 or newer, though json5 itself still supports 3.8. | |
| * v0.11.0 (2025-04-01) | |
| * Add a couple examples to the documentation and run doctest over | |
| them. | |
| * Fix a typing issue in dump and dumps with the `cls` argument; turns | |
| out mypy was right and I was wrong and I didn't realize it :). | |
| * Introduce a new `parse` method that can be used to iterate through | |
| a string, extracting multiple values. | |
| * Add a new `consume_trailing` parameter to `load`/`loads`/`parse` | |
| that specifies whether to keep parsing after a valid object is | |
| reached. By default, this is True and the string must only contain | |
| trailing whitespace. If set to False, parsing will stop when a | |
| valid object is reached. | |
| * Add a new `start` parameter to `load`/`loads`/`parse` to specify | |
| the zero-based offset to start parsing the string or file from. | |
| * [GitHub issue #60](https://github.com/dpranke/pyjson5/issues/60). | |
| Fix a bug where we were attempting to allow '--4' as a valid number. | |
| * v0.10.0 (2024-11-25) | |
| * [GitHub issue #57](https://github.com/dpranke/pyjson5/issues/57). | |
| Added a `JSON5Encoder` class that can be overridden to do custom | |
| encoding of values. This class is vaguely similar to the `JSONEncoder` | |
| class in the standard `json` library, except that it has an | |
| `encode()` method that can be overridden to customize *any* | |
| value, not just ones the standard encoder doesn't know how to handle. | |
| It does also support a `default()` method that can be used to | |
| encode things not normally encodable, like the JSONEncoder class. | |
| It does not support an `iterencode` method. One could probably | |
| be added in the future, although exactly how that would work and | |
| interact with `encode` is a little unclear. | |
| * Restructured the code to use the new encoder class; doing so actually | |
| allowed me to delete a bunch of tediously duplicative code. | |
| * Added a new `quote_style` argument to `dump()`/`dumps()` to control | |
| how strings are encoded by default. For compatibility with older | |
| versions of the json5 library and the standard json library, it | |
| uses `QuoteStyle.ALWAYS_DOUBLE` which encodes all strings with double | |
| quotes all the time. You can also configure it to use single quotes | |
| all the time (`ALWAYS_SINGLE`), and to switch between single and double | |
| when doing so eliminates a need to escape quotes (`PREFER_SINGLE` and | |
| `PREFER_DOUBLE`). This also adds a `--quote-style` argument to | |
| `python -m json5`. | |
| * This release has a fair number of changes, but is intended to be | |
| completely backwards-compatible. Code without changes should run exactly | |
| as it did before. | |
| * v0.9.28 (2024-11-11) | |
| * Fix GitHub CI to install `uv` so `./run tests` works properly. | |
| * Mark Python3.13 as supported in package metadata. | |
| * Update dev package dependencies (note that the latest versions | |
| of coverage and pylint no longer work w/ Python3.8) | |
| * v0.9.27 (2024-11-10) | |
| * Fix typo in //README.md | |
| * v0.9.26 (2024-11-10) | |
| * [GitHub issue #82](https://github.com/dpranke/pyjson5/issues/82) | |
| Add support for the `strict` parameter to `load()`/`loads()`. | |
| * Significantly rework the infra and the `run` script to be | |
| contemporary. | |
| * v0.9.25 (2024-04-12) | |
| * [GitHub issue #81](https://github.com/dpranke/pyjson5/issues/81) | |
| Explicitly specify the directory to use for the package in | |
| pyproject.toml. | |
| * v0.9.24 (2024-03-16) | |
| * Update GitHub workflow config to remove unnecessary steps and | |
| run on pull requests as well as commits. | |
| * Added note about removing `hypothesize` in v0.9.23. | |
| * No code changes. | |
| * v0.9.23 (2024-03-16) | |
| * Lots of cleanup: | |
| * Removed old code needed for Python2 compatibility. | |
| * Removed tests using `hypothesize`. This ran model-based checks | |
| and didn't really add anything useful in terms of coverage to | |
| the test suite, and it introduced dependencies and slowed down | |
| the tests significantly. It was a good experiment but I think | |
| we're better off without it. | |
| * Got everything linting cleanly with pylint 3.1 and `ruff check` | |
| using ruff 0.3.3 (Note that commit message in 00d73a3 says pylint | |
| 3.11, which is a typo). | |
| * Code reformatted with `ruff format` | |
| * Added missing tests to bring coverage up to 100%. | |
| * Lots of minor code changes as the result of linting and coverage | |
| testing, but no intentional functional differences. | |
| * v0.9.22 (2024-03-06) | |
| * Attempt to fix the GitHub CI configuration now that setup.py | |
| is gone. Also, test on 3.12 instead of 3.11. | |
| * No code changes. | |
| * v0.9.21 (2024-03-06) | |
| * Moved the benchmarks/*.json data files' license information | |
| to //LICENSE to (hopefully) make the Google linter happy. | |
| * v0.9.20 (2024-03-03) | |
| * Added `json5.__version__` in addition to `json5.VERSION`. | |
| * More packaging modernization (no more setup.{cfg,py} files). | |
| * Mark Python3.12 as supported in project.classifiers. | |
| * Updated the `//run` script to use python3. | |
| * v0.9.19 (2024-03-03) | |
| * Replaced the benchmarking data files that came from chromium.org with | |
| three files obtained from other datasets on GitHub. Since this repo | |
| is vendored into the chromium/src repo it was occasionally confusing | |
| people who thought the data was actually used for non-benchmarking | |
| purposes and thus updating it for whatever reason. | |
| * No code changes. | |
| * v0.9.18 (2024-02-29) | |
| * Add typing information to the module. This is kind of a big change, | |
| but there should be no functional differences. | |
| * v0.9.17 (2024-02-19) | |
| * Move from `setup.py` to `pyproject.toml`. | |
| * No code changes (other than the version increasing). | |
| * v0.9.16 (2024-02-19) | |
| * Drop Python2 from `setup.py` | |
| * Add minimal packaging instructions to `//README.md`. | |
| * v0.9.15 (2024-02-19) | |
| * Merge in [Pull request #66](https://github.com/dpranke/pyjson5/pull/66) | |
| to include the tests and sample file in a source distribution. | |
| * v0.9.14 (2023-05-14) | |
| * [GitHub issue #63](https://github.com/dpranke/pyjson5/issues/63) | |
| Handle `+Infinity` as well as `-Infinity` and `Infinity`. | |
| * v0.9.13 (2023-03-16) | |
| * [GitHub PR #64](https://github.com/dpranke/pyjson5/pull/64) | |
| Remove a field from one of the JSON benchmark files to | |
| reduce confusion in Chromium. | |
| * No code changes. | |
| * v0.9.12 (2023-01-02) | |
| * Fix GitHub Actions config file to no longer test against | |
| Python 3.6 or 3.7. For now we will only test against an | |
| "oldest" release (3.8 in this case) and a "current" | |
| release (3.11 in this case). | |
| * v0.9.11 (2023-01-02) | |
| * [GitHub issue #60](https://github.com/dpranke/pyjson5/issues/60) | |
| Fixed minor Python2 compatibility issue by referring to | |
| `float("inf")` instead of `math.inf`. | |
| * v0.9.10 (2022-08-18) | |
| * [GitHub issue #58](https://github.com/dpranke/pyjson5/issues/58) | |
| Updated the //README.md to be clear that parsing arbitrary JS | |
| code may not work. | |
| * Otherwise, no code changes. | |
| * v0.9.9 (2022-08-01) | |
| * [GitHub issue #57](https://github.com/dpranke/pyjson5/issues/57) | |
| Fixed serialization for objects that subclass `int` or `float`: | |
| Previously we would use the objects __str__ implementation, but | |
| that might result in an illegal JSON5 value if the object had | |
| customized __str__ to return something illegal. Instead, | |
| we follow the lead of the `JSON` module and call `int.__repr__` | |
| or `float.__repr__` directly. | |
| * While I was at it, I added tests for dumps(-inf) and dumps(nan) | |
| when those were supposed to be disallowed by `allow_nan=False`. | |
| * v0.9.8 (2022-05-08) | |
| * [GitHub issue #47](https://github.com/dpranke/pyjson5/issues/47) | |
| Fixed error reporting in some cases due to how parsing was handling | |
| nested rules in the grammar - previously the reported location for | |
| the error could be far away from the point where it actually happened. | |
| * v0.9.7 (2022-05-06) | |
| * [GitHub issue #52](https://github.com/dpranke/pyjson5/issues/52) | |
| Fixed behavior of `default` fn in `dump` and `dumps`. Previously | |
| we didn't require the function to return a string, and so we could | |
| end up returning something that wasn't actually valid. This change | |
| now matches the behavior in the `json` module. *Note: This is a | |
| potentially breaking change.* | |
| * v0.9.6 (2021-06-21) | |
| * Bump development status classifier to 5 - Production/Stable, which | |
| the library feels like it is at this point. If I do end up significantly | |
| reworking things to speed it up and/or to add round-trip editing, | |
| that'll likely be a 2.0. If this version has no reported issues, | |
| I'll likely promote it to 1.0. | |
| * Also bump the tested Python versions to 2.7, 3.8 and 3.9, though | |
| earlier Python3 versions will likely continue to work as well. | |
| * [GitHub issue #46](https://github.com/dpranke/pyjson5/issues/36) | |
| Fix incorrect serialization of custom subtypes | |
| * Make it possible to run the tests if `hypothesis` isn't installed. | |
| * v0.9.5 (2020-05-26) | |
| * Miscellaneous non-source cleanups in the repo, including setting | |
| up GitHub Actions for a CI system. No changes to the library from | |
| v0.9.4, other than updating the version. | |
| * v0.9.4 (2020-03-26) | |
| * [GitHub pull #38](https://github.com/dpranke/pyjson5/pull/38) | |
| Fix from fredrik@fornwall.net for dumps() crashing when passed | |
| an empty string as a key in an object. | |
| * v0.9.3 (2020-03-17) | |
| * [GitHub pull #35](https://github.com/dpranke/pyjson5/pull/35) | |
| Fix from pastelmind@ for dump() not passing the right args to dumps(). | |
| * Fix from p.skouzos@novafutur.com to remove the tests directory from | |
| the setup call, making the package a bit smaller. | |
| * v0.9.2 (2020-03-02) | |
| * [GitHub pull #34](https://github.com/dpranke/pyjson5/pull/34) | |
| Fix from roosephu@ for a badly formatted nested list. | |
| * v0.9.1 (2020-02-09) | |
| * [GitHub issue #33](https://github.com/dpranke/pyjson5/issues/33): | |
| Fix stray trailing comma when dumping an object with an invalid key. | |
| * v0.9.0 (2020-01-30) | |
| * [GitHub issue #29](https://github.com/dpranke/pyjson5/issues/29): | |
| Fix an issue where objects keys that started with a reserved | |
| word were incorrectly quoted. | |
| * [GitHub issue #30](https://github.com/dpranke/pyjson5/issues/30): | |
| Fix an issue where dumps() incorrectly thought a data structure | |
| was cyclic in some cases. | |
| * [GitHub issue #32](https://github.com/dpranke/pyjson5/issues/32): | |
| Allow for non-string keys in dicts passed to ``dump()``/``dumps()``. | |
| Add an ``allow_duplicate_keys=False`` to prevent possible | |
| ill-formed JSON that might result. | |
| * v0.8.5 (2019-07-04) | |
| * [GitHub issue #25](https://github.com/dpranke/pyjson5/issues/25): | |
| Add LICENSE and README.md to the dist. | |
| * [GitHub issue #26](https://github.com/dpranke/pyjson5/issues/26): | |
| Fix printing of empty arrays and objects with indentation, fix | |
| misreporting of the position on parse failures in some cases. | |
| * v0.8.4 (2019-06-11) | |
| * Updated the version history, too. | |
| * v0.8.3 (2019-06-11) | |
| * Tweaked the README, bumped the version, forgot to update the version | |
| history :). | |
| * v0.8.2 (2019-06-11) | |
| * Actually bump the version properly, to 0.8.2. | |
| * v0.8.1 (2019-06-11) | |
| * Fix bug in setup.py that messed up the description. Unfortunately, | |
| I forgot to bump the version for this, so this also identifies as 0.8.0. | |
| * v0.8.0 (2019-06-11) | |
| * Add `allow_duplicate_keys=True` as a default argument to | |
| `json5.load()`/`json5.loads()`. If you set the key to `False`, duplicate | |
| keys in a single dict will be rejected. The default is set to `True` | |
| for compatibility with `json.load()`, earlier versions of json5, and | |
| because it's simply not clear if people would want duplicate checking | |
| enabled by default. | |
| * v0.7 (2019-03-31) | |
| * Changes dump()/dumps() to not quote object keys by default if they are | |
| legal identifiers. Passing `quote_keys=True` will turn that off | |
| and always quote object keys. | |
| * Changes dump()/dumps() to insert trailing commas after the last item | |
| in an array or an object if the object is printed across multiple lines | |
| (i.e., if `indent` is not None). Passing `trailing_commas=False` will | |
| turn that off. | |
| * The `json5.tool` command line tool now supports the `--indent`, | |
| `--[no-]quote-keys`, and `--[no-]trailing-commas` flags to allow | |
| for more control over the output, in addition to the existing | |
| `--as-json` flag. | |
| * The `json5.tool` command line tool no longer supports reading from | |
| multiple files, you can now only read from a single file or | |
| from standard input. | |
| * The implementation no longer relies on the standard `json` module | |
| for anything. The output should still match the json module (except | |
| as noted above) and discrepancies should be reported as bugs. | |
| * v0.6.2 (2019-03-08) | |
| * Fix [GitHub issue #23](https://github.com/dpranke/pyjson5/issues/23) and | |
| pass through unrecognized escape sequences. | |
| * v0.6.1 (2018-05-22) | |
| * Cleaned up a couple minor nits in the package. | |
| * v0.6.0 (2017-11-28) | |
| * First implementation that attempted to implement 100% of the spec. | |
| * v0.5.0 (2017-09-04) | |
| * First implementation that supported the full set of kwargs that | |
| the `json` module supports. |