calculate
/
calculate-utils-4-lib
6
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity

Some changes of the code design of the variables properies and some comments are added.

Browse Source
packages
Иванов Денис 4 years ago
parent f66b89f6b0
commit f879ea0ae2
8 changed files with 439 additions and 408 deletions
Show Stats Download Patch File Download Diff File

13
calculate/utils/files.py
Unescape View File

@ -10,15 +10,6 @@ import sys
import contextlib import contextlib
def listDirectory(dn, fullpath=False):
if path.exists(dn):
if fullpath:
return [path.join(dn, x) for x in os.listdir(dn)]
else:
return os.listdir(dn)
return []
class FilesError(Exception): class FilesError(Exception):
pass pass
@ -397,11 +388,11 @@ def quite_unlink(file_path):
pass pass
def list_directory(directory_path, full_path=False, only_dir=False): def list_directory(directory_path, fullpath=False, only_dir=False):
if not path.exists(directory_path): if not path.exists(directory_path):
return [] return []
try: try:
if full_path: if fullpath:
if only_dir: if only_dir:
return [node.path for node in os.scandir(directory_path) return [node.path for node in os.scandir(directory_path)
if os.path.isdir(node.path)] if os.path.isdir(node.path)]

177
calculate/vars/datavars.py
Unescape View File

