calculate-utils-4-lib/calculate/vars/datavars.py

# import site
# import os
import re
# import sys
import types
# import functools
from contextlib import contextmanager

_ = lambda x: x


class BaseClass:
    BASE_CLASS = "BaseClass"

    @classmethod
    def is_implementation(cls, check_class):
        '''Метод для проверки того, что класс является производным базового
        класса, а не самим базовым. Используется в автозагрузке переменных из
        модулей.'''
        if isinstance(check_class, type) and issubclass(check_class, cls):
            if check_class.BASE_CLASS == cls.BASE_CLASS and \
                  check_class.__name__ != cls.BASE_CLASS:
                return True
        return False


class VariableError(Exception):
    pass


class VariableNotFoundError(VariableError):
    pass


class CyclicVariableError(VariableError):
    def __init__(self, *queue):
        self.queue = queue

    def __str__(self):
        return _("Cyclic dependence in variables: {}").format(", ".join(
                                                              self.queue[:-1]))


class VariableProperty:
    '''Базовый класс для объектов свойств.'''
    def __init__(self, parent):
        self.parent = parent


class StringVariable(VariableProperty):
    '''Класс свойства, соответствующий переменным просто хранящим строки как
    значения.'''
    pass


class ListVariable(VariableProperty):
    '''Класс свойства, соответствующий переменным хранящим списки значений.'''
    def set_value(self, value, force=False):
        if isinstance(value, (list, tuple)):
            return value
        elif isinstance(value, str):
            return value.split(",")
        else:
            raise VariableError(
                _("The value of variable '{varname}' must be list").format(
                    varname=self.parent.name))

    def post_get(self, value):
        return value


class ReadonlyVariable(VariableProperty):
    def set_value(self, value, force=False):
        if not force:
            raise VariableError(
                _("Attempting to rewrite readonly variable {}").format(
                                                             self.parent.name))
        return value


class IntegerVariable(VariableProperty):
    re_match = re.compile(r"^-?\d+$")

    def check(self, value):
        if value and not self.re_match.match(value):
            raise VariableError(
                _("The value of variable '{varname}' must be integer").format(
                    varname=self.parent.name))

    def post_get(self, value):
        return int(value)


class BooleanVariable(VariableProperty):
    def post_get(self, value):
        return value == "true"


class ChoiceVariable(VariableProperty):
    def check(self, value):
        choices = self.parent.choice()
        if value and value not in choices:
            raise VariableError(
                _("The value for variable '{varname}' may be "
                  "{vartype}").format(varname=self.parent.name,
                                      vartype=",".join(choices)))

    def choice(self):
        if self.parent.__class__.choice == Variable.choice and \
           self.parent.__class__.choice_comment == Variable.choice_comment:
            raise VariableError(_("Wrong choice variable {}").format(
                                                             self.parent.name))
        return [x[0] for x in self.parent.choice_comment()]

    def choice_comment(self):
        return [(x, x) for x in self.parent.choice()]


class DefaultValue(VariableProperty):
    def __init__(self, value):
        self.value = value
        self.parent = None

    def get_value(self, invalidate_subs=None):
        if self.parent._value is None:
            self.parent._unsubscribe_depends()
            self.parent._value = self.value


class IniCreated(DefaultValue):
    pass


