reverse-lookup 1.0.0__tar.gz

reverse_lookup-1.0.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Matias David Szlajen
+
+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.

reverse_lookup-1.0.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: reverse-lookup
+Version: 1.0.0
+Summary: Implementation of reversed lookup allowing classes to decide when to allow control to its subclasses
+Author-email: Matias David Szlajen <matiasszlajen@tutamail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Mszlajen/python-reverse-lookup
+Keywords: metaprogramming,lookup,mro,classes
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Reverse Lookup
+
+Implementation of a reverse lookup similar to [Beta](https://beta.cs.au.dk/) where parent classes have priority and decide when to allow the subclasses (or the instance) to extend its behaviour.
+
+## Installation
+
+Reverse Lookup is made using pure python metaprogamming interfaces so it can be installed easily from pypi
+
+```bash
+python -m pip install reverse_lookup
+```
+
+## Usage
+
+Using Reverse Lookup is as simple as inhereting a class.
+
+```python
+from reverse_lookup import ReverseLookup
+
+class A(ReverseLookup):
+    ...
+```
+
+Now all instances of `A` will have a lookup that looks like `object -> A -> <A object>`.  
+This works for subclasses too.
+
+```python
+class A(ReverseLookup):
+    def m(self):
+        return 'A'
+
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() # => 'A'
+```
+
+To allow subclasses to extend the logic you can use `Inner`.
+
+```python
+from reverse_lookup import ReverseLookup, Inner
+
+class A(ReverseLookup):
+    def m(self):
+        return 'A' + Inner(self, A).m()
+        
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() #=> 'AB'
+```
+
+Like the built-in `super`, `Inner` can be send any message and it will do a lookup for it starting at the step following the class recived as parameter in the mro, it will fail with `AttributeError` if there is not a next implementation and special methods need to be called explicitly.
+
+Since python doesn't allow monkey patching of standard classes (ex. object), special method such as `__str__ ` still use the all lookup.
+
+## Motivation
+
+We mentioned ina class that this was posible using metaprogramming and I though it was a fun project.

reverse_lookup-1.0.0/README.md

@@ -0,0 +1,61 @@
+# Reverse Lookup
+
+Implementation of a reverse lookup similar to [Beta](https://beta.cs.au.dk/) where parent classes have priority and decide when to allow the subclasses (or the instance) to extend its behaviour.
+
+## Installation
+
+Reverse Lookup is made using pure python metaprogamming interfaces so it can be installed easily from pypi
+
+```bash
+python -m pip install reverse_lookup
+```
+
+## Usage
+
+Using Reverse Lookup is as simple as inhereting a class.
+
+```python
+from reverse_lookup import ReverseLookup
+
+class A(ReverseLookup):
+    ...
+```
+
+Now all instances of `A` will have a lookup that looks like `object -> A -> <A object>`.  
+This works for subclasses too.
+
+```python
+class A(ReverseLookup):
+    def m(self):
+        return 'A'
+
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() # => 'A'
+```
+
+To allow subclasses to extend the logic you can use `Inner`.
+
+```python
+from reverse_lookup import ReverseLookup, Inner
+
+class A(ReverseLookup):
+    def m(self):
+        return 'A' + Inner(self, A).m()
+        
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() #=> 'AB'
+```
+
+Like the built-in `super`, `Inner` can be send any message and it will do a lookup for it starting at the step following the class recived as parameter in the mro, it will fail with `AttributeError` if there is not a next implementation and special methods need to be called explicitly.
+
+Since python doesn't allow monkey patching of standard classes (ex. object), special method such as `__str__ ` still use the all lookup.
+
+## Motivation
+
+We mentioned ina class that this was posible using metaprogramming and I though it was a fun project.

reverse_lookup-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reverse-lookup"
+version = "1.0.0"
+description = "Implementation of reversed lookup allowing classes to decide when to allow control to its subclasses"
+readme = "README.md"
+authors = [{name = "Matias David Szlajen", email = "matiasszlajen@tutamail.com" }]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["metaprogramming", "lookup", "mro", "classes"]
+dependencies = []
+requires-python = ">=3.9"
+
+[project.urls]
+Repository = "https://github.com/Mszlajen/python-reverse-lookup"

reverse_lookup-1.0.0/reverse_lookup/__init__.py

@@ -0,0 +1 @@
+from .reverse_lookup import ReverseLookup, Inner

reverse_lookup-1.0.0/reverse_lookup/reverse_lookup.py

@@ -0,0 +1,46 @@
+from inspect import isfunction, ismemberdescriptor
+from types import MethodType
+
+def lookup(self: object, mro: tuple[type, ...], name: str):
+    for t in mro:
+        try:
+            attr = object.__getattribute__(t, name)
+        except AttributeError:
+            continue
+        if ismemberdescriptor(attr):
+            return attr.__get__(self, t)
+        if isfunction(attr):
+            return MethodType(attr, self)
+        return attr
+    
+    try:
+        return object.__getattribute__(self, '__dict__')[name]
+    except (AttributeError, KeyError) as e:
+        ...
+    raise AttributeError(name=name, obj=self)
+
+class ReverseLookup():
+    def __getattribute__(self, name: str):
+        mro = super().__getattribute__('__class__').mro()
+        return lookup(self, mro, name)
+
+    @classmethod
+    def mro(cls):
+        return list(reversed(cls.__mro__))
+
+class Inner:
+    __slots__ = ('__obj__', '__start_type__')
+    
+    def __init__(self, obj: object, start_type: type):
+        self.__obj__ = obj
+        self.__start_type__ = start_type
+    
+    def __getattribute__(self, name: str):
+        if name in ('__obj__', '__start_type__'):
+            return super().__getattribute__(name)
+        start_type = self.__start_type__
+        obj = self.__obj__
+        mro = object.__getattribute__(obj, '__class__').mro()
+        new_mro = mro[mro.index(start_type)+1:]
+        return lookup(obj, new_mro, name)
+        

reverse_lookup-1.0.0/reverse_lookup.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: reverse-lookup
+Version: 1.0.0
+Summary: Implementation of reversed lookup allowing classes to decide when to allow control to its subclasses
+Author-email: Matias David Szlajen <matiasszlajen@tutamail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Mszlajen/python-reverse-lookup
+Keywords: metaprogramming,lookup,mro,classes
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Reverse Lookup
+
+Implementation of a reverse lookup similar to [Beta](https://beta.cs.au.dk/) where parent classes have priority and decide when to allow the subclasses (or the instance) to extend its behaviour.
+
+## Installation
+
+Reverse Lookup is made using pure python metaprogamming interfaces so it can be installed easily from pypi
+
+```bash
+python -m pip install reverse_lookup
+```
+
+## Usage
+
+Using Reverse Lookup is as simple as inhereting a class.
+
+```python
+from reverse_lookup import ReverseLookup
+
+class A(ReverseLookup):
+    ...
+```
+
+Now all instances of `A` will have a lookup that looks like `object -> A -> <A object>`.  
+This works for subclasses too.
+
+```python
+class A(ReverseLookup):
+    def m(self):
+        return 'A'
+
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() # => 'A'
+```
+
+To allow subclasses to extend the logic you can use `Inner`.
+
+```python
+from reverse_lookup import ReverseLookup, Inner
+
+class A(ReverseLookup):
+    def m(self):
+        return 'A' + Inner(self, A).m()
+        
+class B(A):
+    def m(self):
+        return 'B'
+
+B().m() #=> 'AB'
+```
+
+Like the built-in `super`, `Inner` can be send any message and it will do a lookup for it starting at the step following the class recived as parameter in the mro, it will fail with `AttributeError` if there is not a next implementation and special methods need to be called explicitly.
+
+Since python doesn't allow monkey patching of standard classes (ex. object), special method such as `__str__ ` still use the all lookup.
+
+## Motivation
+
+We mentioned ina class that this was posible using metaprogramming and I though it was a fun project.

reverse_lookup-1.0.0/reverse_lookup.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+reverse_lookup/__init__.py
+reverse_lookup/reverse_lookup.py
+reverse_lookup.egg-info/PKG-INFO
+reverse_lookup.egg-info/SOURCES.txt
+reverse_lookup.egg-info/dependency_links.txt
+reverse_lookup.egg-info/top_level.txt
+tests/test.py

reverse_lookup-1.0.0/reverse_lookup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reverse_lookup-1.0.0/reverse_lookup.egg-info/top_level.txt

@@ -0,0 +1 @@
+reverse_lookup

reverse_lookup-1.0.0/setup.cfg

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

reverse_lookup-1.0.0/tests/test.py

@@ -0,0 +1,102 @@
+import unittest
+from reverse_lookup import ReverseLookup, Inner
+
+class ReverseLookUpTest(unittest.TestCase):
+    def test_A_to_B_use_A(self):
+        class A(ReverseLookup):
+            def m(self):
+                return 'A'
+        
+        class B(A):
+            def m(self):
+                return 'B'
+        
+        self.assertEqual(B().m(), 'A')
+    
+    def test_A_to_B_uses_inner(self):
+        class A(ReverseLookup):
+            def m(self):
+                return 'A' + Inner(self, A).m()
+                
+        class B(A):
+            def m(self):
+                return 'B'
+        
+        self.assertEqual(B().m(), 'AB')
+    
+    def test_A_uses_inner_without_implementation(self):
+        class A(ReverseLookup):
+            def m(self):
+                return 'A' + Inner(self, A).m()
+        
+        with self.assertRaises(AttributeError):
+            A().m()
+    
+    @unittest.skip("Will not implement")
+    def test_B_uses_reversed_when_accessing_from_class(self):
+        class A(ReverseLookup):
+            def m(self) -> str:
+                return 'A'
+        
+        class B(A):
+            def m(self):
+                return 'B'
+        
+        self.assertEqual(B.m(B()), 'A')
+    
+    def test_B_has_a_reversed_mro(self):
+        class A(ReverseLookup):
+            ...
+        
+        class B(A):
+            ...
+        
+        self.assertListEqual(B.mro(), [object, ReverseLookup, A, B])
+    
+    def test_A_uses_its_own_to_string(self):
+        class A(ReverseLookup):
+            def __str__(self):
+                return 'A'
+        
+        self.assertEqual(str(A()), 'A')
+    
+    def test_attributes_in_object_are_found(self):
+        class A(ReverseLookup):
+            ...
+        
+        a = A()
+        a.foo = "Bar"
+        
+        self.assertEqual(a.foo, "Bar")
+    
+    def test_attributes_in_object_from_class_are_found(self):
+        class A(ReverseLookup):
+            def __init__(self):
+                self.foo = "Bar"
+        a = A()
+        self.assertEqual(a.foo, "Bar")
+    
+    def test_attributes_in_object_from_slots_are_found(self):
+        class A(ReverseLookup):
+            __slots__ = ('foo', )
+            
+        a = A()
+        a.foo = "Bar"
+        self.assertEqual(a.foo, "Bar")
+    
+    def test_attributes_from_class_override_object(self):
+        class A(ReverseLookup):
+            foo = "Bar"
+        
+        a = A()
+        a.foo = "Zas"
+        self.assertEqual(a.foo, "Bar")
+    
+    def test_inner_works_with_instances(self):
+        class A(ReverseLookup):
+            def m(self):
+                return 'A' + Inner(self, A).m()
+        
+        a = A()
+        a.m = lambda: "a"
+        self.assertEqual(a.m(), "Aa")