pyfemtet 0.4.10__py3-none-any.whl → 0.4.12__py3-none-any.whl

pyfemtet/opt/visualization/process_monitor/application.py

@@ -0,0 +1,201 @@
+from typing import List
+from time import sleep
+from threading import Thread
+
+import pandas as pd
+
+from pyfemtet.opt.visualization.base import PyFemtetApplicationBase, logger
+from pyfemtet.opt.visualization.process_monitor.pages import HomePage, WorkerPage
+
+
+class ProcessMonitorApplication(PyFemtetApplicationBase):
+    """"""
+    """
+        +------+--------+
+        | side | con-   |
+        | bar  | tent   |
+        +--^---+--^-----+
+           │      └─ pages (dict(href: str = layout: Component))
+           └──────── nav_links (dict(order: float) = NavLink)
+
+        Accessible members:
+        - history: History
+           └ local_df: pd.DataFrame
+        - app: Dash
+        - local_entire_status_int: int  <----------------> femopt.statue: OptimizationStatus(Actor)
+        - local_worker_status_int_list: List[int]  <-----> femopt.opt.statue: List[OptimizationStatus(Actor)]
+                                                     ^
+                                                     |
+                                   sync "while" statement in start_server()
+    """
+
+    DEFAULT_PORT = 8080
+
+    def __init__(
+            self,
+            history,
+            status,
+            worker_addresses,
+            worker_status_list,
+            is_debug=False,
+    ):
+        super().__init__(
+            title='PyFemtet Monitor',
+            subtitle='visualize optimization progress',
+            history=history,
+        )
+
+        self._should_get_actor_data = False
+        self.is_debug = is_debug
+
+        # type hint (avoid circular import)
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+
+        # register arguments
+        self.worker_addresses: List[str] = worker_addresses
+        self.entire_status: OptimizationStatus = status  # include actor
+        self.worker_status_list: List[OptimizationStatus] = worker_status_list  # include actor
+
+        # initialize local members (from actors)
+        self._df: pd.DataFrame = self.local_data
+        self.local_entire_status_int: int = self.entire_status.get()
+        self.local_worker_status_int_list: List[int] = [s.get() for s in self.worker_status_list]
+
+    @property
+    def local_data(self) -> pd.DataFrame:
+        if self._should_get_actor_data:
+            return self._df
+        else:
+            return self.history.local_data
+
+
+    @local_data.setter
+    def local_data(self, value: pd.DataFrame):
+        if self._should_get_actor_data:
+            raise NotImplementedError('If should_get_actor_data, ProcessMonitorApplication.local_df is read_only.')
+        else:
+            self.history.local_data = value
+
+
+    def setup_callback(self, debug=False):
+        if not debug:
+            super().setup_callback()
+
+    def start_server(self, host=None, port=None):
+        """Callback の中で使いたい Actor のデータを Application クラスのメンバーとやり取りしつつ、server を落とす関数"""
+
+        self._should_get_actor_data = True
+
+        # avoid circular import
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+
+        host = host or 'localhost'
+        port = port or self.DEFAULT_PORT
+
+        # dash app server を daemon thread で起動
+        server_thread = Thread(
+            target=self.run,
+            args=(host, port,),
+            daemon=True,
+        )
+        server_thread.start()
+
+        # dash app (=flask server) の callback で dask の actor にアクセスすると
+        # おかしくなることがあるので、ここで必要な情報のみやり取りする
+        while True:
+            # running 以前に monitor で current status を interrupting にしていれば actor に反映
+            if (
+                    (self.entire_status.get() <= OptimizationStatus.RUNNING)  # メインプロセスが RUNNING 以前である
+                    and (self.local_entire_status_int == OptimizationStatus.INTERRUPTING)  # Application で status を INTERRUPT にした
+            ):
+                self.entire_status.set(OptimizationStatus.INTERRUPTING)
+                for worker_status in self.worker_status_list:
+                    worker_status.set(OptimizationStatus.INTERRUPTING)
+
+            # status と df を actor から application に反映する
+            self._df = self.history.actor_data.copy()
+            self.local_entire_status_int = self.entire_status.get()
+            self.local_worker_status_int_list = [s.get() for s in self.worker_status_list]
+
+            # terminate_all 指令があれば flask server をホストするプロセスごと終了する
+            if self.entire_status.get() >= OptimizationStatus.TERMINATE_ALL:
+                return 0  # take server down with me
+
+            # interval
+            sleep(1)
+
+    def get_status_color(self, status_int):
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+        # set color
+        if status_int <= OptimizationStatus.SETTING_UP:
+            color = 'secondary'
+        elif status_int <= OptimizationStatus.WAIT_OTHER_WORKERS:
+            color = 'primary'
+        elif status_int <= OptimizationStatus.RUNNING:
+            color = 'primary'
+        elif status_int <= OptimizationStatus.INTERRUPTING:
+            color = 'warning'
+        elif status_int <= OptimizationStatus.TERMINATE_ALL:
+            color = 'dark'
+        elif status_int <= OptimizationStatus.CRASHED:
+            color = 'danger'
+        else:
+            color = 'danger'
+        return color
+
+
+def g_debug():
+    import os
+    os.chdir(os.path.dirname(__file__))
+
+    from pyfemtet.opt._femopt_core import History, OptimizationStatus
+
+    class _OS(OptimizationStatus):
+
+        # noinspection PyMissingConstructor
+        def __init__(self, name):
+            self.name = name
+            self.st = self.INITIALIZING
+
+        def set(self, status_const):
+            self.st = status_const
+
+        def get(self) -> int:
+            return self.st
+
+        def get_text(self) -> int:
+            return self.const_to_str(self.st)
+
+    g_application = ProcessMonitorApplication(
+        history=History(history_path=os.path.join(os.path.dirname(__file__), '..', 'result_viewer', 'sample', 'sample.csv')),
+        status=_OS('entire'),
+        worker_addresses=['worker1', 'worker2', 'worker3'],
+        worker_status_list=[_OS('worker1'), _OS('worker2'), _OS('worker3')],
+        is_debug=True,
+    )
+
+    g_home_page = HomePage('Progress')
+    g_worker_page = WorkerPage('Workers', '/workers', g_application)
+
+    g_application.add_page(g_home_page, 0)
+    g_application.add_page(g_worker_page, 1)
+    g_application.setup_callback(debug=False)
+
+    g_application.run(debug=True)
+
+
+def main(history, status, worker_addresses, worker_status_list, host=None, port=None):
+    g_application = ProcessMonitorApplication(history, status, worker_addresses, worker_status_list)
+
+    g_home_page = HomePage('Progress')
+    g_worker_page = WorkerPage('Workers', '/workers', g_application)
+
+    g_application.add_page(g_home_page, 0)
+    g_application.add_page(g_worker_page, 1)
+    g_application.setup_callback()
+
+    g_application.start_server(host, port)
+
+
+if __name__ == '__main__':
+    g_debug()

