assign-overload 1.0.0__tar.gz

assign_overload-1.0.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: assign-overload
+Version: 1.0.0
+Summary: overloading assignment operator everywhere
+Project-URL: Homepage, https://github.com/pyhacks/assign-overload
+Author-email: pyhacks <enginyildirim111@gmail.com>
+Keywords: assign,assignment,magic,method,operator,overloading
+Description-Content-Type: text/markdown
+
+# assign-overload
+This library makes it possible to overload assignment (=) operator. Inspired by [assign](https://github.com/RyanKung/assign).
+Along with other things, main difference from that library is [assign](https://github.com/RyanKung/assign) calls the overloaded operator of the right hand side while this library calls of the left hand side.
+
+# Installation
+```pip install assign-overload```
+
+# How To Use
+First you need to overload the assignment operator using the function ```_assign_```:
+```python
+class T:        
+    def _assign_(self, value, *annotation):
+        print(f"called with {value}")
+        return self
+```
+_value_ is the value of right hand side. If the assignment is annotated, _annotation_ will take a single argument carrying the annotation. Return value specifies the value of left hand side.
+
+Next, in order to make this method automatically called you should call assign_overload.**patch_and_reload_module**():
+```python
+import assign_overload
+
+class T:        
+    def _assign_(self, value, *annotation):
+        print(f"called with {value}")
+        return self
+
+
+def main():
+    a = T()
+    a = 10 # a will keep holding the T object
+
+
+if assign_overload.patch_and_reload_module():
+    if __name__ == "__main__":
+        main()
+```
+This function will find and modify the current module's source code, replacing right hand side of assignments with calls to ```_assign_```, then execute the modified code. 
+Once called, this function will introduce a new global variable to the current module: ```modified_source```. 
+This variable will be accessible while both executing the original module and modified module. 
+It represents the source code of the modified module.
+Since module's ```__dict__``` attribute is passed as the globals parameter of ```exec```, names created in the modified module will be reflected on the original module along with their values, creating a reloading effect. 
+Return value of this function specifies which module we are currently executing. True means modified module and False means original module.
+Any code outside the first if block will be executed twice. 
+Codes before this function call will first be executed while executing the original module and second while executing the modified module.
+Codes after the first if block will first be executed while executing the modified module and second while executing the original module. 
+This is especially bad because if a piece of code last executed while executing the original module, any function or class definition will have its original definition, not the modified definition they should have.
+Codes inside the first if block will only be executed while executing the modified module.
+You can wrap all your module code including functions and classes inside a single if block like this:
+```python
+import assign_overload
+
+if assign_overload.patch_and_reload_module():
+    class T:        
+        def _assign_(self, value, *annotation):
+            print(f"called with {value}")
+            return self
+
+
+    def main():
+        a = T()
+        a = 10 # a will keep holding the T object
+
+
+    if __name__ == "__main__":
+        main()
+```
+But that doesn't look nice. 
+Functions, classes and constant definitions are most probably okay to be executed twice but actual code should be executed once.
+Thus, the location in the first example is the best location for calling this function.
+This function should be called even if this module isn't the ```__main__``` module because function and class definitions should be modified even if no real code is ought to be executed.
+This function should be called once. Consecutive calls doesn't modify and execute the source code again. 
+Lastly, this function will introduce 2 other global varriables to the current module: ```patched``` and ```executing_patch```.
+These variables are internally used by the library and they are documented here only to prevent the user from changing them.

assign_overload-1.0.0/README.md

@@ -0,0 +1,73 @@
+# assign-overload
+This library makes it possible to overload assignment (=) operator. Inspired by [assign](https://github.com/RyanKung/assign).
+Along with other things, main difference from that library is [assign](https://github.com/RyanKung/assign) calls the overloaded operator of the right hand side while this library calls of the left hand side.
+
+# Installation
+```pip install assign-overload```
+
+# How To Use
+First you need to overload the assignment operator using the function ```_assign_```:
+```python
+class T:        
+    def _assign_(self, value, *annotation):
+        print(f"called with {value}")
+        return self
+```
+_value_ is the value of right hand side. If the assignment is annotated, _annotation_ will take a single argument carrying the annotation. Return value specifies the value of left hand side.
+
+Next, in order to make this method automatically called you should call assign_overload.**patch_and_reload_module**():
+```python
+import assign_overload
+
+class T:        
+    def _assign_(self, value, *annotation):
+        print(f"called with {value}")
+        return self
+
+
+def main():
+    a = T()
+    a = 10 # a will keep holding the T object
+
+
+if assign_overload.patch_and_reload_module():
+    if __name__ == "__main__":
+        main()
+```
+This function will find and modify the current module's source code, replacing right hand side of assignments with calls to ```_assign_```, then execute the modified code. 
+Once called, this function will introduce a new global variable to the current module: ```modified_source```. 
+This variable will be accessible while both executing the original module and modified module. 
+It represents the source code of the modified module.
+Since module's ```__dict__``` attribute is passed as the globals parameter of ```exec```, names created in the modified module will be reflected on the original module along with their values, creating a reloading effect. 
+Return value of this function specifies which module we are currently executing. True means modified module and False means original module.
+Any code outside the first if block will be executed twice. 
+Codes before this function call will first be executed while executing the original module and second while executing the modified module.
+Codes after the first if block will first be executed while executing the modified module and second while executing the original module. 
+This is especially bad because if a piece of code last executed while executing the original module, any function or class definition will have its original definition, not the modified definition they should have.
+Codes inside the first if block will only be executed while executing the modified module.
+You can wrap all your module code including functions and classes inside a single if block like this:
+```python
+import assign_overload
+
+if assign_overload.patch_and_reload_module():
+    class T:        
+        def _assign_(self, value, *annotation):
+            print(f"called with {value}")
+            return self
+
+
+    def main():
+        a = T()
+        a = 10 # a will keep holding the T object
+
+
+    if __name__ == "__main__":
+        main()
+```
+But that doesn't look nice. 
+Functions, classes and constant definitions are most probably okay to be executed twice but actual code should be executed once.
+Thus, the location in the first example is the best location for calling this function.
+This function should be called even if this module isn't the ```__main__``` module because function and class definitions should be modified even if no real code is ought to be executed.
+This function should be called once. Consecutive calls doesn't modify and execute the source code again. 
+Lastly, this function will introduce 2 other global varriables to the current module: ```patched``` and ```executing_patch```.
+These variables are internally used by the library and they are documented here only to prevent the user from changing them.

assign_overload-1.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "assign-overload"
+version = "1.0.0"
+dependencies = []
+description = "overloading assignment operator everywhere"
+readme = "README.md"
+authors = [{name = "pyhacks", email = "enginyildirim111@gmail.com"}]
+keywords = ["assign", "assignment", "operator", "overloading", "magic", "method"]
+
+[project.urls]
+Homepage = "https://github.com/pyhacks/assign-overload"

assign_overload-1.0.0/src/assign_overload/__init__.py

@@ -0,0 +1 @@
+from .patch import patch_and_reload_module

assign_overload-1.0.0/src/assign_overload/magic.py

@@ -0,0 +1,24 @@
+from .transformer import AssignTransformer
+from .patch import patch_and_reload_module
+
+__all__ = ['custom_import']
+
+origin_import = __import__
+
+
+def custom_import(name, *args, **kwargs):
+    module = origin_import(name, *args, **kwargs)
+    if not hasattr(module, '__file__'):
+        return module
+    if module.__name__ == "warnings":
+        return module
+    try:
+        patch_and_reload_module(module, trans=AssignTransformer)
+    except:
+        return module
+    return module
+
+
+__builtins__.update(**dict(
+    __import__=custom_import
+))

assign_overload-1.0.0/src/assign_overload/patch.py

@@ -0,0 +1,52 @@
+import ast
+import sys
+from .transformer import AssignTransformer
+
+
+__all__ = [
+    'patch_node_ast',
+    'patch_code_ast',
+    'patch_file_ast',
+    'patch_module_ast',
+    'patch_and_reload_module'
+]
+
+
+def patch_node_ast(node, trans=AssignTransformer):
+    trans = trans()
+    new_node = trans.visit(node)
+    ast.fix_missing_locations(new_node)
+    return new_node
+
+
+def patch_code_ast(code_str, trans=AssignTransformer):
+    code_ast = ast.parse(code_str)
+    return patch_node_ast(code_ast, trans)
+
+
+def patch_file_ast(filename, trans=AssignTransformer):
+    with open(filename, "r") as f:
+        code_str = ''.join(f.readlines())
+        return patch_code_ast(code_str, trans)
+
+
+def patch_module_ast(module, trans=AssignTransformer):
+    if not hasattr(module, '__file__'):
+        return module
+    filename = module.__file__.replace('.pyc', '.py')
+    return patch_file_ast(filename, trans)
+
+
+def patch_and_reload_module(module = None, trans=AssignTransformer):
+    if module is None:
+        module_name = sys._getframe(1).f_globals["__name__"]
+        module = sys.modules[module_name]    
+    if not hasattr(module, "patched") or not module.patched:
+        module.patched = True
+        patched_ast = patch_module_ast(module)
+        module.modified_source = ast.unparse(patched_ast)
+        patched_code = compile(patched_ast, module.__name__, "exec")
+        module.executing_patch = True
+        exec(patched_code, module.__dict__)
+        module.executing_patch = False
+    return module.executing_patch

assign_overload-1.0.0/src/assign_overload/transformer.py

@@ -0,0 +1,147 @@
+import ast
+import copy
+
+__all__ = [
+    'AssignTransformer'
+
+]
+
+
+class AssignTransformer(ast.NodeTransformer):
+    def generic_visit(self, node):
+        ast.NodeTransformer.generic_visit(self, node)
+        return node
+
+    def gen_assign_checker_ast(self, node):
+        if isinstance(node.targets[0], ast.Tuple):
+            raise RuntimeError("unpacking during assignment is not supported")
+        load_targets = []
+        for target in node.targets:
+            new_target = copy.deepcopy(target)
+            new_target.ctx = ast.Load()
+            load_targets.append(new_target)
+        conditions = []
+        for target in node.targets:
+            load_target = copy.deepcopy(target)
+            load_target.ctx = ast.Load()             
+            if type(target) != ast.Attribute:
+                conditions.append(ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                           args = [load_target, ast.Constant('_assign_')]))
+            else:               
+                conditions.append(ast.BoolOp(op = ast.And(),
+                                             values = [ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                                                args = [load_target, ast.Constant('_assign_')]),
+                                                       ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                                                args = [load_target.value, ast.Constant('__dict__')]),
+                                                       ast.Compare(left = ast.Constant(load_target.attr),
+                                                                   ops = [ast.In()],
+                                                                   comparators = [ast.Attribute(value = load_target.value,
+                                                                                                attr = "__dict__",
+                                                                                                ctx = ast.Load())
+                                                                                 ]
+                                                                   )
+                                                      ]
+                                            )
+                                 )
+                
+        new_node = ast.If(test = ast.Constant(True),
+                          body = [ast.Try(body = [ast.Expr(load_target)],
+                                          handlers = [ast.ExceptHandler(None,
+                                                                        None,
+                                                                        body = [ast.Assign(targets = [target],
+                                                                                           value = node.value)
+                                                                               ])
+                                                     ],
+                                          orelse = [ast.If(test = condition,
+                                                           body = [ast.Assign(targets = [target],
+                                                                              value = ast.Call(func = ast.Attribute(value = load_target,
+                                                                                                                    attr = '_assign_',
+                                                                                                                    ctx = ast.Load()),
+                                                                                               args = [node.value],
+                                                                                               keywords = [],
+                                                                                               starargs = None,
+                                                                                               kwargs = None)
+                                                                              )
+                                                                  ],
+                                                           orelse = [ast.Assign(targets = [target],
+                                                                                value = node.value)
+                                                                    ])
+                                                    ],
+                                          finalbody = []) for target, load_target, condition in zip(node.targets, load_targets, conditions)
+                                  ],
+                          orelse = [])
+        return new_node
+
+    def gen_annassign_checker_ast(self, node):
+        if node.value:
+            target = node.target
+            load_target = copy.deepcopy(node.target)
+            load_target.ctx = ast.Load()
+            if type(target) != ast.Attribute:
+                condition = ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                     args = [load_target, ast.Constant('_assign_')])
+            else:               
+                condition = ast.BoolOp(op = ast.And(),
+                                       values = [ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                                          args = [load_target, ast.Constant('_assign_')]),
+                                                 ast.Call(func = ast.Name(id='hasattr', ctx=ast.Load()),
+                                                          args = [load_target.value, ast.Constant('__dict__')]),
+                                                 ast.Compare(left = ast.Constant(load_target.attr),
+                                                             ops = [ast.In()],
+                                                             comparators = [ast.Attribute(value = load_target.value,
+                                                                                          attr = "__dict__",
+                                                                                          ctx = ast.Load())
+                                                                           ]
+                                                             )
+                                                ]
+                                      )
+                                 
+            
+            new_node = ast.If(test = ast.Constant(True),
+                              body = [ast.Try(body = [ast.Expr(load_target)],
+                                              handlers = [ast.ExceptHandler(None,
+                                                                            None,
+                                                                            body = [ast.AnnAssign(target = target,
+                                                                                                  annotation = node.annotation,
+                                                                                                  value = node.value,
+                                                                                                  simple = node.simple)
+                                                                                   ])
+                                                         ],
+                                              orelse = [ast.If(test = condition,
+                                                               body = [ast.AnnAssign(target = target,
+                                                                                     annotation = node.annotation,
+                                                                                     value = ast.Call(func = ast.Attribute(value = load_target,
+                                                                                                                           attr = '_assign_',
+                                                                                                                           ctx = ast.Load()),
+                                                                                                      args = [node.value, node.annotation],
+                                                                                                      keywords = [],
+                                                                                                      starargs = None,
+                                                                                                      kwargs = None),
+                                                                                     simple = node.simple
+                                                                                     )
+                                                                      ],
+                                                               orelse = [ast.AnnAssign(target = target,
+                                                                                       annotation = node.annotation,
+                                                                                       value = node.value,
+                                                                                       simple = node.simple)
+                                                                        ])
+                                                        ],
+                                              finalbody = [])
+                                      ],
+                              orelse = [])
+        else:
+            new_node = node
+        return new_node
+    
+
+    def visit_Assign(self, node):       
+        new_node = self.gen_assign_checker_ast(node)
+        ast.copy_location(new_node, node)
+        ast.fix_missing_locations(new_node)
+        return new_node
+
+    def visit_AnnAssign(self, node):       
+        new_node = self.gen_annassign_checker_ast(node)
+        ast.copy_location(new_node, node)
+        ast.fix_missing_locations(new_node)
+        return new_node

assign_overload-1.0.0/tests.py

@@ -0,0 +1,42 @@
+import assign_overload
+import wrapt
+
+
+class T(wrapt.ObjectProxy):        
+    def _assign_(self, value, *annotation):
+        print(f"called with {value}")
+        self.__wrapped__ = value
+        return self
+
+
+class A:
+    a = T(10)
+
+
+def test1():
+    global b
+    #a, b = T(), T()
+    print("here")
+    b = c = d = T(10)
+    b = 20
+    print(b)
+    print(type(b))
+
+
+def test2():
+    a = A()
+    a.a = T(5)
+    a.a = 30
+    print(a.a)    
+    del a.a
+    print(a.a)
+
+    
+def main():
+    test1()
+    print()
+    test2()
+
+
+if assign_overload.patch_and_reload_module():
+    main()