jsonobjectify 0.0.0__py3-none-any.whl

jsonobjectify/json_object.py

@@ -0,0 +1,40 @@
+from json import dumps
+
+
+class JsonObject:
+    """Represent a JSON object as a Python object."""
+    def __init__(self, info):
+        self._info = info
+
+    def __getattr__(self, name):
+        """Return a value from the underlying JSON data using dot notation."""
+        try:
+            return self._info[name]
+        except KeyError:
+            raise AttributeError(f"{type(self).__name__} has no attribute {name!r}") from None
+
+    def __setattr__(self, name, value):
+        """Set an attribute (_info) or update the underlying JSON data."""
+        if name == "_info":
+            super().__setattr__(name, value)
+        else:
+            self._info[name] = value
+
+    def to_dict(self):
+        """Convert a JsonObject to dictionary."""
+        out_dict = {}
+        for key, value in self._info.items():
+            if isinstance(value, JsonObject):
+                out_dict[key] = value.to_dict()
+            elif isinstance(value, list):
+                out_dict[key] = [
+                    item.to_dict() if isinstance(item, JsonObject) else item
+                    for item in value
+                ]
+            else:
+                out_dict[key] = value
+        return out_dict
+
+    def to_json(self):
+        """Convert JsonObject to a JSON string."""
+        return dumps(self.to_dict())

jsonobjectify/json_path.py

@@ -0,0 +1,100 @@
+from json import load, loads
+from pathlib import Path
+from .json_object import JsonObject
+
+
+class JsonPath:
+    def __init__(self):
+        """Initialize an empty JSON parser."""
+        self._root_json_object = None
+
+    def __getattr__(self, name):
+        """Delegate attribute access to the json object."""
+        return getattr(self._root_json_object, name)
+
+    def __getitem__(self, index):
+        """Return an item from the root JSON array."""
+        return self._root_json_object[index]
+
+    def __len__(self):
+        """Return the length of root JSON array/object"""
+        if isinstance(self._root_json_object, JsonObject):
+            return len(self._root_json_object.to_dict())
+        return len(self._root_json_object)
+
+    def __setattr__(self, name, value):
+        if name == "_root_json_object":
+            super().__setattr__(name, value)
+        else:
+            setattr(self._root_json_object, name, value)
+
+    def __str__(self):
+        if isinstance(self._root_json_object, JsonObject):
+            return self._root_json_object.to_json()
+        return f"{self._root_json_object}"
+
+    def __repr__(self):
+        if isinstance(self._root_json_object, JsonObject):
+            return f"{type(self).__name__}({self._root_json_object.to_dict()})"
+        return f"{type(self).__name__}({self._root_json_object})"
+
+    def _wrap_dict(self, data):
+        """Wrap a dictionary in a JsonObject."""
+        return JsonObject(data)
+
+    def _is_valid_json_key(self, key):
+        """Check whether a JSON key can be used as a Python attribute."""
+        if key.isidentifier():
+            return True
+        else:
+            print(f"Skipping invalid JSON key {key!r}")
+            return False
+
+    def _process_list(self, data: list):
+        """Recursively process items in a list."""
+        return [self._process_object(item) for item in data]
+
+    def _process_dict(self, data: dict):
+        """Recursively process values in a dictionary."""
+        _data = {
+            key: self._process_object(value)
+            for key, value in data.items()
+            if self._is_valid_json_key(key)
+        }
+        return self._wrap_dict(_data)
+
+    def _process_object(self, value):
+        """Process a JSON object based on its Python type."""
+        if isinstance(value, dict):
+            return self._process_dict(value)
+        elif isinstance(value, list):
+            return self._process_list(value)
+        return value
+
+    def _build_root_object(self, py_object):
+        """Build the root object from the deserialized JSON."""
+        return self._process_object(py_object)
+
+    @classmethod
+    def _from_py_object(cls, py_object):
+        obj = cls()
+        obj._root_json_object = obj._build_root_object(py_object)
+        return obj
+
+    @classmethod
+    def from_json_string(cls, json_string):
+        """Create a JsonPath instance from a JSON string."""
+        if not isinstance(json_string, str):
+            raise TypeError("json_string must be a string")
+        if not json_string.strip():
+            raise ValueError("JSON string cannot be empty")
+        return cls._from_py_object(loads(json_string))
+
+    @classmethod
+    def from_json_file(cls, filename: str):
+        """Create a JsonPath instance from a JSON file."""
+        path = Path(filename)
+        if not path.is_file():
+            raise FileNotFoundError(f"File not found {filename}")
+        with open(path, mode="r", encoding="utf-8") as json_file:
+            return cls._from_py_object(load(json_file))