pyfemtet/opt/visualization/process_monitor/pages.py

@@ -0,0 +1,276 @@
+import numpy as np
+import pandas as pd
+
+from dash import Output, Input, State, callback_context, no_update, ALL
+from dash.exceptions import PreventUpdate
+
+from pyfemtet.opt.visualization.wrapped_components import dcc, dbc, html
+from pyfemtet.opt.visualization.base import AbstractPage, logger
+from pyfemtet.opt.visualization.complex_components.main_graph import MainGraph  # , FLEXBOX_STYLE_ALLOW_VERTICAL_FILL
+
+
+DBC_COLUMN_STYLE_CENTER = {
+    'display': 'flex',
+    'justify-content': 'center',
+    'align-items': 'center',
+}
+
+DBC_COLUMN_STYLE_RIGHT = {
+    'display': 'flex',
+    'justify-content': 'right',
+    'align-items': 'right',
+}
+
+
+def is_iterable(component):
+    return hasattr(component, '__len__')
+
+
+class HomePage(AbstractPage):
+
+    def __init__(self, title, rel_url='/'):
+        super().__init__(title, rel_url)
+
+    def setup_component(self):
+        # main graph
+        # noinspection PyAttributeOutsideInit
+        self.main_graph: MainGraph = MainGraph()
+        self.add_subpage(self.main_graph)
+
+        # entire optimization status
+        # noinspection PyAttributeOutsideInit
+        self.entire_status_message = html.H4(
+            'Optimization status will be shown here.',
+            className='alert-heading',
+            id='optimization-entire-status-message',
+        )
+        # noinspection PyAttributeOutsideInit
+        self.entire_status = dbc.Alert(
+            children=self.entire_status_message,
+            id='optimization-entire-status',
+            color='secondary',
+        )
+
+        # stop update button
+        # noinspection PyAttributeOutsideInit
+        self.toggle_update_graph_button = dbc.Checkbox(
+            label='Auto-update graph',
+            class_name='form-switch',
+            id='toggle-update-graph',
+            value=True,
+        )
+
+        # interrupt button
+        # noinspection PyAttributeOutsideInit
+        self.interrupt_button = dbc.Button(
+            children='Interrupt Optimization',
+            color='danger',
+            id='interrupt-optimization-button',
+            disabled=True,
+        )
+
+        # sync interval
+        # noinspection PyAttributeOutsideInit
+        self.interval = dcc.Interval(id='process-monitor-home-interval', interval=1000)
+
+    def setup_layout(self):
+        """"""
+        """
+            =======================
+            |  | ---------------- |
+            |  | |              | |
+            |  | |  Main Graph  | |
+            |  | |              | |
+            |  | ---------------- |
+            |  | [stop][interrupt]<---- Buttons
+            |  | ---------------- |
+            |  | | Status       | |
+            | ^| ---------------- |
+            ==|====================
+              |
+              SideBar
+        """
+        self.layout = dbc.Container(
+            children=[
+                self.interval,
+                self.main_graph.layout,
+                self.entire_status,
+                dbc.Row(
+                    children=[
+                        dbc.Col(self.toggle_update_graph_button),
+                        dbc.Col(self.interrupt_button, style=DBC_COLUMN_STYLE_RIGHT),
+                    ],
+                ),
+            ]
+        )
+
+    def setup_callback(self):
+        # setup callback of subpages
+        super().setup_callback()
+
+        from pyfemtet.opt.visualization.process_monitor.application import ProcessMonitorApplication
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+        self.application: ProcessMonitorApplication = self.application
+
+        app = self.application.app
+
+        # ===== Delete Loading Animation =====
+        @app.callback(
+            Output(self.main_graph.loading.id, self.main_graph.loading.Prop.target_components),
+            Input(self.main_graph.graph.id, 'figure'),
+            prevent_initial_call=True,
+        )
+        def disable_loading_animation(_):
+            return {}
+
+        # ===== history data to graph ======
+        @app.callback(
+            Output(self.main_graph.dummy.id, 'children', allow_duplicate=True),  # fire update graph callback
+            Input(self.interval.id, self.interval.Prop.n_intervals),
+            State(self.toggle_update_graph_button.id, self.toggle_update_graph_button.Prop.value),
+            State(self.main_graph.data_length.id, self.main_graph.data_length_prop),  # check should update or not
+            prevent_initial_call=True,)
+        def update_graph(_, update_switch, current_graph_data_length):
+            logger.debug('====================')
+            logger.debug(f'update_graph called by {callback_context.triggered_id}')
+
+            current_graph_data_length = 0 if current_graph_data_length is None else current_graph_data_length
+
+            if callback_context.triggered_id is None:
+                raise PreventUpdate
+
+            # update_switch is unchecked, do nothing
+            if not update_switch:
+                raise PreventUpdate
+
+            # If new data does not exist, do nothing
+            if len(self.application.local_data) <= current_graph_data_length:
+                raise PreventUpdate
+
+            # fire callback
+            return ''
+
+        # ===== show optimization state =====
+        @app.callback(
+            Output(self.entire_status.id, self.entire_status.Prop.color),
+            Output(self.entire_status_message.id, 'children'),
+            Input(self.interval.id, self.interval.Prop.n_intervals),
+            prevent_initial_call=False,)
+        def update_entire_status(*_):
+            # get status message
+            status_int = self.application.local_entire_status_int
+            msg = OptimizationStatus.const_to_str(status_int)
+            color = self.application.get_status_color(status_int)
+            return color, msg
+
+        # ===== Interrupt Optimization and Control Button Disabled =====
+        @app.callback(
+            Output(self.interrupt_button.id, self.interrupt_button.Prop.disabled),
+            Input(self.interrupt_button.id, self.interrupt_button.Prop.n_clicks),
+            prevent_initial_call=False,)
+        def interrupt_optimization(*_):
+            # If page (re)loaded,
+            if callback_context.triggered_id is None:
+                # Enable only if the entire_state < INTERRUPTING
+                if self.application.local_entire_status_int < OptimizationStatus.INTERRUPTING:
+                    return False
+                # Keep disable(default) if process is interrupting or terminating.
+                else:
+                    raise PreventUpdate
+
+            # If the entire_state < INTERRUPTING, set INTERRUPTING
+            if self.application.local_entire_status_int < OptimizationStatus.INTERRUPTING:
+                self.application.local_entire_status_int = OptimizationStatus.INTERRUPTING
+                return True
+
+            # keep disabled
+            raise PreventUpdate
+
+        # ===== TEST CODE =====
+        if self.application.is_debug:
+
+            # increment status
+            self.layout.children.append(dbc.Button(children='local_status を進める', id='debug-button-1'))
+
+            @app.callback(Output(self.interval.id, self.interval.Prop.interval),
+                          Input('debug-button-1', 'n_clicks'),
+                          prevent_initial_call=True)
+            def status_change(*_):
+                self.application.local_entire_status_int += 10
+                for i in range(len(self.application.local_worker_status_int_list)):
+                    self.application.local_worker_status_int_list[i] += 10
+                raise PreventUpdate
+
+            # increment data
+            self.layout.children.append(dbc.Button(children='local_data を増やす', id='debug-button-2'))
+
+            @app.callback(Output(self.interval.id, self.interval.Prop.interval, allow_duplicate=True),
+                          Input('debug-button-2', 'n_clicks'),
+                          prevent_initial_call=True)
+            def add_data(*_):
+                metadata = self.application.history.metadata
+                df = self.application.local_data
+
+                new_row = df.iloc[-2:]
+                obj_index = np.where(np.array(metadata) == 'obj')[0]
+                for idx in obj_index:
+                    new_row.iloc[:, idx] = np.random.rand(len(new_row))
+
+                df = pd.concat([df, new_row])
+                df.trial = np.array(range(len(df)))
+                logger.debug(df)
+
+                self.application.local_data = df
+
+                raise PreventUpdate
+
+
+class WorkerPage(AbstractPage):
+
+    def __init__(self, title, rel_url, application):
+        from pyfemtet.opt.visualization.process_monitor.application import ProcessMonitorApplication
+        self.application: ProcessMonitorApplication = None
+        super().__init__(title, rel_url, application)
+
+    def setup_component(self):
+        # noinspection PyAttributeOutsideInit
+        self.interval = dcc.Interval(id='worker-page-interval', interval=1000)
+
+        # noinspection PyAttributeOutsideInit
+        self.worker_status_alerts = []
+        for i in range(len(self.application.worker_addresses)):
+            id_worker_alert = f'worker-status-alert-{i}'
+            alert = dbc.Alert('worker status here', id=id_worker_alert, color='dark')
+            self.worker_status_alerts.append(alert)
+
+    def setup_layout(self):
+        rows = [self.interval]
+        rows.extend([dbc.Row([dbc.Col(html.Div(dcc.Loading(alert, id={"type": "loading", "index": i})))]) for i, alert in enumerate(self.worker_status_alerts)])
+
+        self.layout = dbc.Container(
+            children=rows,
+            fluid=True,
+        )
+
+    def setup_callback(self):
+        app = self.application.app
+
+        @app.callback(
+            [Output(alert.id, 'children') for alert in self.worker_status_alerts],
+            [Output(alert.id, 'color') for alert in self.worker_status_alerts],
+            Output({"type": "loading", "index": ALL}, "target_components"),
+            Input(self.interval.id, 'n_intervals'),
+        )
+        def update_worker_state(_):
+            from pyfemtet.opt._femopt_core import OptimizationStatus
+
+            ret = []
+
+            for worker_address, worker_status_int in zip(self.application.worker_addresses, self.application.local_worker_status_int_list):
+                worker_status_message = OptimizationStatus.const_to_str(worker_status_int)
+                ret.append(f'{worker_address} is {worker_status_message}')
+
+            ret.extend([self.application.get_status_color(status_int) for status_int in self.application.local_worker_status_int_list])
+            ret.append([({} if callback_context.triggered_id is None else no_update) for _ in range(len(self.worker_status_alerts))])
+
+            return tuple(ret)

pyfemtet/opt/visualization/result_viewer/.gitignore

@@ -0,0 +1 @@
+sample

pyfemtet/opt/visualization/result_viewer/application.py

@@ -0,0 +1,44 @@
+from pyfemtet.opt.visualization.base import PyFemtetApplicationBase
+from pyfemtet.opt.visualization.result_viewer.pages import HomePage
+
+
+class ResultViewerApplication(PyFemtetApplicationBase):
+
+    def __init__(self):
+        super().__init__(
+            title='PyFemtet ResultView',
+            subtitle='visualize optimization result',
+            history=None,
+        )
+
+    def setup_callback(self):
+        super().setup_callback()
+
+
+def debug():
+    import os
+    os.chdir(os.path.dirname(__file__))
+
+    g_application = ResultViewerApplication()
+
+    g_home_page = HomePage('result')
+
+    g_application.add_page(g_home_page, 0)
+    g_application.setup_callback()
+
+    g_application.run(debug=True)
+
+
+def main():
+    g_application = ResultViewerApplication()
+
+    g_home_page = HomePage('result')
+
+    g_application.add_page(g_home_page, 0)
+    g_application.setup_callback()
+
+    g_application.run()
+
+
+if __name__ == '__main__':
+    debug()