Python etc

# A class that has some logic and data
class WorkDoer:
    def __init__(self, a, b):
        self._a = a
        self._b = b
        self._c = None
        self._d = None
  
    # Some methods that affect the state of the object
    def prepare_c(self):
        self._c = self.prepare_c_from_ab(self._a, self._b)
      
    def prepare_d(self):
        self._d = self.prepare_d_from_ab(self._a, self._b)
      
    def prepare_ab(self):
        self._a = self.make_new_a_from_c(self._c)
        self._b = self.make_new_b_from_d(self._d)

    def do_job(self):
        # The method which we intend to test.
        # Let's assume its outcome depends on the object's internal state. 
        # It also changes this state.
        # We will need to efficiently recreate desireable starting point.

# In tests
def test():
    a = Factory.create_a()
    b = Factory.create_b()
    work_doer = WorkDoer.new(a, b)
    # We are doing a lot of calls to get into the desired state.
    # It can be prohibitively complex. 
    work_doer.prepare_c()
    work_doer.prepare_d()
    work_doer.prepare_ab()

    # Finally exercising it and checking the returned value
    assert work_doer.do_job() == correct_result
    # It's problematic to validate the changes in :a, :b, :c and :d, since they are private
    # We need to expose them, use reflection or add more methods just for testing.

def apply(func, args, kwargs):
    return func(*args, **kwargs)

package_broken = any(
    part.is_broken() for part package.get_parts()
)
package_ok = all(
    part.ok() for part package.get_parts()
)

def execute_wrapper(
    params_data, db_data, processed_list
):
    # --- Additional code to deal with impurities ---
    # Setting up and preserving the original values
    modified_params_data = params_data.copy()
    orig_processed_list = Global.processed_data.copy()
    DataBase.get().restore_table(db_data)
    # --- End of additional code ---
 
    # Execution
    perform_job_with_side_effecs(modified_params_data)
  
    # --- More additional code    ---
    # --- to deal with impurities ---
    # Preparing modified data for returns
    modified_processed_list = Global.processed_data
    modified_db_data = DataBase.get().dump_table()
    # Clean up and restore
    Global.processed_data = orig_processed_list
    DataBase.get().truncate_table()
    # Artificial returns
    return (
        modified_params_data,
        modified_db_data,
        modified_processed_list,
    )
    # --- End of additional code ---

def perform_job_with_side_effecs(params_data):
    # Mutating some global state 
    Global.processed_data += params_data
    # Modifying params
    params_data.pop()
    # Sending commands to other servers
    DataBase.get().update_table(params_data)

>>> int("10")
10
>>> int("10", 2)
2
>>> def base2(x):
...     return int(x, 2)
...
>>> base2("10")
2

base2 = partial(int, base=2)

>>> map(partial(int, base=2), ["1", "10", "100"])
[1, 2, 4]

>>> map(lambda x: int(x, base=2), ["1", "10", "100"])
[1, 2, 4]

async with aiofiles.open('filename', mode='r') as f:
    contents = await f.read()

>>> Path('/var/data') / Path('a/b')  # OK
PosixPath('/var/data/a/b')
>>> Path('/var/data') / Path('../b')  # oops
PosixPath('/var/data/../b')
>>> Path('/var/data') / Path('/etc/passwd')  # even oopsier
PosixPath('/etc/passwd')

def safe(path):
    return os.path.normpath('/' + path).lstrip('/')

>>> Path('/var/data') / safe('a/b')
PosixPath('/var/data/a/b')
>>> Path('/var/data') / safe('../b')
PosixPath('/var/data/b')
>>> Path('/var/data') / safe('/etc/passwd')
PosixPath('/var/data/etc/passwd')

# Our task is to implement "convert_abc_to_z",
# while all the "extract"/"make" functions are
# assumed to be given.
# If some functionality is moved out from
# the "convert_abc_to_z" to another function this way,
# it would require 4 parameters:
def _mnbc_to_z(m, n, b, c):
    x = make_x(b, m)
    y = make_y(x, n)
    z = make_z(y, c)

def convert_abc_to_z(a, b, c):
    m = extract_m(a)
    n = extract_n(a)
    z = _mnbc_to_z(m, n, b, c) # 4 params


# But if we inline "_mnbc_to_z" and
# then extract some code differently,
# we may significantly reduce the data exchange.
# This is going to result in testing
# of the "_ab_to_y" being simpler
# than of the "_mnbc_to_z" above.
def _ab_to_y(a, b):
    m = extract_m(a)
    n = extract_n(a)
    x = make_x(b, m)
    y = make_y(x, n)

def convert_abc_to_z(a, b, c):
    y = _ab_to_y(a, b) # Only 2 params
    z = make_z(y, c)

>>> bool(datetime(2018, 1, 1).time())
False
>>> bool(datetime(2018, 1, 1, 13, 12, 11).time())
True

def create(created_time=None) -> None:
    if not created_time:
        created_time = datetime.now().time()

In : int('୧৬𝟙༣')
Out: 1613

In : int('෯')
Out: 9

In : '٢'.isdecimal()
Out: True

In : bool(re.match('\d', '౫'))
Out: True

try:
    1 / 0
except ZeroDivisionError:
    raise ValueError('Zero!')

 (most recent call last):
  File "test.py", line 2, in <module>
    1 / 0
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "test.py", line 4, in <module>
    raise ValueError('Zero!')
ValueError: Zero!

division_error = None

try:
    1 / 0
except ZeroDivisionError as e:
    division_error = e

raise ValueError('Zero!') from division_error

 (most recent call last):
  File "test.py", line 4, in <module>
    1 / 0
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    raise ValueError('Zero!') from division_error
ValueError: Zero!

In : class A:
...:     def __init__(self, x):
...:         self._x = x
...:
...:     def __repr__(self):
...:         class_name = type(self).__name__
...:         x = self._x
...:         return f'{class_name}({x!r})'
...:

In : A(1)
Out: A(1)

In : A(2)
Out: A(2)

In : A(3)
Out: A(3)

In : [x for x in gc.get_objects() if isinstance(x, A)]
Out: [A(1), A(2), A(3)]