pyapi-diff 0.0.1__py3-none-any.whl

pyapi/__init__.py

@@ -0,0 +1,4 @@
+from .comparator import json_compare
+from .models import Change
+
+__all__ = ["json_compare", "Change"]

pyapi/comparator.py

@@ -0,0 +1,101 @@
+from pyapi.models import Change
+from pathlib import Path
+import json
+
+def _json_type(value: any) -> any:
+
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "boolean"
+    if isinstance(value, int):
+        return "number"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, dict):
+        return "object"
+    if isinstance(value, list):
+        return "array"
+    return "Unknown"
+
+def _compare(old: dict, new: dict, path: str, changes: list)-> list:
+
+    old_type: any = _json_type(old)
+    new_type: any = _json_type(new)
+
+    if old_type != new_type:
+        changes.append(
+            Change(
+                kind= "type_changed",
+                path= path or "$",
+                old_value= old_type,
+                new_value= new_type
+            )
+        )
+        return
+    
+    if isinstance(old, dict):
+        old_keys: list = set(old)
+        new_keys: list = set(new)
+
+        for key in sorted(old_keys - new_keys):
+            changes.append(
+                Change(
+                    kind="key_removed",
+                    path= f"{path}.{key}",
+                    old_value=old[key]
+                )
+            )
+        
+        for key in sorted(new_keys - old_keys):
+            changes.append(
+                Change(
+                    kind= "key_added",
+                    path= f"{path}.{key}",
+                    new_value= new[key]
+                )
+            )
+        
+        for key in sorted(old_keys & new_keys):
+            _compare(
+                old[key],
+                new[key],
+                f"{path}.{key}",
+                changes
+            )
+
+    elif isinstance(old, list):
+        for index, (old_item, new_item) in enumerate(zip(old, new)):
+            _compare(
+                old_item,
+                new_item,
+                f"{path}[{index}]",
+                changes
+            )
+    
+def json_compare(old: dict, new: dict) -> list:
+    old_path: str = Path(old)
+    new_path: str = Path(new)
+
+    with old_path.open(encoding="utf-8") as f:
+        old_data: dict = json.load(f)
+    
+    with new_path.open(encoding="utf-8") as f:
+        new_data: dict = json.load(f)
+    
+    changes: list= []
+    _compare(
+        old_data,
+        new_data,
+        "$",
+        changes
+    )
+    return changes
+
+
+
+
+        
+
+
+

pyapi/models.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Change:
+    kind:str
+    path: str
+    old_value: object = None
+    new_value: object = None
+
+    def __str__(self)-> str:
+        """
+        This magical method will allow to represent the data in format.
+        :return: data in format
+        :rtype: str
+        """
+        return (
+            f"{self.kind}: {self.path} "
+            f"(old = {self.old_value!r}, "
+            f"new = {self.new_value!r})"
+        )

