jsonobjectify 0.0.0__tar.gz → 0.1.1__tar.gz

jsonobjectify-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sandeep Suryaprasad
+
+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.

jsonobjectify-0.1.1/PKG-INFO

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: jsonobjectify
+Version: 0.1.1
+Summary: A lightweight Python library for converting JSON data into Python objects, simplifying access to nested structures through intuitive dot notation.
+Keywords: json-parsing,Attribute lookup,automated-json-parsing
+Author: Sandeep Suryaprasad
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+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
+
+[![CI](https://github.com/sandeepsuryaprasad/jsonobjectify/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/sandeepsuryaprasad/jsonobjectify/actions/workflows/ci.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![PyPI version](https://img.shields.io/pypi/v/jsonobjectify)](https://pypi.org/project/jsonobjectify/)
+[![Python versions](https://img.shields.io/pypi/pyversions/jsonobjectify)](https://pypi.org/project/jsonobjectify/)
+
+A lightweight Python library for converting JSON data into Python objects, 
+simplifying access to nested structures through dot notation. Instead of writing chained 
+dictionary lookups, you can navigate nested JSON structures using a clean, readable, 
+object-oriented interface.
+
+## Installation
+
+```console
+pip install jsonobjectify
+```
+
+## Usage
+Consider the following JSON data representing an employee and their department:
+
+```python
+response = """{
+    "id": 1,
+    "name": "John Doe",
+    "email": "john.doe@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"}
+    ]
+}"""
+```
+### Create `JsonPath` object from JSON string.
+Here, response is a string containing valid JSON. The `from_string` class method parses 
+the JSON data and creates a `JsonPath` object that allows you to access properties using 
+dot notation.
+```console
+>>> employee = JsonPath.from_string(response)
+```
+You can now access and traverse nested JSON objects using **dot notation**. 
+For JSON arrays, use the standard Python indexing syntax.
+```console
+>>> employee.name
+'John Doe'
+>>> employee.address.city
+'Austin'
+>>> employee.address.geo_location.lng
+'-97.7431'
+>>> employee.skills[0].name
+'Python'
+>>> employee.skills[1].level
+'Advanced'
+>>>
+```
+You can also iterate over JSON arrays using a standard Python for loop and access each 
+element's properties using dot notation.
+```console
+>>> for skill in employee.skills:
+...     print(f"{skill.name}, {skill.level}")
+...     
+Python, Advanced
+C, Advanced
+C++, Intermediate
+>>> 
+```
+### Root response is an array of JSON objects
+A JSON response can contain an array of objects at the root level. You can use 
+`JsonPath.from_string` to parse the response and access each object's properties using 
+dot notation.
+```python
+response = """[
+  {
+    "name": "Olivia Bennett",
+    "email": "olivia.bennett@example.com",
+    "website": "www.example.dev"
+  },
+  {
+    "name": "Ethan Parker",
+    "email": "ethan.parker@example.com",
+    "website": "www.example.io"
+  },
+  {
+    "name": "Sophia Turner",
+    "email": "sophia.turner@example.com",
+    "website": "www.example.edu"
+  }
+]"""
+```
+```console
+>>> employees = JsonPath.from_string(response)
+>>> employees[0]
+<jsonobjectify.jsonobject.JsonObject object at 0x101bb7d50>
+>>> employees[1]
+<jsonobjectify.jsonobject.JsonObject object at 0x101bb7b50>
+>>> employees[2]
+<jsonobjectify.jsonobject.JsonObject object at 0x101aa2120>
+>>> employees[0].name
+'Olivia Bennett'
+>>> employees[0].email
+'olivia.bennett@example.com'
+>>> employees[0].website
+'www.example.dev'
+>>> 
+```
+You can also iterate over JSON arrays using a standard Python for loop and access each 
+element's properties using dot notation.
+```console
+>>> for employee in employees:
+...     print(f"{employee.name}, {employee.email}, {employee.website}")
+...     
+Olivia Bennett, olivia.bennett@example.com, www.example.dev
+Ethan Parker, ethan.parker@example.com, www.example.io
+Sophia Turner, sophia.turner@example.com, www.example.edu
+>>> 
+```
+
+### Create a `JsonPath` object from a JSON file
+You can also create a JsonPath object directly from a JSON file using the `from_file`
+class method. This allows you to work with JSON data stored in a file without having to 
+read and parse its contents manually.
+
+For example, consider an `employee.json` file containing the employee data shown in the 
+previous example.
+
+```console
+>>> employee = JsonPath.from_file("employee.json")
+```
+Once the object is created, you can access nested properties and iterate over JSON arrays
+in the same way
+
+```console
+>>> employee.name
+'Michael Anderson'
+>>> employee.address.city
+'Austin'
+>>> for skill in employee.skills:
+...     print(f"{skill.name}, {skill.level}")
+...
+Python, Advanced
+C, Advanced
+C++, Intermediate
+```
+
+### Working with Scalar Values
+If the **root JSON** value is a scalar, such as a string, number, boolean or null, you can 
+access the underlying value using the `value` property.
+
+```console
+>>> data = JsonPath.from_string("26")
+>>> data.value
+26
+>>> data = JsonPath.from_string("true")
+>>> data.value
+True
+>>> data = JsonPath.from_string("null")
+>>> data.value
+>>>
+>>> json = JsonPath.from_string('"hello world"')
+>>> json.value
+'hello world'
+```
+### Accessing JSON Properties with Normalized Keys
+JSON property names may contain hyphens, spaces, or periods, which cannot be used directly 
+in Python attribute names. jsonobjectify normalizes these characters to underscores, 
+allowing you to access such properties using dot notation.
+
+```python
+response = """{
+  "first-name": "Olivia",
+  "job title": "Software Engineer",
+  "contact.email": "olivia@example.com"
+}"""
+```
+```console
+>>> employee = JsonPath.from_string(response)
+```
+You can access these properties using normalized attribute names,
+
+```console
+>>> employee.first_name
+'Olivia'
+>>> employee.job_title
+'Software Engineer'
+>>> employee.contact_email
+'olivia@example.com'
+```
+**The original JSON property names are preserved when converting the object back to 
+a dictionary or JSON string.**
+
+### 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.12 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 package is distributed under the terms of [MIT](https://github.com/sandeepsuryaprasad/jsonobjectify/blob/main/LICENSE) license

jsonobjectify-0.1.1/README.md

@@ -0,0 +1,220 @@
+# jsonobjectify
+
+[![CI](https://github.com/sandeepsuryaprasad/jsonobjectify/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/sandeepsuryaprasad/jsonobjectify/actions/workflows/ci.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![PyPI version](https://img.shields.io/pypi/v/jsonobjectify)](https://pypi.org/project/jsonobjectify/)
+[![Python versions](https://img.shields.io/pypi/pyversions/jsonobjectify)](https://pypi.org/project/jsonobjectify/)
+
+A lightweight Python library for converting JSON data into Python objects, 
+simplifying access to nested structures through dot notation. Instead of writing chained 
+dictionary lookups, you can navigate nested JSON structures using a clean, readable, 
+object-oriented interface.
+
+## Installation
+
+```console
+pip install jsonobjectify
+```
+
+## Usage
+Consider the following JSON data representing an employee and their department:
+
+```python
+response = """{
+    "id": 1,
+    "name": "John Doe",
+    "email": "john.doe@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"}
+    ]
+}"""
+```
+### Create `JsonPath` object from JSON string.
+Here, response is a string containing valid JSON. The `from_string` class method parses 
+the JSON data and creates a `JsonPath` object that allows you to access properties using 
+dot notation.
+```console
+>>> employee = JsonPath.from_string(response)
+```
+You can now access and traverse nested JSON objects using **dot notation**. 
+For JSON arrays, use the standard Python indexing syntax.
+```console
+>>> employee.name
+'John Doe'
+>>> employee.address.city
+'Austin'
+>>> employee.address.geo_location.lng
+'-97.7431'
+>>> employee.skills[0].name
+'Python'
+>>> employee.skills[1].level
+'Advanced'
+>>>
+```
+You can also iterate over JSON arrays using a standard Python for loop and access each 
+element's properties using dot notation.
+```console
+>>> for skill in employee.skills:
+...     print(f"{skill.name}, {skill.level}")
+...     
+Python, Advanced
+C, Advanced
+C++, Intermediate
+>>> 
+```
+### Root response is an array of JSON objects
+A JSON response can contain an array of objects at the root level. You can use 
+`JsonPath.from_string` to parse the response and access each object's properties using 
+dot notation.
+```python
+response = """[
+  {
+    "name": "Olivia Bennett",
+    "email": "olivia.bennett@example.com",
+    "website": "www.example.dev"
+  },
+  {
+    "name": "Ethan Parker",
+    "email": "ethan.parker@example.com",
+    "website": "www.example.io"
+  },
+  {
+    "name": "Sophia Turner",
+    "email": "sophia.turner@example.com",
+    "website": "www.example.edu"
+  }
+]"""
+```
+```console
+>>> employees = JsonPath.from_string(response)
+>>> employees[0]
+<jsonobjectify.jsonobject.JsonObject object at 0x101bb7d50>
+>>> employees[1]
+<jsonobjectify.jsonobject.JsonObject object at 0x101bb7b50>
+>>> employees[2]
+<jsonobjectify.jsonobject.JsonObject object at 0x101aa2120>
+>>> employees[0].name
+'Olivia Bennett'
+>>> employees[0].email
+'olivia.bennett@example.com'
+>>> employees[0].website
+'www.example.dev'
+>>> 
+```
+You can also iterate over JSON arrays using a standard Python for loop and access each 
+element's properties using dot notation.
+```console
+>>> for employee in employees:
+...     print(f"{employee.name}, {employee.email}, {employee.website}")
+...     
+Olivia Bennett, olivia.bennett@example.com, www.example.dev
+Ethan Parker, ethan.parker@example.com, www.example.io
+Sophia Turner, sophia.turner@example.com, www.example.edu
+>>> 
+```
+
+### Create a `JsonPath` object from a JSON file
+You can also create a JsonPath object directly from a JSON file using the `from_file`
+class method. This allows you to work with JSON data stored in a file without having to 
+read and parse its contents manually.
+
+For example, consider an `employee.json` file containing the employee data shown in the 
+previous example.
+
+```console
+>>> employee = JsonPath.from_file("employee.json")
+```
+Once the object is created, you can access nested properties and iterate over JSON arrays
+in the same way
+
+```console
+>>> employee.name
+'Michael Anderson'
+>>> employee.address.city
+'Austin'
+>>> for skill in employee.skills:
+...     print(f"{skill.name}, {skill.level}")
+...
+Python, Advanced
+C, Advanced
+C++, Intermediate
+```
+
+### Working with Scalar Values
+If the **root JSON** value is a scalar, such as a string, number, boolean or null, you can 
+access the underlying value using the `value` property.
+
+```console
+>>> data = JsonPath.from_string("26")
+>>> data.value
+26
+>>> data = JsonPath.from_string("true")
+>>> data.value
+True
+>>> data = JsonPath.from_string("null")
+>>> data.value
+>>>
+>>> json = JsonPath.from_string('"hello world"')
+>>> json.value
+'hello world'
+```
+### Accessing JSON Properties with Normalized Keys
+JSON property names may contain hyphens, spaces, or periods, which cannot be used directly 
+in Python attribute names. jsonobjectify normalizes these characters to underscores, 
+allowing you to access such properties using dot notation.
+
+```python
+response = """{
+  "first-name": "Olivia",
+  "job title": "Software Engineer",
+  "contact.email": "olivia@example.com"
+}"""
+```
+```console
+>>> employee = JsonPath.from_string(response)
+```
+You can access these properties using normalized attribute names,
+
+```console
+>>> employee.first_name
+'Olivia'
+>>> employee.job_title
+'Software Engineer'
+>>> employee.contact_email
+'olivia@example.com'
+```
+**The original JSON property names are preserved when converting the object back to 
+a dictionary or JSON string.**
+
+### 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.12 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 package is distributed under the terms of [MIT](https://github.com/sandeepsuryaprasad/jsonobjectify/blob/main/LICENSE) license

{jsonobjectify-0.0.0 → jsonobjectify-0.1.1}/pyproject.toml

@@ -1,9 +1,27 @@
+[build-system]
+requires = ["uv_build>=0.9.13,<0.12.0"]
+build-backend = "uv_build"
+
 [project]
 name = "jsonobjectify"
-version = "0.0.0"
+version = "0.1.1"
 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"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "json-parsing",
+    "Attribute lookup",
+    "automated-json-parsing",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
 dependencies = []
 
 [[project.authors]]
@@ -14,19 +32,13 @@ Homepage = "https://github.com/sandeepsuryaprasad/jsonobjectify"
 Repository = "https://github.com/sandeepsuryaprasad/jsonobjectify"
 Issues = "https://github.com/sandeepsuryaprasad/jsonobjectify/issues"
 
+[dependency-groups]
+test = ["pytest>=8.0.0"]
+lint = ["ruff>=0.14.0"]
+
 [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
@@ -94,12 +106,4 @@ ignore = [
 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"
+testpaths = ["tests"]

{jsonobjectify-0.0.0 → jsonobjectify-0.1.1}/pyproject.toml.orig

@@ -1,28 +1,27 @@
+[build-system]
+requires = ["uv_build>=0.9.13,<0.12.0"]
+build-backend = "uv_build"
+
 [project]
 name = "jsonobjectify"
-version = "0.0.0"
+version = "0.1.1"
 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 = []
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords =["json-parsing", "Attribute lookup", "automated-json-parsing"]
 authors = [
     {name= "Sandeep Suryaprasad"}
 ]
-
-[tool.uv.build-backend]
-module-root = "src"
-module-name = "jsonobjectify"
-
 classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
+    "Development Status :: 3 - Alpha",
     "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",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
+dependencies = []
 
 [project.urls]
 Homepage = "https://github.com/sandeepsuryaprasad/jsonobjectify"
@@ -30,8 +29,12 @@ 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"]
+test = ["pytest>=8.0.0"]
+lint = ["ruff>=0.14.0"]
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "jsonobjectify"
 
 [tool.ruff]
 line-length = 119
@@ -100,8 +103,4 @@ ignore = [
 convention = "google"
 
 [tool.pytest.ini_options]
-testpaths = ["./tests"]
-
-[build-system]
-requires = ["uv_build>=0.9.13,<0.12.0"]
-build-backend = "uv_build"
+testpaths = ["tests"]

jsonobjectify-0.0.0/src/jsonobjectify/json_object.py → jsonobjectify-0.1.1/src/jsonobjectify/jsonobject.py

@@ -1,17 +1,23 @@
 from json import dumps
+from re import sub
 
 
 class JsonObject:
     """Represent a JSON object as a Python object."""
+
     def __init__(self, info):
         self._info = info
 
-    def __getattr__(self, name):
+    def _normalize_key(self, key: str) -> str:
+        """Normalize a JSON key for Python attribute access."""
+        return sub(r"[-\s\.]+", "_", key)
+
+    def __getattr__(self, name: str):
         """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
+        for key, value in self._info.items():
+            if self._normalize_key(key) == name:
+                return value
+        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."""

jsonobjectify-0.0.0/src/jsonobjectify/json_path.py → jsonobjectify-0.1.1/src/jsonobjectify/jsonpath.py

@@ -1,6 +1,7 @@
 from json import load, loads
 from pathlib import Path
-from .json_object import JsonObject
+
+from .jsonobject import JsonObject
 
 
 class JsonPath:
@@ -9,7 +10,14 @@ class JsonPath:
         self._root_json_object = None
 
     def __getattr__(self, name):
-        """Delegate attribute access to the json object."""
+        """Delegate attribute access to the root JSON object.
+
+        Raises:
+            AttributeError: If the requested attribute is 'value' or does not
+            exist on the root JSON object.
+        """
+        if name == "value":
+            raise AttributeError("'value' attribute is available only for scalar values")
         return getattr(self._root_json_object, name)
 
     def __getitem__(self, index):
@@ -23,17 +31,34 @@ class JsonPath:
         return len(self._root_json_object)
 
     def __setattr__(self, name, value):
+        """Set an attribute on the root JSON object.
+
+        Delegates attribute assignment to the root JSON object, except for
+        `_root_json_object`, which is assigned directly.
+        """
         if name == "_root_json_object":
             super().__setattr__(name, value)
         else:
             setattr(self._root_json_object, name, value)
 
     def __str__(self):
+        """Return the string representation of the root JSON value.
+
+        Serializes a root `JsonObject` as a JSON string. For scalar values,
+        returns their standard Python string representation without JSON
+        quoting or formatting.
+        """
         if isinstance(self._root_json_object, JsonObject):
             return self._root_json_object.to_json()
         return f"{self._root_json_object}"
 
     def __repr__(self):
+        """Return an unambiguous string representation of the instance.
+
+        Includes the class name and root JSON value. Converts a `JsonObject`
+        to a Python dictionary; scalar values use their standard Python
+        representation.
+        """
         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})"
@@ -42,14 +67,6 @@ class JsonPath:
         """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]
@@ -59,7 +76,6 @@ class JsonPath:
         _data = {
             key: self._process_object(value)
             for key, value in data.items()
-            if self._is_valid_json_key(key)
         }
         return self._wrap_dict(_data)
 
@@ -75,14 +91,30 @@ class JsonPath:
         """Build the root object from the deserialized JSON."""
         return self._process_object(py_object)
 
+    @property
+    def value(self):
+        """Return the root value if the JSON response is a scalar.
+        
+        Raises:
+            AttributeError: If the root JSON response is an object or array.
+        """
+        if isinstance(self._root_json_object, (JsonObject, list)):
+            raise AttributeError("'value' attribute is available only for scalar values")
+        return self._root_json_object
+
     @classmethod
     def _from_py_object(cls, py_object):
+        """Create a `JsonPath` instance from a Python object.
+
+        Builds the root JSON structure from the supplied Python object and
+        returns the initialized instance.
+        """
         obj = cls()
         obj._root_json_object = obj._build_root_object(py_object)
         return obj
 
     @classmethod
-    def from_json_string(cls, json_string):
+    def from_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")
@@ -91,7 +123,7 @@ class JsonPath:
         return cls._from_py_object(loads(json_string))
 
     @classmethod
-    def from_json_file(cls, filename: str):
+    def from_file(cls, filename: str):
         """Create a JsonPath instance from a JSON file."""
         path = Path(filename)
         if not path.is_file():

jsonobjectify-0.0.0/PKG-INFO

@@ -1,115 +0,0 @@
-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

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