magicattr 0.1.7__py3-none-any.whl

magicattr-0.1.7.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: magicattr
+Version: 0.1.7
+Summary: A getattr and setattr that works on nested objects, lists, dicts, and any combination thereof without resorting to eval
+Home-page: https://github.com/frmdstryr/magicattr
+Author: frmdstryr
+Author-email: frmdstryr@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+# Magicattr
+
+[![status](https://github.com/frmdstryr/magicattr/actions/workflows/ci.yml/badge.svg)](https://github.com/frmdstryr/magicattr/actions)
+[![codecov](https://codecov.io/gh/frmdstryr/magicattr/branch/master/graph/badge.svg)](https://codecov.io/gh/frmdstryr/magicattr)
+[![Downloads](https://pepy.tech/badge/magicattr/month)](https://pepy.tech/project/magicattr)
+
+
+A getattr and setattr that works on nested objects, lists,
+dictionaries, and any combination thereof without resorting to eval.
+
+It differs from getattr and setattr in that it retains the failure cause
+instead of always raising an AttributeError.
+
+
+
+### Example
+
+Say we have a person class as follows:
+
+```python
+
+
+class Person:
+    settings = {
+        'autosave': True,
+        'style': {
+            'height': 30,
+            'width': 200
+        },
+        'themes': ['light', 'dark']
+    }
+    def __init__(self, name, age, friends):
+        self.name = name
+        self.age = age
+        self.friends = friends
+
+
+bob = Person(name="Bob", age=31, friends=[])
+jill = Person(name="Jill", age=29, friends=[bob])
+jack = Person(name="Jack", age=28, friends=[bob, jill])
+
+```
+
+With magicattr we can do this
+
+```python
+
+# Nothing new
+assert magicattr.get(bob, 'age') == 31
+
+# Lists
+assert magicattr.get(jill, 'friends[0].name') == 'Bob'
+assert magicattr.get(jack, 'friends[-1].age') == 29
+
+# Dict lookups
+assert magicattr.get(jack, 'settings["style"]["width"]') == 200
+
+# Combination of lookups
+assert magicattr.get(jack, 'settings["themes"][-2]') == 'light'
+assert magicattr.get(jack, 'friends[-1].settings["themes"][1]') == 'dark'
+
+# Setattr
+magicattr.set(bob, 'settings["style"]["width"]', 400)
+assert magicattr.get(bob, 'settings["style"]["width"]') == 400
+
+# Nested objects
+magicattr.set(bob, 'friends', [jack, jill])
+assert magicattr.get(jack, 'friends[0].friends[0]') == jack
+
+magicattr.set(jill, 'friends[0].age', 32)
+assert bob.age == 32
+```
+
+You can also delete like this too.
+
+```python
+
+# Deletion
+magicattr.delete(jill, 'friends[0]')
+assert len(jill.friends) == 0
+
+magicattr.delete(jill, 'age')
+assert not hasattr(jill, 'age')
+
+magicattr.delete(bob, 'friends[0].age')
+assert not hasattr(jack, 'age')
+
+```
+
+What if someone tries to mess with you?
+
+```python
+
+# Unsupported
+with pytest.raises(NotImplementedError) as e:
+    magicattr.get(bob, 'friends[0+1]')
+
+with pytest.raises(SyntaxError) as e:
+    magicattr.get(bob, 'friends[')
+
+with pytest.raises(ValueError) as e:
+    magicattr.get(bob, 'friends = [1,1]')
+
+# Nice try, function calls are not allowed
+with pytest.raises(ValueError):
+    magicattr.get(bob, 'friends.pop(0)')
+
+```
+
+Did I miss anything? Let me know!
+
+
+
+#### What it can't do?
+
+Slicing, expressions, function calls, append/pop from lists, eval stuff, etc...
+
+#### How does it work?
+
+Parses the attr string into an ast node and manually evaluates it.
+
+
+### Installing
+
+`pip install magicattr`
+
+
+### License
+
+MIT
+
+Hope it helps, cheers!

magicattr-0.1.7.dist-info/RECORD

@@ -0,0 +1,6 @@
+magicattr.py,sha256=vMavZii2kH6KEUH5BRGalUKx701SfKJ2VoT7IXBqpQg,5252
+magicattr-0.1.7.dist-info/licenses/LICENSE,sha256=PXZ_zu4-PDlIRHf6gRADkw9r7uHWKi4L4Vlzy_4kJX4,1066
+magicattr-0.1.7.dist-info/METADATA,sha256=3JpxVI4F2s0894ykI7nEUo5Lw0EYlHO-P-P_2KVwTW0,3464
+magicattr-0.1.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+magicattr-0.1.7.dist-info/top_level.txt,sha256=c5xmvEG39EMqzKSEPQ6Xp1tP6nu7zmt5TpKFzrAb_j0,10
+magicattr-0.1.7.dist-info/RECORD,,

magicattr-0.1.7.dist-info/WHEEL

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

magicattr-0.1.7.dist-info/licenses/LICENSE

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

magicattr-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+magicattr

magicattr.py

@@ -0,0 +1,195 @@
+"""
+Copyright (c) 2018-2022, Jairus Martin.
+
+Distributed under the terms of the MIT License.
+
+The full license is in the file LICENSE, distributed with this software.
+
+Created on June, 2018
+"""
+import ast
+import sys
+from functools import reduce
+
+
+#: Types of AST nodes that are used
+_AST_TYPES = (ast.Name, ast.Attribute, ast.Subscript, ast.Call)
+_STRING_TYPE = basestring if sys.version_info.major == 2 else str
+
+
+def get(obj, attr, **kwargs):
+    """A getattr that supports nested lookups on objects, dicts, lists, and
+    any combination in between.
+
+    Parameters
+    ---------
+    obj: Object
+        An object to lookup the attribute on
+    attr: String
+        A attribute string to lookup
+    kwargs:
+        default: Any
+            A default value used as a fallback if attr doesn't exist
+
+    Returns
+    -------
+    result: Object
+        The object retrieved or the default fallback value, if it was passed
+    """
+    for chunk in _parse(attr):
+        try:
+            obj = _lookup(obj, chunk)
+        except Exception as ex:
+            if "default" in kwargs:
+                return kwargs["default"]
+            else:
+                raise ex
+    return obj
+
+
+def set(obj, attr, val):
+    """A setattr that supports nested lookups on objects, dicts, lists, and
+    any combination in between.
+
+    Parameters
+    ---------
+    obj: Object
+        An object to lookup the attribute on
+    attr: String
+        A attribute string to lookup
+    val: Object
+        The value to set
+
+    """
+    obj, attr_or_key, is_subscript = lookup(obj, attr)
+    if is_subscript:
+        obj[attr_or_key] = val
+    else:
+        setattr(obj, attr_or_key, val)
+
+
+def delete(obj, attr):
+    """A delattr that supports deletion of a nested lookups on objects,
+    dicts, lists, and any combination in between.
+
+    Parameters
+    ---------
+    obj: Object
+        An object to lookup the attribute on
+    attr: String
+        A attribute string to lookup
+    """
+    obj, attr_or_key, is_subscript = lookup(obj, attr)
+    if is_subscript:
+        del obj[attr_or_key]
+    else:
+        delattr(obj, attr_or_key)
+
+
+def lookup(obj, attr):
+    """Like get but instead of returning the final value it returns the
+    object and action that will be done. This is useful if you need to do
+    any final checking (such as type validation) before doing a final setattr
+    or delattr.
+
+    Parameters
+    ----------
+    obj: Object
+        An object to lookup the attribute on
+    attr: String
+        A attribute string to lookup
+
+    Returns
+    -------
+    result: Tuple[Object, String, Bool]
+    _   A tuple of the object, the attribute, dict key, or list index that
+        will be used, and whether the former is a subscript operation.
+    """
+    nodes = tuple(_parse(attr))
+    if len(nodes) > 1:
+        obj = reduce(_lookup, nodes[:-1], obj)
+        node = nodes[-1]
+    else:
+        node = nodes[0]
+    if isinstance(node, ast.Attribute):
+        return obj, node.attr, False
+    elif isinstance(node, ast.Subscript):
+        return obj, _lookup_subscript_value(node.slice), True
+    elif isinstance(node, ast.Name):
+        return obj, node.id, False
+    raise NotImplementedError("Node is not supported: %s" % node)
+
+
+def _parse(attr):
+    """Parse and validate an attr string
+
+    Parameters
+    ----------
+    attr: String
+
+    Returns
+    -------
+    nodes: List
+        List of ast nodes
+
+    """
+    if not isinstance(attr, _STRING_TYPE):
+        raise TypeError("Attribute name must be a string")
+    nodes = ast.parse(attr).body
+    if not nodes or not isinstance(nodes[0], ast.Expr):
+        raise ValueError("Invalid expression: %s" % attr)
+    return reversed([n for n in ast.walk(nodes[0]) if isinstance(n, _AST_TYPES)])
+
+
+def _lookup_subscript_value(node):
+    """Lookup the value of ast node.
+
+    Parameters
+    ---------
+    node: ast.Constant, ast.Index, ast.UnaryOp
+        Node to lookup the value of
+
+    Returns
+    -------
+    result: Object
+        The object retrieved
+    """
+    if isinstance(node, ast.Index):
+        node = node.value  # For backwards compatibility
+    # Handle indexes and string keys
+    if isinstance(node, ast.Constant):
+        return node.value
+    # Handle negative indexes
+    elif (
+        isinstance(node, ast.UnaryOp)
+        and isinstance(node.op, ast.USub)
+        and isinstance(node.operand, ast.Constant)
+    ):
+        return -node.operand.value
+    raise NotImplementedError("Subscript node is not supported: " "%s" % ast.dump(node))
+
+
+def _lookup(obj, node):
+    """Lookup the given ast node on the object.
+
+    Parameters
+    ---------
+    obj: Object
+        An object to lookup the attribute, index, or key
+    node: ast.Attribute, ast.Name, or ast.Subscript
+        Node to lookup
+
+    Returns
+    -------
+    result: Object
+        The object retrieved
+    """
+    if isinstance(node, ast.Attribute):
+        return getattr(obj, node.attr)
+    elif isinstance(node, ast.Subscript):
+        return obj[_lookup_subscript_value(node.slice)]
+    elif isinstance(node, ast.Name):
+        return getattr(obj, node.id)
+    elif isinstance(node, ast.Call):
+        raise ValueError("Function calls are not allowed.")
+    raise NotImplementedError("Node is not supported: %s" % node)