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 = 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 = oo.make_observable()
def __init__(self, profile: Profile.Profile): # cache self.__project_panel_items = 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 = 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 = 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 __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 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, 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_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 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 __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()