jsonobjectify 0.0.0__tar.gz

jsonobjectify-0.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,104 @@
+# 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/pyproject.toml

@@ -0,0 +1,105 @@
+[project]
+name = "jsonobjectify"
+version = "0.0.0"
+description = "A lightweight Python library for converting JSON data into Python objects, simplifying access to nested structures through intuitive dot notation."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+
+[[project.authors]]
+name = "Sandeep Suryaprasad"
+
+[project.urls]
+Homepage = "https://github.com/sandeepsuryaprasad/jsonobjectify"
+Repository = "https://github.com/sandeepsuryaprasad/jsonobjectify"
+Issues = "https://github.com/sandeepsuryaprasad/jsonobjectify/issues"
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "jsonobjectify"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[tool.ruff]
+line-length = 119
+exclude = [
+    "tests",
+    "sitepackages",
+    ".git",
+    ".github",
+    "__pycache__",
+    ".venv",
+    "build",
+    "dist",
+    ".pytest_cache",
+    ".tox",
+    ".vscode",
+    ".ruff_cache",
+    ".mypy_cache",
+    ".nox",
+    ".eggs",
+]
+
+[tool.ruff.lint]
+select = [
+    "F",
+    "N",
+    "E9",
+    "I",
+    "E501",
+    "RUF022",
+    "TID252",
+    "F841",
+    "N816",
+    "B007",
+    "D403",
+    "D101",
+    "D102",
+    "D103",
+    "D106",
+    "D201",
+    "D202",
+    "D204",
+    "D300",
+    "D404",
+    "D405",
+    "D419",
+    "E402",
+    "E401",
+    "E711",
+    "E712",
+    "E721",
+    "E722",
+    "E731",
+]
+ignore = [
+    "D100",
+    "D101",
+    "D104",
+    "D105",
+    "D107",
+    "D212",
+    "D415",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.pytest.ini_options]
+testpaths = ["./tests"]
+
+[dependency-groups]
+test = ["pytest==8.2.2"]
+lint = ["ruff==0.11.12"]
+
+[build-system]
+requires = ["uv_build>=0.9.13,<0.12.0"]
+build-backend = "uv_build"

jsonobjectify-0.0.0/pyproject.toml.orig

@@ -0,0 +1,107 @@
+[project]
+name = "jsonobjectify"
+version = "0.0.0"
+description = "A lightweight Python library for converting JSON data into Python objects, simplifying access to nested structures through intuitive dot notation."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+authors = [
+    {name= "Sandeep Suryaprasad"}
+]
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "jsonobjectify"
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/sandeepsuryaprasad/jsonobjectify"
+Repository = "https://github.com/sandeepsuryaprasad/jsonobjectify"
+Issues = "https://github.com/sandeepsuryaprasad/jsonobjectify/issues"
+
+[dependency-groups]
+test = ["pytest==8.2.2"]
+lint = ["ruff==0.11.12"]
+
+[tool.ruff]
+line-length = 119
+exclude = [
+    "tests",
+    "sitepackages",
+    ".git",
+    ".github",
+    "__pycache__",
+    ".venv",
+    "build",
+    "dist",
+    ".pytest_cache",
+    ".tox",
+    ".vscode",
+    ".ruff_cache",
+    ".mypy_cache",
+    ".nox",
+    ".eggs"
+    ]
+
+[tool.ruff.lint]
+select = [
+   "F",
+   "N",
+   "E9",      # Checks for common syntax errors, indendation errors
+   "I",
+   "E501",    # Checks for lines that exceed the specified maximum character length.
+   "RUF022",
+   "TID252",
+   "F841",    # Checks for the presence of unused variables in function scopes.
+   "N816",    # Checks for global variable names that follow the mixedCase convention.
+   "B007",    # Checks for unused variables in loops (e.g., for and while statements).
+   "D403",    # Checks for docstrings that do not start with a capital letter.
+   "D101",
+   "D102",    # Checks for undocumented public method definitions.
+   "D103",    # Checks for undocumented public function definitions.
+   "D106",    # Checks for undocumented public class definitions, for nested classes.
+   "D201",    # Checks for docstrings on functions that are separated by one or more blank lines from the function definition.
+   "D202",    # Checks for docstrings on functions that are separated by one or more blank lines from the function body.
+   "D204",    # Checks for class methods that are not separated from the class's docstring by a blank line.
+   "D300",    # Checks for docstrings that use '''triple single quotes''' instead of """triple double quotes""".
+   "D404",    # Checks for docstrings that start with This.
+   "D405",    # Checks for section headers in docstrings that do not begin with capital letters.
+   "D419",    # Checks for empty docstrings.
+   "E402",    # Checks for imports that are not at the top of the file.
+   "E401",    # Check for multiple imports on one line.
+   "E711",    # Checks for comparisons to None which are not using the is operator.
+   "E712",    # Checks for equality comparisons to boolean literals.
+   "E721",    # Checks for object type comparisons using == and other comparison operators.
+   "E722",    # Checks for bare except catches in try-except statements.
+   "E731",    # Checks for lambda expressions which are assigned to a variable.
+]
+
+ignore = [
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D104", # Missing docstring in public package
+    "D105", # Missing docstring in magic method
+    "D107", # Missing docstring in `__init__`
+    "D212", # Multi-line docstring summary should start at the first line
+    "D415"  # Ignore if the doc string does not end with any punctuation
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.pytest.ini_options]
+testpaths = ["./tests"]
+
+[build-system]
+requires = ["uv_build>=0.9.13,<0.12.0"]
+build-backend = "uv_build"

jsonobjectify-0.0.0/src/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-0.0.0/src/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))