python.function_class.ClassFromFunctions Class Reference

Inheritance diagram for python.function_class.ClassFromFunctions:

Public Member Functions
	__new__ (cls, *args, **kargs)
	__init__ (self, *args, **kargs)
	get_instance (self)
	add_method (cls, function_name, method_name)
	Add the function, method_name to this class as a method named name.
	ya_add_classmethod (cls, function_name, method_name)
	Add the function, method_name to this class as a classmethod named name.
	ya_add_method (cls, function_name, method_name)
	Add the function, method_name to this class as a method named name.
	add_methods_with_prefix (cls, prefix, exclude=[])
	add_constructor_and_methods_with_prefix (cls, prefix, constructor, exclude=[])
	decorate_functions (cls, decorator, *args)
	decorate_method (cls, decorator, method_name, *args, **kargs)
	decorate method method_name of class cls with decorator decorator

Protected Attributes
	_module
	_new_instance

Properties
	instance = property(get_instance)

Detailed Description

Inherit this class to give yourself a python class that wraps a set of
functions that together constitute the methods of the class.

The method functions must all have as a first argument an object
holding the instance data. There must also be a function that
returns a new instance of the class, the constructor.

Your subclass must define
_module - The module where the method functions, including the
constructor can be found
_new_instance - The name of a function that serves as a constructor,
returning the instance data.

To access the instance data, use the read-only property instance.

To add some functions from _module as methods, call classmethods like
add_method and add_methods_with_prefix.

Definition at line 31 of file function_class.py.

Constructor & Destructor Documentation

__init__()

python.function_class.ClassFromFunctions.__init__	(		self,
		*	args,
		**	kargs
	)

Construct a new instance, using either the function
self._module[self._new_instance] or using existing instance
data. (specified with the keyword argument, instance)

if instance argument is None it will be ignored and the
constructor will be called to get a new instance

Pass the arguments that should be passed on to
self._module[self._new_instance]. Any arguments of that
are instances of ClassFromFunctions will be switched with the instance
data. (by calling the .instance property)

Definition at line 57 of file function_class.py.

    def __init__(self, *args, **kargs):
        """Construct a new instance, using either the function
        self._module[self._new_instance] or using existing instance
        data. (specified with the keyword argument, instance)
 
        if instance argument is None it will be ignored and the
        constructor will be called to get a new instance
 
        Pass the arguments that should be passed on to
        self._module[self._new_instance]. Any arguments of that
        are instances of ClassFromFunctions will be switched with the instance
        data. (by calling the .instance property)
        """
        if INSTANCE_ARGUMENT in kargs and kargs[INSTANCE_ARGUMENT] is not None:
            inst = kargs[INSTANCE_ARGUMENT]
            # Unwrap if someone passes a wrapper object as instance data,
            # e.g. GncNumeric(instance=some_GncNumeric).  This can happen
            # when a method's return type is changed from a raw SWIG proxy
            # to a wrapper class and callers still re-wrap the result.
            if isinstance(inst, ClassFromFunctions):
                inst = inst.instance
            self.__instance = inst
        else:
            self.__instance = getattr(self._module, self._new_instance)(
                *process_list_convert_to_instance(args),
                **process_dict_convert_to_instance(kargs))
 

Member Function Documentation

__new__()

python.function_class.ClassFromFunctions.__new__	(		cls,
		*	args,
		**	kargs
	)

Definition at line 50 of file function_class.py.

    def __new__(cls, *args, **kargs):
        # why reimplement __new__? Because later on we're going to
        # use new to avoid creating new instances when existing instances
        # already exist with the same __instance value, or equivalent __instance
        # values, where this is desirable...
        return super(ClassFromFunctions, cls).__new__(cls)
 

add_constructor_and_methods_with_prefix()

python.function_class.ClassFromFunctions.add_constructor_and_methods_with_prefix	(		cls,
			prefix,
			constructor,
			exclude = []
	)

