ITQC/pydase
24
0
Fork 0
mirror of https://github.com/tiqi-group/pydase.git synced 2025-06-23 12:37:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

moving from _full_access_name to callbacks

Browse Source
This commit is contained in:
Mose Müller
2023-08-02 12:06:19 +02:00
parent b67c0f9da3
commit 460be17ecb
5 changed files with 671 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
tests/__init__.py
View File

@ -0,0 +1,13 @@
from typing import Any
from pyDataInterface import DataService
def emit(self: Any, parent_path: str, name: str, value: Any) -> None:
if isinstance(value, DataService):
value = value.serialize()
print(f"{parent_path}.{name} = {value}")
DataService._emit_notification = emit # type: ignore

51
tests/test_emit_on_change.py → tests/test_DataServiceList.py
View File

@ -1,45 +1,8 @@
from typing import Any
from pytest import CaptureFixture
from pyDataInterface import DataService
def emit(self: Any, access_path: set[str], name: str, value: Any) -> None:
if isinstance(value, DataService):
value = value.serialize()
for path in access_path:
print(f"{path}.{name} = {value}")
DataService._emit = emit # type: ignore
def test_class_attribute(capsys: CaptureFixture) -> None:
class ServiceClass(DataService):
attr = 0
service_instance = ServiceClass()
service_instance.attr = 1
captured = capsys.readouterr()
assert captured.out == "ServiceClass.attr = 1\n"
def test_instance_attribute(capsys: CaptureFixture) -> None:
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr = "Hello World"
super().__init__()
service_instance = ServiceClass()
service_instance.attr = "Hello"
captured = capsys.readouterr()
assert captured.out == "ServiceClass.attr = Hello\n"
def test_class_list_attribute(capsys: CaptureFixture) -> None:
class ServiceClass(DataService):
attr = [0, 1]
@ -89,15 +52,15 @@ def test_reused_instance_list_attribute(capsys: CaptureFixture) -> None:
service_instance = ServiceClass()
service_instance.attr[0] = "Hello"
service_instance.attr[0] = 20
captured = capsys.readouterr()
assert service_instance.attr == service_instance.attr_2
assert service_instance.attr != service_instance.attr_3
expected_output = sorted(
[
"ServiceClass.attr[0] = Hello",
"ServiceClass.attr_2[0] = Hello",
"ServiceClass.attr[0] = 20",
"ServiceClass.attr_2[0] = 20",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
@ -123,15 +86,15 @@ def test_nested_reused_instance_list_attribute(capsys: CaptureFixture) -> None:
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr[0] = "Hello"
service_instance.attr[0] = 20
captured = capsys.readouterr()
assert service_instance.attr == service_instance.subclass.attr_list
expected_output = sorted(
[
"ServiceClass.subclass.attr_list_2[0] = Hello",
"ServiceClass.subclass.attr_list[0] = Hello",
"ServiceClass.attr[0] = Hello",
"ServiceClass.subclass.attr_list_2[0] = 20",
"ServiceClass.subclass.attr_list[0] = 20",
"ServiceClass.attr[0] = 20",
]
)
actual_output = sorted(captured.out.strip().split("\n"))

568
tests/test_DataService_attribute_callbacks.py Normal file
View File

@ -0,0 +1,568 @@
from pytest import CaptureFixture
from pyDataInterface import DataService
def test_class_attributes(capsys: CaptureFixture) -> None:
class SubClass(DataService):
name = "Hello"
class ServiceClass(DataService):
attr_1 = SubClass()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr_1.name = "Hi"
captured = capsys.readouterr()
assert captured.out.strip() == "ServiceClass.attr_1.name = Hi"
def test_instance_attributes(capsys: CaptureFixture) -> None:
class SubClass(DataService):
name = "Hello"
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr_1 = SubClass()
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr_1.name = "Hi"
captured = capsys.readouterr()
assert captured.out.strip() == "ServiceClass.attr_1.name = Hi"
def test_class_attribute(capsys: CaptureFixture) -> None:
class ServiceClass(DataService):
attr = 0
service_instance = ServiceClass()
service_instance.attr = 1
captured = capsys.readouterr()
assert captured.out == "ServiceClass.attr = 1\n"
def test_instance_attribute(capsys: CaptureFixture) -> None:
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr = "Hello World"
super().__init__()
service_instance = ServiceClass()
service_instance.attr = "Hello"
captured = capsys.readouterr()
assert captured.out == "ServiceClass.attr = Hello\n"
def test_reused_instance_attributes(capsys: CaptureFixture) -> None:
class SubClass(DataService):
name = "Hello"
subclass_instance = SubClass()
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr_1 = subclass_instance
self.attr_2 = subclass_instance
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr_1.name = "Hi"
captured = capsys.readouterr()
assert service_instance.attr_1 == service_instance.attr_2
expected_output = sorted(
[
"ServiceClass.attr_1.name = Hi",
"ServiceClass.attr_2.name = Hi",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_reused_attributes_mixed(capsys: CaptureFixture) -> None:
class SubClass(DataService):
pass
subclass_instance = SubClass()
class ServiceClass(DataService):
attr_1 = subclass_instance
def __init__(self) -> None:
self.attr_2 = subclass_instance
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr_1.name = "Hi"
captured = capsys.readouterr()
assert service_instance.attr_1 == service_instance.attr_2
expected_output = sorted(
[
"ServiceClass.attr_1.name = Hi",
"ServiceClass.attr_2.name = Hi",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_nested_class_attributes(capsys: CaptureFixture) -> None:
class SubSubSubClass(DataService):
name = "Hello"
class SubSubClass(DataService):
name = "Hello"
attr = SubSubSubClass()
class SubClass(DataService):
name = "Hello"
attr = SubSubClass()
class ServiceClass(DataService):
name = "Hello"
attr = SubClass()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr.attr.attr.name = "Hi"
service_instance.attr.attr.name = "Hou"
service_instance.attr.name = "foo"
service_instance.name = "bar"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Hi",
"ServiceClass.attr.attr.name = Hou",
"ServiceClass.attr.name = foo",
"ServiceClass.name = bar",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_nested_instance_attributes(capsys: CaptureFixture) -> None:
class SubSubSubClass(DataService):
name = "Hello"
class SubSubClass(DataService):
def __init__(self) -> None:
self.attr = SubSubSubClass()
self.name = "Hello"
super().__init__()
class SubClass(DataService):
def __init__(self) -> None:
self.attr = SubSubClass()
self.name = "Hello"
super().__init__()
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr = SubClass()
self.name = "Hello"
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr.attr.attr.name = "Hi"
service_instance.attr.attr.name = "Hou"
service_instance.attr.name = "foo"
service_instance.name = "bar"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Hi",
"ServiceClass.attr.attr.name = Hou",
"ServiceClass.attr.name = foo",
"ServiceClass.name = bar",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_advanced_nested_class_attributes(capsys: CaptureFixture) -> None:
class SubSubSubClass(DataService):
name = "Hello"
class SubSubClass(DataService):
attr = SubSubSubClass()
class SubClass(DataService):
attr = SubSubClass()
class ServiceClass(DataService):
attr = SubClass()
subattr = SubSubClass()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr.attr.attr.name = "Hi"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Hi",
"ServiceClass.subattr.attr.name = Hi",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.subattr.attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Ho",
"ServiceClass.subattr.attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_advanced_nested_instance_attributes(capsys: CaptureFixture) -> None:
class SubSubSubClass(DataService):
name = "Hello"
class SubSubClass(DataService):
def __init__(self) -> None:
self.attr = SubSubSubClass()
super().__init__()
subsubclass_instance = SubSubClass()
class SubClass(DataService):
def __init__(self) -> None:
self.attr = subsubclass_instance
super().__init__()
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr = SubClass()
self.subattr = subsubclass_instance
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
service_instance.attr.attr.attr.name = "Hi"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Hi",
"ServiceClass.subattr.attr.name = Hi",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.subattr.attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.attr.attr.name = Ho",
"ServiceClass.subattr.attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_advanced_nested_attributes_mixed(capsys: CaptureFixture) -> None:
class SubSubClass(DataService):
name = "Hello"
class SubClass(DataService):
class_attr = SubSubClass()
def __init__(self) -> None:
self.attr_1 = SubSubClass()
super().__init__()
class ServiceClass(DataService):
class_attr = SubClass()
def __init__(self) -> None:
self.attr = SubClass()
super().__init__()
service_instance = ServiceClass()
# Subclass.attr is the same for all instances
assert service_instance.attr.class_attr == service_instance.class_attr.class_attr
# attr_1 is different for all instances of SubClass
assert service_instance.attr.attr_1 != service_instance.class_attr.attr_1
# instances of SubSubClass are unequal
assert service_instance.attr.attr_1 != service_instance.class_attr.class_attr
_ = capsys.readouterr()
service_instance.class_attr.class_attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.class_attr.class_attr.name = Ho",
"ServiceClass.attr.class_attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.class_attr.attr_1.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(["ServiceClass.class_attr.attr_1.name = Ho"])
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr.class_attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.class_attr.name = Ho",
"ServiceClass.class_attr.class_attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr.attr_1.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(["ServiceClass.attr.attr_1.name = Ho"])
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_class_list_attributes(capsys: CaptureFixture) -> None:
class SubClass(DataService):
name = "Hello"
subclass_instance = SubClass()
class ServiceClass(DataService):
attr_list = [SubClass() for _ in range(2)]
attr_list_2 = [subclass_instance, subclass_instance]
attr = subclass_instance
service_instance = ServiceClass()
_ = capsys.readouterr()
assert service_instance.attr_list[0] != service_instance.attr_list[1]
service_instance.attr_list[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr_list[0].name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr_list[1].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr_list[1].name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
assert service_instance.attr_list_2[0] == service_instance.attr
assert service_instance.attr_list_2[0] == service_instance.attr_list_2[1]
service_instance.attr_list_2[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr_list_2[0].name = Ho",
"ServiceClass.attr_list_2[1].name = Ho",
"ServiceClass.attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr_list_2[1].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr_list_2[0].name = Ho",
"ServiceClass.attr_list_2[1].name = Ho",
"ServiceClass.attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_nested_class_list_attributes(capsys: CaptureFixture) -> None:
class SubSubClass(DataService):
name = "Hello"
subsubclass_instance = SubSubClass()
class SubClass(DataService):
attr_list = [subsubclass_instance]
class ServiceClass(DataService):
attr = [SubClass()]
subattr = subsubclass_instance
service_instance = ServiceClass()
_ = capsys.readouterr()
assert service_instance.attr[0].attr_list[0] == service_instance.subattr
service_instance.attr[0].attr_list[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr[0].attr_list[0].name = Ho",
"ServiceClass.subattr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.subattr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr[0].attr_list[0].name = Ho",
"ServiceClass.subattr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_instance_list_attributes(capsys: CaptureFixture) -> None:
class SubClass(DataService):
name = "Hello"
subclass_instance = SubClass()
class ServiceClass(DataService):
def __init__(self) -> None:
self.attr_list = [SubClass() for _ in range(2)]
self.attr_list_2 = [subclass_instance, subclass_instance]
self.attr = subclass_instance
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
assert service_instance.attr_list[0] != service_instance.attr_list[1]
service_instance.attr_list[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(["ServiceClass.attr_list[0].name = Ho"])
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr_list[1].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(["ServiceClass.attr_list[1].name = Ho"])
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
assert service_instance.attr_list_2[0] == service_instance.attr
assert service_instance.attr_list_2[0] == service_instance.attr_list_2[1]
service_instance.attr_list_2[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.name = Ho",
"ServiceClass.attr_list_2[0].name = Ho",
"ServiceClass.attr_list_2[1].name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr_list_2[1].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.name = Ho",
"ServiceClass.attr_list_2[0].name = Ho",
"ServiceClass.attr_list_2[1].name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr.name = Ho",
"ServiceClass.attr_list_2[0].name = Ho",
"ServiceClass.attr_list_2[1].name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
def test_nested_instance_list_attributes(capsys: CaptureFixture) -> None:
class SubSubClass(DataService):
name = "Hello"
subsubclass_instance = SubSubClass()
class SubClass(DataService):
def __init__(self) -> None:
self.attr_list = [subsubclass_instance]
super().__init__()
class ServiceClass(DataService):
class_attr = subsubclass_instance
def __init__(self) -> None:
self.attr = [SubClass()]
super().__init__()
service_instance = ServiceClass()
_ = capsys.readouterr()
assert service_instance.attr[0].attr_list[0] == service_instance.class_attr
service_instance.attr[0].attr_list[0].name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr[0].attr_list[0].name = Ho",
"ServiceClass.class_attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output
service_instance.class_attr.name = "Ho"
captured = capsys.readouterr()
expected_output = sorted(
[
"ServiceClass.attr[0].attr_list[0].name = Ho",
"ServiceClass.class_attr.name = Ho",
]
)
actual_output = sorted(captured.out.strip().split("\n"))
assert actual_output == expected_output

364
tests/test_full_access_path.py
View File

@ -1,364 +0,0 @@
from pyDataInterface import DataService
def test_class_attributes() -> None:
class SubClass(DataService):
pass
class ServiceClass(DataService):
attr_1 = SubClass()
test_service = ServiceClass()
assert test_service.attr_1._full_access_path == {"ServiceClass.attr_1"}
def test_instance_attributes() -> None:
class SubClass(DataService):
pass
class ServiceClass(DataService):
def __init__(self):
self.attr_1 = SubClass()
super().__init__()
test_service = ServiceClass()
assert test_service.attr_1._full_access_path == {"ServiceClass.attr_1"}
def test_reused_instance_attributes() -> None:
class SubClass(DataService):
pass
subclass_instance = SubClass()
class ServiceClass(DataService):
def __init__(self):
self.attr_1 = subclass_instance
self.attr_2 = subclass_instance
super().__init__()
test_service = ServiceClass()
assert test_service.attr_1._full_access_path == {
"ServiceClass.attr_1",
"ServiceClass.attr_2",
}
assert test_service.attr_2._full_access_path == {
"ServiceClass.attr_1",
"ServiceClass.attr_2",
}
assert test_service.attr_1._full_access_path == {
"ServiceClass.attr_1",
"ServiceClass.attr_2",
}
def test_reused_attributes_mixed() -> None:
class SubClass(DataService):
pass
subclass_instance = SubClass()
class ServiceClass(DataService):
attr_1 = subclass_instance
def __init__(self):
self.attr_2 = subclass_instance
super().__init__()
test_service = ServiceClass()
assert test_service.attr_1._full_access_path == {
"ServiceClass.attr_1",
"ServiceClass.attr_2",
}
assert test_service.attr_2._full_access_path == {
"ServiceClass.attr_1",
"ServiceClass.attr_2",
}
def test_nested_class_attributes() -> None:
class SubSubSubClass(DataService):
pass
class SubSubClass(DataService):
attr = SubSubSubClass()
class SubClass(DataService):
attr = SubSubClass()
class ServiceClass(DataService):
attr = SubClass()
test_service = ServiceClass()
assert test_service.attr._full_access_path == {
"ServiceClass.attr",
}
assert test_service.attr.attr._full_access_path == {
"ServiceClass.attr.attr",
}
assert test_service.attr.attr.attr._full_access_path == {
"ServiceClass.attr.attr.attr",
}
def test_nested_instance_attributes() -> None:
class SubSubSubClass(DataService):
pass
class SubSubClass(DataService):
def __init__(self):
self.attr = SubSubSubClass()
super().__init__()
class SubClass(DataService):
def __init__(self):
self.attr = SubSubClass()
super().__init__()
class ServiceClass(DataService):
def __init__(self):
self.attr = SubClass()
super().__init__()
test_service = ServiceClass()
assert test_service.attr._full_access_path == {
"ServiceClass.attr",
}
assert test_service.attr.attr._full_access_path == {
"ServiceClass.attr.attr",
}
assert test_service.attr.attr.attr._full_access_path == {
"ServiceClass.attr.attr.attr",
}
def test_advanced_nested_instance_attributes() -> None:
class SubSubSubClass(DataService):
pass
class SubSubClass(DataService):
def __init__(self):
self.attr = SubSubSubClass()
super().__init__()
subsubclass_instance = SubSubClass()
class SubClass(DataService):
def __init__(self):
self.attr = subsubclass_instance
super().__init__()
class ServiceClass(DataService):
def __init__(self):
self.attr = SubClass()
self.subattr = subsubclass_instance
super().__init__()
test_service = ServiceClass()
assert test_service.attr._full_access_path == {
"ServiceClass.attr",
}
assert test_service.attr.attr._full_access_path == {
"ServiceClass.attr.attr",
"ServiceClass.subattr",
}
assert test_service.attr.attr.attr._full_access_path == {
"ServiceClass.attr.attr.attr",
"ServiceClass.subattr.attr", # as the SubSubSubClass does not implement anything, both subattr.attr and attr.attr.attr refer to the same instance
}
def test_advanced_nested_class_attributes() -> None:
class SubSubSubClass(DataService):
pass
class SubSubClass(DataService):
attr = SubSubSubClass()
class SubClass(DataService):
attr = SubSubClass()
class ServiceClass(DataService):
attr = SubClass()
subattr = SubSubClass()
test_service = ServiceClass()
assert test_service.attr._full_access_path == {
"ServiceClass.attr",
}
assert test_service.subattr._full_access_path == {
"ServiceClass.subattr",
}
assert test_service.attr.attr._full_access_path == {
"ServiceClass.attr.attr",
}
assert test_service.attr.attr.attr._full_access_path == {
"ServiceClass.attr.attr.attr",
"ServiceClass.subattr.attr", # as the SubSubSubClass does not implement anything, both subattr.attr and attr.attr.attr refer to the same instance
}
def test_advanced_nested_attributes_mixed() -> None:
class SubSubClass(DataService):
pass
class SubClass(DataService):
attr = SubSubClass()
def __init__(self):
self.attr_1 = SubSubClass()
super().__init__()
class ServiceClass(DataService):
subattr = SubClass()
def __init__(self):
self.attr = SubClass()
super().__init__()
test_service = ServiceClass()
assert test_service.attr._full_access_path == {
"ServiceClass.attr",
}
assert test_service.subattr._full_access_path == {
"ServiceClass.subattr",
}
# Subclass.attr is the same for all instances
assert test_service.attr.attr == test_service.subattr.attr
assert test_service.attr.attr._full_access_path == {
"ServiceClass.attr.attr",
"ServiceClass.subattr.attr",
}
assert test_service.subattr.attr._full_access_path == {
"ServiceClass.subattr.attr",
"ServiceClass.attr.attr",
}
# attr_1 is different for all instances of SubClass
assert test_service.attr.attr_1 != test_service.subattr.attr
assert test_service.attr.attr_1 != test_service.subattr.attr_1
assert test_service.subattr.attr_1._full_access_path == {
"ServiceClass.subattr.attr_1",
}
assert test_service.attr.attr_1._full_access_path == {
"ServiceClass.attr.attr_1",
}
def test_class_list_attributes() -> None:
class SubClass(DataService):
pass
subclass_instance = SubClass()
class ServiceClass(DataService):
attr_list = [SubClass() for _ in range(2)]
attr_list_2 = [subclass_instance, subclass_instance]
attr = subclass_instance
test_service = ServiceClass()
assert test_service.attr_list[0] != test_service.attr_list[1]
assert test_service.attr_list[0]._full_access_path == {
"ServiceClass.attr_list[0]",
}
assert test_service.attr_list[1]._full_access_path == {
"ServiceClass.attr_list[1]",
}
assert test_service.attr_list_2[0] == test_service.attr
assert test_service.attr_list_2[0] == test_service.attr_list_2[1]
assert test_service.attr_list_2[0]._full_access_path == {
"ServiceClass.attr",
"ServiceClass.attr_list_2[0]",
"ServiceClass.attr_list_2[1]",
}
assert test_service.attr_list_2[1]._full_access_path == {
"ServiceClass.attr",
"ServiceClass.attr_list_2[0]",
"ServiceClass.attr_list_2[1]",
}
def test_nested_class_list_attributes() -> None:
class SubSubClass(DataService):
pass
subsubclass_instance = SubSubClass()
class SubClass(DataService):
attr_list = [subsubclass_instance]
class ServiceClass(DataService):
attr = [SubClass()]
subattr = subsubclass_instance
test_service = ServiceClass()
assert test_service.attr[0].attr_list[0] == test_service.subattr
assert test_service.attr[0].attr_list[0]._full_access_path == {
"ServiceClass.attr[0].attr_list[0]",
"ServiceClass.subattr",
}
def test_instance_list_attributes() -> None:
class SubClass(DataService):
pass
subclass_instance = SubClass()
class ServiceClass(DataService):
def __init__(self):
self.attr_list = [SubClass() for _ in range(2)]
self.attr_list_2 = [subclass_instance, subclass_instance]
self.attr = subclass_instance
super().__init__()
test_service = ServiceClass()
assert test_service.attr_list[0] != test_service.attr_list[1]
assert test_service.attr_list[0]._full_access_path == {
"ServiceClass.attr_list[0]",
}
assert test_service.attr_list[1]._full_access_path == {
"ServiceClass.attr_list[1]",
}
assert test_service.attr_list_2[0] == test_service.attr
assert test_service.attr_list_2[0] == test_service.attr_list_2[1]
assert test_service.attr_list_2[0]._full_access_path == {
"ServiceClass.attr",
"ServiceClass.attr_list_2[0]",
"ServiceClass.attr_list_2[1]",
}
assert test_service.attr_list_2[1]._full_access_path == {
"ServiceClass.attr",
"ServiceClass.attr_list_2[0]",
"ServiceClass.attr_list_2[1]",
}
def test_nested_instance_list_attributes() -> None:
class SubSubClass(DataService):
pass
subsubclass_instance = SubSubClass()
class SubClass(DataService):
def __init__(self):
self.attr_list = [subsubclass_instance]
super().__init__()
class ServiceClass(DataService):
subattr = subsubclass_instance
def __init__(self):
self.attr = [SubClass()]
super().__init__()
test_service = ServiceClass()
assert test_service.attr[0].attr_list[0] == test_service.subattr
assert test_service.attr[0].attr_list[0]._full_access_path == {
"ServiceClass.attr[0].attr_list[0]",
"ServiceClass.subattr",
}