fmtr.tools 1.1.1__py3-none-any.whl → 1.3.81__py3-none-any.whl

fmtr/tools/inherit_tools.py

@@ -0,0 +1,27 @@
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+
+class Inherit(Generic[T]):
+    """
+
+    Runtime inheritance. Acts like a wrapper around an instantiated base class of type T, and allows overriding methods in subclasses like regular inheritance.
+
+    """
+
+    def __init__(self, parent: T):
+        """
+
+        Set parent
+
+        """
+        object.__setattr__(self, "_parent", parent)
+
+    def __getattr__(self, name):
+        """
+
+        Since regular attribute access checks own methods first, we don't need to do anything fancy to fall back to the parent when not implemented.
+
+        """
+        return getattr(self._parent, name)

fmtr/tools/interface_tools/__init__.py

@@ -0,0 +1,8 @@
+from fmtr.tools.import_tools import MissingExtraMockModule
+
+try:
+    from fmtr.tools.interface_tools.interface_tools import Base, update, progress
+    from fmtr.tools.interface_tools import controls
+    from fmtr.tools.interface_tools.context import Context
+except ModuleNotFoundError as exception:
+    Interface = update = progress = controls = MissingExtraMockModule('interface', exception)

fmtr/tools/interface_tools/context.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+from flet.core.page import Page
+
+
+@dataclass
+class Context:
+    """
+
+    Base context class
+
+    """
+    page: Page

fmtr/tools/interface_tools/controls.py