Add a group of functions with the same prefix, and set the
_new_instance attribute to prefix + constructor. Don't add methods
in array exclude.

Definition at line 203 of file function_class.py.

    def add_constructor_and_methods_with_prefix(cls, prefix, constructor, exclude=[]):
        """Add a group of functions with the same prefix, and set the
        _new_instance attribute to prefix + constructor. Don't add methods
        in array exclude.
        """
        cls.add_methods_with_prefix(prefix, exclude=exclude)
        cls._new_instance = prefix + constructor
 

add_method()

python.function_class.ClassFromFunctions.add_method	(		cls,
			function_name,
			method_name
	)

Add the function, method_name to this class as a method named name.

arguments:

Parameters

cls	Class: class to add methods to
function_name	string: name of the function to add
method_name	string: name of the method that function will be called

function will be wrapped by method_function

Definition at line 96 of file function_class.py.

    def add_method(cls, function_name, method_name):
        """! Add the function, method_name to this class as a method named name
 
        arguments:
        @param cls Class: class to add methods to
        @param function_name string: name of the function to add
        @param method_name string: name of the method that function will be called
 
        function will be wrapped by method_function"""
 
        def method_function(self, *meth_func_args, **meth_func_kargs):
            """! wrapper method for function
 
            arguments:
            @param self: FunctionClass instance. Will be turned to its instance property.
            @param *meth_func_args: arguments to be passed to function. All FunctionClass
                objects will be turned to their respective instances.
            @param **meth_func_kargs: keyword arguments to be passed to function. All
                FunctionClass objects will be turned to their respective instances."""
            return getattr(self._module, function_name)(
                self.instance,
                *process_list_convert_to_instance(meth_func_args),
                **process_dict_convert_to_instance(meth_func_kargs)
            )
 
        setattr(cls, method_name, method_function)
        setattr(method_function, "__name__", method_name)
        return method_function
 

add_methods_with_prefix()

python.function_class.ClassFromFunctions.add_methods_with_prefix	(		cls,
			prefix,
			exclude = []
	)

Add a group of functions with the same prefix, exclude methods
in array exclude.

Definition at line 192 of file function_class.py.

    def add_methods_with_prefix(cls, prefix, exclude=[]):
        """Add a group of functions with the same prefix, exclude methods
        in array exclude.
        """
        for function_name, function_value, after_prefix in \
                extract_attributes_with_prefix(cls._module, prefix):
 
            if not (function_name in exclude):
                cls.add_method(function_name, after_prefix)
 

decorate_functions()

python.function_class.ClassFromFunctions.decorate_functions	(		cls,
			decorator,
		*	args
	)

Definition at line 212 of file function_class.py.

    def decorate_functions(cls, decorator, *args):
        for function_name in args:
            setattr( cls, function_name,
                     decorator( getattr(cls, function_name) ) )
 

decorate_method()

python.function_class.ClassFromFunctions.decorate_method	(		cls,
			decorator,
			method_name,
		*	args,
		**	kargs
	)

decorate method method_name of class cls with decorator decorator

in difference to decorate_functions() this allows to provide additional arguments for the decorator function.

arguments:

Parameters

cls	class
decorator	function to decorate method
method_name	name of method to decorate (string)
*args	positional arguments for decorator
**kargs	keyword arguments for decorator

Definition at line 218 of file function_class.py.

    def decorate_method(cls, decorator, method_name, *args, **kargs):
        """! decorate method method_name of class cls with decorator decorator
 
        in difference to decorate_functions() this allows to provide additional
        arguments for the decorator function.
 
        arguments:
            @param cls: class
            @param decorator: function to decorate method
            @param method_name: name of method to decorate (string)
            @param *args: positional arguments for decorator
            @param **kargs: keyword arguments for decorator"""
        setattr(cls, method_name,
                    decorator(getattr(cls, method_name), *args, **kargs))
 

