#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os, sys
# Instead of importing from reprlib.py, I added this function in for clarity
def recursive_repr(fillvalue='...'):
'Decorator to make a repr function return fillvalue for a recursive call'
def decorating_function(user_function):
repr_running = set()
def wrapper(self):
key = id(self), get_ident()
if key in repr_running:
return fillvalue
repr_running.add(key)
try:
result = user_function(self)
finally:
repr_running.discard(key)
return result
# Can't use functools.wraps() here because of bootstrap issues
wrapper.__module__ = getattr(user_function, '__module__')
wrapper.__doc__ = getattr(user_function, '__doc__')
wrapper.__name__ = getattr(user_function, '__name__')
wrapper.__qualname__ = getattr(user_function, '__qualname__')
wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
return wrapper
return decorating_function
# Purely functional, no descriptor behaviour
class partial:
__slots__ = "func", "args", "keywords", "__dict__", "__weakref__"
# --- Python usage ---
# __new__ creates a new instance of partial
# __new__ is not the factory __init__ though, pay close attention to that
# For a deep dive into partials use of __new__ checkout the C source
# behind this code in the _functoolsmodule.c module
# --- C Soucre ---
# static PyObject *
# partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
# Also, checkout __new__ in typeobject.c
# static PyObject *
# type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) { ... }
def __new__(*args, **keywords):
if not args:
raise TypeError("descriptor '__new__' of partial needs an argument")
if len(args) < 2:
raise TypeError("type 'partial' takes at least one argument")
cls, func, *args = args
if not callable(func):
raise TypeError("the first argument must be callable")
args = tuple(args)
# Assign instance variables by determining their avialability
if hasattr(func, "func"):
args = func.args + args
# This is pretty awesome, the passed in func keywords are copied
# The func keywords is then updated with the instance keywords
# Keywords is then overwritten with the temporary keywords
# The memory is then released for temporary keywords
tmpkw = func.keywords.copy()
tmpkw.update(keywords)
keywords = tmpkw
del tmpkw
func = func.func
# Following the PEP 8 standard to use cls instead of self
self = super(partial, cls).__new__(cls)
self.func = func
self.args = args
self.keywords = keywords
return self
# --- Python usage ---
# __call__ gives the object returned from the partial the callable functionality
# For example a = partial(func)
# can now be called like this: a(f) because of __call__
# --- C Soucre ---
# For a deep dive into partials use of __call__ checkout the C source
# behind this code in the _functoolsmodule.c module
# static PyObject *
# partial_call(partialobject *pto, PyObject *args, PyObject *kwargs) { ... }
# Also, checkout __call__ checkout in typeobject.c
# static PyObject *
# type_call(PyTypeObject *type, PyObject *args, PyObject *kwds) { ... }
def __call__(*args, **keywords):
if not args:
raise TypeError("descriptor '__call__' of partial needs an argument")
self, *args = args
newkeywords = self.keywords.copy()
newkeywords.update(keywords)
# Here is what makes the passed in func callable
return self.func(*self.args, *args, **newkeywords)
# --- Python usage ---
# __repr__ is used to create an informal string representation of an instance.
# Sometimes, a string cannot be created on a partial so <...> would be used.
# One thing to note, is that this method uses f-string, which is a Python 3.6
# feature only. This allows formatted string literals
# Notice the @recursive_repr() decorator, this is represented above
# --- C Soucre ---
# For a deep dive into partials use of __repr__ checkout the C source
# behind this code in the _functoolsmodule.c module
# static PyObject *
# partial_repr(partialobject *pto) { ... }
# Also, checkout __call__ checkout in typeobject.c
# static PyObject *
# object_repr(PyObject *self) { ... }
# static PyObject *
# type_repr(PyTypeObject *type) { ... }
@recursive_repr()
def __repr__(self):
# Build a string represenation of this instance
qualname = type(self).__qualname__
args = [repr(self.func)]
args.extend(repr(x) for x in self.args)
# This only works with python 3.6 and above because of f-strings
args.extend(f"{k}={v!r}" for (k, v) in self.keywords.items())
# If called to debug, a string representation of this instance will
# be returned, very much like __str__
if type(self).__module__ == "functools":
return f"functools.{qualname}({', '.join(args)})"
return f"{qualname}({', '.join(args)})"
# --- Python usage ---
# In case an instance needs to be pickled (serialized) and a specific
# variable cannot be serialized down properly, __reduce__ will handle this
# for us by dealing with this failure gracefully.
# --- C Soucre ---
# For a deep dive into partials use of __reduce__ checkout the C source
# behind this code in the _functoolsmodule.c module
# static PyObject *
# partial_reduce(partialobject *pto, PyObject *unused) {...}
def __reduce__(self):
return type(self), (self.func,), (self.func, self.args,
self.keywords or None, self.__dict__ or None)
# --- Python usage ---
# In case an instance needs to be pickled (serialized) __setstate__
# can help setup the state of an object before it is pickled so
# that the instance variables matche the state variables
# --- C Soucre ---
# For a deep dive into partials use of __setstate__ checkout the C source
# behind this code in the _functoolsmodule.c module
# static PyObject *
# partial_setstate(partialobject *pto, PyObject *state) { ... }
def __setstate__(self, state):
if not isinstance(state, tuple):
raise TypeError("argument to __setstate__ must be a tuple")
# Check that the state variables match the instances variables
if len(state) != 4:
raise TypeError(f"expected 4 items in state, got {len(state)}")
func, args, kwds, namespace = state
if (not callable(func) or not isinstance(args, tuple) or
(kwds is not None and not isinstance(kwds, dict)) or
(namespace is not None and not isinstance(namespace, dict))):
raise TypeError("invalid partial state")
args = tuple(args) # just in case it's a subclass
if kwds is None:
kwds = {}
elif type(kwds) is not dict: # XXX does it need to be *exactly* dict?
kwds = dict(kwds)
if namespace is None:
namespace = {}
self.__dict__ = namespace
self.func = func
self.args = args
self.keywords = kwds
try:
from _functools import partial
except ImportError:
class Employee():
# Initialize a new instance of the employee
def __init__(self):
self.__employee_name = ""
self.__employee_number = -1
# Setter for employee name
def set_employee_name(self, name):
if len(name) > 0:
self.__employee_name = name
return True
else:
return False
# Getter for employee name
def get_employee_name(self):
return self.__employee_name
# Setter for employee number
def set_employee_number(self, number):
if self.validate_numeric(number):
self.__employee_number = number
return True
else:
return False
# Getter for employee number
def get_employee_number(self):
return self.__employee_number
# Utility validation method
def validate_numeric(self, num):
if len(num) == 0:
return False
try:
x = int(num)
if x < 1:
return False
return True
except ValueError:
return False
def main():
employee = Employee()
instructions = [
"Please enter an employee name: ",
"Please enter an employee number: "
# Usage of our partial class from Python core above!
func_dict = {
0: partial(employee.set_employee_name),
1: partial(employee.set_employee_number)
index = 0
# Process user input
while index < len(instructions):
# Value comes off standard output as a string
input_value = input(instructions[index])
flag = func_dict[index](input_value)
if flag:
index += 1
else:
print("Not a valid input, please try again.")
print("Employee name: " + employee.get_employee_name())
print("Employee number: " + employee.get_employee_number())
# Execute the main function
if __name__ == '__main__':
main()
