pyobjtojson 0.1__tar.gz

pyobjtojson-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Carlos A. Planchón
+
+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.

pyobjtojson-0.1/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.2
+Name: pyobjtojson
+Version: 0.1
+Summary: A Python library that simplifies serializing any Python object to JSON-friendly structures, gracefully handling circular references.
+Author-email: "Carlos A. Planchón" <carlosandresplanchonprestes@gmail.com>
+License: MIT License
+Project-URL: repository, https://github.com/carlosplanchon/pyobjtojson.git
+Keywords: json,serialization,circular references,pydantic,dataclasses
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyobjtojson
+
+A lightweight Python library that simplifies the process of serializing **any** Python object into a JSON-friendly structure without getting tripped up by circular references. With built-in support for dataclasses, Pydantic (v1 & v2), and standard Python collections, **pyobjtojson** helps you convert your objects into a cycle-free, JSON-ready format for logging, storage, or data transfer.
+
+## Features
+
+- **Automatic Circular Reference Detection**  
+  Detects and replaces cyclical structures with `"<circular reference>"` to prevent infinite loops.
+- **Broad Compatibility**  
+  Works seamlessly with dictionaries, lists, custom classes, dataclasses, and Pydantic models (including both `model_dump()` from v2 and `dict()` from v1).
+- **Non-Intrusive Serialization**  
+  No special inheritance or overrides needed. Uses reflection and standard Python methods (`__dict__`, `asdict()`, `to_dict()`, etc.) where available.
+- **Easy to Integrate**  
+  Just call `obj_to_json()` on your data structure—no additional configuration required.
+  
+## Installation
+
+```bash
+pip install pyobjtojson
+```
+
+## Quickstart
+
+### 1. Basic Usage
+
+```python
+from pyobjtojson import obj_to_json
+
+# A simple dictionary with lists
+data = {
+    "key1": "value1",
+    "key2": [1, 2, 3],
+    "nested": {"inner_key": "inner_value"}
+}
+
+json_obj = obj_to_json(data)  # Using json.dumps kwargs
+```
+
+**Output** (example):
+```json
+{
+  "key1": "value1",
+  "key2": [
+    1,
+    2,
+    3
+  ],
+  "nested": {
+    "inner_key": "inner_value"
+  }
+}
+```
+
+### 2. Handling Circular References
+```python
+from pyobjtojson import obj_to_json
+
+a = {"name": "A"}
+b = {"circular": a}
+a["b"] = b  # Creates a circular reference
+
+obj_to_json(a)
+```
+
+**Output**:
+```json
+{
+  "name": "A",
+  "b": {
+    "circular": {
+      "name": "A",
+      "b": "<circular reference>"
+    }
+  }
+}
+```
+
+### 3. Working with Dataclasses and Pydantic
+
+```python
+from dataclasses import dataclass
+from pydantic import BaseModel
+from pyobjtojson import obj_to_json
+
+@dataclass
+class MyDataClass:
+    title: str
+    value: int
+
+class MyModel(BaseModel):
+    name: str
+    age: int
+
+dataclass_instance = MyDataClass(title="Test", value=123)
+pydantic_instance = MyModel(name="Alice", age=30)
+
+obj = {
+    "dataclass": dataclass_instance,
+    "pydantic": pydantic_instance
+}
+
+obj_to_json(obj)
+```
+
+**Output**:
+```json
+{
+  "dataclass": {
+    "title": "Test",
+    "value": 123
+  },
+  "pydantic": {
+    "name": "Alice",
+    "age": 30
+  }
+}
+```
+
+## API Reference
+
+- **`obj_to_json(obj) -> dict | list | Any`**  
+  Returns a cycle-free structure (nested dictionaries/lists) that is JSON-serializable.
+
+## Contributing
+Contributions, bug reports, and feature requests are welcome! Feel free to open an issue or submit a pull request.
+
+## License
+[MIT License](LICENSE)

pyobjtojson-0.1/README.md

