Metadata-Version: 2.1
Name: Mending
Version: 0.1.2
Summary: UNKNOWN
Home-page: https://github.com/Beyonder-Zack/Mending
Author: Zack the White, Qcmcmc
Author-email: ssongaj@connect.ust.hk
License: MIT
Description: # Mending
        ## _Make Overwrite More flexible In Python_
        
        [![Build Status](https://travis-ci.org/joemccann/dillinger.svg?branch=master)](https://travis-ci.org/joemccann/dillinger)
        
        A Lite Package focuses on making project's after-post mending easier and more flexible. Certain Method performs differently in Certain Condition in an event queue. Certainly used for mending or expanding finished Projects without modifying existed Codes.
        
        - No Origin Codes Changes, Injection with Licenses
        - None Invasive Embed Way, More Flexible
        - ✨Easy to use✨
        
        ## Installation
        
        Overwrite requires [Python](https://www.python.org/) 3.6+ to run.
        
        Simply install with one-line pip command.
        
        ```shell
        pip install Mending
        ```
        ## How to Use
        
        **Core Import**
        
        ```python
        from Mending import Mend
        ```
        
        **Set a License**
        Any type of Cipher-text is satisfactory. Set _int 0_ as example.
        
        ```python
        _license = 0
        ```
        **Defined Function**
        Mending function, used for _overwrite_ previous method.
        
        ```python
        def func():
            return
        ```
        **Register Function to _Event queue_.**
        
        1. _Register_type (string)_: 
           Register with the same _Event_queue_type_ will be added to the same event queue (in registration order).
        2. _times (integer)_: 
           The times this function calling is affected. (if affected forever, set times to _-1_)
        3. _license (any)_: 
           Used to identify whether the modification is valid and distinguish between different overwrite events.
        4. _func (function)_: 
           Mending function, used for overwriting.
        
        ```python
        Mend = Mend()
        Mend.Butler.register('Register_type', times, _license, func)
        ```
        
        ```python
        # Add entrance to function
        @Mend.entrance(catalog='Register_type')
        def affected_func():
            return
        ```
        **Add the License Claim**
        If the license is valid, the registered function _affected_func_ will be modified and completely overwritten by _func_. 
        
        ```python
        # Claim above the function calling
        Mend.claim(_license)
        affected_func()
        ```
        The Performance above is same as:
        ```python
        func()
        ```
        ## Features
        
        **Complex Overwrite**
        
        ```python
        Mend.Butler.register('Event_queue_type_A', 1, license_A, func_A)
        Mend.Butler.register('Event_queue_type_A', 2, license_B, func_B)
        Mend.Butler.register('Event_queue_type_B', 1, license_B, func_C)
        ```
        ```python
        def func_A():
            print('1')
            return
        def func_B():
            print('2')
            return
        def func_C():
            print('3')
            return
        ```
        ```python
        @Mend.entrance(catalog='Event_queue_type_A')
        def affected_func_A():
            print('A')
            return
        @Mend.entrance(catalog='Event_queue_type_B')
        def affected_func_B():
            print('B')
            return
        ```
        Different _license_ claiming leads to different way of overwriting. After several times calling set before, the performance of modified function will change back to origin again as a result of event queue gets empty.
        The program works as below:
        
        ```python
        @Mend.claim(license_B)
        affected_func_A() # Output: 2
        @Mend.claim(license_A)
        affected_func_A() # Output: 1
        @Mend.claim(license_B)
        affected_func_A() # Output: 2
        @Mend.claim(license_A)
        affected_func_A() # Output: A
        @Mend.claim(license_B)
        affected_func_A() # Output: A
        @Mend.claim(license_B)
        affected_func_B() # Output: 3
        @Mend.claim(license_B)
        affected_func_B() # Output: B
        ```
        **Get Catalog Name and Available Licenses of Original Function**
        
        ```python
        Mend.Butler.get(affected_func)
        -> dict {'catalog_name': str, 'available_license': list[str]}
        ```
        
        **Browse the Event Queue**
        
        Print details for _Event Queue_:
        
        ```python
        Mend.Queue.print(catalog: str)
        ```
        
        Get length of _Event Queue_:
        
        ```python
        Mend.Queue.len(catalog: str)
        ```
        
        Get _Event Queue_ as following type:
        
        ```python
        Mend.Queue.get(catalog: str)
        ```
        
        ```python
        [{'times_left': int, 'license': any, 'function_name': str}, 
         {'times_left': int, 'license': any, 'function_name': str},
         {'times_left': int, 'license': any, 'function_name': str},]
        ```
        
        **Directly manipulate the Event Queue**
        
        Class Queue redefined, making it compatible with _Pythonic_ Style Commands as below:
        
        ```python
        Mend.Queue.append(catalog: str, event: list)
        Mend.Queue.pop(catalog: str, index: int)
        Mend.Queue.replace(catalog: str, event: list, index: int)
        Mend.Queue.clear(catalog: str)
        ```
        
        ## Threading
        
        For multi-threaded function overrides, the event queue is cross-threaded, and the order of event completion depends on the total program time sequence, asynchrony may cause event order confusion. Instantiating Mending for each individual thread is a reasonable solution.
        
        ## Development
        **Version:**
        *2021.11.18 (0.0.8)*
        
        **Author:** 
        _Zack the White_,  _Qcmcmc_
        
        **Email Contact:**
        [_**Zack the White**_](ssongaj@connect.ust.hk)
        [_**Qcmcmc**_](2778512552@qq.com)
        
        ## License
        
        [**MIT**](https://opensource.org/licenses/MIT)
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Programming Language :: Python :: 3
Description-Content-Type: text/markdown