pyapi_diff-0.0.1.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.5
+Name: pyapi-diff
+Version: 0.0.1
+Summary: python tool to indentify breaking changes in apis.
+Author-email: Prashant Sharma <prashant.ps9833@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: comparison,developer-tools,json,json-diff
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# pyapi
+
+**A lightweight Python library to detect structural changes in JSON data.**
+
+`pyapi` compares two JSON-compatible data structures and identifies changes in their structure and data types, without reporting ordinary value changes.
+
+It is useful for detecting changes in API response structures, checking compatibility between API versions, and identifying unexpected changes in JSON data.
+
+## Features
+
+- **Key Addition Detection** — Identifies keys present in the new structure but missing from the old structure.
+- **Key Removal Detection** — Identifies keys present in the old structure but missing from the new structure.
+- **Type Change Detection** — Detects when a value's data type changes between two structures.
+- **Nested Structure Comparison** — Detects structural changes within nested JSON objects.
+- **Value-Agnostic Comparison** — Ignores changes to values when their data types remain the same.
+- **Readable Change Paths** — Reports the location of each detected change using JSON-style paths.
+
+## Installation
+
+```bash
+pip install pyapi
+```
+
+## Quick Start
+
+```python
+from pyapi import json_compare
+
+old = {
+  "id": 101,
+  "name": "abc",
+  "age": 55,
+  "address": {
+    "city": "san francisco",
+    "pincode": 12345
+  },
+  "skills": ["Python", "SQL"]
+}
+
+new = {
+  "id": "101",
+  "name": "xyz",
+  "contact": 1234567890,
+  "address": {
+    "city": "Seattle",
+    "pincode": 1234
+  },
+  "skills": ["Python", "SQL"]
+}
+
+json_compare(old, new)
+```
+
+### Output
+
+```text
+key_removed: $.age (old = 55, new = None)
+key_added: $.contact (old = None, new = 1234567890)
+type_changed: $.id (old = 'number', new = 'string')
+```
+
+## Detected Change Types
+
+| Change Type | Description |
+|---|---|
+| `key_added` | A key exists in the new structure but not in the old structure. |
+| `key_removed` | A key exists in the old structure but not in the new structure. |
+| `type_changed` | A value's data type differs between the old and new structures. |
+
+## How It Works
+
+`pyapi` compares an old JSON-compatible structure against a new one and reports structural differences.
+
+For example, consider these two objects:
+
+**Old structure**
+
+```json
+{
+  "user": {
+    "id": 101,
+    "name": "Alice"
+  }
+}
+```
+
+**New structure**
+
+```json
+{
+  "user": {
+    "id": "101",
+    "name": "Bob",
+    "email": "alice@example.com"
+  }
+}
+```
+
+The detected changes include:
+
+- `type_changed` at `$.user.id`, because `id` changes from a number to a string.
+- `key_added` at `$.user.email`, because `email` is newly introduced.
+
+The change from `"Alice"` to `"Bob"` is ignored because the value remains a string.
+
+## Use Cases
+
+- **API Response Comparison:** Identify structural changes between responses from different API versions.
+- **Breaking Change Detection:** Find removed keys or changed data types that could break API consumers.
+- **Regression Testing:** Detect unexpected changes in JSON response structures during development.
+- **Data Validation:** Check whether incoming JSON data maintains the expected structure.
+- **Configuration Comparison:** Identify added or removed settings and changes in their data types.
+
+## Requirements
+
+- Python 3.10 or later
+
+## Development
+
+Clone the repository:
+
+```bash
+git clone YOUR_REPOSITORY_URL
+cd pyapi
+```
+
+Install dependencies using [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv sync
+```
+
+Run the example or test script:
+
+```bash
+uv run python tests/test1.py
+```
+
+## Project Status
+
+`pyapi` is currently in its initial release, `0.0.1`.
+
+The current focus is on detecting JSON structural and data type changes. Additional functionality may be introduced in future releases.
+
+## Contributing
+
+Contributions, bug reports, and feature suggestions are welcome.
+
+Feel free to open an issue or submit a pull request in the project's GitHub repository.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

pyapi_diff-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyapi/__init__.py,sha256=TbYWYNFAFsIaxtiHBLqpI_cxsTleRY1-W3Dha4IzPF8,101
+pyapi/comparator.py,sha256=HwkykHy9xJFwKnpKqlJdoytoTyHjEmi3KyS5CqbRwzM,2360
+pyapi/models.py,sha256=RvdW6MI-IK8UVYuyEAcICK-Mn5rwg0-M-3jUvhXbbAQ,487
+pyapi_diff-0.0.1.dist-info/METADATA,sha256=of2bYWDdSEopfLNY9lGZ-mkw_MBvtl-srInnCu0-8EM,4452
+pyapi_diff-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pyapi_diff-0.0.1.dist-info/licenses/LICENSE,sha256=LQrD-qdW6uCj3h5BBAk0C5MVrvuiYDBBjxJAM8BE1_k,1072
+pyapi_diff-0.0.1.dist-info/RECORD,,

pyapi_diff-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pyapi_diff-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prashant Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.