class Variable(BaseClass):
    BASE_CLASS = "Variable"

    On = "on"
    Off = "off"
    value = ""

    class Type:
        Bool = "bool"
        List = "list"
        String = "string"
        Integer = "int"
        Choice = "choice"

    properties = (StringVariable,)

    def __init__(self, name):
        self.name = name
        self._value = None
        self.vars = None
        self.invalidate_subs = set()
        self.depends = set()
        self.calculating = False
        self._properties = [x(self) for x in self.properties]
        # версия значения переменной, если переменная со времен получения
        # значения успела обновиться, исключить сброс ее значения

    @property
    def fullname(self):
        '''Метод для получения полного имени переменной.'''
        return "{}.{}".format(self.vars.get_fullname(), self.name)

    def addProperty(self, prop):
        prop.parent = self
        self._properties.insert(0, prop)

    def findProperty(self, propclass):
        for prop in self._properties:
            if isinstance(prop, propclass):
                return prop
        else:
            return None

    def _emit_invalidate(self, slots):
        for f in slots:
            f()

    def _unsubscribe_depends(self):
        for dependvar in self.depends:
            dependvar.update_unsubscribe(self.invalidate)
        self.depends = set()

    def update_subscribe(self, f_or_var):
        if isinstance(f_or_var, Variable):
            f_or_var.depends.add(self)
            self.invalidate_subs.add(f_or_var.invalidate)
        else:
            self.invalidate_subs.add(f_or_var)

    def update_unsubscribe(self, f):
        if f in self.invalidate_subs:
            self.invalidate_subs.remove(f)

    def invalidate(self):
        self._value = None
        if self.invalidate_subs:
            slots = self.invalidate_subs
            self.invalidate_subs = set()
            self._emit_invalidate(slots)

    def set_parent(self, namespace):
        self.vars = namespace

    @contextmanager
    def _start_calculate(self):
        try:
            self.calculating = True
            yield self
        finally:
            self.calculating = False

    def get_value(self, invalidate_sub=None):
        for f in self.call_properties("get_value"):
            f(invalidate_sub)
        if self.calculating:
            raise CyclicVariableError(self.name)
        if self._value is None:
            with self._start_calculate():
                try:
                    self._unsubscribe_depends()
                    self._value = self.get()
                    if isinstance(self._value, types.GeneratorType):
                        self._value = list(self._value)
                except CyclicVariableError as e:
                    raise CyclicVariableError(self.name, *e.queue)

        if invalidate_sub is not None:
            self.update_subscribe(invalidate_sub)
        return self.post_get(self._value)

    def post_get(self, value):
        for f in self.call_properties("post_get"):
            ret = f(value)
            if ret is not None:
                return ret
        return value

    def call_properties(self, method_name, *args):
        '''Метод для вызова указанного метода у всех объектов, которыми владеет
        переменная.'''
        for _property in self._properties:
            method = getattr(_property, method_name, None)
            if method:
                yield method

    def set_value(self, value, force=False):
        '''Метод для установки некоторого заданного значения всем объектам,
        принадлежащим переменной.'''
        for setter in self.call_properties("set_value"):
            value = setter(value, force)
        value = self.set(value)
        self.check(value)
        self.invalidate()
        self._value = value
        self._unsubscribe_depends()

    def check(self, value):
        '''Метод для проверки корректности устанавливаемого значения путем
        вызова проверочных методов всех объектов, которыми владеет переменная.
        '''
        for checker in self.call_properties("check"):
            checker(value)

    def get(self):
        '''Метод для заполнения переменной.'''
        return self.value

    def get_comment_value(self, invalidate_sub=None):
        '''Этот метод вызывается внутри методов get.'''
        val = self.get_comment()
        if invalidate_sub is not None:
            self.update_subscribe(invalidate_sub)
        return val

    def get_comment(self):
        '''Метод для установки .'''
        for f in self.call_properties("get_comment"):
            return f()
        return self.get_value()

    def set(self, value):
        '''Метод для модификации переменной.'''
        return value

    def choice(self):
        '''Метод возвращет список доступных значений для переменной.'''
        for f in self.call_properties("choice"):
            return f()
        return []

    def choice_comment(self):
        for f in self.call_properties("choice_comment"):
            return f()
        return []


class NamespaceError(Exception):
    pass


class Namespace(BaseClass):
    '''Класс пространства имен.'''
    BASE_CLASS = "Namespace"

    def __init__(self, name="", parent=None):
        self._name = name
        self.variables = {}
        self.childs = {}
        self.parent = parent or self
        self.root = self
        self._next_namespace = 0

    def get_fullname(self):
        '''Метод для получения полного имени пространства имен, включающего в
        себя имена всех родительских пространств имен.'''
        if self.parent is not self and self.parent.parent is not self.parent:
            return "{}.{}".format(self.parent.get_fullname(), self._name)
        else:
            return self._name

    def __getattr__(self, name):
        if name in self.childs:
            return self.childs[name]
        elif name in self.variables:
            return self.variables[name]
        else:
            raise VariableNotFoundError(
                _("Variable or namespace {varname} not found").format(
                                    varname="{}.{}".format(self.get_fullname(),
                                                           name)))

    def clear_childs(self):
        '''Метод для глубокой очистки пространства имен от всех дочерних
        пространств имен.'''
        for child in self.childs.values():
            child.clear_childs()
        self.childs = {}

    def __getitem__(self, name):
        return getattr(self, str(name))

    def __setitem__(self, name, value):
        return getattr(self, str(name)).set_value(value)

    def __iter__(self):
        # Сортировка: вначале числовые ключи потом прочие.
        def sortkey(x):
            k, v = x
            if k.isdigit():
                return (0, int(k), k)
            else:
                return (1, 0, k)
        for k, v in sorted(self.childs.items(), key=sortkey):
            yield v

    def __contains__(self, name):
        return name in self.childs or name in self.variables

    def add_string_variable(self, varname: str, value: str):
        '''Метод для добавления переменной с помощью строк.'''
        var = Variable(varname)
        var.value = value
        var.set_parent(self)
        self.variables[varname] = var

    def add_variable(self, variable: Variable):
        '''Метод для добавления переменной.'''
        self.variables[variable.name] = variable
        variable.set_parent(self)

    def _get_next_namespace_name(self):
        '''Метод для получения имени следующего по счету пространства имен.'''
        name = str(self._next_namespace)
        while name in self.childs:
            self._next_namespace += 1
            name = str(self._next_namespace)
        return name

    def add_namespace(self, namespace=None, name=None):
        '''Метод для добавления пространств имен.'''
        if name is None:
            if namespace is None:
                name = self._get_next_namespace_name()
            else:
                name = namespace._name

        if namespace is None:
            namespace = Namespace(name)

        self.childs[name] = namespace
        namespace.parent = self
        namespace.root = self.root

        return namespace