@@ -0,0 +1,128 @@
+# pyobjtojson
+
+A lightweight Python library that simplifies the process of serializing **any** Python object into a JSON-friendly structure without getting tripped up by circular references. With built-in support for dataclasses, Pydantic (v1 & v2), and standard Python collections, **pyobjtojson** helps you convert your objects into a cycle-free, JSON-ready format for logging, storage, or data transfer.
+
+## Features
+
+- **Automatic Circular Reference Detection**  
+  Detects and replaces cyclical structures with `"<circular reference>"` to prevent infinite loops.
+- **Broad Compatibility**  
+  Works seamlessly with dictionaries, lists, custom classes, dataclasses, and Pydantic models (including both `model_dump()` from v2 and `dict()` from v1).
+- **Non-Intrusive Serialization**  
+  No special inheritance or overrides needed. Uses reflection and standard Python methods (`__dict__`, `asdict()`, `to_dict()`, etc.) where available.
+- **Easy to Integrate**  
+  Just call `obj_to_json()` on your data structure—no additional configuration required.
+  
+## Installation
+
+```bash
+pip install pyobjtojson
+```
+
+## Quickstart
+
+### 1. Basic Usage
+
+```python
+from pyobjtojson import obj_to_json
+
+# A simple dictionary with lists
+data = {
+    "key1": "value1",
+    "key2": [1, 2, 3],
+    "nested": {"inner_key": "inner_value"}
+}
+
+json_obj = obj_to_json(data)  # Using json.dumps kwargs
+```
+
+**Output** (example):
+```json
+{
+  "key1": "value1",
+  "key2": [
+    1,
+    2,
+    3
+  ],
+  "nested": {
+    "inner_key": "inner_value"
+  }
+}
+```
+
+### 2. Handling Circular References
+```python
+from pyobjtojson import obj_to_json
+
+a = {"name": "A"}
+b = {"circular": a}
+a["b"] = b  # Creates a circular reference
+
+obj_to_json(a)
+```
+
+**Output**:
+```json
+{
+  "name": "A",
+  "b": {
+    "circular": {
+      "name": "A",
+      "b": "<circular reference>"
+    }
+  }
+}
+```
+
+### 3. Working with Dataclasses and Pydantic
+
+```python
+from dataclasses import dataclass
+from pydantic import BaseModel
+from pyobjtojson import obj_to_json
+
+@dataclass
+class MyDataClass:
+    title: str
+    value: int
+
+class MyModel(BaseModel):
+    name: str
+    age: int
+
+dataclass_instance = MyDataClass(title="Test", value=123)
+pydantic_instance = MyModel(name="Alice", age=30)
+
+obj = {
+    "dataclass": dataclass_instance,
+    "pydantic": pydantic_instance
+}
+
+obj_to_json(obj)
+```
+
+**Output**:
+```json
+{
+  "dataclass": {
+    "title": "Test",
+    "value": 123
+  },
+  "pydantic": {
+    "name": "Alice",
+    "age": 30
+  }
+}
+```
+
+## API Reference
+
+- **`obj_to_json(obj) -> dict | list | Any`**  
+  Returns a cycle-free structure (nested dictionaries/lists) that is JSON-serializable.
+
+## Contributing
+Contributions, bug reports, and feature requests are welcome! Feel free to open an issue or submit a pull request.
+
+## License
+[MIT License](LICENSE)

pyobjtojson-0.1/pyobjtojson/__init__.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import dataclasses
+from collections.abc import Mapping, Sequence
+
+
+def _serialize_for_json(obj, visited):
+    """
+    Internal recursion logic that can
+    handle circular references using `visited`.
+    """
+    # If it's None, bool, int, float, or str, it’s already serializable
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
+    # If we've seen this object already, it's a circular reference
+    obj_id = id(obj)
+    if obj_id in visited:
+        return "<circular reference>"
+    visited.add(obj_id)
+
+    # If it's a Mapping (like dict), recursively process
+    if isinstance(obj, Mapping):
+        return {
+            key: _serialize_for_json(value, visited)
+            for key, value in obj.items()
+        }
+
+    # If it's a Sequence (like list or tuple) but not a string
+    if isinstance(obj, Sequence) and not isinstance(obj, str):
+        return [_serialize_for_json(item, visited) for item in obj]
+
+    # Check for Pydantic v2's model_dump()
+    if hasattr(obj, "model_dump") and callable(obj.model_dump):
+        return _serialize_for_json(obj.model_dump(), visited)
+
+    # Check for Pydantic v1's dict()
+    if hasattr(obj, "dict") and callable(obj.dict):
+        return _serialize_for_json(obj.dict(), visited)
+
+    # If it's a dataclass, convert it using dataclasses.asdict()
+    if dataclasses.is_dataclass(obj):
+        return _serialize_for_json(dataclasses.asdict(obj), visited)
+
+    # If there's a custom .to_dict() method
+    if hasattr(obj, "to_dict") and callable(obj.to_dict):
+        return _serialize_for_json(obj.to_dict(), visited)
+
+    # If the object has a __dict__, serialize that
+    if hasattr(obj, "__dict__"):
+        return _serialize_for_json(obj.__dict__, visited)
+
+    # If we get here, just convert to string (as a last resort)
+    return str(obj)
+
+
+def obj_to_json(obj):
+    """
+    Public-facing function that starts with a fresh visited set
+    to handle cycles. This calls the internal _serialize_for_json.
+    """
+    return _serialize_for_json(obj, visited=set())

