Overwrite

Make Overwrite More flexible In Python

A Lite Package focuses on making overwrite and mending functions 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 ✨

Package Related

Package ast, inspect, functools Used in Package.

Installation

https://pypi.org/project/Overwrite/0.0.9/

Overwrite requires Python 3.6+ to run.

Simply install with one-line pip command.

pip install Overwrite

How to Use

Set a license Any type of Cipher-text is satisfactory. Set int 0 as example.

_license = 0

Defined function Mending function, used for overwrite previous method.

def func():
    return

Register Function to Event queue.

1. Event_queue_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.

Overwrite = Overwrite()
Overwrite.Butler.register('Register_type', times, _license, func)

# Add overwrite entrance to function
@Overwrite.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.

# Claim above where the function is Called
Overwrite.claim(_license)
affected_func()

The Performance above is same as:

func()

Features

Complex Overwrite

Overwrite.Butler.register('Event_queue_type_A', 1, license_A, func_A)
Overwrite.Butler.register('Event_queue_type_A', 2, license_B, func_B)
Overwrite.Butler.register('Event_queue_type_B', 1, license_B, func_C)

def func_A():
    print('1')
    return
def func_B():
    print('2')
    return
def func_C():
    print('3')
    return

@Overwrite.entrance(catalog='Event_queue_type_A')
def affected_func_A():
    print('A')
    return
@Overwrite.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:

@Overwrite.claim(license_B)
affected_func_A() # Output: 2
@Overwrite.claim(license_A)
affected_func_A() # Output: 1
@Overwrite.claim(license_B)
affected_func_A() # Output: 2
@Overwrite.claim(license_A)
affected_func_A() # Output: A
@Overwrite.claim(license_B)
affected_func_A() # Output: A
@Overwrite.claim(license_B)
affected_func_B() # Output: 3
@Overwrite.claim(license_B)
affected_func_B() # Output: B

Get Catalog Name and Available Licenses of Original Function

Overwrite.Butler.get(affected_func)
-> dict {'catalog_name': str, 'available_license': list[str]}

Browse the Event Queue

Print details for Event Queue:

Overwrite.Queue.print(catalog: str)

Get length of Event Queue:

Overwrite.Queue.len(catalog: str)

Get Event Queue as following type:

Overwrite.Queue.get(catalog: str)

[{'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:

Overwrite.Queue.append(catalog: str, event: list)
Overwrite.Queue.pop(catalog: str, index: int)
Overwrite.Queue.replace(catalog: str, event: list, index: int)
Overwrite.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 classes for each individual thread is a reasonable solution.

Development

Version: 2021.11.18 (0.0.9)

Author: Zack the White, Qcmcmc

Email Contact: Zack the White Qcmcmc

License

MIT