structured_data._processors

Complexity

Total Complexity

18

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	Processor.__call__()	0	2	1
A	ProcessorList.__init__()	0	2	1
A	Processor.__init__()	0	2	1
A	AsPatternProcessor.__call__()	0	4	2
A	ProcessorList.get_processor()	0	5	3
A	ADTProcessor.__call__()	0	4	2
A	TupleProcessor.__call__()	0	4	3
A	ProcessorList.names()	0	15	4
A	ProcessorList.custom()	0	3	1

from ._adt_constructor import ADTConstructor
from ._match_failure import MatchFailure
from ._not_in import not_in
from ._patterns import AsPattern
from ._patterns import Pattern
from ._unpack import unpack


class Processor:

    def __init__(self, target):
        self.target = target

    def __call__(self, value):
        raise NotImplementedError

    type = None


class AsPatternProcessor(Processor):

    def __call__(self, value):
        if self.target is value:
            return reversed(self.target)
        return (value, value)

    type = AsPattern


class ADTProcessor(Processor):

    def __call__(self, value):
        if value.__class__ is not self.target.__class__:
            raise MatchFailure
        return reversed(unpack(value))

    type = ADTConstructor


class TupleProcessor(Processor):

    def __call__(self, value):
        if isinstance(value, self.target.__class__) and len(self.target) == len(value):
            return reversed(value)
        raise MatchFailure

    type = tuple


class ProcessorList:

    def __init__(self, *processors):
        self.processors = tuple(processors)

    def get_processor(self, item):
        for processor in self.processors:
            if isinstance(item, processor.type):
                return processor(item)
        return None

    @classmethod
    def custom(cls, *processors):
        return cls(AsPatternProcessor, ADTProcessor, *processors, TupleProcessor)

    def names(self, target):
        name_list = []
        names_seen = set()
        to_process = [target]
        while to_process:
            item = to_process.pop()
            if isinstance(item, Pattern):
                not_in(names_seen, item.name)
                names_seen.add(item.name)
                name_list.append(item.name)
            else:
                processor = self.get_processor(item)
                if processor:
                    to_process.extend(processor(item))
        return name_list


PROCESSORS = ProcessorList.custom()