pymor.core.base

This module provides base classes from which most classes in pyMOR inherit.

The purpose of these classes is to provide some common functionality for all objects in pyMOR. The most notable features provided by BasicObject are the following:

1. BasicObject sets class UberMeta as metaclass which itself inherits from abc.ABCMeta. Thus it is possible to define interface classes with abstract methods using the abstractmethod decorator. There are also decorators for abstract class methods, static methods, and properties.

2. Using metaclass magic, each class deriving from BasicObject comes with its own logger instance accessible through its logger attribute. The logger prefix is automatically set to the class name.

3. Logging can be disabled and re-enabled for each instance using the BasicObject.disable_logging and BasicObject.enable_logging methods.

4. BasicObject.uid provides a unique id for each instance. While id(obj) is only guaranteed to be unique among all living Python objects, BasicObject.uid will be (almost) unique among all pyMOR objects that have ever existed, including previous runs of the application. This is achieved by building the id from a uuid4 which is newly created for each pyMOR run and a counter which is increased for any object that requests an uid.

5. If not set by the user to another value, BasicObject.name is set to the name of the object’s class.

ImmutableObject derives from BasicObject and adds the following functionality:

1. Using more metaclass magic, each instance which derives from ImmutableObject is locked after its __init__ method has returned. Each attempt to change one of its attributes raises an exception. Private attributes (of the form _name) are exempted from this rule.

2. ImmutableObject.with_ can be used to create a copy of an instance with some changed attributes. E.g.

   obj.with_(a=x, b=y)
   

   creates a copy with the a and b attributes of obj set to x and y. with_ is implemented by creating a new instance, passing the arguments of with_ to __init__. The missing __init__ arguments are taken from instance attributes of the same name.

Module Contents

Classes

UID	Provides unique, quickly computed ids by combining a session UUID4 with a counter.
UberMeta	Metaclass for defining Abstract Base Classes (ABCs).
BasicObject	Base class for most classes in pyMOR.
classinstancemethod
ImmutableMeta	Metaclass for ImmutableObject.
ImmutableObject	Base class for immutable objects in pyMOR.

Attributes

DONT_COPY_DOCSTRINGS
NoneType
abstractmethod
abstractproperty
abstractclassmethod
abstractstaticmethod

pymor.core.base.DONT_COPY_DOCSTRINGS

pymor.core.base.NoneType

class pymor.core.base.UID

Provides unique, quickly computed ids by combining a session UUID4 with a counter.

__slots__ = ['uid']

prefix

counter = [0]

__getstate__(self)

__setstate__(self, v)

class pymor.core.base.UberMeta(cls, name, bases, namespace)

Bases: abc.ABCMeta

Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

class pymor.core.base.BasicObject

Base class for most classes in pyMOR.

logger

A per-class instance of logging.Logger with the class name as prefix.

logging_disabled

True if logging has been disabled.

name

The name of the instance. If not set by the user, the name is set to the class name.

uid

A unique id for each instance. The uid is obtained by using UID and is unique for all pyMOR objects ever created.

_uid

disable_logging(self, doit=True)

Disable logging output for this instance.

enable_logging(self, doit=True)

Enable logging output for this instance.

_format_repr(self, max_width, verbosity, override={})

__repr__(self)

Return repr(self).

pymor.core.base.abstractmethod

pymor.core.base.abstractproperty

pymor.core.base.abstractclassmethod

pymor.core.base.abstractstaticmethod

class pymor.core.base.classinstancemethod(cls_meth)

__get__(self, instance, cls)

instancemethod(self, inst_meth)

class pymor.core.base.ImmutableMeta(cls, name, bases, namespace)

Bases: UberMeta

Metaclass for ImmutableObject.

__call__

_call(self, *args, **kwargs)

class pymor.core.base.ImmutableObject

Bases: BasicObject

Base class for immutable objects in pyMOR.

Instances of ImmutableObject are immutable in the sense that after execution of __init__, any modification of a non-private attribute will raise an exception.

Warning

For instances of ImmutableObject, the result of member function calls should be completely determined by the function’s arguments together with the object’s __init__ arguments and the current state of pyMOR’s global defaults.

While, in principle, you are allowed to modify private members after instance initialization, this should never affect the outcome of future method calls. In particular, if you update any internal state after initialization, you have to ensure that this state is not affected by possible changes of the global defaults.

_locked = False

__setattr__(self, key, value)

Depending on _locked state I delegate the setattr call to object or raise an Exception.

with_(self, new_type=None, **kwargs)

Returns a copy with changed attributes.

A a new class instance is created with the given keyword arguments as arguments for __init__. Missing arguments are obtained form instance attributes with the same name.

Parameters

new_type

If not None, return an instance of this class (instead of type(self)).

**kwargs

Names of attributes to change with their new values. Each attribute name has to be an argument to __init__.

Returns

Copy of self with changed attributes.

__copy__(self)

__deepcopy__(self, memo)