From 813d10fcf7ba1fb06772928d92f8b1fcacdd2f09 Mon Sep 17 00:00:00 2001 From: Zooxy Le Date: Thu, 2 May 2024 00:01:24 +0700 Subject: [PATCH] chore: rename from `Variable` to `EvalObject`, `var_property` to `eo_property` --- src/dictrule/__init__.py | 8 +- .../{var_property.py => eo_property.py} | 34 +-- src/dictrule/{variable.py => eval_object.py} | 52 ++--- tests/variable/test_var_property.py | 88 ++++---- tests/variable/test_variable.py | 208 +++++++++--------- 5 files changed, 195 insertions(+), 195 deletions(-) rename src/dictrule/{var_property.py => eo_property.py} (79%) rename src/dictrule/{variable.py => eval_object.py} (71%) diff --git a/src/dictrule/__init__.py b/src/dictrule/__init__.py index ef0099c..68b9500 100644 --- a/src/dictrule/__init__.py +++ b/src/dictrule/__init__.py @@ -10,8 +10,8 @@ from .generator import Generator from .rule import Rule from .context import Context -from .var_property import var_property -from .variable import Variable +from .eo_property import eo_property +from .eval_object import EvalObject from .__version__ import ( __title__, __description__, @@ -57,8 +57,8 @@ "JoinBlockRule", "JoinEvalRule", "FormatRule", - "var_property", - "Variable", + "eo_property", + "EvalObject", "__title__", "__description__", "__url__", diff --git a/src/dictrule/var_property.py b/src/dictrule/eo_property.py similarity index 79% rename from src/dictrule/var_property.py rename to src/dictrule/eo_property.py index bcbbd64..04db01a 100644 --- a/src/dictrule/var_property.py +++ b/src/dictrule/eo_property.py @@ -1,4 +1,4 @@ -"""var_property decorator module""" +"""eo_property decorator module""" from typing import ( List, @@ -8,23 +8,23 @@ ) -class var_property: - """var_property decorator that defines property for dictrule.Variable. +class eo_property: + """eo_property decorator that defines property for dictrule.EvalObject. Examples: --------- >>> class Person: - ... @var_property + ... @eo_property ... def name(self) -> str: ... return "Zooxy" ... def age(self) -> int: ... return 20 - >>> var = dictrule.Variable.from_object(Person()) - >>> print(isinstance(var, Variable)) + >>> obj = dictrule.EvalObject.from_object(Person()) + >>> print(isinstance(var, EvalObject)) True - >>> print(var.name) + >>> print(obj.name) Zooxy - >>> print(var.age) + >>> print(obj.age) 20 """ @@ -35,7 +35,7 @@ def __init__( fdel: Optional[Callable[[Any], None]] = None, doc: Optional[str] = None, ): - """var_property decorator + """eo_property decorator Args: fget (Optional[Callable[[Any], Any]], optional): Getter method. Defaults to None. @@ -69,13 +69,13 @@ def __delete__(self, obj) -> None: raise AttributeError("can't delete attribute") self.fdel(obj) - def getter(self, fget) -> "var_property": + def getter(self, fget) -> "eo_property": """Getter decorator Examples: --------- >>> class Sample: - ... @var_property + ... @eo_property ... def name(self): ... return "Zooxy" >>> Sample().name @@ -83,7 +83,7 @@ def getter(self, fget) -> "var_property": """ return type(self)(fget, self.fset, self.fdel, self.__doc__) - def setter(self, fset) -> "var_property": + def setter(self, fset) -> "eo_property": """Setter decorator Examples: @@ -94,7 +94,7 @@ def setter(self, fset) -> "var_property": """ return type(self)(self.fget, fset, self.fdel, self.__doc__) - def deleter(self, fdel) -> "var_property": + def deleter(self, fdel) -> "eo_property": """Deleter decorator Examples: @@ -110,18 +110,18 @@ def properties( cls, instance: Any, ) -> List[Callable[[Any], Any]]: - """Fetches all `var_property` of `instance`. + """Fetches all `eo_property` of `instance`. Args: - instance (Any): Instance using `var_property`. + instance (Any): Instance using `eo_property`. Returns: - List[Callable]: List of `var_property` functions + List[Callable]: List of `eo_property` functions """ properties: List[Callable] = [] for name in dir(instance.__class__): attr = getattr(instance.__class__, name, None) - is_prop = isinstance(attr, var_property) + is_prop = isinstance(attr, eo_property) if not is_prop: continue diff --git a/src/dictrule/variable.py b/src/dictrule/eval_object.py similarity index 71% rename from src/dictrule/variable.py rename to src/dictrule/eval_object.py index 26fb36a..29689d0 100644 --- a/src/dictrule/variable.py +++ b/src/dictrule/eval_object.py @@ -1,4 +1,4 @@ -"""Variable module""" +"""EvalObject module""" from typing import ( Any, @@ -8,14 +8,14 @@ Optional, ) -from .var_property import var_property +from .eo_property import eo_property -class Variable: +class EvalObject: """Parses instances with nested values. Supported value types: - - An item in Variable.PRIMITIVE_TYPES: [ + - An item in EvalObject.PRIMITIVE_TYPES: [ int, float, str, @@ -23,20 +23,20 @@ class Variable: - list - set - dict - - Variable + - EvalObject Examples: --------- >>> class Sample: - ... @var_property + ... @eo_property ... def name(self) -> str: ... return "Zooxy" ... def age(self) -> int: ... return 20 - >>> var = Variable.from_var_property_object(Sample()) - >>> print(var.name) + >>> obj = EvalObject.from_eo_property_object(Sample()) + >>> print(obj.name) Zooxy - >>> print(hasattr(var, "age")) + >>> print(hasattr(obj, "age")) False """ @@ -49,26 +49,26 @@ class Variable: ) @staticmethod - def from_var_property_object( + def from_eo_property_object( obj: Any, - ) -> "Variable": - """Parses a Variable from obj where properties are decorated with @var_property. + ) -> "EvalObject": + """Parses a EvalObject from obj where properties are decorated with @eo_property. Args: - obj (Any): The object to parse from @var_property and supported values. + obj (Any): The object to parse from @eo_property and supported values. Returns: - Variable: The parsed variable. + EvalObject: The parsed object. """ - return Variable._parse_value(obj) + return EvalObject._parse_value(obj) def add_object( self, obj: Any, name: str, ): - """Adds a new object to the Variable instance with a given name. + """Adds a new object to the EvalObject instance with a given name. Args: obj (Any): The object to be added. @@ -95,26 +95,26 @@ def _parse_value( return parsed_value = None - if type(value) in Variable.PRIMITIVE_TYPES or isinstance(value, Variable): + if type(value) in EvalObject.PRIMITIVE_TYPES or isinstance(value, EvalObject): parsed_value = value elif isinstance(value, list): - parsed_value = Variable._parse_list( + parsed_value = EvalObject._parse_list( value=value, ) elif isinstance(value, set): - parsed_value = Variable._parse_set( + parsed_value = EvalObject._parse_set( value=value, ) elif isinstance(value, dict): - parsed_value = Variable._parse_dict( + parsed_value = EvalObject._parse_dict( value=value, ) else: - attrs = var_property.properties(value) + attrs = eo_property.properties(value) if not attrs: return None - parsed_value = Variable() + parsed_value = EvalObject() for attr in attrs: setattr(parsed_value, attr.__name__, attr.__get__(value)) @@ -135,7 +135,7 @@ def _parse_list( new_list: List[Any] = [] for v in value: - parsed_value = Variable._parse_value(v) + parsed_value = EvalObject._parse_value(v) if parsed_value: new_list.append(parsed_value) return new_list @@ -155,7 +155,7 @@ def _parse_set( new_set: Set[Any] = set() for v in value: - parsed_value = Variable._parse_value(v) + parsed_value = EvalObject._parse_value(v) if not parsed_value: continue @@ -178,11 +178,11 @@ def _parse_dict( new_dict: Dict[str, Any] = {} for k, v in value.items(): - parsed_key = Variable._parse_value(k) + parsed_key = EvalObject._parse_value(k) if not parsed_key: continue - parsed_value = Variable._parse_value(v) + parsed_value = EvalObject._parse_value(v) if not parsed_value: continue diff --git a/tests/variable/test_var_property.py b/tests/variable/test_var_property.py index 40be25b..d3a5aa7 100644 --- a/tests/variable/test_var_property.py +++ b/tests/variable/test_var_property.py @@ -6,55 +6,55 @@ Any, ) -from dictrule.var_property import var_property +from dictrule.eo_property import eo_property -class VarProperty: +class ObjProperty: """Test class""" def __init__(self) -> None: - self.var_prop_a = "_prop_a" - self.var_prop_b = "_prop_b" - self.var_prop_c = "_prop_c" + self.obj_prop_a = "_prop_a" + self.obj_prop_b = "_prop_b" + self.obj_prop_c = "_prop_c" - @var_property + @eo_property def prop_a(self): """Test method""" - return self.var_prop_a + return self.obj_prop_a - @var_property + @eo_property def prop_b(self): """Test method""" - return self.var_prop_b + return self.obj_prop_b - @var_property + @eo_property def prop_c(self): """Test method""" - return self.var_prop_c + return self.obj_prop_c @prop_a.setter def prop_a(self, value: Any): - self.var_prop_a = value + self.obj_prop_a = value @prop_b.setter def prop_b(self, value: Any): - self.var_prop_b = value + self.obj_prop_b = value @prop_c.setter def prop_c(self, value: Any): - self.var_prop_c = value + self.obj_prop_c = value @prop_a.deleter def prop_a(self): - del self.var_prop_a + del self.obj_prop_a @prop_b.deleter def prop_b(self): - del self.var_prop_b + del self.obj_prop_b @prop_c.deleter def prop_c(self): - del self.var_prop_c + del self.obj_prop_c class TestVarProperty(unittest.TestCase): @@ -63,53 +63,53 @@ class TestVarProperty(unittest.TestCase): def test_get_property(self): """Test method""" - var_prop = VarProperty() - self.assertEqual(var_prop.var_prop_a, var_prop.prop_a) - self.assertEqual(var_prop.var_prop_b, var_prop.prop_b) - self.assertEqual(var_prop.var_prop_c, var_prop.prop_c) + obj_prop = ObjProperty() + self.assertEqual(obj_prop.obj_prop_a, obj_prop.prop_a) + self.assertEqual(obj_prop.obj_prop_b, obj_prop.prop_b) + self.assertEqual(obj_prop.obj_prop_c, obj_prop.prop_c) def test_set_property(self): """Test method""" - var_prop = VarProperty() - var_prop.prop_a = "new_prop_a" - var_prop.prop_b = "new_prop_b" - var_prop.prop_c = "new_prop_c" - self.assertEqual(var_prop.var_prop_a, var_prop.prop_a) - self.assertEqual(var_prop.var_prop_b, var_prop.prop_b) - self.assertEqual(var_prop.var_prop_c, var_prop.prop_c) + obj_prop = ObjProperty() + obj_prop.prop_a = "new_prop_a" + obj_prop.prop_b = "new_prop_b" + obj_prop.prop_c = "new_prop_c" + self.assertEqual(obj_prop.obj_prop_a, obj_prop.prop_a) + self.assertEqual(obj_prop.obj_prop_b, obj_prop.prop_b) + self.assertEqual(obj_prop.obj_prop_c, obj_prop.prop_c) def test_del_property(self): """Test method""" - var_prop = VarProperty() - del var_prop.prop_a - del var_prop.prop_b - del var_prop.prop_c - self.assertFalse(hasattr(var_prop, "prop_a")) - self.assertFalse(hasattr(var_prop, "prop_b")) - self.assertFalse(hasattr(var_prop, "prop_c")) + obj_prop = ObjProperty() + del obj_prop.prop_a + del obj_prop.prop_b + del obj_prop.prop_c + self.assertFalse(hasattr(obj_prop, "prop_a")) + self.assertFalse(hasattr(obj_prop, "prop_b")) + self.assertFalse(hasattr(obj_prop, "prop_c")) def test_properties(self): """Test method""" - var_prop = VarProperty() - props = var_property.properties(var_prop) + obj_prop = ObjProperty() + props = eo_property.properties(obj_prop) self.assertListEqual( [prop.__name__ for prop in props], [ - getattr(var_prop.__class__, "prop_a").__name__, - getattr(var_prop.__class__, "prop_b").__name__, - getattr(var_prop.__class__, "prop_c").__name__, + getattr(obj_prop.__class__, "prop_a").__name__, + getattr(obj_prop.__class__, "prop_b").__name__, + getattr(obj_prop.__class__, "prop_c").__name__, ], ) self.assertListEqual( - [prop.__get__(var_prop) for prop in props], + [prop.__get__(obj_prop) for prop in props], [ - getattr(var_prop.__class__, "prop_a").__get__(var_prop), - getattr(var_prop.__class__, "prop_b").__get__(var_prop), - getattr(var_prop.__class__, "prop_c").__get__(var_prop), + getattr(obj_prop.__class__, "prop_a").__get__(obj_prop), + getattr(obj_prop.__class__, "prop_b").__get__(obj_prop), + getattr(obj_prop.__class__, "prop_c").__get__(obj_prop), ], ) diff --git a/tests/variable/test_variable.py b/tests/variable/test_variable.py index 93447c3..deee54c 100644 --- a/tests/variable/test_variable.py +++ b/tests/variable/test_variable.py @@ -9,177 +9,177 @@ Dict, ) -from dictrule.var_property import var_property -from dictrule.variable import Variable +from dictrule.eo_property import eo_property +from dictrule.eval_object import EvalObject -class VarProperty: +class ObjProperty: """Test class""" def __init__(self) -> None: - self.var_prop_a = "_prop_a" - self.var_prop_b = "_prop_b" - self.var_prop_c = "_prop_c" - self.var_prop_d = "_prop_d" + self.obj_prop_a = "_prop_a" + self.obj_prop_b = "_prop_b" + self.obj_prop_c = "_prop_c" + self.obj_prop_d = "_prop_d" - @var_property + @eo_property def prop_a(self): """Test method""" - return self.var_prop_a + return self.obj_prop_a - @var_property + @eo_property def prop_b(self): """Test method""" - return self.var_prop_b + return self.obj_prop_b - @var_property + @eo_property def prop_c(self): """Test method""" - return self.var_prop_c + return self.obj_prop_c @property def prop_d(self): """Test method""" - return self.var_prop_d + return self.obj_prop_d -class ComplexVariable: +class ComplexObject: """Test class""" def __init__(self) -> None: - self.var_prop_a = [ - VarProperty(), - VarProperty(), - VarProperty(), + self.obj_prop_a = [ + ObjProperty(), + ObjProperty(), + ObjProperty(), ] - self.var_prop_b = set(self.var_prop_a) + self.obj_prop_b = set(self.obj_prop_a) - self.var_prop_c = { - "1": self.var_prop_a[0], - "2": self.var_prop_a[1], - "3": self.var_prop_a[2], + self.obj_prop_c = { + "1": self.obj_prop_a[0], + "2": self.obj_prop_a[1], + "3": self.obj_prop_a[2], } - @var_property + @eo_property def prop_a(self): """Test method""" - return self.var_prop_a + return self.obj_prop_a - @var_property + @eo_property def prop_b(self): """Test method""" - return self.var_prop_b + return self.obj_prop_b - @var_property + @eo_property def prop_c(self): """Test method""" - return self.var_prop_c + return self.obj_prop_c -class TestVariable(unittest.TestCase): +class TestObject(unittest.TestCase): """Test class""" - def test_variable(self): + def test_object(self): """Test method""" - var_prop = VarProperty() - var = Variable.from_var_property_object(var_prop) - self.assertEqual(getattr(var, "prop_a"), var_prop.prop_a) - self.assertEqual(getattr(var, "prop_b"), var_prop.prop_b) - self.assertEqual(getattr(var, "prop_c"), var_prop.prop_c) - self.assertFalse(hasattr(var, "prop_d")) + obj_prop = ObjProperty() + obj = EvalObject.from_eo_property_object(obj_prop) + self.assertEqual(getattr(obj, "prop_a"), obj_prop.prop_a) + self.assertEqual(getattr(obj, "prop_b"), obj_prop.prop_b) + self.assertEqual(getattr(obj, "prop_c"), obj_prop.prop_c) + self.assertFalse(hasattr(obj, "prop_d")) - def test_list_of_variables(self): + def test_list_of_objects(self): """Test method""" - var_prop_list = [ - VarProperty(), - VarProperty(), - VarProperty(), + obj_prop_list = [ + ObjProperty(), + ObjProperty(), + ObjProperty(), ] - var_list: List[Any] = Variable.from_var_property_object(var_prop_list) - self.assertEqual(len(var_prop_list), len(var_list)) - self.assertTrue(isinstance(var_list, list)) - length = len(var_prop_list) + obj_list: List[Any] = EvalObject.from_eo_property_object(obj_prop_list) + self.assertEqual(len(obj_prop_list), len(obj_list)) + self.assertTrue(isinstance(obj_list, list)) + length = len(obj_prop_list) for i in range(length): - self.assertEqual(getattr(var_list[i], "prop_a"), var_prop_list[i].prop_a) - self.assertEqual(getattr(var_list[i], "prop_b"), var_prop_list[i].prop_b) - self.assertEqual(getattr(var_list[i], "prop_c"), var_prop_list[i].prop_c) - self.assertFalse(hasattr(var_list[i], "prop_d")) + self.assertEqual(getattr(obj_list[i], "prop_a"), obj_prop_list[i].prop_a) + self.assertEqual(getattr(obj_list[i], "prop_b"), obj_prop_list[i].prop_b) + self.assertEqual(getattr(obj_list[i], "prop_c"), obj_prop_list[i].prop_c) + self.assertFalse(hasattr(obj_list[i], "prop_d")) - def test_set_of_variables(self): + def test_set_of_objects(self): """Test method""" - var_prop_list = [ - VarProperty(), - VarProperty(), - VarProperty(), + obj_prop_list = [ + ObjProperty(), + ObjProperty(), + ObjProperty(), ] - var_prop_set = set(var_prop_list) - var_set: Set[Any] = Variable.from_var_property_object(var_prop_set) - self.assertEqual(len(var_prop_set), len(var_set)) - self.assertTrue(isinstance(var_set, set)) + obj_prop_set = set(obj_prop_list) + obj_set: Set[Any] = EvalObject.from_eo_property_object(obj_prop_set) + self.assertEqual(len(obj_prop_set), len(obj_set)) + self.assertTrue(isinstance(obj_set, set)) index = 0 - for var in var_set: - self.assertEqual(getattr(var, "prop_a"), var_prop_list[index].prop_a) - self.assertEqual(getattr(var, "prop_b"), var_prop_list[index].prop_b) - self.assertEqual(getattr(var, "prop_c"), var_prop_list[index].prop_c) - self.assertFalse(hasattr(var, "prop_d")) + for obj in obj_set: + self.assertEqual(getattr(obj, "prop_a"), obj_prop_list[index].prop_a) + self.assertEqual(getattr(obj, "prop_b"), obj_prop_list[index].prop_b) + self.assertEqual(getattr(obj, "prop_c"), obj_prop_list[index].prop_c) + self.assertFalse(hasattr(obj, "prop_d")) index += 1 - def test_dict_of_variables(self): + def test_dict_of_objects(self): """Test method""" - var_prop_dict = { - "1": VarProperty(), - "2": VarProperty(), - "3": VarProperty(), + obj_prop_dict = { + "1": ObjProperty(), + "2": ObjProperty(), + "3": ObjProperty(), } - var_dict: Dict[Any, Any] = Variable.from_var_property_object(var_prop_dict) - self.assertEqual(len(var_prop_dict), len(var_dict)) - self.assertTrue(isinstance(var_dict, dict)) + obj_dict: Dict[Any, Any] = EvalObject.from_eo_property_object(obj_prop_dict) + self.assertEqual(len(obj_prop_dict), len(obj_dict)) + self.assertTrue(isinstance(obj_dict, dict)) - for key, var in var_dict.items(): - self.assertEqual(getattr(var, "prop_a"), var_prop_dict[key].prop_a) - self.assertEqual(getattr(var, "prop_b"), var_prop_dict[key].prop_b) - self.assertEqual(getattr(var, "prop_c"), var_prop_dict[key].prop_c) - self.assertFalse(hasattr(var, "prop_d")) + for key, obj in obj_dict.items(): + self.assertEqual(getattr(obj, "prop_a"), obj_prop_dict[key].prop_a) + self.assertEqual(getattr(obj, "prop_b"), obj_prop_dict[key].prop_b) + self.assertEqual(getattr(obj, "prop_c"), obj_prop_dict[key].prop_c) + self.assertFalse(hasattr(obj, "prop_d")) - def test_object(self): + def test_add_object(self): """Test method""" - var_prop = VarProperty() - var: Variable = Variable.from_var_property_object(var_prop) - self.assertFalse(hasattr(var, "prop_d")) - var.add_object(0, "prop_d") - self.assertTrue(hasattr(var, "prop_d")) + obj_prop = ObjProperty() + obj: EvalObject = EvalObject.from_eo_property_object(obj_prop) + self.assertFalse(hasattr(obj, "prop_d")) + obj.add_object(0, "prop_d") + self.assertTrue(hasattr(obj, "prop_d")) - def test_complex_variable(self): + def test_complex_objects(self): """Test method""" - complex_var = ComplexVariable() - var: ComplexVariable = Variable.from_var_property_object(complex_var) - self.assertTrue(isinstance(var.prop_a, list)) - self.assertTrue(isinstance(var.prop_b, set)) - self.assertTrue(isinstance(var.prop_c, dict)) + complex_obj = ComplexObject() + obj: ComplexObject = EvalObject.from_eo_property_object(complex_obj) + self.assertTrue(isinstance(obj.prop_a, list)) + self.assertTrue(isinstance(obj.prop_b, set)) + self.assertTrue(isinstance(obj.prop_c, dict)) - length = len(var.prop_a) + length = len(obj.prop_a) for i in range(length): - self.assertEqual(getattr(var.prop_a[i], "prop_a"), var.prop_a[i].prop_a) - self.assertEqual(getattr(var.prop_a[i], "prop_b"), var.prop_a[i].prop_b) - self.assertEqual(getattr(var.prop_a[i], "prop_c"), var.prop_a[i].prop_c) - - for var_b in var.prop_b: - self.assertEqual(getattr(var_b, "prop_a"), var.prop_a[0].prop_a) - self.assertEqual(getattr(var_b, "prop_b"), var.prop_a[0].prop_b) - self.assertEqual(getattr(var_b, "prop_c"), var.prop_a[0].prop_c) - - for key, var_c in var.prop_c.items(): - self.assertEqual(getattr(var_c, "prop_a"), var.prop_c[key].prop_a) - self.assertEqual(getattr(var_c, "prop_b"), var.prop_c[key].prop_b) - self.assertEqual(getattr(var_c, "prop_c"), var.prop_c[key].prop_c) + self.assertEqual(getattr(obj.prop_a[i], "prop_a"), obj.prop_a[i].prop_a) + self.assertEqual(getattr(obj.prop_a[i], "prop_b"), obj.prop_a[i].prop_b) + self.assertEqual(getattr(obj.prop_a[i], "prop_c"), obj.prop_a[i].prop_c) + + for obj_b in obj.prop_b: + self.assertEqual(getattr(obj_b, "prop_a"), obj.prop_a[0].prop_a) + self.assertEqual(getattr(obj_b, "prop_b"), obj.prop_a[0].prop_b) + self.assertEqual(getattr(obj_b, "prop_c"), obj.prop_a[0].prop_c) + + for key, obj_c in obj.prop_c.items(): + self.assertEqual(getattr(obj_c, "prop_a"), obj.prop_c[key].prop_a) + self.assertEqual(getattr(obj_c, "prop_b"), obj.prop_c[key].prop_b) + self.assertEqual(getattr(obj_c, "prop_c"), obj.prop_c[key].prop_c) if __name__ == "__main__":