def __init__(self, profile: Profile.Profile) -> None:
super().__init__()
# cache
self.__project_panel_items: typing.Optional[
typing.List[ProjectPanelItemLike]] = None
# define the top level list
self.__root_node = TreeNode()
# define events to make this a model
self.property_changed_event = Event.Event()
# define the closed items
self.__closed_items = set(profile.closed_items)
self.on_closed_items_changed: typing.Optional[typing.Callable[
[typing.Set[str]], None]] = None
def update_items(item: Observer.ItemValue) -> None:
if self.__project_panel_items is not None:
self.property_changed_event.fire("value")
# build an observer that will call update_items whenever any of the project_references changes.
oo = Observer.ObserverBuilder()
oo.source(profile).tuple(
oo.x.ordered_sequence_from_array(
"project_references").collect_list()).action_fn(update_items)
self.__profile_observer = typing.cast(Observer.AbstractItemSource,
oo.make_observable())
def __init__(self,
storage_system=None,
storage_cache=None,
*,
auto_project: bool = True):
super().__init__()
self.define_root_context()
self.define_type("profile")
self.define_relationship("workspaces", WorkspaceLayout.factory)
self.define_relationship("data_groups", DataGroup.data_group_factory)
self.define_relationship("project_references",
project_reference_factory,
insert=self.__insert_project_reference,
remove=self.__remove_project_reference)
self.define_property("workspace_uuid",
converter=Converter.UuidToStringConverter())
self.define_property(
"data_item_references", dict(), hidden=True
) # map string key to data item, used for data acquisition channels
self.define_property(
"data_item_variables", dict(), hidden=True
) # map string key to data item, used for reference in scripts
self.define_property("target_project_reference_uuid",
converter=Converter.UuidToStringConverter(),
changed=self.__property_changed)
self.define_property("work_project_reference_uuid",
converter=Converter.UuidToStringConverter(),
changed=self.__property_changed)
self.define_property("closed_items", list())
self.storage_system = storage_system or FileStorageSystem.MemoryPersistentStorageSystem(
)
self.storage_system.load_properties()
self.__work_project_reference: typing.Optional[ProjectReference] = None
self.__target_project_reference: typing.Optional[
ProjectReference] = None
self.storage_cache = storage_cache or Cache.DictStorageCache(
) # need to deallocate
self.set_storage_system(self.storage_system)
self.__document_model = None
self.profile_context = None
# helper object to produce the projects sequence
oo = Observer.ObserverBuilder()
oo.source(self).ordered_sequence_from_array("project_references").map(
oo.x.prop("project")).filter(lambda x: x is not None).trampoline(
self, "projects")
self.__projects_observer = oo.make_observable()
self.__is_read = False
if auto_project:
self.profile_context = MemoryProfileContext()
project_reference = self.add_project_memory()
self.work_project_reference_uuid = project_reference.uuid
self.target_project_reference_uuid = project_reference.uuid
def __init__(self, base_title: str,
data_group: typing.Optional[DataGroup.DataGroup],
filter_id: typing.Optional[str],
document_controller: DocumentController.DocumentController):
self.__base_title = base_title
self.__data_group = data_group
self.__filter_id = filter_id
self.__filter_predicate = document_controller.get_filter_predicate(
filter_id) if self.__filter_id else ListModel.Filter(True)
self.on_title_changed: typing.Optional[typing.Callable[[str],
None]] = None
self.__count = 0
# useful for drag and drop
self.document_controller = document_controller
self.document_model = document_controller.document_model
container = self.__data_group or document_controller.document_model
def count_changed(count: Observer.ItemValue) -> None:
self.__count = count
if callable(self.on_title_changed):
self.on_title_changed(self.title)
oo = Observer.ObserverBuilder()
oo.source(container).sequence_from_array(
"display_items",
predicate=self.__filter_predicate.matches).len().action_fn(
count_changed)
self.__count_observer = typing.cast(Observer.AbstractItemSource,
oo.make_observable())
def test_observer_action(self):
# configure the model
str_field = StructuredModel.define_field("s",
StructuredModel.STRING,
default="ss")
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
value = ""
class Action(Observer.AbstractAction):
def __init__(self, item_value):
nonlocal value
value = item_value
def close(self):
pass
oo = Observer.ObserverBuilder()
oo.source(model).prop("s").action(Action)
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
self.assertEqual("ss", value)
model.s = "tt"
self.assertEqual("tt", value)
def test_observer_item_ordered_sequence_len(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a",
array_field,
default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
length = 0
def len_changed(new_length: Observer.ItemValue) -> None:
nonlocal length
length = new_length
oo = Observer.ObserverBuilder()
oo.source(model).ordered_sequence_from_array("a").map(
oo.x.transform(lambda x: x.upper())).len().action_fn(len_changed)
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
# items will be ordered
self.assertEqual(3, length)
model.a.insert(1, "a-b")
self.assertEqual(4, length)
del model.a[0]
self.assertEqual(3, length)
def test_observer_item_sequence_filter(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a",
array_field,
default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
predicate = lambda x: not x.startswith("a")
oo.source(model).ordered_sequence_from_array("a").filter(predicate)
with contextlib.closing(
typing.cast(Observer.AbstractItemSequenceSource,
oo.make_observable())) as o:
# check the observer functionality
self.assertEqual(["b", "c"], o.items) # a, b, c
model.a.insert(1, "a-b")
self.assertEqual(["b", "c"], o.items) # a, a-b, b, c
model.a.insert(0, "b-a")
self.assertEqual(["b-a", "b", "c"], o.items) # b-a, a, a-b, b, c
del model.a[1]
self.assertEqual(["b-a", "b", "c"], o.items) # b-a, a-b, b, c
del model.a[2]
self.assertEqual(["b-a", "c"], o.items) # b-a, a-b, c
def test_observer_item_sequence_for_each(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a",
array_field,
default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
values = list()
class Action(Observer.AbstractAction):
def __init__(self, item_value):
nonlocal values
values.append(item_value)
def close(self):
pass
oo = Observer.ObserverBuilder()
oo.source(model).sequence_from_array("a").for_each(oo.x.action(Action))
with contextlib.closing(
typing.cast(Observer.AbstractItemSequenceSource,
oo.make_observable())) as o:
# check the observer functionality
# items will be unordered
self.assertEqual(["a", "b", "c"], values)
model.a.insert(1, "a-b")
self.assertEqual(["a", "b", "c", "a-b"], values)
def __init__(
self,
storage_system: typing.Optional[
FileStorageSystem.PersistentStorageSystem] = None,
storage_cache: typing.Optional[Cache.CacheLike] = None,
*,
profile_context: typing.Optional[ProfileContext] = None) -> None:
super().__init__()
self.__class__.count += 1
self.define_root_context()
self.define_type("profile")
self.define_property("last_project_reference",
converter=Converter.UuidToStringConverter(),
hidden=True)
self.define_property("work_project_reference_uuid",
converter=Converter.UuidToStringConverter(),
hidden=True)
self.define_property("closed_items", list(), hidden=True)
self.define_property("script_items_updated",
False,
changed=self.__property_changed,
hidden=True)
self.define_relationship("project_references",
project_reference_factory,
insert=self.__insert_project_reference,
remove=self.__remove_project_reference,
hidden=True)
self.define_relationship(
"script_items",
typing.cast(
typing.Callable[[typing.Callable[[str], str]],
typing.Optional[Persistence.PersistentObject]],
script_item_factory),
hidden=True)
self.storage_system = storage_system or FileStorageSystem.MemoryPersistentStorageSystem(
)
self.storage_system.load_properties()
self.storage_cache: typing.Any = storage_cache or Cache.DictStorageCache(
) # need to deallocate
self.set_storage_system(self.storage_system)
self.profile_context = None
# helper object to produce the projects sequence
oo = Observer.ObserverBuilder()
oo.source(typing.cast(
Observer.ItemValue,
self)).ordered_sequence_from_array("project_references").map(
oo.x.prop("project")).filter(
lambda x: x is not None).trampoline(self, "projects")
self.__projects_observer = oo.make_observable()
if profile_context:
self.profile_context = profile_context
self.add_project_memory()
def test_observer_item_constant(self):
# configure the model
str_field = StructuredModel.define_field("s", StructuredModel.STRING, default="ss")
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
oo.source(model).prop("s").constant("N/A")
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
self.assertEqual("N/A", o.item)
model.s = "tt"
self.assertEqual("N/A", o.item)
def test_observer_item_tuple(self):
# configure the model
str_field = StructuredModel.define_field("s", StructuredModel.STRING, default="ss")
number_field = StructuredModel.define_field("n", StructuredModel.INT, default=10)
schema = StructuredModel.define_record("R", [str_field, number_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
oo.source(model).tuple(oo.x.prop("s"), oo.x.prop("n"))
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
self.assertEqual(("ss", 10), o.item)
model.s = "tt"
self.assertEqual(("tt", 10), o.item)
model.n = 4
self.assertEqual(("tt", 4), o.item)
def test_observer_item_array(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a", array_field, default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
oo.source(model).array("a")
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
self.assertEqual(["a", "b", "c"], o.item)
model.a.insert(1, "a-b")
self.assertEqual(["a", "a-b", "b", "c"], o.item)
del model.a[2]
self.assertEqual(["a", "a-b", "c"], o.item)
def __init__(self, project_reference: Profile.ProjectReference):
self.__project_reference = project_reference
self.__count = 0
self.on_title_changed = None
def count_changed(count: Observer.ItemValue) -> None:
self.__count = count
if callable(self.on_title_changed):
self.on_title_changed(self.title)
oo = Observer.ObserverBuilder()
oo.source(
self.__project_reference).prop("project").sequence_from_array(
"display_items").len().action_fn(count_changed)
self.__count_observer = oo.make_observable()
def __init__(self, window: Window.Window, profile: Profile.Profile):
content_widget = window.ui.create_column_widget()
super().__init__(content_widget)
ui = window.ui
self._tree_model = TreeModel(profile)
def closed_items_changed(closed_items: typing.Set[str]) -> None:
profile.closed_items = list(closed_items)
self._tree_model.on_closed_items_changed = closed_items_changed
self._tree_selection = Selection.IndexedSelection(
Selection.Style.multiple)
projects_list_widget = Widgets.ListWidget(
ui,
ProjectTreeCanvasItemDelegate(window, self._tree_model),
selection=self._tree_selection,
v_scroll_enabled=False,
v_auto_resize=True)
projects_list_widget.wants_drag_events = True
projects_list_widget.bind_items(
Binding.PropertyBinding(self._tree_model, "value"))
projects_section = Widgets.SectionWidget(ui, _("Projects"),
projects_list_widget)
projects_section.expanded = True
content_widget.add(projects_section)
# configure an observer for watching for project references changes.
# this serves as the master updater for changes. move to document controller?
def project_references_changed(item: Observer.ItemValue) -> None:
# update the tree model.
project_references = typing.cast(
typing.Sequence[Profile.ProjectReference], item)
self._tree_model.update_project_references(project_references)
oo = Observer.ObserverBuilder()
oo.source(profile).ordered_sequence_from_array(
"project_references").collect_list().action_fn(
project_references_changed)
self.__projects_model_observer = typing.cast(
Observer.AbstractItemSource, oo.make_observable())
def test_observer_item_array_sequence(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a", array_field, default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
oo.source(model).sequence_from_array("a")
with contextlib.closing(typing.cast(Observer.AbstractItemSequenceSource, oo.make_observable())) as o:
# check the observer functionality
# items will be unordered
self.assertEqual(["a", "b", "c"], o.items)
model.a.insert(1, "a-b")
self.assertEqual(["a", "b", "c", "a-b"], o.items)
del model.a[0]
self.assertEqual(["b", "c", "a-b"], o.items)
def test_observer_item_sequence_index(self):
# configure the model
array_field = StructuredModel.define_array(StructuredModel.STRING)
str_field = StructuredModel.define_field("a", array_field, default=["a", "b", "c"])
schema = StructuredModel.define_record("R", [str_field])
model = StructuredModel.build_model(schema)
# build the observer
oo = Observer.ObserverBuilder()
oo.source(model).ordered_sequence_from_array("a").map(oo.x.transform(lambda x: x.upper())).index(0)
with contextlib.closing(oo.make_observable()) as o:
# check the observer functionality
# items will be ordered
self.assertEqual("A", o.item)
model.a.insert(1, "a-b")
self.assertEqual("A", o.item)
del model.a[0]
self.assertEqual("A-B", o.item)
def __init__(self, project_reference: Profile.ProjectReference):
self.__project_reference = project_reference
self.__count = 0
self.on_title_changed: typing.Optional[typing.Callable[[str],
None]] = None
def count_changed(count: Observer.ItemValue) -> None:
self.__count = count
if callable(self.on_title_changed):
self.on_title_changed(self.title)
oo = Observer.ObserverBuilder()
oo.source(
self.__project_reference).prop("project").sequence_from_array(
"display_items").len().action_fn(count_changed)
self.__count_observer = typing.cast(Observer.AbstractItemSource,
oo.make_observable())
def __init__(self,
storage_system=None,
storage_cache=None,
*,
profile_context: typing.Optional[ProfileContext] = None):
super().__init__()
self.__class__.count += 1
self.define_root_context()
self.define_type("profile")
self.define_relationship("project_references",
project_reference_factory,
insert=self.__insert_project_reference,
remove=self.__remove_project_reference)
self.define_property("last_project_reference",
converter=Converter.UuidToStringConverter())
self.define_property("work_project_reference_uuid",
converter=Converter.UuidToStringConverter())
self.define_property("closed_items", list())
self.storage_system = storage_system or FileStorageSystem.MemoryPersistentStorageSystem(
)
self.storage_system.load_properties()
self.storage_cache = storage_cache or Cache.DictStorageCache(
) # need to deallocate
self.set_storage_system(self.storage_system)
self.profile_context = None
# helper object to produce the projects sequence
oo = Observer.ObserverBuilder()
oo.source(self).ordered_sequence_from_array("project_references").map(
oo.x.prop("project")).filter(lambda x: x is not None).trampoline(
self, "projects")
self.__projects_observer = oo.make_observable()
if profile_context:
self.profile_context = profile_context
self.add_project_memory()