@@ -0,0 +1,354 @@
+import flet as ft
+from dataclasses import dataclass
+from flet.core.gesture_detector import TapEvent
+from flet.core.page import Page
+from flet.core.types import ColorValue, IconValue
+from functools import cached_property
+from typing import Optional
+
+from fmtr.tools.logging_tools import logger
+
+
+class SliderSteps(ft.Slider):
+    """
+
+    Slider control using step instead of divisions
+
+    """
+
+    def __init__(self, *args, min=10, max=100, step=10, **kwargs):
+        self.step = step
+        divisions = (max - min) // step
+        super().__init__(*args, min=min, max=max, divisions=divisions, **kwargs)
+
+
+class Cell(ft.DataCell):
+    """
+
+    Context-aware, clickable data cell.
+
+    """
+
+    def __init__(self, series, column):
+        """
+
+        Store context
+
+        """
+        self.series = series
+        self.column = column
+        self.value = series[column]
+
+        super().__init__(self.gesture_detector)
+
+    @cached_property
+    def text(self):
+        """
+
+        Cell contents text
+
+        """
+
+        return ft.Text(str(self.value), color=self.color, bgcolor=self.bgcolor)
+
+    @property
+    def color(self):
+        """
+
+        Basic conditional formatting
+
+        """
+        if self.value is None:
+            return ft.Colors.GREY
+        else:
+            return None
+
+    @property
+    def bgcolor(self):
+        """
+
+        Basic conditional formatting
+
+        """
+        return None
+
+    @cached_property
+    def gesture_detector(self):
+        """
+
+        Make arbitrary content clickable
+
+        """
+        return ft.GestureDetector(content=self.text, on_tap=self.click_tap, on_double_tap=self.click_double_tap)
+
+    async def click_tap(self, event: TapEvent):
+        """
+
+        Default cell click behavior — override in subclass if needed
+
+        """
+        value = await self.click(event=event)
+        event.page.update()
+        return value
+
+    async def click(self, event: Optional[TapEvent] = None):
+        """
+
+        Default cell click behavior — override in subclass if needed
+
+        """
+        logger.info(f"Clicked {self.column=} {self.series.name=} {self.value=}")
+
+    async def click_double_tap(self, event: TapEvent):
+        """
+
+        Default cell click behavior — override in subclass if needed
+
+        """
+        value = await self.double_click(event=event)
+        event.page.update()
+        return value
+
+    async def double_click(self, event: Optional[TapEvent] = None):
+        """
+
+        Default cell double click behavior — override in subclass if needed
+
+        """
+        logger.info(f"Double-clicked {self.column=} {self.series.id=} {self.value=}")
+
+
+class Row(ft.DataRow):
+    """
+
+    Instantiate a row from a series
+
+    """
+
+    TypesCells = {None: Cell}
+
+    def __init__(self, series):
+        self.series = series
+        super().__init__(self.cells_controls, color=self.row_color)
+
+    @cached_property
+    def cells_data(self) -> dict[str, list[Cell]]:
+        """
+
+        Cell controls lookup
+
+        """
+        data = {}
+        for col in self.series.index:
+            default = self.TypesCells[None]
+            TypeCell = self.TypesCells.get(col, default)
+            data.setdefault(col, []).append(TypeCell(self.series, col))
+        return data
+
+    @cached_property
+    def cells_controls(self) -> list[Cell]:
+        """
+
+        Flat list of controls
+
+        """
+        controls = []
+        for cells in self.cells_data.values():
+            for cell in cells:
+                controls.append(cell)
+        return controls
+
+    def __getitem__(self, item) -> list[Cell]:
+        """
+
+        Get cells by column name
+
+        """
+        return self.cells_data[item]
+
+    @property
+    def row_color(self):
+        """
+
+        Basic conditional formatting
+
+        """
+        return None
+
+
+class Column(ft.DataColumn):
+    """
+
+    Column stub
+
+    """
+
+    def __init__(self, col_name: str):
+        """
+
+        Store context
+
+        """
+
+        self.col_name = col_name
+
+        super().__init__(label=self.text)
+
+    @cached_property
+    def text(self):
+        """
+
+        Cell contents text
+
+        """
+        return ft.Text(str(self.col_name), weight=self.weight)
+
+    @property
+    def weight(self):
+        """
+
+        Default bold headers
+
+        """
+        return ft.FontWeight.BOLD
+
+
+class Table(ft.DataTable):
+    """
+
+    Dataframe with clickable cells
+
+    """
+
+    TypesRows = {None: Row}
+    TypesColumns = {None: Column}
+
+    def __init__(self, df):  # todo move to submodule with tabular deps
+        """
+
+        Set columns/rows using relevant types
+
+        """
+        self.df = df
+        super().__init__(columns=self.columns_controls, rows=self.rows_controls)
+
+    @cached_property
+    def columns_data(self) -> dict[str, list[Column]]:
+        """
+
+        Columns controls lookup
+
+        """
+        data = {}
+        for col in self.df.columns:
+            default = self.TypesColumns[None]
+            TypeColumn = self.TypesColumns.get(col, default)
+            data.setdefault(col, []).append(TypeColumn(col))
+        return data
+
+    @cached_property
+    def columns_controls(self) -> list[Column]:
+        """
+
+        Flat list of controls
+
+        """
+        controls = []
+        for columns in self.columns_data.values():
+            for column in columns:
+                controls.append(column)
+        return controls
+
+    @cached_property
+    def rows_data(self) -> dict[str, list[Row]]:
+        """
+
+        Row controls lookup
+
+        """
+        data = {}
+        for index, row in self.df.iterrows():
+            default = self.TypesRows[None]
+            TypeRow = self.TypesRows.get(index, default)
+            data.setdefault(index, []).append(TypeRow(row))
+        return data
+
+    @cached_property
+    def rows_controls(self) -> list[Row]:
+        """
+
+        Flat list of controls
+
+        """
+        controls = []
+        for rows in self.rows_data.values():
+            for row in rows:
+                controls.append(row)
+        return controls
+
+    def __getitem__(self, item) -> list[Row]:
+        """
+
+        Get row by index
+
+        """
+
+        return self.rows_data[item]
+
+
+@dataclass
+class NotificationDatum:
+    """
+
+    Color and icon for notification bar
+
+    """
+    color: ColorValue
+    icon: IconValue
+
+
+class NotificationBar(ft.SnackBar):
+    """
+
+    Combined logging and notification bar: infers the appropriate UI representation from the log level
+
+    """
+    DATA = {
+        logger.info: NotificationDatum(color=ft.Colors.BLUE, icon=ft.Icons.INFO),
+        logger.warning: NotificationDatum(color=ft.Colors.AMBER, icon=ft.Icons.WARNING),
+        logger.error: NotificationDatum(color=ft.Colors.RED, icon=ft.Icons.ERROR),
+        logger.debug: NotificationDatum(color=ft.Colors.GREY, icon=ft.Icons.BUG_REPORT),
+        logger.exception: NotificationDatum(color=ft.Colors.RED_ACCENT, icon=ft.Icons.REPORT),
+    }
+
+    def __init__(self, msg: str, method=logger.info):
+        """
+
+        Log the message immediately, otherwise configure notification bar icon/color.
+
+        """
+        self.msg = msg
+        self.method = method
+        self.method(msg)
+
+        icon = ft.Icon(self.data.icon, color=self.data.color)
+        text = ft.Text(self.msg)
+        content = ft.Row(controls=[icon, text])
+        super().__init__(content=content)
+
+    @cached_property
+    def data(self) -> NotificationDatum:
+        """
+
+        Fetching data using logging method.
+
+        """
+        return self.DATA[self.method]
+
+    def show(self, page: Page):
+        """
+
+        Show the notification on the relevant page.
+
+        """
+        page.open(self)

fmtr/tools/interface_tools/interface_tools.py

