fibomat.backend.backendbase module#

Provides the BackendBase class.

exception fibomat.backend.backendbase.ShapeNotSupportedError[source]#

Bases: TypeError

Exception is used in BackendBase for (all) unimplemented shape methods.

__init__(*args, **kwargs)#

args#

with_traceback()#: Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

fibomat.backend.backendbase.shape_type(type_: Type[Shape]) → Callable[source]#

Function is used as a decorator in BackendBase to mark shape methods. See BackendBase class and its implementation for details.

Note

This decorator is only needed if a custom shape type is introduced and should be made available to the backend

Args:: type_ (Type[Shape]): Type of shape.
Returns:: Callable: Decorator

class fibomat.backend.backendbase.BackendBase(**kwargs)[source]#

Bases: object

Base class for any backend. For all default shapes (see …), a method stub is implemented.

TODO: UPDATE THIS!

Use BackendBase as base class for a custom backend and implement all shape methods with should be supported and ignore the rest. If any other new shape is introduced and should be supported by the custom backend, use the following example as a base structure.

class MyNewBackendBase(BackendBase):
    def __init__(self):  # is it needed?
        super().__init__()

    @availabe_shape_method('My_new_shape_name')
    def my_new_shape(self, parameters):
        raise ShapeNotSupportedError

class MyNewBackend(MyNewBackendBase):
    ...

    def my_new_shape(self, parameters):
        ...

Actually not needed: Make sure, that the base methods of each pattern function (e.g. fibomat.backend.backendbase.BackendBase.rect()) is called, e.g.

def rect(self, ptn: Pattern):
    super().rect(pattern)
    # ... do your stuff here

__init__(**kwargs)[source]#

Args:

**kwargs: optional parameters for the backend given by **kwargs in: fibomat.project.Project.export()

process_pattern(ptn: Pattern) → None[source]#

Add a pattern to the backend. The appropriate method is determined by the pattern’s shape class automatically.

If pattern contains a Layout, the contained shapes will be extracted automatically.

Args:: ptn (Pattern): pattern to be added. on_unknown_shape:
Returns:: None

process_unknown(ptn: Pattern) → None[source]#

Process a shape, which do not have a registered shape handler. Raises an exception by default.

Args:: ptn (Pattern): pattern to be added.
Returns:: None

property shape_methods: Dict[Shape, Callable]#: Dict[Shape, str]: all (abstract) shape methods

property implemented_shape_methods: Dict[Shape, Callable]#: Dict[Shape, str]: implemented shape methods of backend

process_site(new_site: Site) → None[source]#

Adds a fibomat.site.Site to the backend. Note, that this method processes all patterns contained in the site. Use the following example as reference, if a backend overwrites this method.

...
def process_site(self, site: Site):
    # ...
    # do the backend specific stuff here (e.g. initialize a new patterning site)

    # call base method to add all patterns automatically
    super().process_site(site)
...