artificial_artwork.pretrained_model.model_handler

Complexity

Total Complexity

9

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	Modelhandler.load_model_layers()	0	4	1
A	ReporterProtocol.get_weights()	0	1	1
A	Modelhandler._load_model_layers()	0	6	2
A	ModelHandlerFacility.create()	0	3	1
A	Modelhandler._create_reporter()	0	4	1
A	Modelhandler.reporter()	0	3	1
A	Modelhandler.__init__()	0	2	1

import os
from typing import Tuple, Protocol
from numpy.typing import NDArray

from artificial_artwork.utils import SubclassRegistry
from .model_handler_interface import ModelHandlerInterface
from .layers_getter import ModelReporter


class ReporterProtocol(Protocol):
    def get_weights(self, layer_id: str) -> Tuple[NDArray, NDArray]: ...


class Modelhandler(ModelHandlerInterface):
    _reporter: ReporterProtocol
    def __init__(self):
        self._reporter = None

    @property
    def reporter(self) -> ReporterProtocol:
        return self._reporter

    @reporter.setter
    def reporter(self, layers) -> None:
        self._reporter = self._create_reporter(layers)

    def _create_reporter(self, layers: NDArray) -> ReporterProtocol:
        return ModelReporter(
            self.model_routines.get_layers_dict(layers),
            self.model_routines.get_weights
        )

    def load_model_layers(self) -> NDArray:
        layers = self._load_model_layers()
        self._reporter = self._create_reporter(layers)
        return layers

    def _load_model_layers(self) -> NDArray:
        try:
            return self.model_routines.load_layers(os.environ[self.environment_variable])
        except KeyError as variable_not_found:
            raise NoImageModelSpesifiedError(self.model_load_exception_text) \
                from variable_not_found


class NoImageModelSpesifiedError(Exception): pass


class ModelHandlerFactoryMeta(SubclassRegistry[Modelhandler]): pass


class ModelHandlerFactory(metaclass=ModelHandlerFactoryMeta): pass


class ModelHandlerFacility:
    # routines_interface: type = PretrainedModelRoutines
    handler_class: type = Modelhandler
    factory = ModelHandlerFactory

    @classmethod
    def create(cls, handler_type, *args, **kwargs) -> Modelhandler:
        return cls.factory.create(handler_type, *args, **kwargs)