@@ -0,0 +1,189 @@
+import os
+from typing import TypeVar, Generic, Type
+
+import flet as ft
+from flet.core.control_event import ControlEvent
+from flet.core.types import AppView
+from flet.core.view import View
+
+from fmtr.tools import environment_tools
+from fmtr.tools.constants import Constants
+from fmtr.tools.function_tools import MethodDecorator
+from fmtr.tools.interface_tools.context import Context
+from fmtr.tools.logging_tools import logger
+
+
+class update(MethodDecorator):
+    """
+
+    Update the page after the decorated function is called.
+
+    """
+
+    def stop(self, instance, *args, **kwargs):
+        instance.page.update()
+
+
+class progress(update):
+    """
+
+    Run the function while a progress indicator (e.g. spinner) is and within the object-defined context (e.g. logging span).
+
+    """
+
+    def start(self, instance, *args, **kwargs):
+        """
+
+        Make progress visible and update.
+
+        """
+        instance.progress.visible = True
+        instance.page.update()
+
+    def stop(self, instance, *args, **kwargs):
+        """
+
+         Make progress not visible and update.
+
+        """
+        instance.progress.visible = False
+        super().stop(instance)
+
+
+T = TypeVar('T', bound=Context)
+
+
+class Base(Generic[T], ft.Column):
+    """
+
+    Simple interface base class.
+
+    """
+    TITLE = 'Base Interface'
+    HOST = '0.0.0.0'
+    PORT = 8080
+    URL = Constants.FMTR_DEV_INTERFACE_URL if environment_tools.IS_DEV else None
+    APPVIEW = AppView.WEB_BROWSER
+    PATH_ASSETS = None
+    PATH_UPLOADS = None
+    SCROLL = ft.ScrollMode.AUTO
+
+    SECRET_KEY_KEY = 'FLET_SECRET_KEY'
+    ROUTE_ROOT = '/'
+
+    TypeContext: Type[T] = Context
+
+    @classmethod
+    async def new(cls, page: ft.Page):
+        """
+
+        Interface entry point/async constructor. Set relevant callbacks, and add instantiated self to page views.
+
+        Override this to work with `Context`, do async setup. Otherwise, override __init__ (which is regular Column __init__) for a simple interface.
+
+        """
+        page.scroll = cls.SCROLL
+        page.title = cls.TITLE
+        page.on_connect = cls.on_connect
+        page.on_disconnect = cls.on_disconnect
+        page.on_route_change = cls.route
+        page.on_view_pop = cls.pop
+        page.theme = cls.get_theme()
+
+        context = cls.TypeContext(page=page)
+        self = cls()
+        self.context = context
+
+        page.controls.append(self)
+        page.update()
+
+        return self
+
+    @classmethod
+    def route(cls, event: ft.RouteChangeEvent):
+        """
+
+        Overridable router.
+
+        """
+        logger.debug(f'Route change: {event=}')
+
+    @classmethod
+    def pop(cls, view: View, page: ft.Page):
+        """
+
+        Overridable view pop.
+
+        """
+        logger.debug(f'View popped: {page.route=} {len(page.views)=} {view=}')
+
+    @classmethod
+    def on_connect(cls, event: ControlEvent):
+        """
+
+        Log connections
+
+        """
+        page = event.control
+        logger.warning(f'Connect: {page.client_user_agent=} {page.platform.name=}')
+
+    @classmethod
+    def on_disconnect(cls, event: ControlEvent):
+        """
+
+        Log disconnections
+
+        """
+        page = event.control
+        logger.warning(f'Disconnect {page.client_user_agent=} {page.platform.name=}')
+
+
+    @classmethod
+    def get_theme(self):
+        """
+
+        Overridable theme definition
+
+        """
+        text_style = ft.TextStyle(size=20)
+        theme = ft.Theme(
+            text_theme=ft.TextTheme(body_large=text_style),
+        )
+        return theme
+
+    @classmethod
+    def launch(cls):
+        """
+
+        Launch via async constructor method
+
+        """
+
+        if cls.URL:
+            url = cls.URL
+        else:
+            url = f'http://{cls.HOST}:{cls.PORT}'
+
+        if not environment_tools.get(cls.SECRET_KEY_KEY, default=None):
+            os.environ["FLET_SECRET_KEY"] = os.urandom(12).hex()
+
+        logger.info(f"Launching {cls.TITLE} at {url}")
+        ft.app(cls.new, view=cls.APPVIEW, host=cls.HOST, port=cls.PORT, assets_dir=cls.PATH_ASSETS, upload_dir=cls.PATH_UPLOADS)
+
+
+class Test(Base[Context]):
+    """
+
+    Simple test interface, showing typing example.
+
+    """
+    TypeContext: Type[Context] = Context
+
+    TITLE = 'Test Interface'
+
+    def __init__(self):
+        controls = [ft.Text(self.TITLE)]
+        super().__init__(controls=controls)
+
+if __name__ == "__main__":
+    Test.launch()

fmtr/tools/iterator_tools.py

@@ -1,6 +1,8 @@
 from itertools import chain, batched
 from typing import List, Dict, Any
 
+from fmtr.tools.datatype_tools import is_none
+
 
 def enlist(value) -> List[Any]:
     """
@@ -52,3 +54,30 @@ def rebatch(batches, size: int):
 
     """
     return batched(chain.from_iterable(batches), size)
+
+
+def strip_none(*items):
+    """
+
+    Remove nones from a list of arguments
+
+    """
+    return [item for item in items if not is_none(item)]
+
+
+def dedupe(items):
+    """
+
+    Deduplicate a list of items, retaining order
+
+    """
+    return list(dict.fromkeys(items))
+
+
+def get_class_lookup(*classes, name_function=lambda cls: cls.__name__):
+    """
+
+    Dictionary of class names to classes
+
+    """
+    return {name_function(cls): cls for cls in classes}