rich-object 0.1.0__py3-none-any.whl

rich_object/__init__.py

@@ -0,0 +1,4 @@
+# rich_object package
+from .object import Object
+
+__all__ = ["Object"]

rich_object/object.py

@@ -0,0 +1,558 @@
+import copy
+import json
+import re
+
+class ObjectList(list):
+    """A list subclass that respects lock state and auto-wraps dicts into Objects."""
+    def __init__(self, iterable=(), lock=False):
+        self._lock = False
+        super().__init__()
+        for item in iterable:
+            self.append(item)
+        self._lock = lock
+
+    def _check_lock(self):
+        if getattr(self, '_lock', False):
+            raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be modified")
+
+    def _wrap(self, item):
+        if isinstance(item, dict) and not isinstance(item, Object):
+            return Object(item, lock=self._lock)
+        elif isinstance(item, list) and not isinstance(item, ObjectList):
+            return ObjectList(item, lock=self._lock)
+        return item
+
+    def append(self, item):
+        self._check_lock()
+        super().append(self._wrap(item))
+
+    def extend(self, iterable):
+        self._check_lock()
+        super().extend(self._wrap(item) for item in iterable)
+
+    def insert(self, index, item):
+        self._check_lock()
+        super().insert(index, self._wrap(item))
+
+    def remove(self, item):
+        self._check_lock()
+        super().remove(item)
+
+    def pop(self, index=-1):
+        self._check_lock()
+        return super().pop(index)
+
+    def clear(self):
+        self._check_lock()
+        super().clear()
+
+    def __setitem__(self, index, item):
+        self._check_lock()
+        super().__setitem__(index, self._wrap(item))
+
+    def __delitem__(self, index):
+        self._check_lock()
+        super().__delitem__(index)
+
+    def __iadd__(self, other):
+        self._check_lock()
+        super().extend(self._wrap(item) for item in other)
+        return self
+
+    def __copy__(self):
+        new_list = ObjectList(lock=False)
+        for item in self:
+            super(ObjectList, new_list).append(item)
+        new_list._lock = self._lock
+        return new_list
+
+    def __deepcopy__(self, memo):
+        new_list = ObjectList(lock=False)
+        memo[id(self)] = new_list
+        for item in self:
+            super(ObjectList, new_list).append(copy.deepcopy(item, memo))
+        new_list._lock = self._lock
+        return new_list
+
+
+class Object(dict):
+    """A dictionary subclass that allows dot notation attribute access
+    and automatically creates missing paths (autovivification).
+    
+    Supports lock (disables create/update/delete).
+    """
+
+    def __init__(self, *args, lock=False, **kwargs):
+        """Initializes a new Object instance.
+
+        Args:
+            *args: Initial dictionary or iterable of key-value pairs to populate the Object.
+            lock (bool): If True, disables any create, update, or delete operations on this Object
+                         and all of its descendants/elements recursively.
+            **kwargs: Additional key-value pairs to populate the Object.
+
+        Example:
+            >>> obj = Object(name="John", address={"city": "New York"})
+            >>> obj.name
+            'John'
+            >>> obj.address.city
+            'New York'
+            >>> locked_obj = Object(x=1, lock=True)
+            >>> locked_obj.x = 2
+            TypeError: 'Object' is locked and cannot be modified
+        """
+        object.__setattr__(self, '_lock', lock)
+        object.__setattr__(self, '_initialized', False)
+        
+        super().__init__()
+        self.update(dict(*args, **kwargs))
+        
+        object.__setattr__(self, '_initialized', True)
+
+    def __getattr__(self, key: str):
+        if key.startswith('__') and key.endswith('__'):
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")
+            
+        if key not in self:
+            if object.__getattribute__(self, '_lock') and object.__getattribute__(self, '_initialized'):
+                raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be modified")
+                
+            lock_val = object.__getattribute__(self, '_lock')
+            self[key] = Object(lock=lock_val)
+        return self[key]
+
+    def __setattr__(self, key: str, value):
+        if key == '_lock':
+            if getattr(self, '_initialized', False):
+                raise TypeError("Cannot modify '_lock' after initialization")
+            object.__setattr__(self, key, value)
+        elif key == '_initialized':
+            object.__setattr__(self, key, value)
+        else:
+            self[key] = value
+
+    def __delattr__(self, key: str):
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")
+
+    def __getitem__(self, key):
+        if key not in self:
+            if object.__getattribute__(self, '_lock') and object.__getattribute__(self, '_initialized'):
+                raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be modified")
+                
+            lock_val = object.__getattribute__(self, '_lock')
+            self[key] = Object(lock=lock_val)
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value):
+        if object.__getattribute__(self, '_lock') and getattr(self, '_initialized', True):
+            raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be modified")
+
+        lock_val = object.__getattribute__(self, '_lock')
+
+        if isinstance(value, dict) and not isinstance(value, Object):
+            value = Object(value, lock=lock_val)
+        elif isinstance(value, list) and not isinstance(value, ObjectList):
+            value = ObjectList(value, lock=lock_val)
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        if object.__getattribute__(self, '_lock') and getattr(self, '_initialized', True):
+            raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be modified")
+        super().__delitem__(key)
+
+    def update(self, *args, **kwargs):
+        for k, v in dict(*args, **kwargs).items():
+            self[k] = v
+
+    def set(self, path: str, value):
+        """Sets a value at the specified path, creating nested Objects or ObjectLists as needed.
+
+        Supports dot notation for dict keys and bracket notation with indices for list elements.
+
+        Args:
+            path (str): The dot-and-bracket path (e.g., 'a.b.list[0].c').
+            value: The value to set at the path.
+
+        Raises:
+            TypeError: If the Object is locked or if the path encounters a non-container type.
+
+        Example:
+            >>> obj = Object()
+            >>> obj.set("store.books[1].title", "Moby Dick")
+            >>> obj.store.books[1].title
+            'Moby Dick'
+            >>> obj.store.books[0] is None
+            True
+        """
+        tokens = re.findall(r"[^.\[\]]+|\[\d+\]", path)
+        parsed_tokens = []
+        for t in tokens:
+            if t.startswith("[") and t.endswith("]"):
+                parsed_tokens.append(int(t[1:-1]))
+            else:
+                parsed_tokens.append(t)
+                
+        if not parsed_tokens:
+            return
+
+        curr = self
+        for i in range(len(parsed_tokens) - 1):
+            token = parsed_tokens[i]
+            next_token = parsed_tokens[i+1]
+            
+            node_type = ObjectList if isinstance(next_token, int) else Object
+            
+            if isinstance(curr, dict):
+                if token not in curr:
+                    curr[token] = node_type()
+                curr = curr[token]
+            elif isinstance(curr, list):
+                while len(curr) <= token:
+                    curr.append(Object() if isinstance(next_token, str) else ObjectList())
+                if curr[token] is None:
+                    curr[token] = node_type()
+                curr = curr[token]
+            else:
+                raise TypeError(f"Cannot set property '{next_token}' on non-object '{token}'")
+
+        last_token = parsed_tokens[-1]
+        if isinstance(curr, dict):
+            curr[last_token] = value
+        elif isinstance(curr, list):
+            while len(curr) <= last_token:
+                curr.append(None)
+            curr[last_token] = value
+
+    def get(self, key, default=None):
+        """Retrieves a value by key. Supports JSONPath expressions if the key starts with '$'.
+
+        Args:
+            key (str): The key or JSONPath expression (e.g., '$.store.book[*].price').
+            default: The fallback value to return if the key/path is not found.
+
+        Returns:
+            The matched value, a list of matched values (for JSONPath), or the default value.
+
+        Example:
+            >>> obj = Object({"store": {"book": [{"price": 10}, {"price": 15}]}})
+            >>> obj.get("$.store.book[*].price")
+            [10, 15]
+            >>> obj.get("nonexistent_key", "default_val")
+            'default_val'
+        """
+        if isinstance(key, str) and key.startswith('$'):
+            try:
+                from jsonpath_ng import parse
+                jsonpath_expr = parse(key)
+                matches = [match.value for match in jsonpath_expr.find(self)]
+                
+                if not matches:
+                    return default
+                if len(matches) == 1:
+                    return matches[0]
+                return matches
+            except Exception:
+                return default
+        return super().get(key, default)
+
+    def __add__(self, other):
+        """Merges this Object with another dictionary or Object and returns a new Object.
+
+        Performs a deep merge, extending list items and recursively merging nested mappings.
+
+        Args:
+            other (dict): The dictionary or Object to merge with.
+
+        Returns:
+            Object: A new merged Object.
+
+        Raises:
+            TypeError: If this Object is locked, or other is not a dictionary.
+
+        Example:
+            >>> obj1 = Object({"a": {"x": 1}, "b": [1, 2]})
+            >>> obj2 = {"a": {"y": 2}, "b": [3, 4]}
+            >>> merged = obj1 + obj2
+            >>> merged.to_dict()
+            {'a': {'x': 1, 'y': 2}, 'b': [1, 2, 3, 4]}
+        """
+        if object.__getattribute__(self, '_lock'):
+            raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be merged")
+        if not isinstance(other, dict):
+            return NotImplemented
+
+        result = copy.deepcopy(self)
+        
+        def merge(target, source):
+            for k, v in source.items():
+                if k in target:
+                    if isinstance(target[k], dict) and isinstance(v, dict):
+                        merge(target[k], v)
+                    elif isinstance(target[k], list) and isinstance(v, list):
+                        # Use target[k].extend so ObjectList wraps new dicts
+                        target[k].extend(copy.deepcopy(v))
+                    else:
+                        target[k] = copy.deepcopy(v)
+                else:
+                    target[k] = copy.deepcopy(v)
+                    
+        merge(result, other)
+        return result
+
+    def to_dict(self):
+        """Recursively converts this Object and all nested Objects/ObjectLists to standard Python dicts and lists.
+
+        Returns:
+            dict: A standard Python dict representation of this Object.
+
+        Example:
+            >>> obj = Object(a=1, b={"c": 2})
+            >>> type(obj.b)
+            <class 'rich_object.object.Object'>
+            >>> d = obj.to_dict()
+            >>> type(d['b'])
+            <class 'dict'>
+        """
+        def _convert(obj):
+            if isinstance(obj, Object):
+                return {k: _convert(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [_convert(v) for v in obj]
+            return obj
+        return {k: _convert(v) for k, v in self.items()}
+
+    def render(self, **kwargs):
+        """Renders Jinja2 templates in all string values recursively across the entire structure.
+
+        Args:
+            **kwargs: Additional context variables passed to the Jinja template rendering environment.
+
+        Returns:
+            Object: A copy of this Object with all template variables rendered.
+
+        Raises:
+            TypeError: If this Object is locked.
+            ImportError: If the 'jinja2' package is not installed.
+
+        Example:
+            >>> obj = Object({"greeting": "Hello {{ name }}!"})
+            >>> rendered = obj.render(name="World")
+            >>> rendered.greeting
+            'Hello World!'
+
+            >>> # Using filters like 'int' and 'str'
+            >>> obj = Object({
+            ...     "number": "{{ '42' | int }}",
+            ...     "serialized_list": "{{ [1, 2, 3] | str }}",
+            ...     "serialized_dict": "{{ {'a': 1} | str }}"
+            ... })
+            >>> res = obj.render()
+            >>> res.number
+            42
+            >>> res.serialized_list
+            '[1, 2, 3]'
+
+            >>> # Passing helper objects like a faker instance or datetime
+            >>> from datetime import datetime
+            >>> class MockFaker:
+            ...     def name(self): return "Alice Smith"
+            ...
+            >>> obj = Object({
+            ...     "username": "{{ fake.name() }}",
+            ...     "created_year": "{{ now.strftime('%Y') }}"
+            ... })
+            >>> res = obj.render(fake=MockFaker(), now=datetime(2026, 7, 6))
+            >>> res.username
+            'Alice Smith'
+            >>> res.created_year
+            '2026'
+
+            >>> # Passing entire modules
+            >>> import datetime
+            >>> obj = Object({
+            ...     "year": "{{ dt.datetime(2026, 7, 6).year }}",
+            ...     "future_date": "{{ (dt.datetime(2026, 7, 6) + dt.timedelta(days=5)).strftime('%Y-%m-%d') }}"
+            ... })
+            >>> res = obj.render(dt=datetime)
+            >>> res.year
+            2026
+            >>> res.future_date
+            '2026-07-11'
+        """
+        if object.__getattribute__(self, '_lock'):
+            raise TypeError(f"'{self.__class__.__name__}' is locked and cannot be rendered")
+        try:
+            from jinja2.nativetypes import NativeEnvironment
+            from jinja2 import DebugUndefined
+        except ImportError:
+            raise ImportError("jinja2 is required to use the render() method. Install it with 'pip install jinja2'")
+            
+        env = NativeEnvironment(undefined=DebugUndefined)
+        
+        def parse_bool(val):
+            if isinstance(val, str):
+                return val.lower() in ('true', '1', 't', 'yes', 'y')
+            return bool(val)
+            
+        env.filters['bool'] = parse_bool
+        env.filters['Object'] = Object
+        
+        env.filters['str'] = lambda val: json.dumps(val) if isinstance(val, (dict, list)) else str(val)
+        
+        env.globals['true'] = True
+        env.globals['false'] = False
+        env.globals['null'] = None
+        env.globals['Object'] = Object
+        
+        context = self.to_dict()
+        context.update(kwargs)
+        
+        result = copy.deepcopy(self)
+        
+        def traverse_item(item):
+            if isinstance(item, str):
+                try:
+                    template = env.from_string(item)
+                    return template.render(**context)
+                except Exception:
+                    return item
+            elif isinstance(item, dict):
+                for k, v in item.items():
+                    item[k] = traverse_item(v)
+                return item
+            elif isinstance(item, list):
+                for i in range(len(item)):
+                    item[i] = traverse_item(item[i])
+                return item
+            return item
+
+        for k, v in result.items():
+            result[k] = traverse_item(v)
+            
+        return result
+
+    def diff(
+        self,
+        other,
+        ignore_order=False,
+        ignore_string_case=False,
+        exclude_paths=None,
+        exclude_regex_paths=None,
+        exclude_types=None,
+        include_paths=None,
+        significant_digits=None,
+        math_epsilon=None,
+        ignore_numeric_type_changes=False,
+        ignore_type_in_groups=None,
+        ignore_type_subclasses=False,
+        ignore_string_type_changes=False,
+        ignore_nan_inequality=False,
+        ignore_encoding_errors=False,
+        ignore_private_variables=True,
+        truncate_datetime=None,
+        cutoff_distance_for_pairs=0.3,
+        cutoff_intersection_for_pairs=0.7,
+        cache_size=0,
+        cache_purge_level=1,
+        log_frequency_in_sec=0,
+        max_passes=10000000,
+        max_diffs=None,
+        verbose_level=1,
+        view="text",
+        **kwargs
+    ):
+        """Computes the difference between this Object and another object using DeepDiff.
+
+        Args:
+            other: The other object or dictionary to compare against.
+            ignore_order (bool): See DeepDiff documentation.
+            ignore_string_case (bool): See DeepDiff documentation.
+            exclude_paths (list/set): See DeepDiff documentation.
+            exclude_regex_paths (list/set): See DeepDiff documentation.
+            exclude_types (list/set): See DeepDiff documentation.
+            include_paths (list/set): See DeepDiff documentation.
+            significant_digits (int): See DeepDiff documentation.
+            math_epsilon (float): See DeepDiff documentation.
+            ignore_numeric_type_changes (bool): See DeepDiff documentation.
+            ignore_type_in_groups: See DeepDiff documentation.
+            ignore_type_subclasses (bool): See DeepDiff documentation.
+            ignore_string_type_changes (bool): See DeepDiff documentation.
+            ignore_nan_inequality (bool): See DeepDiff documentation.
+            ignore_encoding_errors (bool): See DeepDiff documentation.
+            ignore_private_variables (bool): See DeepDiff documentation.
+            truncate_datetime: See DeepDiff documentation.
+            cutoff_distance_for_pairs (float): See DeepDiff documentation.
+            cutoff_intersection_for_pairs (float): See DeepDiff documentation.
+            cache_size (int): See DeepDiff documentation.
+            cache_purge_level (int): See DeepDiff documentation.
+            log_frequency_in_sec (int): See DeepDiff documentation.
+            max_passes (int): See DeepDiff documentation.
+            max_diffs (int): See DeepDiff documentation.
+            verbose_level (int): See DeepDiff documentation.
+            view (str): See DeepDiff documentation.
+            **kwargs: Additional keyword arguments passed directly to DeepDiff.
+
+        Returns:
+            DeepDiff: The resulting comparison object.
+
+        Raises:
+            ImportError: If the 'deepdiff' package is not installed.
+
+        Example:
+            >>> obj1 = Object({"a": 1})
+            >>> obj2 = {"a": 2}
+            >>> diff = obj1.diff(obj2)
+            >>> 'values_changed' in diff
+            True
+        """
+        try:
+            from deepdiff import DeepDiff
+        except ImportError:
+            raise ImportError("deepdiff is required to use the diff() method. Install it with pip install deepdiff")
+            
+        kwargs.update({
+            "ignore_order": ignore_order,
+            "ignore_string_case": ignore_string_case,
+            "exclude_paths": exclude_paths,
+            "exclude_regex_paths": exclude_regex_paths,
+            "exclude_types": exclude_types,
+            "include_paths": include_paths,
+            "significant_digits": significant_digits,
+            "math_epsilon": math_epsilon,
+            "ignore_numeric_type_changes": ignore_numeric_type_changes,
+            "ignore_type_in_groups": ignore_type_in_groups,
+            "ignore_type_subclasses": ignore_type_subclasses,
+            "ignore_string_type_changes": ignore_string_type_changes,
+            "ignore_nan_inequality": ignore_nan_inequality,
+            "ignore_encoding_errors": ignore_encoding_errors,
+            "ignore_private_variables": ignore_private_variables,
+            "truncate_datetime": truncate_datetime,
+            "cutoff_distance_for_pairs": cutoff_distance_for_pairs,
+            "cutoff_intersection_for_pairs": cutoff_intersection_for_pairs,
+            "cache_size": cache_size,
+            "cache_purge_level": cache_purge_level,
+            "log_frequency_in_sec": log_frequency_in_sec,
+            "max_passes": max_passes,
+            "max_diffs": max_diffs,
+            "verbose_level": verbose_level,
+            "view": view,
+        })
+        
+        kwargs = {k: v for k, v in kwargs.items() if v is not None}
+            
+        return DeepDiff(
+            self.to_dict(),
+            other.to_dict() if hasattr(other, "to_dict") else other,
+            **kwargs
+        )
+
+
+
+    def __str__(self) -> str:
+        return str(self.to_dict())
+
+    def __repr__(self) -> str:
+        return repr(self.to_dict())

rich_object-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: rich-object
+Version: 0.1.0
+Summary: A Python package containing rich-object utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: jsonpath-ng~=1.7
+Requires-Dist: jinja2~=3.1
+Requires-Dist: deepdiff~=9.0
+
+# rich-object
+
+A powerful dictionary wrapper subclass that enables dot-notation attribute access, automatic nested path creation (autovivification), recursive locking, template rendering, JSONPath query resolution, and deep structure diffing.
+
+## Installation
+
+```bash
+pip install rich-object
+```
+
+## Features & Examples
+
+### 1. Basic Usage & Dot Access
+Create an `Object` from mappings or keyword arguments and access properties with standard dot notation.
+```python
+from rich_object import Object
+
+# Initialize using keywords or raw dictionaries
+obj = Object(name="John", address={"city": "New York"})
+
+print(obj.name)          # -> "John"
+print(obj.address.city)  # -> "New York"
+```
+
+### 2. Autovivification
+Missing nested directories/attributes are automatically initialized when accessed, resolving nested paths on the fly.
+```python
+obj = Object()
+obj.user.profile.settings.theme = "dark"
+
+print(obj.to_dict())
+# -> {'user': {'profile': {'settings': {'theme': 'dark'}}}}
+```
+
+### 3. Structural Locks
+Prevent mutations (creation, updates, deletes) recursively across all nested dictionaries and lists by passing `lock=True`.
+```python
+frozen = Object({"items": [1, 2], "user": {"id": 42}}, lock=True)
+
+# Any mutation throws a TypeError
+try:
+    frozen.user.id = 99
+except TypeError as e:
+    print(e)  # -> 'Object' is locked and cannot be modified
+
+try:
+    frozen.items.append(3)
+except TypeError as e:
+    print(e)  # -> 'ObjectList' is locked and cannot be modified
+```
+
+### 4. Advanced Property Setting (`set`)
+Assign values safely to deeply nested paths using dot notation and bracket indices. Intermediary dictionary keys and list slots expand automatically.
+```python
+obj = Object()
+obj.set("store.books[1].title", "Moby Dick")
+
+print(obj.store.books[1].title)  # -> "Moby Dick"
+print(obj.store.books[0])        # -> None (automatically padded slot)
+```
+
+### 5. JSONPath Querying (`get`)
+Query the data structure dynamically by passing JSONPath queries starting with `$`.
+```python
+data = Object({
+    "store": {
+        "book": [
+            {"category": "fiction", "price": 8.95},
+            {"category": "reference", "price": 12.00}
+        ]
+    }
+})
+
+# Retrieve a single value
+print(data.get("$.store.book[0].category"))  # -> "fiction"
+
+# Retrieve matching node value list
+print(data.get("$..price"))                  # -> [8.95, 12.0]
+```
+
+### 6. Deep Merging (`+`)
+Perform clean, recursive merges of two structures using the `+` operator. Nested lists are automatically concatenated, and conflicting keys default to the right-hand value.
+```python
+obj1 = Object({"a": {"x": 1}, "b": [1, 2]})
+obj2 = Object({"a": {"y": 2}, "b": [3, 4]})
+
+res = obj1 + obj2
+print(res.to_dict())
+# -> {'a': {'x': 1, 'y': 2}, 'b': [1, 2, 3, 4]}
+```
+
+### 7. Template Rendering (`render`)
+Render Jinja2 templates in all string values recursively across the entire structure (including nested dictionaries and lists).
+```python
+obj = Object({
+    "first_name": "Jane",
+    "greeting": "Hello {{ first_name }}!",
+    "matrix": [["Welcome {{ first_name }}"]]
+})
+
+rendered = obj.render()
+print(rendered.greeting)  # -> "Hello Jane!"
+print(rendered.matrix)    # -> [["Welcome Jane"]]
+```
+
+You can also pass entire modules or objects to the `render` method to use them inside your templates:
+```python
+import datetime
+
+obj = Object({
+    "year": "{{ dt.datetime(2026, 7, 6).year }}",
+    "future_date": "{{ (dt.datetime(2026, 7, 6) + dt.timedelta(days=5)).strftime('%Y-%m-%d') }}"
+})
+
+res = obj.render(dt=datetime)
+print(res.year)         # -> 2026
+print(res.future_date)  # -> "2026-07-11"
+```
+
+### 8. Structural Diffing (`diff`)
+Identify differences between two objects using the built-in DeepDiff interface.
+```python
+obj1 = Object({"a": 1, "b": 2})
+obj2 = Object({"a": 1, "b": 3})
+
+difference = obj1.diff(obj2)
+print(difference)
+# -> {'values_changed': {"root['b']": {'new_value': 3, 'old_value': 2}}}
+```

rich_object-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+rich_object/__init__.py,sha256=WHDyu-jkBrraMHkPhJVJ-x-ziM9-3rqlhinnrnY2Q20,71
+rich_object/object.py,sha256=5hZOuugzPD2jr471QFa1d7dW3x8PWjRGqL-mLDx0gZs,20889
+rich_object-0.1.0.dist-info/METADATA,sha256=5blIiqVaI2DwKibHPhcZEeMaybOy19wTeF1185berpw,4316
+rich_object-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+rich_object-0.1.0.dist-info/top_level.txt,sha256=CG_kf4Ih8st1axr8bMHR1-A8nKaGct0l7prrLcvQJJc,12
+rich_object-0.1.0.dist-info/RECORD,,

rich_object-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rich_object-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rich_object