get_instance()

python.function_class.ClassFromFunctions.get_instance

(

self

)

Get the instance data.

You can also call the instance property

Definition at line 84 of file function_class.py.

    def get_instance(self):
        """Get the instance data.
 
        You can also call the instance property
        """
        return self.__instance
 

ya_add_classmethod()

python.function_class.ClassFromFunctions.ya_add_classmethod	(		cls,
			function_name,
			method_name
	)

Add the function, method_name to this class as a classmethod named name.

Taken from function_class and modified from add_method() to add classmethod instead of method and not to turn self argument to self.instance.

arguments:

Parameters

cls	Class: class to add methods to
function_name	string: name of the function to add
method_name	string: name of the classmethod that function will be called

function will be wrapped by method_function

Definition at line 126 of file function_class.py.

    def ya_add_classmethod(cls, function_name, method_name):
        """! Add the function, method_name to this class as a classmethod named name
 
        Taken from function_class and modified from add_method() to add classmethod
        instead of method and not to turn self argument to self.instance.
 
        arguments:
        @param cls Class: class to add methods to
        @param function_name string: name of the function to add
        @param method_name string: name of the classmethod that function will be called
 
        function will be wrapped by method_function"""
 
        def method_function(self, *meth_func_args, **meth_func_kargs):
            """! wrapper method for function
 
            arguments:
            @param self: FunctionClass instance.
            @param *meth_func_args: arguments to be passed to function. All FunctionClass
                objects will be turned to their respective instances.
            @param **meth_func_kargs: keyword arguments to be passed to function. All
                FunctionClass objects will be turned to their respective instances."""
            return getattr(self._module, function_name)(
                self,
                *process_list_convert_to_instance(meth_func_args),
                **process_dict_convert_to_instance(meth_func_kargs)
            )
 
        setattr(cls, method_name, classmethod(method_function))
        setattr(method_function, "__name__", method_name)
        return method_function
 

ya_add_method()

python.function_class.ClassFromFunctions.ya_add_method	(		cls,
			function_name,
			method_name
	)

Add the function, method_name to this class as a method named name.

Taken from function_class. Modified to not turn self to self.instance as add_method() does.

arguments:

Parameters

cls	Class: class to add methods to
function_name	string: name of the function to add
method_name	string: name of the method that function will be called

function will be wrapped by method_function

Definition at line 159 of file function_class.py.

    def ya_add_method(cls, function_name, method_name):
        """! Add the function, method_name to this class as a method named name
 
        Taken from function_class. Modified to not turn self to self.instance
        as add_method() does.
 
        arguments:
        @param cls Class: class to add methods to
        @param function_name string: name of the function to add
        @param method_name string: name of the method that function will be called
 
        function will be wrapped by method_function"""
 
        def method_function(self, *meth_func_args, **meth_func_kargs):
            """! wrapper method for function
 
            arguments:
            @param self: FunctionClass instance.
            @param *meth_func_args: arguments to be passed to function. All FunctionClass
                objects will be turned to their respective instances.
            @param **meth_func_kargs: keyword arguments to be passed to function. All
                FunctionClass objects will be turned to their respective instances."""
            return getattr(self._module, function_name)(
                self,
                *process_list_convert_to_instance(meth_func_args),
                **process_dict_convert_to_instance(meth_func_kargs)
            )
 
        setattr(cls, method_name, method_function)
        setattr(method_function, "__name__", method_name)
        return method_function
 

Field Documentation

_module

python.function_class.ClassFromFunctions._module

protected

Definition at line 115 of file function_class.py.

_new_instance

python.function_class.ClassFromFunctions._new_instance

protected

Definition at line 209 of file function_class.py.

Property Documentation

instance

python.function_class.ClassFromFunctions.instance = property(get_instance)

static

Definition at line 91 of file function_class.py.

---

The documentation for this class was generated from the following file:

• function_class.py