pyobjtojson-0.1/pyobjtojson.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.2
+Name: pyobjtojson
+Version: 0.1
+Summary: A Python library that simplifies serializing any Python object to JSON-friendly structures, gracefully handling circular references.
+Author-email: "Carlos A. Planchón" <carlosandresplanchonprestes@gmail.com>
+License: MIT License
+Project-URL: repository, https://github.com/carlosplanchon/pyobjtojson.git
+Keywords: json,serialization,circular references,pydantic,dataclasses
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyobjtojson
+
+A lightweight Python library that simplifies the process of serializing **any** Python object into a JSON-friendly structure without getting tripped up by circular references. With built-in support for dataclasses, Pydantic (v1 & v2), and standard Python collections, **pyobjtojson** helps you convert your objects into a cycle-free, JSON-ready format for logging, storage, or data transfer.
+
+## Features
+
+- **Automatic Circular Reference Detection**  
+  Detects and replaces cyclical structures with `"<circular reference>"` to prevent infinite loops.
+- **Broad Compatibility**  
+  Works seamlessly with dictionaries, lists, custom classes, dataclasses, and Pydantic models (including both `model_dump()` from v2 and `dict()` from v1).
+- **Non-Intrusive Serialization**  
+  No special inheritance or overrides needed. Uses reflection and standard Python methods (`__dict__`, `asdict()`, `to_dict()`, etc.) where available.
+- **Easy to Integrate**  
+  Just call `obj_to_json()` on your data structure—no additional configuration required.
+  
+## Installation
+
+```bash
+pip install pyobjtojson
+```
+
+## Quickstart
+
+### 1. Basic Usage
+
+```python
+from pyobjtojson import obj_to_json
+
+# A simple dictionary with lists
+data = {
+    "key1": "value1",
+    "key2": [1, 2, 3],
+    "nested": {"inner_key": "inner_value"}
+}
+
+json_obj = obj_to_json(data)  # Using json.dumps kwargs
+```
+
+**Output** (example):
+```json
+{
+  "key1": "value1",
+  "key2": [
+    1,
+    2,
+    3
+  ],
+  "nested": {
+    "inner_key": "inner_value"
+  }
+}
+```
+
+### 2. Handling Circular References
+```python
+from pyobjtojson import obj_to_json
+
+a = {"name": "A"}
+b = {"circular": a}
+a["b"] = b  # Creates a circular reference
+
+obj_to_json(a)
+```
+
+**Output**:
+```json
+{
+  "name": "A",
+  "b": {
+    "circular": {
+      "name": "A",
+      "b": "<circular reference>"
+    }
+  }
+}
+```
+
+### 3. Working with Dataclasses and Pydantic
+
+```python
+from dataclasses import dataclass
+from pydantic import BaseModel
+from pyobjtojson import obj_to_json
+
+@dataclass
+class MyDataClass:
+    title: str
+    value: int
+
+class MyModel(BaseModel):
+    name: str
+    age: int
+
+dataclass_instance = MyDataClass(title="Test", value=123)
+pydantic_instance = MyModel(name="Alice", age=30)
+
+obj = {
+    "dataclass": dataclass_instance,
+    "pydantic": pydantic_instance
+}
+
+obj_to_json(obj)
+```
+
+**Output**:
+```json
+{
+  "dataclass": {
+    "title": "Test",
+    "value": 123
+  },
+  "pydantic": {
+    "name": "Alice",
+    "age": 30
+  }
+}
+```
+
+## API Reference
+
+- **`obj_to_json(obj) -> dict | list | Any`**  
+  Returns a cycle-free structure (nested dictionaries/lists) that is JSON-serializable.
+
+## Contributing
+Contributions, bug reports, and feature requests are welcome! Feel free to open an issue or submit a pull request.
+
+## License
+[MIT License](LICENSE)

pyobjtojson-0.1/pyobjtojson.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+pyobjtojson/__init__.py
+pyobjtojson.egg-info/PKG-INFO
+pyobjtojson.egg-info/SOURCES.txt
+pyobjtojson.egg-info/dependency_links.txt
+pyobjtojson.egg-info/top_level.txt

pyobjtojson-0.1/pyobjtojson.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyobjtojson-0.1/pyobjtojson.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyobjtojson

pyobjtojson-0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[options]
+package_dir = "pyobjtojson"
+packages = ["pyobjtojson"]
+
+[project]
+name = "pyobjtojson"
+version = "0.1"
+authors = [
+    {name = "Carlos A. Planchón", email = "carlosandresplanchonprestes@gmail.com"},
+]
+description = "A Python library that simplifies serializing any Python object to JSON-friendly structures, gracefully handling circular references."
+classifiers = [
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+]
+license = {text = "MIT License"}
+keywords = ["json", "serialization", "circular references", "pydantic", "dataclasses"]
+readme = "README.md"
+
+[project.urls]
+repository = "https://github.com/carlosplanchon/pyobjtojson.git"

pyobjtojson-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+