# Fuzzy JSON Repair
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
You ask an LLM for JSON, it gives you `{"nam": "John", "emal": "john@example.com"}` instead of `{"name": "John", "email": "john@example.com"}`. Your Pydantic validation fails. You spend an hour writing error handling code.
This library fixes those typos automatically using fuzzy string matching. No more manual key mapping, no more try-except blocks everywhere.
## Install
```bash
pip install fuzzy-json-repair
```
If you're processing lots of data, install with numpy for ~10x faster batch processing:
```bash
pip install fuzzy-json-repair[fast]
```
## Usage
The simplest way - repair and validate in one go:
```python
from pydantic import BaseModel
from fuzzy_json_repair import fuzzy_model_validate_json
class User(BaseModel):
name: str
age: int
email: str
# Your LLM gave you this
json_str = '{"nam": "John", "agge": 30, "emal": "john@example.com"}'
# This just works
user = fuzzy_model_validate_json(json_str, User)
print(user) # User(name='John', age=30, email='john@example.com')
```
Or if you want more control:
```python
from fuzzy_json_repair import repair_keys
schema = User.model_json_schema()
data = {'nam': 'John', 'agge': 30, 'emal': 'john@example.com'}
result = repair_keys(data, schema)
if result.success:
user = User.model_validate(result.data)
else:
print(f"Repair failed: {len(result.errors)} errors")
print(f"Error ratio: {result.error_ratio:.2%}")
```
## Advanced Usage
### Nested Objects
```python
class Address(BaseModel):
street: str
city: str
zip_code: str
class Person(BaseModel):
name: str
address: Address
data = {
'nam': 'John',
'addres': {
'stret': '123 Main St',
'cty': 'NYC',
'zip_cod': '10001'
}
}
schema = Person.model_json_schema()
result = repair_keys(data, schema, max_error_ratio_per_key=0.5)
# All nested typos are fixed!
if result.success:
person = Person.model_validate(result.data)
```
### Lists of Objects
```python
class Product(BaseModel):
product_id: str
name: str
price: float
class Cart(BaseModel):
cart_id: str
products: list[Product]
data = {
'cart_idd': 'C123',
'prodcts': [
{'product_idd': 'P1', 'nam': 'Laptop', 'pric': 999.99},
{'product_idd': 'P2', 'nam': 'Mouse', 'pric': 29.99}
]
}
schema = Cart.model_json_schema()
result = repair_keys(data, schema, max_error_ratio_per_key=0.5)
# Repairs all typos in the list items too!
if result.success:
cart = Cart.model_validate(result.data)
```
### Drop Unrepairable Items
Sometimes list items are beyond repair. Drop them automatically while respecting `minItems` constraints:
```python
class Product(BaseModel):
name: str
price: float
class Cart(BaseModel):
items: list[Product]
data = {
'items': [
{'nam': 'Laptop', 'pric': 999}, # Repairable
{'completely': 'wrong', 'keys': 123}, # Beyond repair
{'nme': 'Mouse', 'prce': 29} # Repairable
]
}
schema = Cart.model_json_schema()
result = repair_keys(
data, schema,
drop_unrepairable_items=True # Drop items that can't be fixed
)
if result.success:
# Returns 2 items (dropped the broken one)
print(len(result.data['items'])) # 2
```
Works with nested structures too:
```python
class Order(BaseModel):
order_id: str
products: list[Product]
class Customer(BaseModel):
name: str
orders: list[Order]
# Drops unrepairable items at any nesting level
result = repair_keys(
data, schema,
drop_unrepairable_items=True
)
if result.success:
use(result.data)
```
### Complex Nested Structures
```python
class Customer(BaseModel):
customer_id: str
name: str
email: str
class Order(BaseModel):
order_id: str
customer: Customer
products: list[Product]
total: float
# Works with arbitrarily complex nesting!
json_str = '''
{
"order_idd": "ORD-123",
"custmer": {
"customer_idd": "C-001",
"nam": "John",
"emal": "john@example.com"
},
"prodcts": [
{"product_idd": "P-001", "nam": "Laptop", "pric": 1299.99}
],
"totl": 1299.99
}
'''
order = fuzzy_model_validate_json(
json_str,
Order,
max_total_error_ratio=2.0 # Allow higher error ratio for complex structures
)
```
## API Reference
### `repair_keys(data, json_schema, max_error_ratio_per_key=0.3, max_total_error_ratio=0.5, strict_validation=False, drop_unrepairable_items=False)`
Repair dictionary keys using fuzzy matching against a JSON schema.
**Parameters:**
- `data` (dict): Input dictionary with potential typos
- `json_schema` (dict): JSON schema from `model.model_json_schema()`
- `max_error_ratio_per_key` (float): Maximum error ratio per individual key (0.0-1.0). Default: 0.3
- `max_total_error_ratio` (float): Maximum average error ratio across all schema fields (0.0-1.0). Default: 0.5
- `strict_validation` (bool): If True, reject unrecognized keys. Default: False
- `drop_unrepairable_items` (bool): If True, drop list items that can't be repaired (respects minItems). Default: False
**Returns:**
- `RepairResult`: Object with:
- `success` (bool): Whether repair succeeded
- `data` (dict | None): Repaired data (None if failed)
- `error_ratio` (float): Total error ratio
- `errors` (list[RepairError]): List of errors encountered
**Example:**
```python
schema = User.model_json_schema()
result = repair_keys(data, schema)
if result.success:
user = User.model_validate(result.data)
else:
print(f"Repair failed: {len(result.errors)} errors")
```
### `fuzzy_model_validate_json(json_data, model_cls, repair_syntax=True, max_error_ratio_per_key=0.3, max_total_error_ratio=0.3, strict_validation=False, drop_unrepairable_items=False)`
Repair JSON string and return validated Pydantic model instance.
**Parameters:**
- `json_data` (str): JSON string to repair
- `model_cls` (type[BaseModel]): Pydantic model class
- `repair_syntax` (bool): Attempt to fix JSON syntax errors. Default: True (requires json-repair)
- `max_error_ratio_per_key` (float): Max error per individual key. Default: 0.3
- `max_total_error_ratio` (float): Max average error across all fields. Default: 0.3
- `strict_validation` (bool): Reject unrecognized keys. Default: False
- `drop_unrepairable_items` (bool): Drop list items that can't be repaired (respects minItems). Default: False
**Returns:**
- `BaseModel`: Validated Pydantic model instance
**Raises:**
- `ValueError`: If repair fails or validation fails
**Example:**
```python
user = fuzzy_model_validate_json(json_str, User)
```
## Error Types
```python
from fuzzy_json_repair import ErrorType, RepairError, RepairResult
# ErrorType enum:
ErrorType.misspelled_key # Typo was fixed
ErrorType.unrecognized_key # Unknown key (kept if not strict)
ErrorType.missing_expected_key # Required field missing
# RepairError dataclass:
error = RepairError(
error_type=ErrorType.misspelled_key,
from_key='nam',
to_key='name',
error_ratio=0.143,
)
print(error)
# "Misspelled key 'nam' → 'name' (error: 14.3%)"
# RepairResult dataclass:
result = RepairResult(
success=True,
data={'name': 'John', 'age': 30},
error_ratio=0.15,
errors=[error]
)
print(f"Success: {result.success}")
print(f"Misspelled: {len(result.misspelled_keys)}")
print(f"Failed: {result.failed}")
```
## Configuration
### Error Ratio Thresholds
```python
# Strict (only very close matches)
repair_keys(data, schema, max_error_ratio_per_key=0.2)
# Moderate (default, good for most cases)
repair_keys(data, schema, max_error_ratio_per_key=0.3)
# Lenient (fix even poor matches)
repair_keys(data, schema, max_error_ratio_per_key=0.5)
```
### Strict Validation
```python
# Reject unrecognized keys
result = repair_keys(data, schema, strict_validation=True)
if result.success:
use(result.data)
```
### Drop Unrepairable Items
```python
# Drop list items that exceed error thresholds
result = repair_keys(
data, schema,
drop_unrepairable_items=True
)
# Respects minItems constraints
from pydantic import Field
class Cart(BaseModel):
items: list[Product] = Field(min_length=2)
# If dropping would violate minItems=2, repair fails
result = repair_keys(data, schema, drop_unrepairable_items=True)
if not result.success:
print("Would violate minItems constraint")
```
## Performance
The library uses two matching strategies:
- **With numpy**: Uses `process.cdist()` for batch processing (10-20x faster)
- **Without numpy**: Uses `process.extractOne()` loop (still fast)
Both use `fuzz.ratio` from RapidFuzz - no raw Levenshtein distance anywhere.
**Benchmark (1000 repairs):**
- With numpy: ~0.05s
- Without numpy: ~0.5s
Install with `pip install fuzzy-json-repair[fast]` for best performance.
## How It Works
1. **Schema Extraction**: Extracts expected keys, nested schemas, and `$ref` definitions from Pydantic's JSON schema
2. **Exact Matching**: Processes keys that match exactly (fast path)
3. **Fuzzy Matching**: For typos, uses RapidFuzz's `fuzz.ratio` to find best match
4. **Batch Processing**: Computes all similarities at once with `cdist` (when numpy available)
5. **Recursive Repair**: Automatically handles nested objects and lists
6. **Validation**: Returns repaired data ready for Pydantic validation
## Use Cases
- **LLM Output Validation**: Fix typos in JSON generated by language models
- **API Integration**: Handle variations in third-party API responses
- **Data Migration**: Repair legacy data with inconsistent field names
- **User Input**: Correct typos in user-provided configuration files
- **Robust Parsing**: Build fault-tolerant JSON parsers
## Requirements
- Python 3.11+
- pydantic >= 2.0.0
- rapidfuzz >= 3.0.0
**Optional:**
- numpy >= 1.20.0 (for faster batch processing)
- json-repair >= 0.7.0 (for JSON syntax repair)
## Development
```bash
# Clone repository
git clone https://github.com/sayef/fuzzy-json-repair.git
cd fuzzy-json-repair
# Install with dev dependencies
pip install -e ".[dev,fast,syntax]"
# Run tests
pytest
# Run tests with coverage
pytest --cov=fuzzy_json_repair --cov-report=term-missing
# Format code
black fuzzy_json_repair tests
isort fuzzy_json_repair tests
# Type check
mypy fuzzy_json_repair
# Lint
ruff check fuzzy_json_repair tests
```
## License
MIT License - see [LICENSE](LICENSE) file for details.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
## Credits
- Uses [RapidFuzz](https://github.com/maxbachmann/RapidFuzz) for fast fuzzy matching
- Built for [Pydantic](https://github.com/pydantic/pydantic) integration
- Optional [json-repair](https://github.com/mangiucugna/json_repair) support
Raw data
{
"_id": null,
"home_page": null,
"name": "fuzzy-json-repair",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.11",
"maintainer_email": null,
"keywords": "json, repair, fuzzy, matching, typo, pydantic, validation, llm",
"author": null,
"author_email": "Sayef <hello@sayef.tech>",
"download_url": "https://files.pythonhosted.org/packages/ca/f3/3f09ec219e32a6155ddd4e83d56b5d9c4c6e27f93affe4b575ca3f350b2b/fuzzy_json_repair-0.1.4.tar.gz",
"platform": null,
"description": "# Fuzzy JSON Repair\n\n[](https://www.python.org/downloads/)\n[](https://opensource.org/licenses/MIT)\n\nYou ask an LLM for JSON, it gives you `{\"nam\": \"John\", \"emal\": \"john@example.com\"}` instead of `{\"name\": \"John\", \"email\": \"john@example.com\"}`. Your Pydantic validation fails. You spend an hour writing error handling code.\n\nThis library fixes those typos automatically using fuzzy string matching. No more manual key mapping, no more try-except blocks everywhere.\n\n## Install\n\n```bash\npip install fuzzy-json-repair\n```\n\nIf you're processing lots of data, install with numpy for ~10x faster batch processing:\n\n```bash\npip install fuzzy-json-repair[fast]\n```\n\n## Usage\n\nThe simplest way - repair and validate in one go:\n\n```python\nfrom pydantic import BaseModel\nfrom fuzzy_json_repair import fuzzy_model_validate_json\n\nclass User(BaseModel):\n name: str\n age: int\n email: str\n\n# Your LLM gave you this\njson_str = '{\"nam\": \"John\", \"agge\": 30, \"emal\": \"john@example.com\"}'\n\n# This just works\nuser = fuzzy_model_validate_json(json_str, User)\nprint(user) # User(name='John', age=30, email='john@example.com')\n```\n\nOr if you want more control:\n\n```python\nfrom fuzzy_json_repair import repair_keys\n\nschema = User.model_json_schema()\ndata = {'nam': 'John', 'agge': 30, 'emal': 'john@example.com'}\n\nresult = repair_keys(data, schema)\n\nif result.success:\n user = User.model_validate(result.data)\nelse:\n print(f\"Repair failed: {len(result.errors)} errors\")\n print(f\"Error ratio: {result.error_ratio:.2%}\")\n```\n\n## Advanced Usage\n\n### Nested Objects\n\n```python\nclass Address(BaseModel):\n street: str\n city: str\n zip_code: str\n\nclass Person(BaseModel):\n name: str\n address: Address\n\ndata = {\n 'nam': 'John',\n 'addres': {\n 'stret': '123 Main St',\n 'cty': 'NYC',\n 'zip_cod': '10001'\n }\n}\n\nschema = Person.model_json_schema()\nresult = repair_keys(data, schema, max_error_ratio_per_key=0.5)\n\n# All nested typos are fixed!\nif result.success:\n person = Person.model_validate(result.data)\n```\n\n### Lists of Objects\n\n```python\nclass Product(BaseModel):\n product_id: str\n name: str\n price: float\n\nclass Cart(BaseModel):\n cart_id: str\n products: list[Product]\n\ndata = {\n 'cart_idd': 'C123',\n 'prodcts': [\n {'product_idd': 'P1', 'nam': 'Laptop', 'pric': 999.99},\n {'product_idd': 'P2', 'nam': 'Mouse', 'pric': 29.99}\n ]\n}\n\nschema = Cart.model_json_schema()\nresult = repair_keys(data, schema, max_error_ratio_per_key=0.5)\n\n# Repairs all typos in the list items too!\nif result.success:\n cart = Cart.model_validate(result.data)\n```\n\n### Drop Unrepairable Items\n\nSometimes list items are beyond repair. Drop them automatically while respecting `minItems` constraints:\n\n```python\nclass Product(BaseModel):\n name: str\n price: float\n\nclass Cart(BaseModel):\n items: list[Product]\n\ndata = {\n 'items': [\n {'nam': 'Laptop', 'pric': 999}, # Repairable\n {'completely': 'wrong', 'keys': 123}, # Beyond repair\n {'nme': 'Mouse', 'prce': 29} # Repairable\n ]\n}\n\nschema = Cart.model_json_schema()\nresult = repair_keys(\n data, schema,\n drop_unrepairable_items=True # Drop items that can't be fixed\n)\n\nif result.success:\n # Returns 2 items (dropped the broken one)\n print(len(result.data['items'])) # 2\n```\n\nWorks with nested structures too:\n\n```python\nclass Order(BaseModel):\n order_id: str\n products: list[Product]\n\nclass Customer(BaseModel):\n name: str\n orders: list[Order]\n\n# Drops unrepairable items at any nesting level\nresult = repair_keys(\n data, schema,\n drop_unrepairable_items=True\n)\nif result.success:\n use(result.data)\n```\n\n### Complex Nested Structures\n\n```python\nclass Customer(BaseModel):\n customer_id: str\n name: str\n email: str\n\nclass Order(BaseModel):\n order_id: str\n customer: Customer\n products: list[Product]\n total: float\n\n# Works with arbitrarily complex nesting!\njson_str = '''\n{\n \"order_idd\": \"ORD-123\",\n \"custmer\": {\n \"customer_idd\": \"C-001\",\n \"nam\": \"John\",\n \"emal\": \"john@example.com\"\n },\n \"prodcts\": [\n {\"product_idd\": \"P-001\", \"nam\": \"Laptop\", \"pric\": 1299.99}\n ],\n \"totl\": 1299.99\n}\n'''\n\norder = fuzzy_model_validate_json(\n json_str,\n Order,\n max_total_error_ratio=2.0 # Allow higher error ratio for complex structures\n)\n```\n\n## API Reference\n\n### `repair_keys(data, json_schema, max_error_ratio_per_key=0.3, max_total_error_ratio=0.5, strict_validation=False, drop_unrepairable_items=False)`\n\nRepair dictionary keys using fuzzy matching against a JSON schema.\n\n**Parameters:**\n- `data` (dict): Input dictionary with potential typos\n- `json_schema` (dict): JSON schema from `model.model_json_schema()`\n- `max_error_ratio_per_key` (float): Maximum error ratio per individual key (0.0-1.0). Default: 0.3\n- `max_total_error_ratio` (float): Maximum average error ratio across all schema fields (0.0-1.0). Default: 0.5\n- `strict_validation` (bool): If True, reject unrecognized keys. Default: False\n- `drop_unrepairable_items` (bool): If True, drop list items that can't be repaired (respects minItems). Default: False\n\n**Returns:**\n- `RepairResult`: Object with:\n - `success` (bool): Whether repair succeeded\n - `data` (dict | None): Repaired data (None if failed)\n - `error_ratio` (float): Total error ratio\n - `errors` (list[RepairError]): List of errors encountered\n\n**Example:**\n```python\nschema = User.model_json_schema()\nresult = repair_keys(data, schema)\nif result.success:\n user = User.model_validate(result.data)\nelse:\n print(f\"Repair failed: {len(result.errors)} errors\")\n```\n\n### `fuzzy_model_validate_json(json_data, model_cls, repair_syntax=True, max_error_ratio_per_key=0.3, max_total_error_ratio=0.3, strict_validation=False, drop_unrepairable_items=False)`\n\nRepair JSON string and return validated Pydantic model instance.\n\n**Parameters:**\n- `json_data` (str): JSON string to repair\n- `model_cls` (type[BaseModel]): Pydantic model class\n- `repair_syntax` (bool): Attempt to fix JSON syntax errors. Default: True (requires json-repair)\n- `max_error_ratio_per_key` (float): Max error per individual key. Default: 0.3\n- `max_total_error_ratio` (float): Max average error across all fields. Default: 0.3\n- `strict_validation` (bool): Reject unrecognized keys. Default: False\n- `drop_unrepairable_items` (bool): Drop list items that can't be repaired (respects minItems). Default: False\n\n**Returns:**\n- `BaseModel`: Validated Pydantic model instance\n\n**Raises:**\n- `ValueError`: If repair fails or validation fails\n\n**Example:**\n```python\nuser = fuzzy_model_validate_json(json_str, User)\n```\n\n## Error Types\n\n```python\nfrom fuzzy_json_repair import ErrorType, RepairError, RepairResult\n\n# ErrorType enum:\nErrorType.misspelled_key # Typo was fixed\nErrorType.unrecognized_key # Unknown key (kept if not strict)\nErrorType.missing_expected_key # Required field missing\n\n# RepairError dataclass:\nerror = RepairError(\n error_type=ErrorType.misspelled_key,\n from_key='nam',\n to_key='name',\n error_ratio=0.143,\n)\nprint(error)\n# \"Misspelled key 'nam' \u2192 'name' (error: 14.3%)\"\n\n# RepairResult dataclass:\nresult = RepairResult(\n success=True,\n data={'name': 'John', 'age': 30},\n error_ratio=0.15,\n errors=[error]\n)\nprint(f\"Success: {result.success}\")\nprint(f\"Misspelled: {len(result.misspelled_keys)}\")\nprint(f\"Failed: {result.failed}\")\n```\n\n## Configuration\n\n### Error Ratio Thresholds\n\n```python\n# Strict (only very close matches)\nrepair_keys(data, schema, max_error_ratio_per_key=0.2)\n\n# Moderate (default, good for most cases)\nrepair_keys(data, schema, max_error_ratio_per_key=0.3)\n\n# Lenient (fix even poor matches)\nrepair_keys(data, schema, max_error_ratio_per_key=0.5)\n```\n\n### Strict Validation\n\n```python\n# Reject unrecognized keys\nresult = repair_keys(data, schema, strict_validation=True)\nif result.success:\n use(result.data)\n```\n\n### Drop Unrepairable Items\n\n```python\n# Drop list items that exceed error thresholds\nresult = repair_keys(\n data, schema,\n drop_unrepairable_items=True\n)\n\n# Respects minItems constraints\nfrom pydantic import Field\n\nclass Cart(BaseModel):\n items: list[Product] = Field(min_length=2)\n\n# If dropping would violate minItems=2, repair fails\nresult = repair_keys(data, schema, drop_unrepairable_items=True)\nif not result.success:\n print(\"Would violate minItems constraint\")\n```\n\n## Performance\n\nThe library uses two matching strategies:\n\n- **With numpy**: Uses `process.cdist()` for batch processing (10-20x faster)\n- **Without numpy**: Uses `process.extractOne()` loop (still fast)\n\nBoth use `fuzz.ratio` from RapidFuzz - no raw Levenshtein distance anywhere.\n\n**Benchmark (1000 repairs):**\n- With numpy: ~0.05s\n- Without numpy: ~0.5s\n\nInstall with `pip install fuzzy-json-repair[fast]` for best performance.\n\n## How It Works\n\n1. **Schema Extraction**: Extracts expected keys, nested schemas, and `$ref` definitions from Pydantic's JSON schema\n2. **Exact Matching**: Processes keys that match exactly (fast path)\n3. **Fuzzy Matching**: For typos, uses RapidFuzz's `fuzz.ratio` to find best match\n4. **Batch Processing**: Computes all similarities at once with `cdist` (when numpy available)\n5. **Recursive Repair**: Automatically handles nested objects and lists\n6. **Validation**: Returns repaired data ready for Pydantic validation\n\n## Use Cases\n\n- **LLM Output Validation**: Fix typos in JSON generated by language models\n- **API Integration**: Handle variations in third-party API responses\n- **Data Migration**: Repair legacy data with inconsistent field names\n- **User Input**: Correct typos in user-provided configuration files\n- **Robust Parsing**: Build fault-tolerant JSON parsers\n\n## Requirements\n\n- Python 3.11+\n- pydantic >= 2.0.0\n- rapidfuzz >= 3.0.0\n\n**Optional:**\n- numpy >= 1.20.0 (for faster batch processing)\n- json-repair >= 0.7.0 (for JSON syntax repair)\n\n## Development\n\n```bash\n# Clone repository\ngit clone https://github.com/sayef/fuzzy-json-repair.git\ncd fuzzy-json-repair\n\n# Install with dev dependencies\npip install -e \".[dev,fast,syntax]\"\n\n# Run tests\npytest\n\n# Run tests with coverage\npytest --cov=fuzzy_json_repair --cov-report=term-missing\n\n# Format code\nblack fuzzy_json_repair tests\nisort fuzzy_json_repair tests\n\n# Type check\nmypy fuzzy_json_repair\n\n# Lint\nruff check fuzzy_json_repair tests\n```\n\n## License\n\nMIT License - see [LICENSE](LICENSE) file for details.\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request.\n\n## Credits\n\n- Uses [RapidFuzz](https://github.com/maxbachmann/RapidFuzz) for fast fuzzy matching\n- Built for [Pydantic](https://github.com/pydantic/pydantic) integration\n- Optional [json-repair](https://github.com/mangiucugna/json_repair) support\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Fix typos in JSON keys using fuzzy matching with RapidFuzz",
"version": "0.1.4",
"project_urls": {
"Documentation": "https://github.com/sayef/fuzzy-json-repair#readme",
"Homepage": "https://github.com/sayef/fuzzy-json-repair",
"Issues": "https://github.com/sayef/fuzzy-json-repair/issues",
"Repository": "https://github.com/sayef/fuzzy-json-repair"
},
"split_keywords": [
"json",
" repair",
" fuzzy",
" matching",
" typo",
" pydantic",
" validation",
" llm"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "2492b6a243f96d1bab505480cf7fe99ce6c6df8eac03bd069be76de4145e0878",
"md5": "89e6ecdde90b4b1070086581fd0ab315",
"sha256": "bfb91ce1e2eb2a930fe967c73e3c29edb8f2c626b002d0a9440876a9ffae9a98"
},
"downloads": -1,
"filename": "fuzzy_json_repair-0.1.4-py3-none-any.whl",
"has_sig": false,
"md5_digest": "89e6ecdde90b4b1070086581fd0ab315",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.11",
"size": 12535,
"upload_time": "2025-10-26T11:16:15",
"upload_time_iso_8601": "2025-10-26T11:16:15.845511Z",
"url": "https://files.pythonhosted.org/packages/24/92/b6a243f96d1bab505480cf7fe99ce6c6df8eac03bd069be76de4145e0878/fuzzy_json_repair-0.1.4-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "caf33f09ec219e32a6155ddd4e83d56b5d9c4c6e27f93affe4b575ca3f350b2b",
"md5": "71e4d4bc6ca808a06656dddd6f5566f5",
"sha256": "530ed6ac95a9b651a8d0623c1216288bab7be32a9354a55509f3e9639ecd76b3"
},
"downloads": -1,
"filename": "fuzzy_json_repair-0.1.4.tar.gz",
"has_sig": false,
"md5_digest": "71e4d4bc6ca808a06656dddd6f5566f5",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.11",
"size": 17746,
"upload_time": "2025-10-26T11:16:17",
"upload_time_iso_8601": "2025-10-26T11:16:17.198765Z",
"url": "https://files.pythonhosted.org/packages/ca/f3/3f09ec219e32a6155ddd4e83d56b5d9c4c6e27f93affe4b575ca3f350b2b/fuzzy_json_repair-0.1.4.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-26 11:16:17",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "sayef",
"github_project": "fuzzy-json-repair#readme",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "fuzzy-json-repair"
}
JSON