@ -13,7 +13,7 @@ class BaseClass:
BASE_CLASS = "BaseClass" BASE_CLASS = "BaseClass"
@classmethod @classmethod
def isImplementation(cls, check_class): def is_implementation(cls, check_class):
'''Метод для проверки того, что класс является производным базового '''Метод для проверки того, что класс является производным базового
класса, а не самим базовым. Используется в автозагрузке переменных из класса, а не самим базовым. Используется в автозагрузке переменных из
модулей.''' модулей.'''
@ -42,16 +42,20 @@ class CyclicVariableError(VariableError):
class VariableProperty: class VariableProperty:
'''Базовый класс для объектов свойств.'''
def __init__(self, parent): def __init__(self, parent):
self.parent = parent self.parent = parent
class StringVariable(VariableProperty): class StringVariable(VariableProperty):
'''Класс свойства, соответствующий переменным просто хранящим строки как
значения.'''
pass pass
class ListVariable(VariableProperty): class ListVariable(VariableProperty):
def setValue(self, value, force=False): '''Класс свойства, соответствующий переменным хранящим списки значений.'''
def set_value(self, value, force=False):
if isinstance(value, (list, tuple)): if isinstance(value, (list, tuple)):
return value return value
elif isinstance(value, str): elif isinstance(value, str):
@ -66,7 +70,7 @@ class ListVariable(VariableProperty):
class ReadonlyVariable(VariableProperty): class ReadonlyVariable(VariableProperty):
def setValue(self, value, force=False): def set_value(self, value, force=False):
if not force: if not force:
raise VariableError( raise VariableError(
_("Attempting to rewrite readonly variable {}").format( _("Attempting to rewrite readonly variable {}").format(
@ -75,10 +79,10 @@ class ReadonlyVariable(VariableProperty):
class IntegerVariable(VariableProperty): class IntegerVariable(VariableProperty):
reMatch = re.compile(r"^-?\d+$") re_match = re.compile(r"^-?\d+$")
def check(self, value): def check(self, value):
if value and not self.reMatch.match(value): if value and not self.re_match.match(value):
raise VariableError( raise VariableError(
_("The value of variable '{varname}' must be integer").format( _("The value of variable '{varname}' must be integer").format(
varname=self.parent.name)) varname=self.parent.name))
@ -103,12 +107,12 @@ class ChoiceVariable(VariableProperty):
def choice(self): def choice(self):
if self.parent.__class__.choice == Variable.choice and \ if self.parent.__class__.choice == Variable.choice and \
self.parent.__class__.choiceComment == Variable.choiceComment: self.parent.__class__.choice_comment == Variable.choice_comment:
raise VariableError(_("Wrong choice variable {}").format( raise VariableError(_("Wrong choice variable {}").format(
self.parent.name)) self.parent.name))
return [x[0] for x in self.parent.choiceComment()] return [x[0] for x in self.parent.choice_comment()]
def choiceComment(self): def choice_comment(self):
return [(x, x) for x in self.parent.choice()] return [(x, x) for x in self.parent.choice()]
@ -117,7 +121,7 @@ class DefaultValue(VariableProperty):
self.value = value self.value = value
self.parent = None self.parent = None
def getValue(self, invalidate_subs=None): def get_value(self, invalidate_subs=None):
if self.parent._value is None: if self.parent._value is None:
self.parent._unsubscribe_depends() self.parent._unsubscribe_depends()
self.parent._value = self.value self.parent._value = self.value
@ -156,7 +160,8 @@ class Variable(BaseClass):
@property @property
def fullname(self): def fullname(self):
return "{}.{}".format(self.vars.getFullname(), self.name) '''Метод для получения полного имени переменной.'''
return "{}.{}".format(self.vars.get_fullname(), self.name)
def addProperty(self, prop): def addProperty(self, prop):
prop.parent = self prop.parent = self
@ -196,7 +201,7 @@ class Variable(BaseClass):
self.invalidate_subs = set() self.invalidate_subs = set()
self._emit_invalidate(slots) self._emit_invalidate(slots)
def setParent(self, namespace): def set_parent(self, namespace):
self.vars = namespace self.vars = namespace
@contextmanager @contextmanager
@ -207,8 +212,8 @@ class Variable(BaseClass):
finally: finally:
self.calculating = False self.calculating = False
def getValue(self, invalidate_sub=None): def get_value(self, invalidate_sub=None):
for f in self.callProperties("getValue"): for f in self.call_properties("get_value"):
f(invalidate_sub) f(invalidate_sub)
if self.calculating: if self.calculating:
raise CyclicVariableError(self.name) raise CyclicVariableError(self.name)
@ -227,21 +232,25 @@ class Variable(BaseClass):
return self.post_get(self._value) return self.post_get(self._value)
def post_get(self, value): def post_get(self, value):
for f in self.callProperties("post_get"): for f in self.call_properties("post_get"):
ret = f(value) ret = f(value)
if ret is not None: if ret is not None:
return ret return ret
return value return value
def callProperties(self, fname, *args): def call_properties(self, method_name, *args):
for prop in self._properties: '''Метод для вызова указанного метода у всех объектов, которыми владеет
f = getattr(prop, fname, None) переменная.'''
if f: for _property in self._properties:
yield f method = getattr(_property, method_name, None)
if method:
def setValue(self, value, force=False): yield method
for f in self.callProperties("setValue"):
value = f(value, force) def set_value(self, value, force=False):
'''Метод для установки некоторого заданного значения всем объектам,
принадлежащим переменной.'''
for setter in self.call_properties("set_value"):
value = setter(value, force)
value = self.set(value) value = self.set(value)
self.check(value) self.check(value)
self.invalidate() self.invalidate()
@ -249,26 +258,28 @@ class Variable(BaseClass):
self._unsubscribe_depends() self._unsubscribe_depends()
def check(self, value): def check(self, value):
'''Метод для проверки значения устанавливаемого значения.''' '''Метод для проверки корректности устанавливаемого значения путем
for f in self.callProperties("check"): вызова проверочных методов всех объектов, которыми владеет переменная.
f(value) '''
for checker in self.call_properties("check"):
checker(value)
def get(self): def get(self):
'''Метод для заполнения переменной.''' '''Метод для заполнения переменной.'''
return self.value return self.value
def getCommentValue(self, invalidate_sub=None): def get_comment_value(self, invalidate_sub=None):
'''Этот метод вызывается внутри методов get.''' '''Этот метод вызывается внутри методов get.'''
val = self.getComment() val = self.get_comment()
if invalidate_sub is not None: if invalidate_sub is not None:
self.update_subscribe(invalidate_sub) self.update_subscribe(invalidate_sub)
return val return val
def getComment(self): def get_comment(self):
'''Комментарий к значению.''' '''Метод для установки .'''
for f in self.callProperties("getComment"): for f in self.call_properties("get_comment"):
return f() return f()
return self.getValue() return self.get_value()
def set(self, value): def set(self, value):
'''Метод для модификации переменной.''' '''Метод для модификации переменной.'''
@ -276,12 +287,12 @@ class Variable(BaseClass):
def choice(self): def choice(self):
'''Метод возвращет список доступных значений для переменной.''' '''Метод возвращет список доступных значений для переменной.'''
for f in self.callProperties("choice"): for f in self.call_properties("choice"):
return f() return f()
return [] return []
def choiceComment(self): def choice_comment(self):
for f in self.callProperties("choiceComment"): for f in self.call_properties("choice_comment"):
return f() return f()
return [] return []
@ -291,6 +302,7 @@ class NamespaceError(Exception):
class Namespace(BaseClass): class Namespace(BaseClass):
'''Класс пространства имен.'''
BASE_CLASS = "Namespace" BASE_CLASS = "Namespace"
def __init__(self, name="", parent=None): def __init__(self, name="", parent=None):
@ -299,11 +311,13 @@ class Namespace(BaseClass):
self.childs = {} self.childs = {}
self.parent = parent or self self.parent = parent or self
self.root = self self.root = self
self._nextns = 0 self._next_namespace = 0
def getFullname(self): def get_fullname(self):
'''Метод для получения полного имени пространства имен, включающего в
себя имена всех родительских пространств имен.'''
if self.parent is not self and self.parent.parent is not self.parent: if self.parent is not self and self.parent.parent is not self.parent:
return "{}.{}".format(self.parent.getFullname(), self._name) return "{}.{}".format(self.parent.get_fullname(), self._name)
else: else:
return self._name return self._name
@ -315,22 +329,24 @@ class Namespace(BaseClass):
else: else:
raise VariableNotFoundError( raise VariableNotFoundError(
_("Variable or namespace {varname} not found").format( _("Variable or namespace {varname} not found").format(
varname="{}.{}".format(self.getFullname(), varname="{}.{}".format(self.get_fullname(),
name))) name)))
def clearChilds(self): def clear_childs(self):
'''Метод для глубокой очистки пространства имен от всех дочерних
пространств имен.'''
for child in self.childs.values(): for child in self.childs.values():
child.clearChilds() child.clear_childs()
self.childs = {} self.childs = {}
def __getitem__(self, name): def __getitem__(self, name):
return getattr(self, str(name)) return getattr(self, str(name))
def __setitem__(self, name, value): def __setitem__(self, name, value):
return getattr(self, str(name)).setValue(value) return getattr(self, str(name)).set_value(value)
def __iter__(self): def __iter__(self):
'''Сортировка: вначале числовые ключи потом прочие.''' # Сортировка: вначале числовые ключи потом прочие.
def sortkey(x): def sortkey(x):
k, v = x k, v = x
if k.isdigit(): if k.isdigit():
@ -343,39 +359,46 @@ class Namespace(BaseClass):
def __contains__(self, name): def __contains__(self, name):
return name in self.childs or name in self.variables return name in self.childs or name in self.variables
def addStringVariable(self, varname, value): def add_string_variable(self, varname: str, value: str):
'''Метод для добавления переменной с помощью строк.'''
var = Variable(varname) var = Variable(varname)
var.value = value var.value = value
var.setParent(self) var.set_parent(self)
self.variables[varname] = var self.variables[varname] = var
def addVariable(self, variable): def add_variable(self, variable: Variable):
'''Метод для добавления переменной.'''
self.variables[variable.name] = variable self.variables[variable.name] = variable
variable.setParent(self) variable.set_parent(self)
def _getNextNamespaceName(self): def _get_next_namespace_name(self):
name = str(self._nextns) '''Метод для получения имени следующего по счету пространства имен.'''
name = str(self._next_namespace)
while name in self.childs: while name in self.childs:
self._nextns += 1 self._next_namespace += 1
name = str(self._nextns) name = str(self._next_namespace)
return name return name
def addNamespace(self, namespace=None, name=None): def add_namespace(self, namespace=None, name=None):
'''Метод для добавления пространств имен.'''
if name is None: if name is None:
if namespace is None: if namespace is None:
name = self._getNextNamespaceName() name = self._get_next_namespace_name()
else: else:
name = namespace._name name = namespace._name
if namespace is None: if namespace is None:
namespace = Namespace(name) namespace = Namespace(name)
self.childs[name] = namespace self.childs[name] = namespace
namespace.parent = self namespace.parent = self
namespace.root = self.root namespace.root = self.root
return namespace return namespace
class HashVariable(Namespace): class HashVariable(Namespace):
"""Классс переменных представляющих собой словарь.""" '''Класс переменных, представляющих собой словарь.'''
BASE_CLASS = "HashVariable" BASE_CLASS = "HashVariable"
class HashValue(Variable): class HashValue(Variable):
@ -386,10 +409,10 @@ class HashVariable(Namespace):
self.parent = None self.parent = None
self.master_variable = master_variable self.master_variable = master_variable
def getValue(self, invalidate_sub=None): def get_value(self, invalidate_sub=None):
return self.master_variable.getHashValue(self.name, invalidate_sub) return self.master_variable.getHashValue(self.name, invalidate_sub)
def setValue(self, value, force=False): def set_value(self, value, force=False):
return self.master_variable.setHashValue(self.name, value, force) return self.master_variable.setHashValue(self.name, value, force)
def invalidate(self): def invalidate(self):
@ -399,19 +422,19 @@ class HashVariable(Namespace):
BASE_CLASS = "Data" BASE_CLASS = "Data"
def getHashValue(self, name, invalidate_sub=None): def getHashValue(self, name, invalidate_sub=None):
return self.getValue(invalidate_sub)[name] return self.get_value(invalidate_sub)[name]
def setHashValue(self, name, value, force): def setHashValue(self, name, value, force):
if name in self.readonly_vars and not force: if name in self.readonly_vars and not force:
raise VariableError( raise VariableError(
_("Attempting to rewrite readonly variable {}"). _("Attempting to rewrite readonly variable {}").
format(name)) format(name))
data = self.getValue().copy() data = self.get_value().copy()
data[name] = value data[name] = value
self.setValue(data, force) self.set_value(data, force)
def getValue(self, invalidate_sub=None): def get_value(self, invalidate_sub=None):
return self.master_variable.getValue(invalidate_sub) return self.master_variable.get_value(invalidate_sub)
hash_vars = [] hash_vars = []
readonly_vars = [] readonly_vars = []
@ -425,13 +448,13 @@ class HashVariable(Namespace):
if not self.hash_vars: if not self.hash_vars:
raise VariableError( raise VariableError(
_("Missed '{attrname}' attribute for hash variable {varname}"). _("Missed '{attrname}' attribute for hash variable {varname}").
format(attrname="hash_vars", varname=self.getFullname())) format(attrname="hash_vars", varname=self.get_fullname()))
self.master_variable = self.Data(name) self.master_variable = self.Data(name)
self.master_variable.setParent(parent) self.master_variable.set_parent(parent)
self.master_variable.readonly_vars = self.readonly_vars self.master_variable.readonly_vars = self.readonly_vars
for varname in self.hash_vars: for varname in self.hash_vars:
var = self.HashValue(varname, self.master_variable) var = self.HashValue(varname, self.master_variable)
self.addVariable(var) self.add_variable(var)
def invalidate(self): def invalidate(self):
self.master_variable.invalidate() self.master_variable.invalidate()
@ -465,7 +488,7 @@ class TableVariable(Namespace):
BASE_CLASS = "Data" BASE_CLASS = "Data"
def getTableValue(self, name, index, invalidate_sub=None): def getTableValue(self, name, index, invalidate_sub=None):
data = self.getValue(invalidate_sub) data = self.get_value(invalidate_sub)
return data[index][name] return data[index][name]
def setTableValue(self, name, index, value, force): def setTableValue(self, name, index, value, force):
@ -473,15 +496,15 @@ class TableVariable(Namespace):
raise VariableError( raise VariableError(
_("Attempting to rewrite readonly variable {}").format( _("Attempting to rewrite readonly variable {}").format(
name)) name))
data = [x.copy() for x in self.getValue()] data = [x.copy() for x in self.get_value()]
rowdata = data[index] rowdata = data[index]
rowdata[name] = value rowdata[name] = value
self.setValue(data, force) self.set_value(data, force)
@property @property
def childs(self): def childs(self):
if self._childs is None: if self._childs is None:
value = self.master_variable.getValue() value = self.master_variable.get_value()
self._childs = {} self._childs = {}
for i, row in enumerate(value): for i, row in enumerate(value):
hashvar = self.TableHashVariable(self.master_variable.name, hashvar = self.TableHashVariable(self.master_variable.name,
@ -494,11 +517,11 @@ class TableVariable(Namespace):
def childs(self, value): def childs(self, value):
self._childs = value self._childs = value
def getValue(self, invalidate_sub=None): def get_value(self, invalidate_sub=None):
return self.master_variable.getValue(invalidate_sub) return self.master_variable.get_value(invalidate_sub)
def setValue(self, value, force=False): def set_value(self, value, force=False):
self.master_variable.setValue(value, force) self.master_variable.set_value(value, force)
def invalidate(self): def invalidate(self):
self.master_variable.invalidate() self.master_variable.invalidate()
@ -510,8 +533,8 @@ class TableVariable(Namespace):
self._childs = None self._childs = None
self.master_variable.update_subscribe(self._drop_childs) self.master_variable.update_subscribe(self._drop_childs)
def clearChilds(self): def clear_childs(self):
super().clearChilds() super().clear_childs()
self._drop_childs() self._drop_childs()
def __init__(self, name, parent=None): def __init__(self, name, parent=None):
@ -522,8 +545,8 @@ class TableVariable(Namespace):
raise VariableError( raise VariableError(
_("Missed '{attrname}' attribute for table variable {varname}"). _("Missed '{attrname}' attribute for table variable {varname}").
format(attrname="hash_vars", format(attrname="hash_vars",
varname=self.getFullname())) varname=self.get_fullname()))
self.master_variable = self.Data(name) self.master_variable = self.Data(name)
self.master_variable.setParent(parent) self.master_variable.set_parent(parent)
self.master_variable.readonly_vars = self.readonly_vars self.master_variable.readonly_vars = self.readonly_vars
self.master_variable.update_subscribe(self._drop_childs) self.master_variable.update_subscribe(self._drop_childs)

80
calculate/vars/vars_loader.py
Unescape View File

@ -9,7 +9,7 @@ from calculate.vars.datavars import Variable, Namespace, HashVariable,\
TableVariable, IniCreated, DefaultValue TableVariable, IniCreated, DefaultValue
from calculate.utils.gentoo import ProfileWalker from calculate.utils.gentoo import ProfileWalker
from calculate.utils.fs import readFile from calculate.utils.fs import readFile
from calculate.utils.files import listDirectory from calculate.utils.files import list_directory
class NamespaceIniFiller(CalculateIniParser): class NamespaceIniFiller(CalculateIniParser):
@ -28,7 +28,7 @@ class NamespaceIniFiller(CalculateIniParser):
self.curns = self.ns self.curns = self.ns
for section in sections: for section in sections:
if section not in self.curns.childs: if section not in self.curns.childs:
self.curns.addNamespace(Namespace(section)) self.curns.add_namespace(Namespace(section))
self.curns = self.curns[section] self.curns = self.curns[section]
def clear_section(self, sections): def clear_section(self, sections):
@ -37,16 +37,16 @@ class NamespaceIniFiller(CalculateIniParser):
if section not in curns.childs: if section not in curns.childs:
return return
curns = curns[section] curns = curns[section]
curns.clearChilds() curns.clear_childs()
def change_value(self, key, value): def change_value(self, key, value):
self.curns[key].setValue(value) self.curns[key].set_value(value)
def define_variable(self, key, value): def define_variable(self, key, value):
self.curns.addStringVariable(key, value) self.curns.add_string_variable(key, value)
def append_value(self, key, value): def append_value(self, key, value):
l = self.curns[key].getValue().split(",") l = self.curns[key].get_value().split(",")
vlist = value.split(",") vlist = value.split(",")
for v in vlist: for v in vlist:
if v not in l: if v not in l:
@ -54,7 +54,7 @@ class NamespaceIniFiller(CalculateIniParser):
self.change_value(key, ",".join(l)) self.change_value(key, ",".join(l))
def remove_value(self, key, value): def remove_value(self, key, value):
l = self.curns[key].getValue().split(",") l = self.curns[key].get_value().split(",")
vlist = value.split(",") vlist = value.split(",")
for v in vlist: for v in vlist:
if v in l: if v in l:
@ -94,7 +94,7 @@ class NamespaceIniFillerStrict(NamespaceIniFiller):
self.canCreate = False self.canCreate = False
for newns in self.availableSection: for newns in self.availableSection:
if newns not in ns: if newns not in ns:
ns.addNamespace(Namespace(newns)) ns.add_namespace(Namespace(newns))
super().fill(ns, data) super().fill(ns, data)
def start_section(self, sections): def start_section(self, sections):
@ -103,34 +103,34 @@ class NamespaceIniFillerStrict(NamespaceIniFiller):
for section in sections: for section in sections:
if section not in self.curns.childs: if section not in self.curns.childs:
if isinstance(self.curns, TableVariable) or self.canCreate: if isinstance(self.curns, TableVariable) or self.canCreate:
self.curns.addNamespace(Namespace(section)) self.curns.add_namespace(Namespace(section))
else: else:
self.curns = None self.curns = None
self.curns = self.curns[section] self.curns = self.curns[section]
#def clear_section(self, sections): # def clear_section(self, sections):
# curns = self.ns # curns = self.ns
# self.canCreate = sections[0] in self.availableSection # self.canCreate = sections[0] in self.availableSection
# for section in sections: # for section in sections:
# if section not in curns.childs: # if section not in curns.childs:
# return # return
# curns = curns[section] # curns = curns[section]
# curns.clearChilds() # curns.clear_childs()
def define_variable(self, key, value): def define_variable(self, key, value):
if not self.canCreate: if not self.canCreate:
pass pass
var = Variable(key) var = Variable(key)
var.addProperty(IniCreated(value)) var.addProperty(IniCreated(value))
self.curns.addVariable(var) self.curns.add_variable(var)
def change_value(self, key, value): def change_value(self, key, value):
var = self.curns[key] var = self.curns[key]
var.setValue(value) var.set_value(value)
if isinstance(var, HashVariable.HashValue): if isinstance(var, HashVariable.HashValue):
var = var.master_variable var = var.master_variable
value = var.getValue() value = var.get_value()
prop = var.findProperty(DefaultValue) prop = var.findProperty(DefaultValue)
if prop: if prop:
@ -141,40 +141,34 @@ class NamespaceIniFillerStrict(NamespaceIniFiller):
class VariableLoader: class VariableLoader:
""" '''Класс, используемый для загрузки переменных из python модуля.'''
Объект используемый для загрузки переменных из python модуля re_upper = re.compile("(.)([A-Z])")
"""
reUpper = re.compile("(.)([A-Z])")
def _get_varlike_attrs(self, obj): def _get_varlike_attrs(self, obj):
""" '''Метод для получения списка аттрибутов похожих на переменные.'''
Получить список аттрибутов похожих на переменные
"""
for attrname in (x for x in dir(obj) if x[:1].isupper()): for attrname in (x for x in dir(obj) if x[:1].isupper()):
yield self.reUpper.sub(r"\1_\2", attrname).lower(), \ yield self.re_upper.sub(r"\1_\2", attrname).lower(), \
getattr(obj, attrname) getattr(obj, attrname)
def fill(self, ns, dirpath, package): def fill(self, ns, dirpath, package):
""" '''Загрузить в namespace переменные из указанных модулей.'''
Загрузить в namespace переменные из указанных модулей for fullfn in list_directory(dirpath, fullpath=True):
"""
for fullfn in listDirectory(dirpath, fullpath=True):
dn, fn = os.path.split(fullfn) dn, fn = os.path.split(fullfn)
if os.path.isdir(fullfn): if os.path.isdir(fullfn):
newns = ns.addNamespace(Namespace(fn)) newns = ns.add_namespace(Namespace(fn))
self.fill(newns, fullfn, "%s.%s"%(package,fn)) self.fill(newns, fullfn, "{}.{}".format(package, fn))
elif fn.endswith(".py"): elif fn.endswith(".py"):
module = self._load_module_source(package, fn, fullfn) module = self._load_module_source(package, fn, fullfn)
for varname, cls in self._get_varlike_attrs(module): for varname, cls in self._get_varlike_attrs(module):
if Variable.isImplementation(cls): if Variable.is_implementation(cls):
ns.addVariable(cls(varname)) ns.add_variable(cls(varname))
elif HashVariable.isImplementation(cls) or \ elif HashVariable.is_implementation(cls) or \
TableVariable.isImplementation(cls) or \ TableVariable.is_implementation(cls) or \
Namespace.isImplementation(cls): Namespace.is_implementation(cls):
_newns = ns.addNamespace(cls(varname,ns)) _newns = ns.add_namespace(cls(varname, ns))
for _varname, _cls in self._get_varlike_attrs(cls): for _varname, _cls in self._get_varlike_attrs(cls):
if Variable.isImplementation(_cls): if Variable.is_implementation(_cls):
_newns.addVariable(_cls(_varname)) _newns.add_variable(_cls(_varname))
@classmethod @classmethod
def default(cls): def default(cls):
@ -207,7 +201,7 @@ class ProfileFiller:
basename = "calculate.ini" basename = "calculate.ini"
def get_repository_map(self, ns): def get_repository_map(self, ns):
return { return {
x.name.getValue(): x.path.getValue() x.name.get_value(): x.path.get_value()
for x in ns.os.gentoo.repositories for x in ns.os.gentoo.repositories
} }

496
tests/vars/test_namespace.py
Unescape View File

@ -19,20 +19,20 @@ class TestNamespace:
def test_create_variable(self): def test_create_variable(self):
ns = Namespace() ns = Namespace()
ns.addStringVariable("test", "12345") ns.add_string_variable("test", "12345")
assert ns.test.getValue() == "12345" assert ns.test.get_value() == "12345"
ns.addStringVariable("zxcv", "23456") ns.add_string_variable("zxcv", "23456")
assert ns.zxcv.getValue() == "23456" assert ns.zxcv.get_value() == "23456"
def test_create_ns_with_vars(self): def test_create_ns_with_vars(self):
ns = Namespace() ns = Namespace()
ns.addNamespace(Namespace("os")) ns.add_namespace(Namespace("os"))
ns.os.addStringVariable("test", "123") ns.os.add_string_variable("test", "123")
ns.os.addNamespace(Namespace("linux")) ns.os.add_namespace(Namespace("linux"))
ns.os.linux.addStringVariable("shortname", "CLD") ns.os.linux.add_string_variable("shortname", "CLD")
assert ns.os.test.getValue() == "123" assert ns.os.test.get_value() == "123"
assert ns.os["test"].getValue() == "123" assert ns.os["test"].get_value() == "123"
assert ns.os.linux.shortname.getValue() == "CLD" assert ns.os.linux.shortname.get_value() == "CLD"
assert ns.os.root == ns assert ns.os.root == ns
def test_fill_namespace_simple(self): def test_fill_namespace_simple(self):
@ -47,9 +47,9 @@ class TestNamespace:
fullname = Calculate Linux Desktop fullname = Calculate Linux Desktop
""") """)
assert ns.os.test.getValue() == "123" assert ns.os.test.get_value() == "123"
assert ns.os.linux.shortname.getValue() == "CLD" assert ns.os.linux.shortname.get_value() == "CLD"
assert ns.os.linux.fullname.getValue() == "Calculate Linux Desktop" assert ns.os.linux.fullname.get_value() == "Calculate Linux Desktop"
assert ns.os.linux.root == ns assert ns.os.linux.root == ns
nsif.fill(ns, """ nsif.fill(ns, """
@ -57,8 +57,8 @@ class TestNamespace:
shortname = CLDX shortname = CLDX
""") """)
assert ns.os.linux.shortname.getValue() == "CLDX" assert ns.os.linux.shortname.get_value() == "CLDX"
assert ns.os.linux.fullname.getValue() == "Calculate Linux Desktop" assert ns.os.linux.fullname.get_value() == "Calculate Linux Desktop"
def test_fill_namespace_append_and_remove(self): def test_fill_namespace_append_and_remove(self):
ns = Namespace() ns = Namespace()
@ -71,28 +71,28 @@ class TestNamespace:
test += 345 test += 345
""") """)
assert ns.os.test.getValue() == "123,345" assert ns.os.test.get_value() == "123,345"
nsif.fill(ns, """ nsif.fill(ns, """
[os] [os]
test -= 123 test -= 123
""") """)
assert ns.os.test.getValue() == "345" assert ns.os.test.get_value() == "345"
nsif.fill(ns, """ nsif.fill(ns, """
[os] [os]
test += asdf,qwer,zxcv test += asdf,qwer,zxcv
""") """)
assert ns.os.test.getValue() == "345,asdf,qwer,zxcv" assert ns.os.test.get_value() == "345,asdf,qwer,zxcv"
nsif.fill(ns, """ nsif.fill(ns, """
[os] [os]
test -= asdf,zxcv test -= asdf,zxcv
""") """)
assert ns.os.test.getValue() == "345,qwer" assert ns.os.test.get_value() == "345,qwer"
def test_fill_namespace_clear_namespaces(self): def test_fill_namespace_clear_namespaces(self):
ns = Namespace() ns = Namespace()
@ -111,9 +111,9 @@ class TestNamespace:
mount = /var/calculate mount = /var/calculate
""") """)
assert [x.dev.getValue() for x in ns.test] == ['/dev/sda1', assert [x.dev.get_value() for x in ns.test] == ['/dev/sda1',
'/dev/sda2', '/dev/sda2',
'/dev/sda5'] '/dev/sda5']
nsif.fill(ns, """ nsif.fill(ns, """
[test][0] [test][0]
@ -125,9 +125,9 @@ class TestNamespace:
mount = / mount = /
""") """)
assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1', assert [x.dev.get_value() for x in ns.test] == ['/dev/sdb1',
'/dev/sdb2', '/dev/sdb2',
'/dev/sda5'] '/dev/sda5']
nsif.fill(ns, """ nsif.fill(ns, """
[test][] [test][]
@ -141,8 +141,8 @@ class TestNamespace:
mount = / mount = /
""") """)
assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1', assert [x.dev.get_value() for x in ns.test] == ['/dev/sdb1',
'/dev/sdb2'] '/dev/sdb2']
def test_fill_namespace_strict_clear(self): def test_fill_namespace_strict_clear(self):
ns = Namespace() ns = Namespace()
@ -167,8 +167,8 @@ class TestNamespace:
zxcv = 2 zxcv = 2
""") """)
assert ns.custom.test.zxcv.getValue() == "1" assert ns.custom.test.zxcv.get_value() == "1"
assert ns.custom.test2.zxcv.getValue() == "2" assert ns.custom.test2.zxcv.get_value() == "2"
nsifs = NamespaceIniFillerStrict() nsifs = NamespaceIniFillerStrict()
nsifs.fill(ns, """ nsifs.fill(ns, """
@ -182,16 +182,16 @@ class TestNamespace:
def test_get_namespace_attrs(self): def test_get_namespace_attrs(self):
ns = Namespace() ns = Namespace()
os = Namespace("os") os = Namespace("os")
os.addStringVariable("test", "zxcv") os.add_string_variable("test", "zxcv")
ns.addNamespace(os) ns.add_namespace(os)
assert ns.os.test.getValue() == "zxcv" assert ns.os.test.get_value() == "zxcv"
assert ns.os["test"].getValue() == "zxcv" assert ns.os["test"].get_value() == "zxcv"
assert "test" in ns.os assert "test" in ns.os
ns.os.test.setValue("123") ns.os.test.set_value("123")
assert ns.os.test.getValue() == "123" assert ns.os.test.get_value() == "123"
ns.os["test"].setValue("234") ns.os["test"].set_value("234")
assert ns.os.test.getValue() == "234" assert ns.os.test.get_value() == "234"
def test_variable_get_value(self): def test_variable_get_value(self):
class TestVar(Variable): class TestVar(Variable):
@ -200,62 +200,62 @@ class TestNamespace:
var = TestVar("test") var = TestVar("test")
assert var.getValue() == "A" assert var.get_value() == "A"
def test_namespace_lookup(self): def test_namespace_lookup(self):
ns = Namespace() ns = Namespace()
os = Namespace("os") os = Namespace("os")
device = Namespace("device") device = Namespace("device")
linux = Namespace("linux") linux = Namespace("linux")
ns.addNamespace(os) ns.add_namespace(os)
os.addNamespace(linux) os.add_namespace(linux)
os.addNamespace(device) os.add_namespace(device)
device1 = device.addNamespace() device1 = device.add_namespace()
device1.addStringVariable("dev", "/dev/sda") device1.add_string_variable("dev", "/dev/sda")
device2 = device.addNamespace() device2 = device.add_namespace()
device2.addStringVariable("dev", "/dev/sdb") device2.add_string_variable("dev", "/dev/sdb")
device3 = device.addNamespace() device3 = device.add_namespace()
device3.addStringVariable("dev", "/dev/sdc") device3.add_string_variable("dev", "/dev/sdc")
ns.addStringVariable("first", "first") ns.add_string_variable("first", "first")
os.addStringVariable("second", "second") os.add_string_variable("second", "second")
linux.addStringVariable("third", "third") linux.add_string_variable("third", "third")
assert ns.first.getValue() == "first" assert ns.first.get_value() == "first"
assert ns.root.os.second.getValue() == "second" assert ns.root.os.second.get_value() == "second"
assert ns.os.second.getValue() == "second" assert ns.os.second.get_value() == "second"
assert os.root.os.second.getValue() == "second" assert os.root.os.second.get_value() == "second"
assert os.second.getValue() == "second" assert os.second.get_value() == "second"
assert linux.third.getValue() == "third" assert linux.third.get_value() == "third"
assert linux.root.os.second.getValue() == "second" assert linux.root.os.second.get_value() == "second"
with pytest.raises(VariableNotFoundError): with pytest.raises(VariableNotFoundError):
os.third os.third
assert ns.os.device[0].dev.getValue() == "/dev/sda" assert ns.os.device[0].dev.get_value() == "/dev/sda"
assert ns.os.device["0"].dev.getValue() == "/dev/sda" assert ns.os.device["0"].dev.get_value() == "/dev/sda"
assert ns.os.device[1].dev.getValue() == "/dev/sdb" assert ns.os.device[1].dev.get_value() == "/dev/sdb"
assert ns.os.device[2].dev.getValue() == "/dev/sdc" assert ns.os.device[2].dev.get_value() == "/dev/sdc"
assert ns.os.device.parent.second.getValue() == "second" assert ns.os.device.parent.second.get_value() == "second"
assert ns.os.device.parent.parent.os.second.getValue() == "second" assert ns.os.device.parent.parent.os.second.get_value() == "second"
assert ns.os.device.parent.parent.parent.os.second.\ assert ns.os.device.parent.parent.parent.os.second.\
getValue() == "second" get_value() == "second"
def test_variable_get_value_by_variable(self): def test_variable_get_value_by_variable(self):
class TestVar1(Variable): class TestVar1(Variable):
def get(self): def get(self):
return "%s,B" % self.vars.test2.getValue(self) return "%s,B" % self.vars.test2.get_value(self)
class TestVar2(Variable): class TestVar2(Variable):
def get(self): def get(self):
return "A" return "A"
ns = Namespace() ns = Namespace()
ns.addVariable(TestVar1("test1")) ns.add_variable(TestVar1("test1"))
ns.addVariable(TestVar2("test2")) ns.add_variable(TestVar2("test2"))
assert ns.test1.getValue() == "A,B" assert ns.test1.get_value() == "A,B"
def test_variable_get_value_by_changed_variable(self): def test_variable_get_value_by_changed_variable(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -263,59 +263,59 @@ class TestNamespace:
def get(self): def get(self):
self.counter += 1 self.counter += 1
return "%s,B" % self.vars.test2.getValue(self) return "%s,B" % self.vars.test2.get_value(self)
ns = Namespace() ns = Namespace()
test1 = TestVar1("test1") test1 = TestVar1("test1")
ns.addVariable(test1) ns.add_variable(test1)
ns.addStringVariable("test2", "A") ns.add_string_variable("test2", "A")
assert ns.test1.getValue() == "A,B" assert ns.test1.get_value() == "A,B"
assert test1.counter == 1 assert test1.counter == 1
# test for get cached variable value # test for get cached variable value
assert ns.test1.getValue() == "A,B" assert ns.test1.get_value() == "A,B"
assert test1.counter == 1 assert test1.counter == 1
# change value of test2 for recalculate test1 # change value of test2 for recalculate test1
ns.test2.setValue("C") ns.test2.set_value("C")
assert ns.test1.getValue() == "C,B" assert ns.test1.get_value() == "C,B"
assert test1.counter == 2 assert test1.counter == 2
# change value of test2 for recalculate test1 # change value of test2 for recalculate test1
ns.test2.setValue("D") ns.test2.set_value("D")
assert ns.test1.getValue() == "D,B" assert ns.test1.get_value() == "D,B"
assert test1.counter == 3 assert test1.counter == 3
def test_cyclic_variable(self): def test_cyclic_variable(self):
class TestVar1(Variable): class TestVar1(Variable):
def get(self): def get(self):
return "%s,test1" % self.vars.test2.getValue(self) return "%s,test1" % self.vars.test2.get_value(self)
class TestVar2(Variable): class TestVar2(Variable):
def get(self): def get(self):
return "%s,test2" % self.vars.test3.getValue(self) return "%s,test2" % self.vars.test3.get_value(self)
class TestVar3(Variable): class TestVar3(Variable):
def get(self): def get(self):
return "%s,test3" % self.vars.test1.getValue(self) return "%s,test3" % self.vars.test1.get_value(self)
test1 = TestVar1("test1") test1 = TestVar1("test1")
test2 = TestVar2("test2") test2 = TestVar2("test2")
test3 = TestVar3("test3") test3 = TestVar3("test3")
ns = Namespace() ns = Namespace()
ns.addVariable(test1) ns.add_variable(test1)
ns.addVariable(test2) ns.add_variable(test2)
ns.addVariable(test3) ns.add_variable(test3)
with pytest.raises(CyclicVariableError) as e: with pytest.raises(CyclicVariableError) as e:
ns.test1.getValue() ns.test1.get_value()
assert e.value.queue[:-1] == ("test1", "test2", "test3") assert e.value.queue[:-1] == ("test1", "test2", "test3")
with pytest.raises(VariableError) as e: with pytest.raises(VariableError) as e:
ns.test1.getValue() ns.test1.get_value()
def test_drop_invalidate_after_set_value(self): def test_drop_invalidate_after_set_value(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -323,7 +323,7 @@ class TestNamespace:
def get(self): def get(self):
self.counter += 1 self.counter += 1
return "%s,test1" % self.vars.test2.getValue(self) return "%s,test1" % self.vars.test2.get_value(self)
class TestVar2(Variable): class TestVar2(Variable):
def get(self): def get(self):
@ -332,24 +332,24 @@ class TestNamespace:
test1 = TestVar1("test1") test1 = TestVar1("test1")
test2 = TestVar2("test2") test2 = TestVar2("test2")
ns = Namespace() ns = Namespace()
ns.addVariable(test1) ns.add_variable(test1)
ns.addVariable(test2) ns.add_variable(test2)
assert test1.getValue() == "ZZZZ,test1" assert test1.get_value() == "ZZZZ,test1"
test1.setValue("VVVV") test1.set_value("VVVV")
assert test1.getValue() == "VVVV" assert test1.get_value() == "VVVV"
assert test1.counter == 1 assert test1.counter == 1
test2.setValue("XXXX") test2.set_value("XXXX")
assert test1.getValue() == "VVVV" assert test1.get_value() == "VVVV"
assert test1.counter == 1 assert test1.counter == 1
test1.invalidate() test1.invalidate()
assert test1.getValue() == "XXXX,test1" assert test1.get_value() == "XXXX,test1"
assert test1.counter == 2 assert test1.counter == 2
def test_change_invalidator_variable(self): def test_change_invalidator_variable(self):
@ -359,31 +359,31 @@ class TestNamespace:
def get(self): def get(self):
self.counter += 1 self.counter += 1
if self.vars.ifvar.getValue(self): if self.vars.ifvar.get_value(self):
return "%s,test1" % self.vars.vara.getValue(self) return "%s,test1" % self.vars.vara.get_value(self)
else: else:
return "%s,test1" % self.vars.varb.getValue(self) return "%s,test1" % self.vars.varb.get_value(self)
vartest = VarTest("vartest") vartest = VarTest("vartest")
ns = Namespace() ns = Namespace()
ns.addVariable(vartest) ns.add_variable(vartest)
ns.addStringVariable("vara", "vara") ns.add_string_variable("vara", "vara")
ns.addStringVariable("varb", "varb") ns.add_string_variable("varb", "varb")
ns.addStringVariable("ifvar", "true") ns.add_string_variable("ifvar", "true")
assert vartest.getValue() == "vara,test1" assert vartest.get_value() == "vara,test1"
assert vartest.counter == 1 assert vartest.counter == 1
ns.vara.setValue("varc") ns.vara.set_value("varc")
assert vartest.getValue() == "varc,test1" assert vartest.get_value() == "varc,test1"
assert vartest.counter == 2 assert vartest.counter == 2
ns.ifvar.setValue("") ns.ifvar.set_value("")
assert vartest.getValue() == "varb,test1" assert vartest.get_value() == "varb,test1"
assert vartest.counter == 3 assert vartest.counter == 3
ns.vara.setValue("vard") ns.vara.set_value("vard")
assert vartest.getValue() == "varb,test1" assert vartest.get_value() == "varb,test1"
assert vartest.counter == 3 assert vartest.counter == 3
def test_readonly_varaible(self): def test_readonly_varaible(self):
@ -394,14 +394,14 @@ class TestNamespace:
return "test1" return "test1"
test1 = TestVar1("test1") test1 = TestVar1("test1")
assert test1.getValue() == "test1" assert test1.get_value() == "test1"
with pytest.raises(VariableError): with pytest.raises(VariableError):
test1.setValue("test2") test1.set_value("test2")
assert test1.getValue() == "test1" assert test1.get_value() == "test1"
test1.setValue("test2", force=True) test1.set_value("test2", force=True)
assert test1.getValue() == "test2" assert test1.get_value() == "test2"
def test_choice_variable(self): def test_choice_variable(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -412,9 +412,9 @@ class TestNamespace:
test1 = TestVar1("test1") test1 = TestVar1("test1")
with pytest.raises(VariableError): with pytest.raises(VariableError):
test1.setValue("test3") test1.set_value("test3")
test1.setValue("test2") test1.set_value("test2")
assert test1.getValue() == "test2" assert test1.get_value() == "test2"
def test_integer_variable(self): def test_integer_variable(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -422,11 +422,11 @@ class TestNamespace:
test1 = TestVar1("test1") test1 = TestVar1("test1")
with pytest.raises(VariableError): with pytest.raises(VariableError):
test1.setValue("test3") test1.set_value("test3")
test1.setValue("33") test1.set_value("33")
assert test1.getValue() == 33 assert test1.get_value() == 33
test1.setValue("-33") test1.set_value("-33")
assert test1.getValue() == -33 assert test1.get_value() == -33
def test_default_value_property(self): def test_default_value_property(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -434,14 +434,14 @@ class TestNamespace:
return "123" return "123"
test1 = TestVar1("test1") test1 = TestVar1("test1")
assert test1.getValue() == "123" assert test1.get_value() == "123"
test1.setValue("987") test1.set_value("987")
test1.addProperty(DefaultValue("567")) test1.addProperty(DefaultValue("567"))
assert test1.getValue() == "987" assert test1.get_value() == "987"
test1.invalidate() test1.invalidate()
assert test1.getValue() == "567" assert test1.get_value() == "567"
def test_get_comment(self): def test_get_comment(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -452,30 +452,30 @@ class TestNamespace:
def get(self): def get(self):
return "234" return "234"
def getComment(self): def get_comment(self):
return "[%s]" % self.getValue() return "[%s]" % self.get_value()
class TestVar3(Variable): class TestVar3(Variable):
def get(self): def get(self):
return "ZXC %s" % self.vars.test2.getCommentValue(self) return "ZXC %s" % self.vars.test2.get_comment_value(self)
ns = Namespace() ns = Namespace()
test1 = TestVar1("test1") test1 = TestVar1("test1")
assert test1.getValue() == "123" assert test1.get_value() == "123"
assert test1.getComment() == "123" assert test1.get_comment() == "123"
test2 = TestVar2("test2") test2 = TestVar2("test2")
assert test2.getValue() == "234" assert test2.get_value() == "234"
assert test2.getComment() == "[234]" assert test2.get_comment() == "[234]"
test3 = TestVar3("test3") test3 = TestVar3("test3")
ns.addVariable(test1) ns.add_variable(test1)
ns.addVariable(test2) ns.add_variable(test2)
ns.addVariable(test3) ns.add_variable(test3)
assert test3.getValue() == "ZXC [234]" assert test3.get_value() == "ZXC [234]"
test2.setValue("567") test2.set_value("567")
assert test3.getValue() == "ZXC [567]" assert test3.get_value() == "ZXC [567]"
def test_wrong_choice_varaible(self): def test_wrong_choice_varaible(self):
class TestVar1(Variable): class TestVar1(Variable):
@ -490,7 +490,7 @@ class TestNamespace:
class TestVar3(Variable): class TestVar3(Variable):
properties = [ChoiceVariable] properties = [ChoiceVariable]
def choiceComment(self): def choice_comment(self):
return [("test1", "Test1"), return [("test1", "Test1"),
("test2", "Test2")] ("test2", "Test2")]
@ -502,30 +502,30 @@ class TestNamespace:
test1.choice() test1.choice()
with pytest.raises(VariableError): with pytest.raises(VariableError):
test1.choiceComment() test1.choice_comment()
assert test2.choice() == ["test1", "test2"] assert test2.choice() == ["test1", "test2"]
assert test2.choiceComment() == [("test1", "test1"), assert test2.choice_comment() == [("test1", "test1"),
("test2", "test2")] ("test2", "test2")]
assert test3.choice() == ["test1", "test2"] assert test3.choice() == ["test1", "test2"]
assert test3.choiceComment() == [("test1", "Test1"), assert test3.choice_comment() == [("test1", "Test1"),
("test2", "Test2")] ("test2", "Test2")]
def test_loading_test_variable_module(self): def test_loading_test_variable_module(self):
ns = Namespace() ns = Namespace()
vl = VariableLoader() vl = VariableLoader()
vl.fill(ns, "tests/vars/variables", "testvars") vl.fill(ns, "tests/vars/variables", "testvars")
assert ns.level.simple.getValue() == "simple value" assert ns.level.simple.get_value() == "simple value"
assert ns.level.uselocalsimple.getValue() == "Using simple value" assert ns.level.uselocalsimple.get_value() == "Using simple value"
assert ns.level.usefullsimple.getValue() == "Using simple value" assert ns.level.usefullsimple.get_value() == "Using simple value"
with pytest.raises(VariableError): with pytest.raises(VariableError):
ns.level.badchoice.choice() ns.level.badchoice.choice()
with pytest.raises(VariableError): with pytest.raises(VariableError):
ns.level.badchoice.choiceComment() ns.level.badchoice.choice_comment()
assert ns.level.simple_choice.choice() == ["/dev/sda1", assert ns.level.simple_choice.choice() == ["/dev/sda1",
"/dev/sda2", "/dev/sda2",
@ -533,23 +533,23 @@ class TestNamespace:
assert ns.level.comment_choice.choice() == ["/dev/sda1", assert ns.level.comment_choice.choice() == ["/dev/sda1",
"/dev/sda2", "/dev/sda2",
"/dev/sda3"] "/dev/sda3"]
assert ns.level.comment_choice.choiceComment() == [ assert ns.level.comment_choice.choice_comment() == [
("/dev/sda1", "SWAP"), ("/dev/sda1", "SWAP"),
("/dev/sda2", "ROOT"), ("/dev/sda2", "ROOT"),
("/dev/sda3", "DATA")] ("/dev/sda3", "DATA")]
ns.level.disks.setValue(["/dev/sda2", "/dev/sda1"]) ns.level.disks.set_value(["/dev/sda2", "/dev/sda1"])
assert ns.level.disks.getValue() == ["/dev/sda2", "/dev/sda1"] assert ns.level.disks.get_value() == ["/dev/sda2", "/dev/sda1"]
assert ns.level.comment_choice.choice() == ["/dev/sda2", "/dev/sda1"] assert ns.level.comment_choice.choice() == ["/dev/sda2", "/dev/sda1"]
assert ns.level.comment_choice.choiceComment() == [ assert ns.level.comment_choice.choice_comment() == [
("/dev/sda2", "ROOT"), ("/dev/sda2", "ROOT"),
("/dev/sda1", "SWAP")] ("/dev/sda1", "SWAP")]
assert ns.level is not ns.level.level2.root assert ns.level is not ns.level.level2.root
assert ns is ns.level.level2.root assert ns is ns.level.level2.root
assert ns.level.level2.vargetter.getValue() == "/ test" assert ns.level.level2.vargetter.get_value() == "/ test"
def test_hash_variable(self): def test_hash_variable(self):
# hash variable # hash variable
@ -557,43 +557,43 @@ class TestNamespace:
vl = VariableLoader() vl = VariableLoader()
vl.fill(ns, "tests/vars/variables", "testvars") vl.fill(ns, "tests/vars/variables", "testvars")
assert ns.level.linux.getFullname() == "level.linux" assert ns.level.linux.get_fullname() == "level.linux"
assert ns.level.linux.ver.fullname == "level.linux.ver" assert ns.level.linux.ver.fullname == "level.linux.ver"
assert ns.level.linux.ver.getValue() == "1.0" assert ns.level.linux.ver.get_value() == "1.0"
assert ns.level.linux.shortname.getValue() == "CLD" assert ns.level.linux.shortname.get_value() == "CLD"
# проверка обновления значения hash переменной при обновлении # проверка обновления значения hash переменной при обновлении
# значения у зависимой перемнной # значения у зависимой перемнной
ns.level.version.setValue("2.0") ns.level.version.set_value("2.0")
assert ns.level.linux.ver.getValue() == "2.0" assert ns.level.linux.ver.get_value() == "2.0"
# проверка установки значения hash переменной # проверка установки значения hash переменной
ns.level.linux.ver.setValue("3.0") ns.level.linux.ver.set_value("3.0")
assert ns.level.linux.ver.getValue() == "3.0" assert ns.level.linux.ver.get_value() == "3.0"
# после установки хотя бы одного значения в hash переменной # после установки хотя бы одного значения в hash переменной
# обновление остальных прекращаются до инвалидации (так как # обновление остальных прекращаются до инвалидации (так как
# значения рассматриваются комплексно) # значения рассматриваются комплексно)
ns.level.myshortname.setValue("CLDG") ns.level.myshortname.set_value("CLDG")
assert ns.level.linux.shortname.getValue() == "CLD" assert ns.level.linux.shortname.get_value() == "CLD"
# проверка попытки изменить readonly переменную # проверка попытки изменить readonly переменную
with pytest.raises(VariableError): with pytest.raises(VariableError):
ns.level.linux.shortname.setValue("CLDX") ns.level.linux.shortname.set_value("CLDX")
# проверка сбора значения hash перемнной # проверка сбора значения hash перемнной
ns.level.linux.invalidate() ns.level.linux.invalidate()
assert ns.level.linux.ver.getValue() == "2.0" assert ns.level.linux.ver.get_value() == "2.0"
assert ns.level.linux.shortname.getValue() == "CLDG" assert ns.level.linux.shortname.get_value() == "CLDG"
assert ns.level.linux.test.getValue() == "my test - 2.0" assert ns.level.linux.test.get_value() == "my test - 2.0"
# проверка обновления значения переменной, используеющей одно # проверка обновления значения переменной, используеющей одно
# из значений hash переменной # из значений hash переменной
assert ns.level.shortname_test.getValue() == "CLDG test" assert ns.level.shortname_test.get_value() == "CLDG test"
ns.level.linux.shortname.setValue("CLDX", force=True) ns.level.linux.shortname.set_value("CLDX", force=True)
assert ns.level.shortname_test.getValue() == "CLDX test" assert ns.level.shortname_test.get_value() == "CLDX test"
def test_table_variable(self): def test_table_variable(self):
# table variable # table variable
@ -601,53 +601,53 @@ class TestNamespace:
vl = VariableLoader() vl = VariableLoader()
vl.fill(ns, "tests/vars/variables", "testvars") vl.fill(ns, "tests/vars/variables", "testvars")
assert ns.level.device[0].dev.getValue() == "/dev/sda" assert ns.level.device[0].dev.get_value() == "/dev/sda"
assert ns.level.device[1].dev.getValue() == "/dev/sdb" assert ns.level.device[1].dev.get_value() == "/dev/sdb"
assert ns.level.device.getValue() == [{"dev": "/dev/sda", assert ns.level.device.get_value() == [{"dev": "/dev/sda",
"type": "hdd", "type": "hdd",
"name": "Samsung SSD"}, "name": "Samsung SSD"},
{"dev": "/dev/sdb", {"dev": "/dev/sdb",
"type": "flash", "type": "flash",
"name": "Transcend 64GB"}] "name": "Transcend 64GB"}]
assert ns.level.device[1].type.getValue() == "flash" assert ns.level.device[1].type.get_value() == "flash"
# проверка обновления списка пространства имён у табличной переменной # проверка обновления списка пространства имён у табличной переменной
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", "/dev/sdc"]) ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb", "/dev/sdc"])
assert ns.level.device[2].type.getValue() == "usbhdd" assert ns.level.device[2].type.get_value() == "usbhdd"
assert [x.type.getValue() for x in ns.level.device] == ["hdd", assert [x.type.get_value() for x in ns.level.device] == ["hdd",
"flash", "flash",
"usbhdd"] "usbhdd"]
assert ns.level.device_child.getValue() == "hdd" assert ns.level.device_child.get_value() == "hdd"
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb"]) ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb"])
ns.level.device[0].type.setValue("flash") ns.level.device[0].type.set_value("flash")
assert ns.level.device.getValue() == [{"dev": "/dev/sda", assert ns.level.device.get_value() == [{"dev": "/dev/sda",
"type": "flash", "type": "flash",
"name": "Samsung SSD"}, "name": "Samsung SSD"},
{"dev": "/dev/sdb", {"dev": "/dev/sdb",
"type": "flash", "type": "flash",
"name": "Transcend 64GB"}] "name": "Transcend 64GB"}]
assert ns.level.device_child.getValue() == "flash" assert ns.level.device_child.get_value() == "flash"
# после установки хотя бы одного значения в table переменной # после установки хотя бы одного значения в table переменной
# обновление остальных прекращаются до инвалидации (так как # обновление остальных прекращаются до инвалидации (так как
# значения рассматриваются комплексно) # значения рассматриваются комплексно)
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", "/dev/sdc"]) ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb", "/dev/sdc"])
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda", assert [x.dev.get_value() for x in ns.level.device] == ["/dev/sda",
"/dev/sdb"] "/dev/sdb"]
ns.level.device.invalidate() ns.level.device.invalidate()
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda", assert [x.dev.get_value() for x in ns.level.device] == ["/dev/sda",
"/dev/sdb", "/dev/sdb",
"/dev/sdc"] "/dev/sdc"]
# проверить на повторное изменение, убедится, что _drop_child # проверить на повторное изменение, убедится, что _drop_child
# отрабатывает # отрабатывает
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb",
"/dev/sdc", "/dev/sdd"]) "/dev/sdc", "/dev/sdd"])
ns.level.device.invalidate() ns.level.device.invalidate()
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda", assert [x.dev.get_value() for x in ns.level.device] == ["/dev/sda",
"/dev/sdb", "/dev/sdb",
"/dev/sdc", "/dev/sdc",
"/dev/sdd"] "/dev/sdd"]
def test_wrong_table_variable(self): def test_wrong_table_variable(self):
class Testtable(TableVariable): class Testtable(TableVariable):
@ -656,13 +656,13 @@ class TestNamespace:
return [{'dev': '123', 'name': '098'}] return [{'dev': '123', 'name': '098'}]
ns = Namespace() ns = Namespace()
ns.addNamespace(Namespace("test")) ns.add_namespace(Namespace("test"))
ns.test.addNamespace(Namespace("test2")) ns.test.add_namespace(Namespace("test2"))
error_message = ("Missed 'hash_vars' attribute for table " error_message = ("Missed 'hash_vars' attribute for table "
"variable test.test2.testtable") "variable test.test2.testtable")
with pytest.raises(VariableError) as e: with pytest.raises(VariableError) as e:
ns.test.test2.addNamespace(Testtable("testtable", ns.test.test2)) ns.test.test2.add_namespace(Testtable("testtable", ns.test.test2))
assert str(e.value) == error_message assert str(e.value) == error_message
def test_wrong_hash_variable(self): def test_wrong_hash_variable(self):
@ -672,33 +672,33 @@ class TestNamespace:
return {'dev': '123', 'name': '098'} return {'dev': '123', 'name': '098'}
ns = Namespace() ns = Namespace()
ns.addNamespace(Namespace("test")) ns.add_namespace(Namespace("test"))
ns.test.addNamespace(Namespace("test2")) ns.test.add_namespace(Namespace("test2"))
error_message = ("Missed 'hash_vars' attribute for hash " error_message = ("Missed 'hash_vars' attribute for hash "
"variable test.test2.testhash") "variable test.test2.testhash")
with pytest.raises(VariableError) as e: with pytest.raises(VariableError) as e:
ns.test.test2.addNamespace(Testhash("testhash", ns.test.test2)) ns.test.test2.add_namespace(Testhash("testhash", ns.test.test2))
assert str(e.value) == error_message assert str(e.value) == error_message
def test_namespace_iteration(self): def test_namespace_iteration(self):
ns = Namespace() ns = Namespace()
ns0 = ns.addNamespace() ns0 = ns.add_namespace()
ns0.addStringVariable("test", "123") ns0.add_string_variable("test", "123")
ns1 = ns.addNamespace() ns1 = ns.add_namespace()
ns1.addStringVariable("test", "234") ns1.add_string_variable("test", "234")
ns2 = ns.addNamespace() ns2 = ns.add_namespace()
ns2.addStringVariable("test", "456") ns2.add_string_variable("test", "456")
assert [x.test.getValue() for x in ns] == ["123", "234", "456"] assert [x.test.get_value() for x in ns] == ["123", "234", "456"]
def test_subnamespace(self): def test_subnamespace(self):
ns = Namespace() ns = Namespace()
vl = VariableLoader() vl = VariableLoader()
vl.fill(ns, "tests/vars/variables", "testvars") vl.fill(ns, "tests/vars/variables", "testvars")
assert ns.level.level3.my_var1.getValue() == "testing" assert ns.level.level3.my_var1.get_value() == "testing"
assert ns.level.level3.myvar2.getValue() == "testing2" assert ns.level.level3.myvar2.get_value() == "testing2"
def test_variable_not_found(self): def test_variable_not_found(self):
ns = Namespace() ns = Namespace()
@ -707,7 +707,7 @@ class TestNamespace:
error_message = "Variable or namespace level.level3.myvar3 not found" error_message = "Variable or namespace level.level3.myvar3 not found"
with pytest.raises(VariableError) as e: with pytest.raises(VariableError) as e:
ns.level.level3.myvar3.getValue() ns.level.level3.myvar3.get_value()
assert str(e.value) == error_message assert str(e.value) == error_message
# TODO: тест использует значения на конкретной машине # TODO: тест использует значения на конкретной машине
@ -716,13 +716,14 @@ class TestNamespace:
# vl = VariableLoader() # vl = VariableLoader()
# vl.fill(ns, *VariableLoader.default()) # vl.fill(ns, *VariableLoader.default())
# # нужно исправить тест, так # # нужно исправить тест, так
# # assert [x.name.getValue() for x in ns.os.gentoo.repositories] ==\ # # assert [x.name.get_value() for x in ns.os.gentoo.repositories] ==\
# ["gentoo","distros","calculate","custom"] # ["gentoo","distros","calculate","custom"]
# assert ns.os.gentoo.make_profile.getValue() ==\ # assert ns.os.gentoo.make_profile.get_value() ==\
# "/etc/portage/make.profile" # "/etc/portage/make.profile"
# assert ns.os.gentoo.profile.path.getValue() ==\ # assert ns.os.gentoo.profile.path.get_value() ==\
# "/var/db/repos/distros/profiles/CLD/amd64/20" # "/var/db/repos/distros/profiles/CLD/amd64/20"
# assert ns.os.gentoo.profile.name.getValue() == "distros:CLD/amd64/20" # assert ns.os.gentoo.profile.name.get_value() ==\
# "distros:CLD/amd64/20"
def test_profile_filler(self): def test_profile_filler(self):
ns = Namespace() ns = Namespace()
@ -742,37 +743,38 @@ class TestNamespace:
os.path.join(curdir, os.path.join(curdir,
"tests/utils/gentoo/portage")} "tests/utils/gentoo/portage")}
assert ns.os.hashvar.value1.getValue() == "test1" assert ns.os.hashvar.value1.get_value() == "test1"
assert ns.os.hashvar.value2.getValue() == "test2" assert ns.os.hashvar.value2.get_value() == "test2"
assert ns.os.tablevar[0].dev.getValue() == "/dev/sdb1" assert ns.os.tablevar[0].dev.get_value() == "/dev/sdb1"
assert ns.os.tablevar[1].dev.getValue() == "/dev/sdb2" assert ns.os.tablevar[1].dev.get_value() == "/dev/sdb2"
pf = ProfileFillerTest() pf = ProfileFillerTest()
pf.fill(ns, "tests/utils/gentoo/repos/distros/profiles/CLD/amd64") pf.fill(ns, "tests/utils/gentoo/repos/distros/profiles/CLD/amd64")
assert ns.os.linux.test.getValue() == "test" assert ns.os.linux.test.get_value() == "test"
assert ns.os.linux.arch.getValue() == "amd64" assert ns.os.linux.arch.get_value() == "amd64"
assert ns.os.linux.title.getValue() == "Calculate Linux Desktop KDE 20" assert ns.os.linux.title.get_value() ==\
"Calculate Linux Desktop KDE 20"
# Hash # Hash
assert ns.os.hashvar.value1.getValue() == "20" assert ns.os.hashvar.value1.get_value() == "20"
assert ns.os.hashvar.value2.getValue() == "30" assert ns.os.hashvar.value2.get_value() == "30"
ns.os.hashvar.value1.setValue("40") ns.os.hashvar.value1.set_value("40")
assert ns.os.hashvar.value1.getValue() == "40" assert ns.os.hashvar.value1.get_value() == "40"
ns.os.hashvar.value1.invalidate() ns.os.hashvar.value1.invalidate()
assert ns.os.hashvar.value1.getValue() == "20" assert ns.os.hashvar.value1.get_value() == "20"
# Table # Table
assert ns.os.tablevar[0].dev.getValue() == "/dev/sda1" assert ns.os.tablevar[0].dev.get_value() == "/dev/sda1"
assert ns.os.tablevar[1].dev.getValue() == "/dev/sda2" assert ns.os.tablevar[1].dev.get_value() == "/dev/sda2"
assert ns.os.tablevar[2].dev.getValue() == "/dev/sda5" assert ns.os.tablevar[2].dev.get_value() == "/dev/sda5"
ns.os.tablevar[0].dev.invalidate() ns.os.tablevar[0].dev.invalidate()
assert ns.os.tablevar[0].dev.getValue() == "/dev/sda1" assert ns.os.tablevar[0].dev.get_value() == "/dev/sda1"
assert ns.os.tablevar[1].dev.getValue() == "/dev/sda2" assert ns.os.tablevar[1].dev.get_value() == "/dev/sda2"
assert ns.os.tablevar[2].dev.getValue() == "/dev/sda5" assert ns.os.tablevar[2].dev.get_value() == "/dev/sda5"
def test_fill_namespace_by_module(self): def test_fill_namespace_by_module(self):
pass pass
@ -782,4 +784,4 @@ class TestNamespace:
# assert "os" in ns # assert "os" in ns
# assert "config" in ns.os.gentoo # assert "config" in ns.os.gentoo
# assert "main" in ns # assert "main" in ns
# assert ns.os.gentoo.config.getValue() is not None # assert ns.os.gentoo.config.get_value() is not None