jsonobjectify-0.0.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.3
+Name: jsonobjectify
+Version: 0.0.0
+Summary: A lightweight Python library for converting JSON data into Python objects, simplifying access to nested structures through intuitive dot notation.
+Author: Sandeep Suryaprasad
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/sandeepsuryaprasad/jsonobjectify
+Project-URL: Repository, https://github.com/sandeepsuryaprasad/jsonobjectify
+Project-URL: Issues, https://github.com/sandeepsuryaprasad/jsonobjectify/issues
+Description-Content-Type: text/markdown
+
+# jsonobjectify
+
+A lightweight Python library for converting JSON data into Python objects, 
+simplifying access to nested structures through intuitive dot notation.
+
+## Overview
+Working with complex JSON data often involves repetitive dictionary lookups, especially 
+when accessing deeply nested structures. `jsonobjectify` simplifies this process by 
+converting JSON data into Python objects, allowing you to access JSON properties using 
+familiar attribute notation.
+
+Instead of writing chained dictionary lookups, you can navigate nested JSON structures 
+using a clean, readable, object-oriented interface.
+
+## Features
+
+* **Dot-notation access:** Access JSON properties using Python attributes.
+* **Nested object support:** Navigate deeply nested JSON structures naturally.
+* **List support:** Work with collections of JSON objects.
+* **Dictionary conversion:** Convert mapped objects back into standard Python dictionaries.
+* **JSON serialization:** Serialize objects back into JSON.
+* **Simple API:** Keep your code readable when working with complex JSON responses.
+
+## Installation
+
+```bash
+pip install jsonobjectify
+```
+
+## Usage
+
+Consider the following JSON data representing an employee and their department:
+
+```python
+response = """{
+    "id": 1,
+    "name": "Michael Anderson",
+    "email": "michael.anderson@example.com",
+    "website": "www.example.dev",
+    "address": {
+      "city": "Austin",
+      "state": "TX",
+      "country": "United States",
+      "geo_location": {"lat": "30.2672", "lng": "-97.7431"}
+    },
+    "skills": [
+      {"name": "Python", "level": "Advanced"},
+      {"name": "C", "level": "Advanced"},
+      {"name": "C++", "level": "Intermediate"}
+    ]
+}"""
+```
+
+With `jsonobjectify`, you can access the data through object attributes rather than 
+repeated dictionary lookups.
+
+```python
+from jsonobjectify import JsonPath
+
+employee = JsonPath.from_json_string(response)
+
+print(employee.name)
+print(employee.address.city)
+print(employee.skills[0].name)
+print(employee.skills[1].level)
+```
+
+**Output**
+
+```text
+'Michael Anderson'
+'Austin'
+'Python'
+'Advanced'
+```
+
+The example above illustrates the intended API. Adjust the import and construction methods 
+to match the implementation in your repository.
+
+## Converting Objects Back to JSON
+
+`jsonobjectify` is intended to support conversion back to standard Python dictionaries and 
+JSON strings, making it convenient to work with transformed data.
+
+```python
+# Convert the object to a Python dictionary
+data = employee.to_dict()
+
+# Serialize the object to a JSON string
+json_data = employee.to_json()
+```
+
+## Requirements
+
+* Python 3.9 or later
+
+## Contributing
+
+Contributions, bug reports, and feature suggestions are welcome. Please open an issue to 
+discuss a proposed change before submitting a pull request.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

jsonobjectify-0.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+jsonobjectify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonobjectify/json_object.py,sha256=t-tflGSwGG2zqDlK6Iv6f7IEFB78GPl5Zlx9aR3YReg,1311
+jsonobjectify/json_path.py,sha256=tA1qsD7ZtySb1t50z1ZMEo6gh_cUSFKzh3q0MbWoc5I,3531
+jsonobjectify-0.0.0.dist-info/WHEEL,sha256=xTCBFIZIIyRSxyowOv5Wqg_jFU6KsdIffuulBB09Ph8,80
+jsonobjectify-0.0.0.dist-info/METADATA,sha256=KVCmFJMtnFQvXoG0F61CAKHp2h_qCdU8V-S8WoC5zvQ,3436
+jsonobjectify-0.0.0.dist-info/RECORD,,

jsonobjectify-0.0.0.dist-info/WHEEL

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