PyFemtet 0.3.1__tar.gz → 0.3.3__tar.gz

{pyfemtet-0.3.1 → pyfemtet-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfemtet
-Version: 0.3.1
+Version: 0.3.3
 Summary: Design parameter optimization using Femtet.
 Home-page: https://github.com/pyfemtet/pyfemtet
 License: BSD-3-Clause
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: botorch (>=0.9.5,<0.10.0) ; python_version < "3.12"
+Requires-Dist: colorlog (>=6.8.0,<7.0.0)
 Requires-Dist: dash (>=2.14.2,<3.0.0)
 Requires-Dist: dash-bootstrap-components (>=1.5.0,<2.0.0)
 Requires-Dist: dask (>=2023.12.1,<2024.0.0)

pyfemtet-0.3.3/pyfemtet/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.3"

{pyfemtet-0.3.1 → pyfemtet-0.3.3}/pyfemtet/dispatch_extensions.py

@@ -3,8 +3,6 @@ from typing import Tuple
 import os
 from time import time, sleep
 from multiprocessing import current_process
-import logging
-import warnings
 
 import psutil
 from dask.distributed import Lock
@@ -18,15 +16,13 @@ from femtetutils import util
 from multiprocessing.context import BaseContext, SpawnProcess, _concrete_contexts
 from multiprocessing.process import _children, _cleanup
 
-
-logger = logging.getLogger('dispatch_log')
-handler = logging.StreamHandler()
-handler.setFormatter(logging.Formatter('[%(process)d] %(message)s'))
-logger.addHandler(handler)
-# logger.setLevel(logging.INFO)
+import logging
+from .logger import get_logger
+logger = get_logger('dispatch')
+logger.setLevel(logging.INFO)
 
 
-DISPATCH_TIMEOUT = 60
+DISPATCH_TIMEOUT = 120
 
 
 class DispatchExtensionException(Exception):
@@ -114,11 +110,6 @@ _concrete_contexts.update(
 )
 
 
-def _log_prefix():
-    prefix = current_process().name + ' : '
-    return prefix
-
-
 def _get_hwnds(pid):
     """Proces ID から window handle を取得します."""
     def callback(hwnd, _hwnds):
@@ -160,7 +151,6 @@ def launch_and_dispatch_femtet(timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
     Returns:
         Tuple[IFemtet, int]:
     """
-
     util.execute_femtet()
     pid = util.get_last_executed_femtet_process_id()
     logger.debug(f'Target pid is {pid}.')
@@ -169,7 +159,7 @@ def launch_and_dispatch_femtet(timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
     return Femtet, pid
 
 
-def dispatch_femtet(timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
+def dispatch_femtet(timeout=DISPATCH_TIMEOUT, subprocess_log_prefix='') -> Tuple[IFemtet, int]:
     """Connect to existing Femtet process.
 
     Args:
@@ -181,11 +171,13 @@ def dispatch_femtet(timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
     Returns:
         Tuple[IFemtet, int]:
     """
-
     # Dispatch
-    logger.debug(f'{_log_prefix()}Try to connect Femtet.')
+    if subprocess_log_prefix:
+        logger.debug('%s'+'Try to connect Femtet.', subprocess_log_prefix)
+    else:
+        logger.info('Try to connect Femtet.')
     Femtet = Dispatch('FemtetMacro.Femtet')
-    logger.debug(f'{_log_prefix()}Dispatched.')
+    logger.debug('%s'+'Dispatch finished.', subprocess_log_prefix)
 
     # timeout 秒以内に接続が確立するか
     start = time()
@@ -194,27 +186,31 @@ def dispatch_femtet(timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
 
         # 接続が確立
         if hwnd > 0:
-            logger.debug(f'{_log_prefix()}Current hwnd is {hwnd}.')
+            logger.debug('%s'+f'Dispatched hwnd is {hwnd} and its pid is {_get_pid(hwnd)}. Connection established.', subprocess_log_prefix)
             break
         else:
-            logger.debug(f'{_log_prefix()}Current hwnd is {hwnd}. Wait for established connection.')
+            logger.debug('%s'+f'Dispatched hwnd is {hwnd}. Waiting for establishing connection.', subprocess_log_prefix)
 
         # 接続がタイムアウト
         if time()-start > timeout:
-            raise FemtetConnectionTimeoutError(f'Connect trial with Femtet is timed out in {timeout} sec')
+            raise FemtetConnectionTimeoutError(f'Connection trial with Femtet is timed out in {timeout} sec')
 
         sleep(1)
 
     # pid を取得
     pid = _get_pid(hwnd)
-    logger.info(f'{_log_prefix()}hwnd is {hwnd} and pid is {pid} of connected Femtet.')
-
-    if ('MainProcess' in _log_prefix()) or 'Dask Worker Process' in _log_prefix():
-        print(f'INFO: Process id of connected Femtet = {pid}')
+    if subprocess_log_prefix:
+        logger.debug('%s'+f'Successfully connected. The pid of Femtet is {pid}.', subprocess_log_prefix)
+    else:
+        logger.info(f'Successfully connected. The pid of Femtet is {pid}.')
 
     return Femtet, pid
 
 
+def _get_subprocess_log_prefix():
+    return f'({current_process().name}) '
+
+
 def _block_other_femtets(
         target_pid,
         subprocess_idx,
@@ -239,9 +235,10 @@ def _block_other_femtets(
     else:
         lock_inter_subproc.acquire()
         try:
-            logger.debug(f'{_log_prefix()}Try to block Femtet.')
-            _, my_pid = dispatch_femtet(2)
+            logger.debug('%s'+f'Subprocess started.', _get_subprocess_log_prefix())
+            _, my_pid = dispatch_femtet(2, _get_subprocess_log_prefix())
         except DispatchExtensionException:
+            logger.debug('%s'+f'Connection failed. The other subprocesses will skip.', _get_subprocess_log_prefix())
             my_pid = 0
             # ひとつでもここに来れば、それ以降は探しても無駄なのでスキップフラグを立てる
             for i in range(len(connection_flags)-1):
@@ -251,8 +248,6 @@ def _block_other_femtets(
 
     # # target なら Dispatch の終了を通知する前に main を lock する
     # if my_pid == target_pid:
-    #     logger.info(f'{_log_prefix()}Connected to {my_pid}. This is the target.')
-    #     logger.info(f'{_log_prefix()}Start to block main process.')
     #     lock_main.acquire()
 
     # Dispatch の終了を通知
@@ -266,32 +261,32 @@ def _block_other_femtets(
         #     if all(connection_flags[:-1]):
         #         break
         #     if time()-start > timeout_main_wait_for_us:
-        #         logger.error(f'{_log_prefix()}Timed out while waiting for other subprocesses.')
         #         return -1
         #     sleep(1)
-        # logger.debug(f'{_log_prefix()}All subprocesses seems to finish connection. Release {my_pid} and main.')
-        logger.debug(f'{_log_prefix()}Release {my_pid}.')
+        logger.debug('%s'+f'Release {my_pid}.', _get_subprocess_log_prefix())
         # lock_main.release()
         return 0
 
     # my_pid が非正なら何にも関与しないので即刻終了する
     elif my_pid <= 0:
-        logger.debug(f'{_log_prefix()}Failed or timed out to connect Femtet. Exit immediately.')
+        logger.debug('%s'+'Failed or timed out to connect Femtet.', _get_subprocess_log_prefix())
         return 1
 
     # そうでなければメインプロセスが Dispatch を終えるまで解放しない
     else:
-        logger.debug(f'{_log_prefix()}Connected to {my_pid}. Keep connection to block.')
+        logger.debug('%s'+f'Connected to {my_pid}. Keep connection to block.', _get_subprocess_log_prefix())
         start = time()
         while True:
             if connection_flags[-1]:
-                break
+                logger.debug('%s'+'Main process seems to connect target Femtet.', _get_subprocess_log_prefix())
+                return 1
             if time()-start > timeout_main_wait_for_us:
-                logger.error(f'{_log_prefix()}Timed out while waiting for the main process.')
+                logger.warning(
+                    '%s'+f'Timed out to wait for the main process to {timeout_main_wait_for_us}',
+                    _get_subprocess_log_prefix()
+                )
                 return -1
             sleep(1)
-        logger.debug(f'{_log_prefix()}Main process seems to connect target Femtet. Exit immediately.')
-        return 1
 
 
 def dispatch_specific_femtet(pid, timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
@@ -323,7 +318,7 @@ def dispatch_specific_femtet(pid, timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, in
     return dispatch_specific_femtet_core(pid, timeout)  # for logger, out of except.
 
 
-def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
+def dispatch_specific_femtet_core(pid, timeout=DISPATCH_TIMEOUT) -> Tuple[IFemtet, int]:
     """Connect Femtet whose process id is specified.
 
     Warnings:
@@ -380,7 +375,6 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
     Returns:
         Tuple[IFemtet, int]:
     """
-
     # TODO: 安定性を見て lock_main を復活させるか決める
 
     if timeout < 5:
@@ -388,7 +382,7 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
 
     # 存在する Femtet プロセスの列挙
     pids = _get_pids('Femtet.exe')
-    logger.info(f'{_log_prefix()}PID of existing Femtet processes: {pids}')
+    logger.info(f'PID of existing Femtet processes: {pids}')
     if not (pid in pids):
         raise FemtetNotFoundException(f"Femtet (pid = {pid}) doesn't exist.")
 
@@ -406,9 +400,11 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
             connection_flags.append(False)
 
         # 目的以外の Femtet をブロックする子プロセスを開始
+        logger.debug('Start subprocess to block Femtet other than target pid.')
         processes = []
         for subprocess_id in range(len(pids)):
             p = _NestableSpawnProcess(
+            # p = Process(
                 target=_block_other_femtets,
                 args=(
                     pid,
@@ -427,7 +423,15 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
         while True:
             if all(connection_flags[:-1]):
                 break
-            if time()-start > 10:
+            if time()-start > timeout:
+                # 子プロセスを終了する
+                for p in processes:
+                    p.terminate()
+                    p.join()
+                try:
+                    lock_inter_subproc.release()
+                except RuntimeError:
+                    pass
                 raise FemtetConnectionTimeoutError(f'Connect trial with specific Femtet (pid = {pid}) is timed out in {timeout} sec')
             sleep(1)
 
@@ -436,7 +440,7 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
 
         # 子プロセスによるブロックが終了しているので Dispatch する
         try:
-            logger.debug(f'{_log_prefix()}All Femtets except to target seem to be blocked. Try Dispatch.')
+            logger.debug('Block process seems to be finished. Try Dispatch.')
             Femtet, my_pid = dispatch_femtet()
         except DispatchExtensionException as e:
             # lock_main.release()
@@ -451,12 +455,13 @@ def dispatch_specific_femtet_core(pid, timeout=10) -> Tuple[IFemtet, int]:
 
     if my_pid != pid:  # pid の結果が違う場合
         txt = f'Target pid is {pid}, but connected pid is {my_pid}. '
-        txt += f'The common reason is that this python process once connected {pid}.'
-        warnings.warn(txt)
+        txt += f'The common reason is that THIS python process once connected {pid}.'
+        logger.warn(txt)
+        # warnings.warn(txt)
 
     return Femtet, my_pid
 
 
 if __name__ == '__main__':
-    _Femtet, _my_pid = launch_and_dispatch_femtet()
+    _Femtet, _my_pid = launch_and_dispatch_femtet(5)
     # _Femtet, _my_pid = dispatch_specific_femtet(pid=26124)

pyfemtet-0.3.3/pyfemtet/logger.py

@@ -0,0 +1,99 @@
+import os
+import sys
+import logging
+from colorlog import ColoredFormatter
+from dask.distributed import get_worker
+
+
+__all__ = ['get_logger']
+
+
+def _get_worker_name_as_prefix():
+    name = '(Main) '
+    try:
+        worker = get_worker()
+        # address = worker.address
+        name = f'(Worker:{worker.name}) '
+    except ValueError:
+        pass
+    return name
+
+
+class DaskLogRecord(logging.LogRecord):
+    """Generate a log message with dask worker name."""
+
+    # def __init__(self, *args, **kwargs):
+    #     super().__init__(*args, **kwargs)
+    #     self.worker = _get_worker_name_as_prefix()
+
+    def getMessage(self):
+        """Add worker name to loggin message.
+
+        This function is originated from logging.LogRecord.
+
+            # Copyright (C) 2001-2022 Vinay Sajip. All Rights Reserved.
+
+        """
+        msg = str(self.msg)
+        if self.args:
+            msg = msg % self.args
+        msg = _get_worker_name_as_prefix() + msg
+        return msg
+
+
+logging.setLogRecordFactory(DaskLogRecord)  # すべての logging %(message)s の前に prefix を入れる
+
+
+def _color_supported() -> bool:
+    """Detection of color support.
+
+    This function is originated from optuna.logging.
+
+        # Copyright (c) 2018 Preferred Networks, Inc.
+
+    """
+
+    # NO_COLOR environment variable:
+    if os.environ.get("NO_COLOR", None):
+        return False
+
+    if not hasattr(sys.stderr, "isatty") or not sys.stderr.isatty():
+        return False
+    else:
+        return True
+
+
+def _create_formatter() -> logging.Formatter:
+    """Create a formatter."""
+    # header = f"[pyfemtet %(name)s] %(levelname).4s %(worker)s]"
+    header = f"[pyfemtet %(name)s %(levelname).4s]"
+    message = "%(message)s"
+
+    formatter = ColoredFormatter(
+        f"%(log_color)s{header}%(reset)s {message}",
+        datefmt=None,
+        reset=True,
+        log_colors={
+            "DEBUG": "purple",
+            "INFO": "cyan",
+            "WARNING": "yellow",
+            "ERROR": "light_red",
+            "CRITICAL": "red",
+        },
+    )
+
+    return formatter
+
+
+def get_logger(logger_name):
+    """Return a logger with a default ColoredFormatter."""
+
+    formatter = _create_formatter()
+
+    logger = logging.getLogger(logger_name)
+    handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.DEBUG)
+
+    return logger

{pyfemtet-0.3.1 → pyfemtet-0.3.3}/pyfemtet/opt/base.py

@@ -9,7 +9,6 @@ from time import time, sleep
 from threading import Thread
 from subprocess import Popen
 import warnings
-import logging
 
 import numpy as np
 import pandas as pd
@@ -19,7 +18,7 @@ from optuna.study import MaxTrialsCallback
 from optuna.trial import TrialState
 from optuna.exceptions import ExperimentalWarning
 from optuna._hypervolume import WFG
-from dask.distributed import LocalCluster, Client, Lock, get_worker
+from dask.distributed import LocalCluster, Client, Lock
 
 from win32com.client import constants, Constants
 
@@ -27,12 +26,10 @@ from ..core import ModelError, MeshError, SolveError
 from .interface import FEMInterface, FemtetInterface
 from .monitor import Monitor
 
-
-logger = logging.getLogger('optimization-main')
-handler = logging.StreamHandler()
-handler.setFormatter(logging.Formatter('[%(process)d] %(message)s'))
-logger.addHandler(handler)
-logger.setLevel(logging.INFO)  # TODO: optuna, dask の logger の書式を統一する
+import logging
+from ..logger import get_logger
+logger = get_logger('opt')
+logger.setLevel(logging.INFO)
 
 
 warnings.filterwarnings('ignore', category=ExperimentalWarning)
@@ -350,6 +347,7 @@ class History:
 
         # 引数の処理
         self.path = history_path  # .csv
+        self.is_restart = False
         self._future = client.submit(HistoryDfCore, actor=True)
         self._actor_data = self._future.result()
         self.param_names = []
@@ -359,6 +357,7 @@ class History:
         # path が存在すれば dataframe を読み込む
         if os.path.isfile(self.path):
             self.actor_data = pd.read_csv(self.path, encoding='shift-jis')
+            self.is_restart = True
 
     @property
     def actor_data(self):
@@ -597,7 +596,7 @@ class OptimizationStatus:
         # self._actor.status_int = status_const
         # self._actor.status = self.const_to_str(status_const)
         self._actor.set(status_const, self.const_to_str(status_const)).result()
-        print(f'---{self.const_to_str(status_const)}---')
+        logger.info(f'---{self.const_to_str(status_const)}---')
 
     def get(self):
         return self._actor.status_int
@@ -722,6 +721,7 @@ class OptunaOptimizer(AbstractOptimizer):
         self.study_name = None
         self.storage = None
         self.study = None
+        self.optimize_callbacks = []
         self.sampler_class = optuna.samplers.TPESampler if sampler_class is None else sampler_class
         self.sampler_kwargs = dict() if sampler_kwargs is None else sampler_kwargs
         self.additional_initial_parameter = []
@@ -759,7 +759,7 @@ class OptunaOptimizer(AbstractOptimizer):
             if cns.ub is not None:
                 feasible = feasible and (cns.ub >= cns_value)
             if not feasible:
-                print(f'以下の変数で拘束 {cns.name} が満たされませんでした。')
+                logger.info(f'以下の変数で拘束 {cns.name} が満たされませんでした。')
                 print(self.get_parameter('dict'))
                 raise optuna.TrialPruned()  # set TrialState PRUNED because FAIL causes similar candidate loop.
 
@@ -767,8 +767,9 @@ class OptunaOptimizer(AbstractOptimizer):
         try:
             _, _y, c = self.f(x)
         except (ModelError, MeshError, SolveError) as e:
-            print(str(type(e)).split("'")[1].split('.')[-1], e)
-            print('FEM 解析に失敗しました.')
+            logger.info(str(type(e)).split("'")[1].split('.')[-1], e)
+            logger.info('以下の変数で FEM 解析に失敗しました。')
+            print(self.get_parameter('dict'))
 
             # 中断の確認 (解析中に interrupt されている場合対策)
             if self.status.get() == OptimizationStatus.INTERRUPTING:
@@ -807,8 +808,19 @@ class OptunaOptimizer(AbstractOptimizer):
         if self.is_cluster:  # remote cluster なら scheduler の working dir に保存
             storage_path = os.path.basename(self.history.path).replace('.csv', '.db')
 
-        # create study if storage is not exists
-        if not os.path.exists(storage_path):
+        # callback to terminate
+        if self.n_trials is not None:
+            n_trials = self.n_trials
+
+            # restart である場合、追加 N 回と見做す
+            if self.history.is_restart:
+                n_existing_trials = len(self.history.actor_data)
+                n_trials += n_existing_trials
+
+            self.optimize_callbacks.append(MaxTrialsCallback(n_trials, states=(TrialState.COMPLETE,)))
+
+        # if not restart, create study if storage is not exists
+        if not self.history.is_restart:
 
             self.storage = optuna.integration.dask.DaskStorage(
                 f'sqlite:///{storage_path}',
@@ -852,12 +864,17 @@ class OptunaOptimizer(AbstractOptimizer):
                             d, user_attrs={"message": "additional initial (Latin Hypercube Sampling)"}
                         )
 
+        # if is_restart, load study
         else:
-
+            if not os.path.exists(storage_path):
+                raise FileNotFoundError(f'{storage_path} が見つかりません。.db ファイルは .csv ファイルと同じフォルダに生成されます。クラスター解析の場合は、スケジューラを起動したフォルダに生成されます。')
             self.storage = optuna.integration.dask.DaskStorage(
                 f'sqlite:///{storage_path}',
             )
 
+
+
+
     def add_init_parameter(
             self,
             parameter: dict or Iterable,
@@ -901,18 +918,11 @@ class OptunaOptimizer(AbstractOptimizer):
             sampler=sampler,
         )
 
-        # callback to terminate
-        callbacks = []
-        n_existing_trials = len(self.history.actor_data)
-        if self.n_trials is not None:
-            n_trials = n_existing_trials + self.n_trials
-            callbacks.append(MaxTrialsCallback(n_trials, states=(TrialState.COMPLETE,)))
-
         # run
         study.optimize(
             self._objective,
             timeout=self.timeout,
-            callbacks=callbacks,
+            callbacks=self.optimize_callbacks,
         )
 
         # finalize
@@ -1224,13 +1234,13 @@ class FEMOpt:
 
         else:
             logger.info('Launching single machine cluster. This may take tens of seconds.')
-            cluster = LocalCluster(processes=True, threads_per_worker=1)
+            cluster = LocalCluster(processes=True)
             self.client = Client(cluster, direct_to_workers=False)
             self.scheduler_address = self.client.scheduler.address
 
         # monitor 用 worker を起動
         logger.info('Launching monitor server. This may take a few seconds.')
-        self.monitor_process_worker_name = datetime.datetime.now().strftime("monitor-server-process-%Y%m%d%H%M%S")
+        self.monitor_process_worker_name = datetime.datetime.now().strftime("Monitor-%Y%m%d-%H%M%S")
         cmd = f'dask worker {self.client.scheduler.address} --name {self.monitor_process_worker_name} --no-nanny'
         worker_addresses = list(self.client.has_what().keys())
         Popen(cmd, shell=True)  #, stdout=PIPE) --> cause stream error
@@ -1331,9 +1341,8 @@ class FEMOpt:
         # 一応
         t_save_history.join()
 
-        print(f'Optimization finished. Elapsed time is {end - start} sec.')
-        print('計算が終了しました. ウィンドウを閉じると終了します.')
-        print(f'結果は{self.history.path}を確認してください.')
+        logger.info(f'計算が終了しました. 実行時間は {int(end - start)} 秒でした。ウィンドウを閉じると終了します.')
+        logger.info(f'結果は{self.history.path}を確認してください.')
 
     def terminate_all(self):
 
@@ -1342,13 +1351,13 @@ class FEMOpt:
 
         # terminate monitor process
         self.status.set(OptimizationStatus.TERMINATE_ALL)
-        print(self.monitor_process_future.result())
+        logger.info(self.monitor_process_future.result())
         sleep(1)
 
         # terminate actors
         self.client.cancel(self.history._future, force=True)
         self.client.cancel(self.status._future, force=True)
-        print('Terminate actors.')
+        logger.info('Terminate actors.')
         sleep(1)
 
         # terminate monitor worker
@@ -1360,19 +1369,23 @@ class FEMOpt:
         )
         while n_workers == len(self.client.nthreads()):
             sleep(1)
-        print('Terminate monitor processes worker.')
+        logger.info('Terminate monitor processes worker.')
         sleep(1)
 
         # close scheduler, other workers(, cluster)
         self.client.close()
         while self.client.scheduler is not None:
             sleep(1)
-        print('Terminate client.')
+        logger.info('Terminate client.')
+
+        # close FEM (if specified to quit when deconstruct)
+        del self.fem
+        logger.info('Terminate FEM.')
 
         # terminate dask relative processes.
         if not self.opt.is_cluster:
             self.client.shutdown()
-            print('Terminate all relative processes.')
+            logger.info('Terminate all relative processes.')
         sleep(3)
 
 

{pyfemtet-0.3.1 → pyfemtet-0.3.3}/pyfemtet/opt/interface.py

@@ -1,9 +1,9 @@
 import os
 import sys
-from time import sleep
+from time import sleep, time
 import json
 import subprocess
-import logging
+import signal
 
 import pandas as pd
 import psutil
@@ -26,14 +26,11 @@ from ..dispatch_extensions import (
     DispatchExtensionException,
 )
 
-
-logger = logging.getLogger('fem_interface_log')
-handler = logging.StreamHandler()
-handler.setFormatter(logging.Formatter('[pid %(process)d] %(message)s'))
-logger.addHandler(handler)
+import logging
+from ..logger import get_logger
+logger = get_logger('FEM')
 logger.setLevel(logging.INFO)
 
-
 here, me = os.path.split(__file__)
 
 
@@ -187,7 +184,11 @@ class FemtetInterface(FEMInterface):
                 hwnd = self.Femtet.hWnd
                 pid = _get_pid(hwnd)
                 util.close_femtet(hwnd, 1, True)
+                start = time()
                 while psutil.pid_exists(pid):
+                    if time() - start > 30:  # 30 秒経っても存在するのは何かおかしい
+                        os.kill(pid, signal.SIGKILL)
+                        break
                     sleep(1)
                 sleep(1)
 
@@ -299,6 +300,10 @@ class FemtetInterface(FEMInterface):
         -------
 
         """
+
+        # FIXME: Gaudi へのアクセスなど、self.Femtet.Gaudi.somefunc() のような場合、この関数を呼び出す前に Gaudi へのアクセスの時点で com_error が起こる
+        # FIXME: => 文字列で渡して eval() すればよい。
+
         if args is None:
             args = tuple()
         if kwargs is None:
@@ -309,7 +314,7 @@ class FemtetInterface(FEMInterface):
         # 2. API 実行時に成功失敗を示す戻り値を返し、ShowLastError で例外にアクセスできる状態になる
 
         # Gaudi コマンドなら Gaudi.Activate する
-        # if self.pp: print(' '*print_indent, 'コマンド', fun.__name__, args, kwargs)
+        logger.debug(' '*print_indent + f'Femtet API:{fun.__name__}, args:{args}, kwargs:{kwargs}')
         if is_Gaudi_method:  # Optimizer は Gogh に触らないので全部にこれをつけてもいい気がする
             try:
                 self._call_femtet_api(
@@ -333,7 +338,7 @@ class FemtetInterface(FEMInterface):
                 returns = ret_if_failed
             else:
                 returns = [ret_if_failed]*(ret_for_check_idx+1)
-        # if self.pp: print(' '*print_indent, 'コマンド結果', returns)
+        logger.debug(' '*print_indent + f'Femtet API result:{returns}')
 
         # チェックすべき値の抽出
         if ret_for_check_idx is None:
@@ -352,29 +357,28 @@ class FemtetInterface(FEMInterface):
             if self.femtet_is_alive():
                 # 生きていてもここにきているなら
                 # 指定された Exception を送出する
-                # if self.pp: print(' '*print_indent, error_message)
+                logger.debug(' ' * print_indent + error_message)
                 raise if_error(error_message)
 
             # 死んでいるなら再起動
             else:
                 # 再起動試行回数の上限に達していたら諦める
-                # if self.pp: print(' '*print_indent, '現在の Femtet 再起動回数：', recourse_depth)
+                logger.debug(' ' * print_indent + f'現在の Femtet 再起動回数: {recourse_depth}')
                 if recourse_depth >= self.max_api_retry:
                     raise Exception('Femtet のプロセスが異常終了し、正常に再起動できませんでした.')
 
                 # 再起動
-                # if self.pp: print(' '*print_indent, 'Femtet プロセスの異常終了が検知されました. 再起動を試みます.')
-                print('Femtet プロセスの異常終了が検知されました. 回復を試みます.')
+                logger.warn('Femtet プロセスの異常終了が検知されました. 回復を試みます.')
+                CoInitialize()
                 self.connect_femtet(connect_method='new')
                 self.open(self.femprj_path, self.model_name)
 
                 # 状態を復元するために一度変数を渡して解析を行う（fun.__name__がSolveなら2度手間だが）
-                # if self.pp: print(' '*print_indent, f'再起動されました. コマンド{fun.__name__}の再試行のため、解析を行います.')
+                logger.info(' ' * print_indent + f'Femtet が再起動されました。解析を行い、状態回復を試みます。')
                 self.update(self.parameters)
 
                 # 与えられた API の再帰的再試行
-                # if self.pp: print(' '*print_indent, f'回復されました. コマンド{fun.__name__}の再試行を行います.')
-                print('回復されました.')
+                logger.info(' ' * print_indent + f'Femtet が回復されました。コマンド {fun.__name__} を再試行します。')
                 return self._call_femtet_api(
                     fun,
                     ret_if_failed,
@@ -507,7 +511,7 @@ class FemtetInterface(FEMInterface):
                     args=(name, value),
                 )
             else:
-                print(f'変数 {name} は .femprj に含まれていません。無視されます。')
+                logger.warn(f'変数 {name} は .femprj に含まれていません。無視されます。')
 
         # ここでは ReExecute しない
         pass

{pyfemtet-0.3.1 → pyfemtet-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyfemtet"
-version = "0.3.1"  # ignored by versioning plugin
+version = "0.3.3"  # ignored by versioning plugin
 description = "Design parameter optimization using Femtet."
 authors = ["kazuma.naito <kazuma.naito@murata.com>"]
 readme = "README.md"
@@ -24,6 +24,7 @@ dash-bootstrap-components = "^1.5.0"
 dask = "^2023.12.1"
 distributed = "^2023.12.1"
 botorch = { version = "^0.9.5", python = "<3.12" }
+colorlog = "^6.8.0"
 
 [tool.poetry.group.dev.dependencies]
 pip-licenses = "^4.3.3"

pyfemtet-0.3.1/pyfemtet/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.1"

pyfemtet-0.3.1/pyfemtet/opt/_optimizer.py

@@ -1,241 +0,0 @@
-# import os
-# import gc
-# import warnings
-#
-# import numpy as np
-# from scipy.stats.qmc import LatinHypercube
-# import optuna
-# from optuna.study import MaxTrialsCallback
-# from optuna.trial import TrialState
-# from optuna.exceptions import ExperimentalWarning
-# # optuna.logging.disable_default_handler()
-#
-# from .core import UserInterruption, ModelError, MeshError, SolveError
-# from .base import OptimizerBase
-#
-#
-# warnings.filterwarnings('ignore', category=ExperimentalWarning)
-#
-#
-# def generate_lhs(bounds: list[list[float]], seed: int or None = None) -> np.ndarray:
-#     """Latin Hypercube Sampling from given design parameter bounds.
-#
-#     If the number of parameters is d,
-#     sampler returns (N, d) shape ndarray.
-#     N equals p**2, p is the minimum prime number over d.
-#     For example, when d=3, then p=5 and N=25.
-#
-#     Args:
-#         bounds (list[list[float]]): List of [lower_bound, upper_bound] of parameters.
-#         seed (int or None, optional): Random seed. Defaults to None.
-#
-#     Returns:
-#         np.ndarray: (N, d) shape ndarray.
-#     """
-#
-#     d = len(bounds)
-#
-#     sampler = LatinHypercube(
-#         d,
-#         scramble=False,
-#         strength=2,
-#         # optimization='lloyd',
-#         optimization='random-cd',
-#         seed=seed,
-#     )
-#
-#     LIMIT = 100
-#
-#     def is_prime(p):
-#         for i in range(2, p):
-#             if p % i == 0:
-#                 return False
-#         return True
-#
-#     def get_prime(minimum):
-#         for p in range(minimum, LIMIT):
-#             if is_prime(p):
-#                 return p
-#
-#     n = get_prime(d + 1) ** 2
-#     data = sampler.random(n)  # [0,1)
-#
-#     for i, (data_range, datum) in enumerate(zip(bounds, data.T)):
-#         minimum, maximum = data_range
-#         band = maximum - minimum
-#         converted_datum = datum * band + minimum
-#         data[:, i] = converted_datum
-#
-#     return data  # data.shape = (N, d)
-#
-#
-# class OptimizerOptuna(OptimizerBase):
-#     """Optimizer class using Optuna.
-#
-#     """
-#
-#     def _objective(self, trial):
-#
-#         # 中断指令の処理
-#         if self.ipv.get_state() == 'interrupting':
-#             raise UserInterruption
-#
-#         # message の設定
-#         try:
-#             message = trial.user_attrs["message"]  # あれば
-#         except (AttributeError, KeyError):
-#             message = ''  # なければ
-#
-#         # x の生成
-#         x = []
-#         for i, row in self.parameters.iterrows():
-#             x.append(trial.suggest_float(row['name'], row['lb'], row['ub']))
-#         x = np.array(x)
-#         self.parameters['value'] = x
-#
-#         # strict 拘束の計算で Prune することになったとき
-#         # constraint attr がないとエラーになるのでダミーを置いておく
-#         trial.set_user_attr("constraint", (1.,))  # 非正が feasible 扱い
-#
-#         # GetVariableValue 経由で変数にアクセスするなどの場合
-#         self.fem.update_parameter(self.parameters)
-#
-#         # strict 拘束の計算
-#         tmp = [[cns.calc(self.fem), cns.lb, cns.ub, name] for name, cns in self.constraints.items() if cns.strict]
-#         for val, lb, ub, name in tmp:
-#             if lb is not None:
-#                 if not (lb <= val):
-#                     print(f'拘束 {name} が満たされませんでした。')
-#                     print('変数の組み合わせは以下の通りです。')
-#                     print(self.parameters)
-#                     raise optuna.TrialPruned()
-#             if ub is not None:
-#                 if not (val <= ub):
-#                     print(f'拘束 {name} が満たされませんでした。')
-#                     print('変数の組み合わせは以下の通りです。')
-#                     print(self.parameters)
-#                     raise optuna.TrialPruned()
-#
-#         # 解析実行
-#         try:
-#             obj_values = self.f(x, message)  # obj_val と cns_val の更新
-#         except (ModelError, MeshError, SolveError):
-#             print('FEM 解析に失敗しました。')
-#             print('変数の組み合わせは以下の通りです。')
-#             print(self.parameters)
-#             raise optuna.TrialPruned()
-#
-#         # 拘束 attr の更新
-#         _cns_values = []  # 非正なら OK
-#         for (name, cns), cns_val in zip(self.constraints.items(), self.cns_values):
-#             lb, ub = cns.lb, cns.ub
-#             if lb is not None:  # fun >= lb  <=>  lb - fun <= 0
-#                 _cns_values.append(lb - cns_val)
-#             if ub is not None:  # ub >= fun  <=>  fun - ub <= 0
-#                 _cns_values.append(cns_val - ub)
-#         trial.set_user_attr("constraint", _cns_values)
-#
-#         # 一応
-#         gc.collect()
-#
-#         return tuple(obj_values)
-#
-#     def _constraint_function(self, trial):
-#         return trial.user_attrs["constraint"]
-#
-#     def setup_concrete_main(self, use_lhs_init=True):
-#         """Performs the setup for the optimization using Optuna.
-#
-#         Do sampler settings, study creation or loading and initial trials settings.
-#
-#         Args:
-#             use_lhs_init (bool, optional): Flag indicating whether to use Latin Hypercube Sampling for initializing trials. Defaults to True.
-#
-#         """
-#
-#         # sampler の設定
-#         self.sampler_kwargs = dict(
-#             # n_startup_trials=5,
-#             constraints_func=self._constraint_function
-#         )
-#         self.sampler_class = optuna.samplers.TPESampler
-#         if self.method == 'botorch':
-#             self.sampler_class = optuna.integration.BoTorchSampler
-#             # self.sampler_kwargs.update(
-#             #     dict(
-#             #         consider_running_trials=True
-#             #     )
-#             # )
-#
-#         # study name の設定
-#         self.study_name = os.path.splitext(os.path.basename(self.history.path))[0]
-#         self.storage_path = os.path.splitext(self.history.path)[0] + '.db'
-#         self.storage = f"sqlite:///{self.storage_path}"
-#
-#         # storage の設定
-#         study = optuna.create_study(
-#             study_name=self.study_name,
-#             storage=self.storage,
-#             load_if_exists=True,
-#             directions=['minimize']*len(self.objectives),
-#             )
-#
-#         # 初期値の設定
-#         if len(study.trials) == 0:  # リスタートでなければ
-#             # ユーザーの指定した初期値
-#             params = self.get_parameter('dict')
-#             study.enqueue_trial(params, user_attrs={"message": "initial"})
-#
-#             # LHS を初期値にする
-#             if use_lhs_init:
-#                 names = []
-#                 bounds = []
-#                 for i, row in self.parameters.iterrows():
-#                     names.append(row['name'])
-#                     lb = row['lb']
-#                     ub = row['ub']
-#                     bounds.append([lb, ub])
-#                 data = generate_lhs(bounds, seed=self.seed)
-#                 for datum in data:
-#                     d = {}
-#                     for name, v in zip(names, datum):
-#                         d[name] = v
-#                     study.enqueue_trial(d, user_attrs={"message": "initial Latin Hypercube Sampling"})
-#
-#     def concrete_main(self, subprocess_idx=None):
-#         """Optimization using Optuna."""
-#
-#         # 乱数シードをプロセス固有にする
-#         seed = self.seed
-#         if seed is not None:
-#             if subprocess_idx is not None:
-#                 seed = seed + (1 + subprocess_idx)  # main process と subprocess0 が重複する
-#
-#         # sampler の restore
-#         sampler = self.sampler_class(
-#             seed=seed,
-#             **self.sampler_kwargs
-#         )
-#
-#         # storage の restore
-#         study = optuna.load_study(
-#             study_name=self.study_name,
-#             storage=self.storage,
-#             sampler=sampler,
-#         )
-#
-#         # 最大実行回数の指定
-#         callbacks = []
-#         n_existing_trials = len(self.history.actor_data)
-#         if self.n_trials is not None:
-#             n_trials = n_existing_trials + self.n_trials
-#             callbacks.append(MaxTrialsCallback(n_trials, states=(TrialState.COMPLETE,)))
-#
-#         # run
-#         study.optimize(
-#             self._objective,
-#             timeout=self.timeout,
-#             callbacks=callbacks,
-#         )
-#
-#         return study