63
tests/vars/variables/level/__init__.py
Unescape View File

@ -1,75 +1,90 @@
from calculate.vars.datavars import Namespace, Variable, ChoiceVariable, ReadonlyVariable, ListVariable, HashVariable, TableVariable, ListVariable from calculate.vars.datavars import Namespace, Variable, ChoiceVariable,\
ReadonlyVariable, ListVariable,\
HashVariable, TableVariable, ListVariable
class Simple(Variable): class Simple(Variable):
def get(self): def get(self):
return "simple value" return "simple value"
class Uselocalsimple(Variable): class Uselocalsimple(Variable):
def get(self): def get(self):
return "Using %s" % self.vars.simple.getValue(self) return "Using %s" % self.vars.simple.get_value(self)
class Usefullsimple(Variable): class Usefullsimple(Variable):
def get(self): def get(self):
return "Using %s" % self.vars.root.level.simple.getValue(self) return "Using %s" % self.vars.root.level.simple.get_value(self)
class Badchoice(Variable): class Badchoice(Variable):
properties = [ChoiceVariable] properties = [ChoiceVariable]
class Disks(Variable): class Disks(Variable):
properties = [ListVariable] properties = [ListVariable]
def get(self): def get(self):
return ["/dev/sda1", "/dev/sda2", "/dev/sda3"] return ["/dev/sda1", "/dev/sda2", "/dev/sda3"]
def getComment(self): def get_comment(self):
mymap = {'/dev/sda1':'SWAP', mymap = {'/dev/sda1': 'SWAP',
'/dev/sda2':'ROOT', '/dev/sda2': 'ROOT',
'/dev/sda3':'DATA'} '/dev/sda3': 'DATA'}
return [mymap.get(x) for x in self.getValue()] return [mymap.get(x) for x in self.get_value()]
class SimpleChoice(Variable): class SimpleChoice(Variable):
properties = [ChoiceVariable] properties = [ChoiceVariable]
def choice(self): def choice(self):
return self.vars.disks.getValue(self) return self.vars.disks.get_value(self)
class CommentChoice(Variable): class CommentChoice(Variable):
properties = [ChoiceVariable] properties = [ChoiceVariable]
def choiceComment(self): def choice_comment(self):
return list(zip(self.vars.disks.getValue(), return list(zip(self.vars.disks.get_value(),
self.vars.disks.getComment())) self.vars.disks.get_comment()))
class Version(Variable): class Version(Variable):
value = "1.0" value = "1.0"
class Myshortname(Variable): class Myshortname(Variable):
value = "CLD" value = "CLD"
class Linux(HashVariable): class Linux(HashVariable):
class Data(HashVariable.Data): class Data(HashVariable.Data):
def get(self): def get(self):
return { return {
'ver':self.vars.version.getValue(self), 'ver': self.vars.version.get_value(self),
'shortname':self.vars.myshortname.getValue(self) 'shortname': self.vars.myshortname.get_value(self)
} }
class Test(Variable): class Test(Variable):
def get(self): def get(self):
return "my test - %s" % self.vars.ver.getValue(self) return "my test - %s" % self.vars.ver.get_value(self)
readonly_vars = ['shortname'] readonly_vars = ['shortname']
hash_vars = ["ver", "shortname"] hash_vars = ["ver", "shortname"]
class ShortnameTest(Variable): class ShortnameTest(Variable):
def get(self): def get(self):
return "{} test".format(self.vars.linux.shortname.getValue(self)) return "{} test".format(self.vars.linux.shortname.get_value(self))
class Devicelist(Variable): class Devicelist(Variable):
properties = [ListVariable] properties = [ListVariable]
def get(self): def get(self):
return ["/dev/sda","/dev/sdb"] return ["/dev/sda", "/dev/sdb"]
class Device(TableVariable): class Device(TableVariable):
class Data(TableVariable.Data): class Data(TableVariable.Data):
@ -79,18 +94,20 @@ class Device(TableVariable):
'/dev/sdc': ["usbhdd", "WD 1TB"]} '/dev/sdc': ["usbhdd", "WD 1TB"]}
defaultValue = ["hdd", "Unknown"] defaultValue = ["hdd", "Unknown"]
return [ return [
{"dev":x, {"dev": x,
"type":mapData.get(x,defaultValue)[0], "type": mapData.get(x, defaultValue)[0],
"name":mapData.get(x,defaultValue)[1]} "name": mapData.get(x, defaultValue)[1]}
for x in self.vars.devicelist.getValue(self) for x in self.vars.devicelist.get_value(self)
] ]
hash_vars = ["dev","type","name"] hash_vars = ["dev", "type", "name"]
readonly_vars = ["name"] readonly_vars = ["name"]
class DeviceChild(Variable): class DeviceChild(Variable):
def get(self): def get(self):
return self.vars.device[0].type.getValue(self) return self.vars.device[0].type.get_value(self)
class Level3(Namespace): class Level3(Namespace):
class MyVar1(Variable): class MyVar1(Variable):

