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

packages
Иванов Денис 4 years ago
parent f66b89f6b0
commit f879ea0ae2

@ -10,15 +10,6 @@ import sys
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):
pass
@ -397,11 +388,11 @@ def quite_unlink(file_path):
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):
return []
try:
if full_path:
if fullpath:
if only_dir:
return [node.path for node in os.scandir(directory_path)
if os.path.isdir(node.path)]

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

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

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

@ -1,76 +1,91 @@
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):
def get(self):
return "simple value"
class Uselocalsimple(Variable):
def get(self):
return "Using %s" % self.vars.simple.getValue(self)
return "Using %s" % self.vars.simple.get_value(self)
class Usefullsimple(Variable):
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):
properties = [ChoiceVariable]
class Disks(Variable):
properties = [ListVariable]
def get(self):
return ["/dev/sda1", "/dev/sda2", "/dev/sda3"]
def getComment(self):
def get_comment(self):
mymap = {'/dev/sda1': 'SWAP',
'/dev/sda2': 'ROOT',
'/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):
properties = [ChoiceVariable]
def choice(self):
return self.vars.disks.getValue(self)
return self.vars.disks.get_value(self)
class CommentChoice(Variable):
properties = [ChoiceVariable]
def choiceComment(self):
return list(zip(self.vars.disks.getValue(),
self.vars.disks.getComment()))
def choice_comment(self):
return list(zip(self.vars.disks.get_value(),
self.vars.disks.get_comment()))
class Version(Variable):
value = "1.0"
class Myshortname(Variable):
value = "CLD"
class Linux(HashVariable):
class Data(HashVariable.Data):
def get(self):
return {
'ver':self.vars.version.getValue(self),
'shortname':self.vars.myshortname.getValue(self)
'ver': self.vars.version.get_value(self),
'shortname': self.vars.myshortname.get_value(self)
}
class Test(Variable):
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']
hash_vars = ["ver", "shortname"]
class ShortnameTest(Variable):
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):
properties = [ListVariable]
def get(self):
return ["/dev/sda", "/dev/sdb"]
class Device(TableVariable):
class Data(TableVariable.Data):
def get(self):
@ -82,15 +97,17 @@ class Device(TableVariable):
{"dev": x,
"type": mapData.get(x, defaultValue)[0],
"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"]
readonly_vars = ["name"]
class DeviceChild(Variable):
def get(self):
return self.vars.device[0].type.getValue(self)
return self.vars.device[0].type.get_value(self)
class Level3(Namespace):
class MyVar1(Variable):

@ -1,5 +1,6 @@
from calculate.vars.datavars import Variable
class Vargetter(Variable):
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,5 +1,6 @@
from calculate.vars.datavars import Variable, ReadonlyVariable
class Chroot(Variable):
properties = [ReadonlyVariable]
value = "/"

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

Loading…
Cancel
Save