class HashVariable(Namespace):
    '''Класс переменных, представляющих собой словарь.'''
    BASE_CLASS = "HashVariable"

    class HashValue(Variable):
        BASE_CLASS = "HashValue"

        def __init__(self, name, master_variable):
            super().__init__(name)
            self.parent = None
            self.master_variable = master_variable

        def get_value(self, invalidate_sub=None):
            return self.master_variable.getHashValue(self.name, invalidate_sub)

        def set_value(self, value, force=False):
            return self.master_variable.setHashValue(self.name, value, force)

        def invalidate(self):
            self.master_variable.invalidate()

    class Data(Variable):
        BASE_CLASS = "Data"

        def getHashValue(self, name, invalidate_sub=None):
            return self.get_value(invalidate_sub)[name]

        def setHashValue(self, name, value, force):
            if name in self.readonly_vars and not force:
                raise VariableError(
                               _("Attempting to rewrite readonly variable {}").
                               format(name))
            data = self.get_value().copy()
            data[name] = value
            self.set_value(data, force)

    def get_value(self, invalidate_sub=None):
        return self.master_variable.get_value(invalidate_sub)

    hash_vars = []
    readonly_vars = []

    def __init__(self, name, parent=None, hash_vars=None):
        super().__init__(name)
        if hash_vars is not None:
            self.hash_vars = hash_vars

        self.parent = parent
        if not self.hash_vars:
            raise VariableError(
                _("Missed '{attrname}' attribute for hash variable {varname}").
                format(attrname="hash_vars", varname=self.get_fullname()))
        self.master_variable = self.Data(name)
        self.master_variable.set_parent(parent)
        self.master_variable.readonly_vars = self.readonly_vars
        for varname in self.hash_vars:
            var = self.HashValue(varname, self.master_variable)
            self.add_variable(var)

    def invalidate(self):
        self.master_variable.invalidate()


class TableVariable(Namespace):
    """
    Переменная представляет собой список словарей
    """
    BASE_CLASS = "TableVariable"

    class TableHashVariable(HashVariable):
        BASE_CLASS = "TableHashVariable"

        def __init__(self, name, parent=None, hash_vars=None,
                     master_variable=None, index=None):
            super().__init__(name, parent, hash_vars)
            self.master_variable._index = index

        class Data(HashVariable.Data):
            def getHashValue(self, name, invalidate_sub=None):
                return self.vars.master_variable.getTableValue(name,
                                                               self._index,
                                                               invalidate_sub)

            def setHashValue(self, name, value, force):
                self.vars.master_variable.setTableValue(name, self._index,
                                                        value, force)

    class Data(Variable):
        BASE_CLASS = "Data"

        def getTableValue(self, name, index, invalidate_sub=None):
            data = self.get_value(invalidate_sub)
            return data[index][name]

        def setTableValue(self, name, index, value, force):
            if name in self.readonly_vars and not force:
                raise VariableError(
                    _("Attempting to rewrite readonly variable {}").format(
                                                                         name))
            data = [x.copy() for x in self.get_value()]
            rowdata = data[index]
            rowdata[name] = value
            self.set_value(data, force)

    @property
    def childs(self):
        if self._childs is None:
            value = self.master_variable.get_value()
            self._childs = {}
            for i, row in enumerate(value):
                hashvar = self.TableHashVariable(self.master_variable.name,
                                                 self, self.hash_vars,
                                                 self.master_variable, i)
                self._childs[str(i)] = hashvar
        return self._childs

    @childs.setter
    def childs(self, value):
        self._childs = value

    def get_value(self, invalidate_sub=None):
        return self.master_variable.get_value(invalidate_sub)

    def set_value(self, value, force=False):
        self.master_variable.set_value(value, force)

    def invalidate(self):
        self.master_variable.invalidate()

    hash_vars = []
    readonly_vars = []

    def _drop_childs(self):
        self._childs = None
        self.master_variable.update_subscribe(self._drop_childs)

    def clear_childs(self):
        super().clear_childs()
        self._drop_childs()

    def __init__(self, name, parent=None):
        super().__init__(name)
        self._childs = None
        self.parent = parent
        if not self.hash_vars:
            raise VariableError(
               _("Missed '{attrname}' attribute for table variable {varname}").
               format(attrname="hash_vars",
                      varname=self.get_fullname()))
        self.master_variable = self.Data(name)
        self.master_variable.set_parent(parent)
        self.master_variable.readonly_vars = self.readonly_vars
        self.master_variable.update_subscribe(self._drop_childs)