Metadata-Version: 2.1
Name: renew
Version: 0.1
Summary: UNKNOWN
Home-page: https://gitlab.com/kamichal/renew
Author: Michal Kaczmarczyk
Author-email: michal.s.kaczmarczyk@gmail.com
Maintainer: Michal Kaczmarczyk
Maintainer-email: michal.s.kaczmarczyk@gmail.com
License: MIT license
Description: # renew
        
        Semi-text-pickling in pure python.
        If you meet just a few restrictions, you can store classes
        state into a python file and import or evaluate it somewhere 
        else or later on. 
        
        ## repr(object)
        
        Does `repr` stand for "representation" or "reproduction"?
        According to python documentation `__repr__` functionality has two 
        separate approaches. From https://docs.python.org/3/library/functions.html#repr (v 3.7.2)
        
        > `repr(object)` Return a string containing a printable representation of an object. 
        > For many types, this function makes an attempt to return a string 
        > that would yield an object with the same value when passed to eval(), 
        > otherwise the representation is a string enclosed in angle brackets 
        > that contains the name of the type of the object together with 
        > additional information often including the name and address of
        > the object. A class can control what this function returns for
        > its instances by defining a `__repr__()` method.
        
        
        ## 1. reproducible repr:
        For several native objects it returns a string that can be used to reproduce given object, i.e. to 
        create a copy of given object.
        
        ```python
        a = [1, 3.141559, None, "string"]
        statement_str = repr(a)
        assert statement_str == '[1, 3.141559, None, "string"]'
        ```
        
        You may tell that repr of an object is `reproducible` if this is meet:
        
        ```python
        a = [1, 3.14159, None, "string"]
        statement_str = repr(a)
        assert repr(eval(statement_str)) == statement_str
        # if the object implements __eq__ this should be also true:
        assert eval(statement_str) == a
        ``` 
        
        ## 2. descriptive repr:
        Unfortunately python does not serve the "reproducible repr" out of the box
        for types defined by user:
        
        ```python
        class Car(object):
            def __init__(self, body_type, engine_power):
                self.body_type = body_type
                self.engine_power = engine_power
        
        car = Car("coupe", 124.0)
        # repr(car) == '<__main__.Car object at 0x7f0ff6313290>'
        # but using renew:
        
        import renew
        
        @renew.reproducible(namespace="")
        class ReproducibleCar(object):
            def __init__(self, body_type, engine_power):
                self.body_type = body_type
                self.engine_power = engine_power
        
        car2 = ReproducibleCar("sedan", 110.0)
        assert repr(car2) == 'ReproducibleCar("sedan", 110.0)'
        assert repr(eval(repr(car2))) == 'ReproducibleCar("sedan", 110.0)'
        
        ```
        ## How it works?
        Note that ReproducibleCar does not explicitly implement the `__repr__`, but the `renew.reproducible`
        decorator supplements (overrides) it. 
        `renew.reproduction_string` inspects constructor's argument specification 
        of decorated class and yields a string that tries to be a call statement composed of 
        * `namespace`, e.g. your package name (according to desired importing convention)
        * given class name 
        * given class' attributes values, that have the same names and order as constructor arguments
        
        That forms the only one usage restriction:
        
        **The class has to store all the constructor arguments in its attributes with the same 
        name** (as in `ReproducibleCar` definition above).
        
        ## Limitations
        
        Besides the statement above:
        * plain `keyword-arguments` are not (yet) supported (`default-arguments` work well, however)
        * keys of `dict` being complex objects are getting a bit ugly layout.
        
        For full list of features and usage examples, please refer to unit tests.
        
Platform: UNKNOWN
Classifier: Development Status :: 1 - Planning
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Operating System :: OS Independent
Classifier: License :: OSI Approved :: MIT License
Description-Content-Type: text/markdown