3
tests/vars/variables/level/level2/__init__.py
Unescape View File

@ -1,5 +1,6 @@
from calculate.vars.datavars import Variable from calculate.vars.datavars import Variable
class Vargetter(Variable): class Vargetter(Variable):
def get(self): def get(self):
return "%s test" % self.vars.root.main.chroot.getValue(self) return "%s test".format(self.vars.root.main.chroot.get_value(self))

1
tests/vars/variables/main/__init__.py
Unescape View File

@ -1,5 +1,6 @@
from calculate.vars.datavars import Variable, ReadonlyVariable from calculate.vars.datavars import Variable, ReadonlyVariable
class Chroot(Variable): class Chroot(Variable):
properties = [ReadonlyVariable] properties = [ReadonlyVariable]
value = "/" value = "/"

14
tests/vars/variables/os/__init__.py
Unescape View File

@ -22,14 +22,15 @@ class Linux(Namespace):
class Title(Variable): class Title(Variable):
def get(self): def get(self):
subname = self.vars.subname.getValue(self) subname = self.vars.subname.get_value(self)
fullname = self.vars.fullname.getValue(self) fullname = self.vars.fullname.get_value(self)
ver = self.vars.ver.getValue(self) ver = self.vars.ver.get_value(self)
if subname: if subname:
return "%s %s %s" % (fullname, subname, ver) return "%s %s %s" % (fullname, subname, ver)
else: else:
return "%s %s" % (fullname, ver) return "%s %s" % (fullname, ver)
class Hashvar(HashVariable): class Hashvar(HashVariable):
class Data(HashVariable.Data): class Data(HashVariable.Data):
def get(self): def get(self):
@ -41,12 +42,13 @@ class Hashvar(HashVariable):
class Calculate(Variable): class Calculate(Variable):
def get(self): def get(self):
return "%s %s" % ( return "%s %s" % (
self.vars.value1.getValue(self), self.vars.value1.get_value(self),
self.vars.value2.getValue(self) self.vars.value2.get_value(self)
) )
hash_vars = ["value1", "value2"] hash_vars = ["value1", "value2"]
class Tablevar(TableVariable): class Tablevar(TableVariable):
class Data(TableVariable.Data): class Data(TableVariable.Data):
def get(self): def get(self):

Write Preview
Loading…
Cancel
Save