pyfemtet 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

pyfemtet/__init__.py

@@ -1 +1 @@
-__version__ = "0.6.3"
+__version__ = "0.6.5"

pyfemtet/_femtet_config_util/autosave.py

@@ -4,20 +4,31 @@ from typing import Final
 # レジストリのパスと値の名前
 _REGISTRY_PATH: Final[str] = r"SOFTWARE\Murata Software\Femtet2014\Femtet"
 _VALUE_NAME: Final[str] = "AutoSave"
+_DEFAULT_VALUE: Final[bool] = True
 
 
 def _get_autosave_enabled() -> bool:
-    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH) as key:
-        value, regtype = winreg.QueryValueEx(key, _VALUE_NAME)
-        if regtype == winreg.REG_DWORD:
-            return bool(value)
-        else:
-            raise ValueError("Unexpected registry value type.")
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH) as key:
+            value, regtype = winreg.QueryValueEx(key, _VALUE_NAME)
+            if regtype == winreg.REG_DWORD:
+                return bool(value)
+            else:
+                raise ValueError("Unexpected registry value type.")
+
+    except FileNotFoundError:  # [WinError 2] 指定されたファイルが見つかりません。
+        __create_registry_key()
+        return _get_autosave_enabled()
 
 
 def _set_autosave_enabled(enable: bool) -> None:
-    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH, 0, winreg.KEY_SET_VALUE) as key:
-        winreg.SetValueEx(key, _VALUE_NAME, 0, winreg.REG_DWORD, int(enable))
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH, 0, winreg.KEY_SET_VALUE) as key:
+            winreg.SetValueEx(key, _VALUE_NAME, 0, winreg.REG_DWORD, int(enable))
+
+    except FileNotFoundError:  # [WinError 2] 指定されたファイルが見つかりません。
+        __create_registry_key()
+        _set_autosave_enabled(enable)
 
 
 def __test_autosave_setting():
@@ -36,3 +47,12 @@ def __test_autosave_setting():
     print(f"Current AutoSave setting is {'enabled' if after_setting else 'disabled'}.")
 
     assert new_setting == after_setting, "レジストリ編集に失敗しました。"
+
+
+def __create_registry_key():
+    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH) as key:
+        winreg.SetValueEx(key, _VALUE_NAME, 0, winreg.REG_DWORD, int(_DEFAULT_VALUE))
+
+
+if __name__ == '__main__':
+    print(_get_autosave_enabled())

pyfemtet/_util/excel_macro_util.py

@@ -0,0 +1,197 @@
+"""Excel のエラーダイアログを補足します。"""
+import sys
+from time import sleep
+from threading import Thread
+import logging
+import asyncio  # for timeout
+import win32gui
+import win32con
+import win32api
+
+logger = logging.getLogger(__name__)
+if __name__ == '__main__':
+    formatter = logging.Formatter(logging.BASIC_FORMAT)
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.DEBUG)
+
+
+class _ExcelDialogProcessor:
+
+    def __init__(self, excel_, timeout):
+        self.excel = excel_
+        self.__excel_window_title = f' - Excel'  # {basename} - Excel
+        self.__error_dialog_title = 'Microsoft Visual Basic'
+        self.__vbe_window_title = f'Microsoft Visual Basic for Applications - '  # Microsoft Visual Basic for Applications - {basename}
+        self.should_stop = False
+        self.timeout = timeout
+        self.__timed_out = False
+        self.__workbook_paths = [wb.FullName for wb in excel_.Workbooks]
+        self.__error_raised = False
+        self.__excel_state_stash = dict()
+        self.__watch_thread = None
+
+    async def watch(self):
+
+        while True:
+            if self.should_stop:
+                logger.debug('エラーダイアログの監視を終了')
+                return
+            logger.debug('エラーダイアログを監視中...')
+
+            win32gui.EnumWindows(self.enum_callback_to_activate, [])
+            await asyncio.sleep(0.5)
+
+            found = []
+            win32gui.EnumWindows(self.enum_callback_to_close_dialog, found)
+            await asyncio.sleep(0.5)
+            if any(found):
+                break
+
+        logger.debug('ブックを閉じます。')
+        win32gui.EnumWindows(self.enum_callback_to_close_book, [])  # 成功していればこの時点でメイン処理では例外がスローされる
+        await asyncio.sleep(1)
+
+        logger.debug('確認ダイアログがあれば閉じます。')
+        win32gui.EnumWindows(self.enum_callback_to_close_confirm_dialog, [])
+        await asyncio.sleep(1)
+        self.__error_raised = True
+
+    def enum_callback_to_activate(self, hwnd, _):
+        title = win32gui.GetWindowText(hwnd)
+        # Excel 本体
+        if self.__excel_window_title in title:
+            # Visible == True の際、エラーが発生した際、
+            # 一度 Excel ウィンドウをアクティブ化しないと dialog が出てこない
+            # が、これだけではダメかも。
+            win32gui.PostMessage(hwnd, win32con.WM_ACTIVATE, win32con.WA_ACTIVE, 0)
+
+    def enum_callback_to_close_dialog(self, hwnd, found):
+        title = win32gui.GetWindowText(hwnd)
+        # エラーダイアログ
+        if self.__error_dialog_title == title:
+            # 何故かこのコマンド以外受け付けず、
+            # このコマンドで問答無用でデバッグモードに入る
+            logger.debug('エラーダイアログを見つけました。')
+            win32api.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_RETURN, 0)
+            win32api.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_RETURN, 0)
+            logger.debug('エラーダイアログを閉じました。')
+            found.append(True)
+
+    def enum_callback_to_close_confirm_dialog(self, hwnd, _):
+        title = win32gui.GetWindowText(hwnd)
+        # 確認ダイアログ
+        if "Microsoft Excel" in title:
+            # DisplayAlerts が False の場合は不要
+            win32gui.SendMessage(hwnd, win32con.WM_SYSCOMMAND, win32con.SC_CLOSE, 0)
+
+    def enum_callback_to_close_book(self, hwnd, _):
+        title = win32gui.GetWindowText(hwnd)
+        # VBE
+        if self.__vbe_window_title in title:
+            # 何故かこれで book 本体が閉じる
+            win32gui.SendMessage(hwnd, win32con.WM_CLOSE, 0, 0)
+
+    async def watch_main(self):
+        try:
+            await asyncio.wait_for(self.watch(), timeout=self.timeout)
+        except asyncio.TimeoutError:
+            logger.debug('タイムアウトしました。')
+            self.should_stop = True
+            self.__timed_out = True
+
+    def __enter__(self):
+        logger.debug('Excel を 不可視にします。')
+        self.__excel_state_stash['visible'] = self.excel.Visible
+        self.__excel_state_stash['display_alerts'] = self.excel.DisplayAlerts
+        self.excel.Visible = False
+        self.excel.DisplayAlerts = False
+
+        logger.debug('エラー監視を開始します。')
+        self.__watch_thread = Thread(
+            target=asyncio.run,
+            args=(self.watch_main(),),
+        )
+        self.__watch_thread.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+
+        logger.debug('Excel の状態を回復します。')
+
+        self.should_stop = True
+        self.__watch_thread.join()
+
+        self.excel.Visible = self.__excel_state_stash['visible']
+        self.excel.DisplayAlerts = self.__excel_state_stash['display_alerts']
+
+        if self.__timed_out:
+            logger.debug('Excel プロセスを強制終了します。')
+            logger.error('Excel プロセス強制終了は未実装です。')
+            raise TimeoutError('マクロの実行がタイムアウトしました。')
+
+        # if exc_type is not None:
+        #     if issubclass(exc_type, com_error) and self.__error_raised:
+        if self.__error_raised:
+                logger.debug('エラーハンドリングの副作用でブックを閉じているので'
+                             'Excel のブックを開きなおします。')
+                for wb_path in self.__workbook_paths:
+                    self.excel.Workbooks.Open(wb_path)
+
+
+def watch_excel_macro_error(excel_, timeout):
+    """Excel のエラーダイアログの出現を監視し、検出されればブックを閉じます。"""
+    return _ExcelDialogProcessor(excel_, timeout)
+
+
+if __name__ == '__main__':
+
+    import os
+    os.chdir(os.path.dirname(__file__))
+
+    path = os.path.abspath('sample.xlsm')
+    path2 = os.path.abspath('sample2.xlsm')
+
+
+    from win32com.client import Dispatch
+    from pythoncom import com_error
+
+    logger.debug('Excel を起動しています。')
+    excel = Dispatch('Excel.Application')
+    excel.Visible = True
+    excel.DisplayAlerts = False
+    excel.Interactive = True
+
+    logger.debug('Workbook を開いています。')
+    excel.Workbooks.Open(path)
+
+    logger.debug('別の Workbook を開いています。')
+    excel.Workbooks.Open(path2)
+
+    logger.debug('Workbook に変更を加えます。')
+    excel.Workbooks(1).ActiveSheet.Range('A1').Value = 1.
+
+    logger.debug('開いている Workbooks 数：')
+    logger.debug(excel.Workbooks.Count)
+
+    try:
+        with watch_excel_macro_error(excel, timeout=10):
+            sleep(3)
+            try:
+                excel.Run('raise_error')
+            except com_error as e:
+                logger.debug('この段階ではまだ Excel 回復機能が働きません。')
+                logger.debug('開いている Workbooks 数：')
+                logger.debug(excel.Workbooks.Count)
+                raise e
+
+            # excel.Run('no_error')
+
+    except com_error as e:
+        logger.debug('メイン処理でエラーを補足しました。：')
+        logger.debug(e)
+
+    logger.debug('開いている Workbooks 数：')
+    logger.debug(excel.Workbooks.Count)
+
+    logger.debug('保存していない場合、Workbook の変更は失われます。')

pyfemtet/_warning.py

@@ -2,15 +2,19 @@ import warnings
 from functools import wraps
 
 
+def show_experimental_warning(feature_name):
+    warnings.warn(
+        f"The function '{feature_name}' is experimental and may change in the future.",
+        category=UserWarning,
+        stacklevel=2
+    )
+
+
 def experimental_feature(func):
 
     @wraps(func)
     def wrapper(*args, **kwargs):
-        warnings.warn(
-            f"The function '{func.__name__}' is experimental and may change in the future.",
-            category=UserWarning,
-            stacklevel=2
-        )
+        show_experimental_warning(func.__name__)
         return func(*args, **kwargs)
 
     return wrapper
@@ -62,6 +66,10 @@ if __name__ == '__main__':
         print("This is an experimental function.")
 
     class Sample:
+
+        def __init__(self):
+            show_experimental_warning("Sample")
+
         @experimental_feature
         def add(self, a, b):
             return a + b

pyfemtet/opt/interface/_excel_interface.py

@@ -25,7 +25,9 @@ from pyfemtet.dispatch_extensions._impl import _NestableSpawnProcess
 from pyfemtet._femtet_config_util.exit import _exit_or_force_terminate
 from pyfemtet._femtet_config_util.autosave import _set_autosave_enabled, _get_autosave_enabled
 
-from pyfemtet._warning import experimental_class
+from pyfemtet._util.excel_macro_util import watch_excel_macro_error
+
+from pyfemtet._warning import show_experimental_warning
 
 import logging
 
@@ -33,7 +35,6 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
 
-@experimental_class
 class ExcelInterface(FEMInterface):
 
     input_xlsm_path: Path  # 操作対象の xlsm パス
@@ -52,8 +53,8 @@ class ExcelInterface(FEMInterface):
     wb_output: CDispatch  # システムを構成する Workbook
     sh_output: CDispatch  # 計算結果の定義された WorkSheet (sh_input と同じでもよい)
 
-    visible: bool = True  # excel を可視化するかどうか
-    display_alerts: bool = True  # ダイアログを表示するかどうか
+    visible: bool = False  # excel を可視化するかどうか
+    display_alerts: bool = False  # ダイアログを表示するかどうか
 
     _load_problem_from_me: bool = True  # TODO: add_parameter() 等を省略するかどうか。定義するだけでフラグとして機能する。
     _excel_pid: int
@@ -69,7 +70,9 @@ class ExcelInterface(FEMInterface):
             procedure_name: str = None,
             procedure_args: list or tuple = None,
             connect_method: str = 'auto',  # or 'new'
+            procedure_timeout: float or None = None,
     ):
+        show_experimental_warning("ExcelInterface")
 
         # 初期化
         self.input_xlsm_path = None  # あとで取得する
@@ -81,6 +84,7 @@ class ExcelInterface(FEMInterface):
         assert connect_method in ['new', 'auto']
         self.connect_method = connect_method
         self._femtet_autosave_buffer = _get_autosave_enabled()
+        self.procedure_timeout = procedure_timeout
 
         # dask サブプロセスのときは space 直下の input_xlsm_path を参照する
         try:
@@ -119,8 +123,9 @@ class ExcelInterface(FEMInterface):
             procedure_name=self.procedure_name,
             procedure_args=self.procedure_args,
             connect_method='new',  # subprocess で connect する際は new を強制する
+            procedure_timeout=self.procedure_timeout,
         )
-        super().__init__(**kwargs)
+        FEMInterface.__init__(self, **kwargs)
 
     def __del__(self):
         try:
@@ -256,20 +261,18 @@ class ExcelInterface(FEMInterface):
 
         # マクロ実行
         try:
-            self.excel.Run(
-                f'{self.wb_input.Name}!{self.procedure_name}',
-                *self.procedure_args
-            )
+            with watch_excel_macro_error(self.excel, timeout=self.procedure_timeout):
+                self.excel.Run(
+                    f'{self.wb_input.Name}!{self.procedure_name}',
+                    *self.procedure_args
+                )
 
-        # FIXME: エラーハンドリング
-        #   com_error をキャッチする(solveerror)か、
-        #   sh_out に解析結果を書く(拘束違反)ようにして、
-        #   それが FALSE なら SolveError を raise する。
-        except ...:
-            raise SolveError('Excelアップデートに失敗しました')
+            # 再計算
+            self.excel.CalculateFull()
+
+        except com_error:
+            raise SolveError(f'Failed to run macro {self.wb_input.Name}!{self.procedure_name}')
 
-        # 再計算
-        self.excel.CalculateFull()
 
     def quit(self):
         logger.info('Excel-Femtet の終了処理を開始します。')  # FIXME: message にする

pyfemtet/opt/interface/_femtet_with_sldworks.py

@@ -3,10 +3,11 @@ import re
 from time import sleep, time
 
 import pandas as pd
-from dask.distributed import get_worker
+from dask.distributed import get_worker, Lock
 
 from win32com.client import DispatchEx
-from pythoncom import CoInitialize, CoUninitialize
+# noinspection PyUnresolvedReferences
+from pythoncom import CoInitialize, CoUninitialize, com_error
 
 from pyfemtet.core import ModelError
 from pyfemtet.opt.interface import FemtetInterface, logger
@@ -47,34 +48,58 @@ class FemtetWithSolidworksInterface(FemtetInterface):
     def __init__(
             self,
             sldprt_path,
+            quit_sldworks_on_terminate=False,
             **kwargs
     ):
         # 引数の処理
-        # dask サブプロセスのときは space 直下の sldprt_path を参照する
-        try:
-            worker = get_worker()
-            space = worker.local_directory
-            self.sldprt_path = os.path.join(space, os.path.basename(sldprt_path))
-        except ValueError:  # get_worker に失敗した場合
-            self.sldprt_path = os.path.abspath(sldprt_path)
+        self._orig_sldprt_basename = os.path.basename(sldprt_path)
+
+        # # dask サブプロセスのときは space 直下の sldprt_path を参照する
+        # try:
+        #     worker = get_worker()
+        #     space = worker.local_directory
+        #     name_ext = os.path.basename(sldprt_path)
+        #     name, ext = os.path.splitext(name_ext)
+        #     self.sldprt_path = os.path.join(space, name_ext)
+        #
+        #     # ただし solidworks は 1 プロセスで同名のファイルを開けないので
+        #     # 名前を更新する
+        #     new_sldprt_path = os.path.join(
+        #         space,
+        #         f'{name}'
+        #         f'_{os.path.basename(space)}'  # worker に対し一意
+        #         f'{ext}'  # ext は . を含む
+        #     )
+        #     os.rename(
+        #         self.sldprt_path,
+        #         new_sldprt_path
+        #     )
+        #     self.sldprt_path = new_sldprt_path
+        #
+        # except ValueError:  # get_worker に失敗した場合
+        #     self.sldprt_path = os.path.abspath(sldprt_path)
+        self.sldprt_path = os.path.abspath(sldprt_path)
+        self.quit_sldworks_on_terminate = quit_sldworks_on_terminate
 
         # FemtetInterface の設定 (femprj_path, model_name の更新など)
         # + restore 情報の上書き
         super().__init__(
             sldprt_path=self.sldprt_path,
+            quit_sldworks_on_terminate=self.quit_sldworks_on_terminate,
             **kwargs
         )
 
     def initialize_sldworks_connection(self):
         # SolidWorks を捕まえ、ファイルを開く
+
         self.swApp = DispatchEx('SLDWORKS.Application')
         self.swApp.Visible = True
 
-        # open model
-        self.swApp.OpenDoc(self.sldprt_path, self.swDocPART)
-        self.swModel = self.swApp.ActiveDoc
-        self.swEqnMgr = self.swModel.GetEquationMgr
-        self.nEquation = self.swEqnMgr.GetCount
+        # solidworks は単一プロセスなので開くファイルはひとつだけ
+        try:
+            get_worker()
+        except ValueError:
+            self.swApp.OpenDoc(self.sldprt_path, self.swDocPART)
 
     def check_param_value(self, param_name):
         """Override FemtetInterface.check_param_value().
@@ -104,25 +129,39 @@ class FemtetWithSolidworksInterface(FemtetInterface):
         # Femtet が参照している x_t パスを取得する
         x_t_path = self.Femtet.Gaudi.LastXTPath
 
+        # dask サブプロセスならば競合しないよう保存先を scratch 直下にしておく
+        try:
+            get_worker()
+            x_t_path = os.path.splitext(self.sldprt_path)[0] + '.x_t'
+
+        except ValueError:  # No worker found
+            pass
+
         # 前のが存在するならば消しておく
         if os.path.isfile(x_t_path):
             os.remove(x_t_path)
 
         # solidworks のモデルの更新
-        self.update_sw_model(parameters)
+        try:
+            with Lock('update-model-sldworks'):
+                sleep(0.5)  # 並列処理でクラッシュすることが多かったため試験的に導入
+                self.update_sw_model(parameters, x_t_path)
 
-        # export as x_t
-        self.swModel.SaveAs(x_t_path)
+        # femopt を使わない場合
+        except RuntimeError:  # <class 'distributed.lock.Lock'> object not properly initialized. ...
+            self.update_sw_model(parameters, x_t_path)
 
-        # 30 秒待っても x_t ができてなければエラー(COM なので)
-        timeout = 30
-        start = time()
-        while True:
-            if os.path.isfile(x_t_path):
-                break
-            if time() - start > timeout:
-                raise ModelError(Msg.ERR_MODEL_UPDATE_FAILED)
-            sleep(1)
+        # dask サブプロセスならば LastXTPath を更新する
+        try:
+            get_worker()
+            try:
+                self.Femtet.Gaudi.LastXTPath = x_t_path
+            except (KeyError, AttributeError, com_error):
+                raise RuntimeError('This feature is available from Femtet version 2023.2. Please update Femtet.')
+
+        # dask を使わない場合
+        except ValueError:  # No worker found
+            pass
 
         # モデルの再インポート
         self._call_femtet_api(
@@ -145,40 +184,78 @@ class FemtetWithSolidworksInterface(FemtetInterface):
         # femprj モデルの変数も更新
         super().update_model(parameters)
 
-    def update_sw_model(self, parameters: pd.DataFrame):
+    def update_sw_model(self, parameters: pd.DataFrame, x_t_path):
         """Update .sldprt"""
+
         # df を dict に変換
         user_param_dict = {}
         for i, row in parameters.iterrows():
             user_param_dict[row['name']] = row['value']
 
-        # プロパティを退避
-        buffer_aso = self.swEqnMgr.AutomaticSolveOrder
-        buffer_ar = self.swEqnMgr.AutomaticRebuild
-        self.swEqnMgr.AutomaticSolveOrder = False
-        self.swEqnMgr.AutomaticRebuild = False
-
-        for i in range(self.nEquation):
-            # name, equation の取得
-            current_equation = self.swEqnMgr.Equation(i)
-            current_name = self._get_name_from_equation(current_equation)
-            # 対象なら処理
-            if current_name in list(user_param_dict.keys()):
-                new_equation = f'"{current_name}" = {user_param_dict[current_name]}'
-                self.swEqnMgr.Equation(i, new_equation)
-
-        # 式の計算
-        # noinspection PyStatementEffect
-        self.swEqnMgr.EvaluateAll  # always returns -1
-
-        # プロパティをもとに戻す
-        self.swEqnMgr.AutomaticSolveOrder = buffer_aso
-        self.swEqnMgr.AutomaticRebuild = buffer_ar
-
-        # 更新する（ここで失敗はしうる）
-        result = self.swModel.EditRebuild3  # モデル再構築
-        if not result:
-            raise ModelError(Msg.ERR_UPDATE_SOLIDWORKS_MODEL_FAILED)
+        while True:
+
+            try:
+
+                # ===== model を取得 =====
+                swModel = get_model_by_basename(self.swApp, os.path.basename(self.sldprt_path))
+
+                # ===== equation manager を取得 =====
+                swEqnMgr = swModel.GetEquationMgr
+                nEquation = swEqnMgr.GetCount
+
+                # プロパティを退避
+                buffer_aso = swEqnMgr.AutomaticSolveOrder
+                buffer_ar = swEqnMgr.AutomaticRebuild
+                swEqnMgr.AutomaticSolveOrder = False
+                swEqnMgr.AutomaticRebuild = False
+
+                for i in range(nEquation):
+                    # name, equation の取得
+                    current_equation = swEqnMgr.Equation(i)
+                    current_name = self._get_name_from_equation(current_equation)
+                    # 対象なら処理
+                    if current_name in list(user_param_dict.keys()):
+                        new_equation = f'"{current_name}" = {user_param_dict[current_name]}'
+                        swEqnMgr.Equation(i, new_equation)
+
+                # 式の計算
+                # noinspection PyStatementEffect
+                swEqnMgr.EvaluateAll  # always returns -1
+
+                # プロパティをもとに戻す
+                swEqnMgr.AutomaticSolveOrder = buffer_aso
+                swEqnMgr.AutomaticRebuild = buffer_ar
+
+                # 更新する（ここで失敗はしうる）
+                result = swModel.EditRebuild3  # モデル再構築
+                if not result:
+                    raise ModelError(Msg.ERR_UPDATE_SOLIDWORKS_MODEL_FAILED)
+
+                # export as x_t
+                swModel.SaveAs(x_t_path)
+
+                # 30 秒待っても x_t ができてなければエラー(COM なのでありうる)
+                timeout = 30
+                start = time()
+                while True:
+                    if os.path.isfile(x_t_path):
+                        break
+                    if time() - start > timeout:
+                        raise ModelError(Msg.ERR_MODEL_UPDATE_FAILED)
+                    sleep(1)
+
+            except AttributeError as e:
+                if 'SLDWORKS.Application.' in str(e):
+                    # re-launch solidworks
+                    self.swApp = DispatchEx('SLDWORKS.Application')
+                    self.swApp.Visible = True
+                    self.swApp.OpenDoc(self.sldprt_path, self.swDocPART)
+                    continue
+
+                else:
+                    raise e
+
+            break
 
     def _get_name_from_equation(self, equation: str):
         pattern = r'^\s*"(.+?)"\s*$'
@@ -187,3 +264,35 @@ class FemtetWithSolidworksInterface(FemtetInterface):
             return matched.group(1)
         else:
             return None
+
+    def quit(self, timeout=1, force=True):
+        if self.quit_sldworks_on_terminate:
+            try:
+                get_worker()
+            except ValueError:
+                try:
+                    self.swApp.ExitApp()
+                except AttributeError:
+                    pass
+
+        super().quit(timeout, force)
+
+
+def get_model_by_basename(swApp, basename):
+    swModel = swApp.GetFirstDocument
+    while swModel is not None:
+        pathname = swModel.GetPathName
+        if os.path.basename(pathname) == basename:
+            from win32com.client import Dispatch
+            # swModel_ = swApp.ActivateDoc3(
+            #     basename,
+            #     False,
+            #     1,  # swRebuildOnActivation_e.swDontRebuildActiveDoc,
+            #     Dispatch("Scripting.List"),
+            # )
+            swApp.OpenDoc(pathname, 1)
+            swModel_ = swApp.ActiveDoc
+            return swModel_
+        else:
+            swModel = swModel.GetNext
+    raise ModuleNotFoundError(f'No model named {basename}')

pyfemtet/opt/optimizer/_optuna/_optuna.py

@@ -7,8 +7,8 @@ import inspect
 
 # 3rd-party
 import optuna
-from optuna.trial import TrialState
-from optuna.study import MaxTrialsCallback
+from optuna.trial import TrialState, FrozenTrial
+from optuna.study import MaxTrialsCallback, Study
 
 # pyfemtet relative
 from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
@@ -86,6 +86,8 @@ class OptunaOptimizer(AbstractOptimizer):
         self.additional_initial_parameter = []
         self.additional_initial_methods = add_init_method if hasattr(add_init_method, '__iter__') else [add_init_method]
         self.method_checker = OptunaMethodChecker(self)
+        self._temporary_storage = None
+        self._temporary_storage_path = '_pyfemtet_temporary_file.db'
 
     def _objective(self, trial):
 
@@ -277,6 +279,35 @@ class OptunaOptimizer(AbstractOptimizer):
                 f'sqlite:///{storage_path}',
             )
 
+            # if TPESampler, create temporary study
+            # due to instability in case of many pruned trials.
+            from optuna.samplers import TPESampler
+            if issubclass(self.sampler_class, TPESampler):
+
+                if os.path.exists(self._temporary_storage_path):
+                    os.remove(self._temporary_storage_path)
+
+                self._temporary_storage = optuna.integration.dask.DaskStorage(
+                    f'sqlite:///{self._temporary_storage_path}',
+                )
+
+                study = optuna.load_study(
+                    study_name=None,
+                    storage=self.storage,
+                    sampler=None,
+                )
+
+                _study = optuna.create_study(
+                    study_name='tmp',
+                    storage=self._temporary_storage,
+                    load_if_exists=True,
+                    directions=['minimize'] * len(self.objectives),
+                )
+
+                # Copy COMPLETE trials to temporary study.
+                existing_trials = study.get_trials(states=(optuna.trial.TrialState.COMPLETE,))
+                _study.add_trials(existing_trials)
+
     def add_init_parameter(
             self,
             parameter: dict or Iterable,
@@ -336,62 +367,45 @@ class OptunaOptimizer(AbstractOptimizer):
             sampler=sampler,
         )
 
-        # 一時的な実装。
-        #   TPESampler の場合、リスタート時などの場合で、
-        #   Pruned が多いとエラーを起こす挙動があるので、
-        #   Pruned な Trial は remove したい。
-        #   study.remove_trial がないので、一度ダミー
-        #   study を作成して最適化終了後に結果をコピーする。
-        if isinstance(sampler, optuna.samplers.TPESampler):
-            tmp_db = f"tmp{self.subprocess_idx}.db"
-            if os.path.exists(tmp_db):
-                os.remove(tmp_db)
-
-            _study = optuna.create_study(
-                study_name="tmp",
-                storage=f"sqlite:///{tmp_db}",
-                sampler=sampler,
-                directions=['minimize']*len(self.objectives),
-                load_if_exists=False,
-            )
-
-            # 既存の trials のうち COMPLETE のものを取得
-            existing_trials = study.get_trials(states=(optuna.trial.TrialState.COMPLETE,))
-            _study.add_trials(existing_trials)
-
+        # use temporary storage or not
+        if self._temporary_storage is None:
             # run
-            _study.optimize(
+            study.optimize(
                 self._objective,
                 timeout=self.timeout,
                 callbacks=self.optimize_callbacks,
             )
 
-            # trial.number と trial_id は _study への add_trials 時に
-            # 振りなおされるため重複したものをフィルタアウトするために
-            # datetime_start を利用。
-            added_trials = []
-            for _trial in _study.get_trials():
-                if _trial.datetime_start not in [t.datetime_start for t in existing_trials]:
-                    added_trials.append(_trial)
-
-            # Write back added trials to the existing study.
-            study.add_trials(added_trials)
+        else:
+            # load study
+            _study = optuna.load_study(
+                study_name="tmp",
+                storage=self._temporary_storage,
+                sampler=sampler,
+            )
 
-            # clean up
-            from optuna.storages import get_storage
-            storage = get_storage(f"sqlite:///{tmp_db}")
-            storage.remove_session()
-            del _study
-            del storage
-            import gc
-            gc.collect()
-            if os.path.exists(tmp_db):
-                os.remove(tmp_db)
+            # Add callback to coppy back each trial.
+            class CopyBack:
+                def __call__(self, _: Study, trial: FrozenTrial) -> None:
+                    # Write back added trials to the existing study.
+                    study.add_trial(trial)
+            self.optimize_callbacks.append(CopyBack())
 
-        else:
             # run
-            study.optimize(
+            _study.optimize(
                 self._objective,
                 timeout=self.timeout,
                 callbacks=self.optimize_callbacks,
             )
+
+            # clean up
+            try:
+                self._temporary_storage.remove_session()
+                del self._temporary_storage
+                del _study
+                import gc
+                gc.collect()
+                if os.path.exists(self._temporary_storage_path):
+                    os.remove(self._temporary_storage_path)
+            except:
+                pass

{pyfemtet-0.6.3.dist-info → pyfemtet-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfemtet
-Version: 0.6.3
+Version: 0.6.5
 Summary: Design parameter optimization using Femtet.
 Home-page: https://github.com/pyfemtet/pyfemtet
 License: BSD-3-Clause

{pyfemtet-0.6.3.dist-info → pyfemtet-0.6.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
-pyfemtet/__init__.py,sha256=_SsQ0ZcyZbUqlFFT370nQxs8UER9D0oW_EmCr4Q-hx4,21
+pyfemtet/__init__.py,sha256=_f8whmZJ36ZCTk0Zldzy3KONxDBm0bxyKt7pCSHC3cE,21
 pyfemtet/_femtet_config_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyfemtet/_femtet_config_util/autosave.py,sha256=e-_GJdiJ5un7iuTet3bK5vwwq4Aqh7B_YVTANDJfZl8,1383
+pyfemtet/_femtet_config_util/autosave.py,sha256=dNirA9XGuFehas8_Jkj2BW9GOzMbPyhnt1WHcH_ObSU,2070
 pyfemtet/_femtet_config_util/exit.py,sha256=sx8Wcepgi-lL5qJpJl6WvlzbeVheU9_Dtf1f38mmoTo,1822
 pyfemtet/_message/1. make_pot.bat,sha256=wrTA0YaL7nUfNB0cS8zljOmwq2qgyG6RMwHQbrwjvY4,476
 pyfemtet/_message/2. make_mo.bat,sha256=6shJ3Yn4BXjDc0hhv_kiGUtVTq4oSRz8-iS4vW29rNE,155
@@ -9,7 +9,9 @@ pyfemtet/_message/babel.cfg,sha256=AQIFCQ7NlAA84PhV0gowHhbIXH41zA55mzhgyROniJk,7
 pyfemtet/_message/locales/ja/LC_MESSAGES/messages.po,sha256=F2bJGHVMtk086pekjVwY2dluCSl7qeYPgJe1A9CSrxA,24526
 pyfemtet/_message/locales/messages.pot,sha256=8Yjf462pJdEtxBLySKT34zMG5CH5uLB_8VaJQll_QsY,14493
 pyfemtet/_message/messages.py,sha256=F8ENLZKoHq5irn-Ag7rqA3aSDsTmRWDyNHvOLY76ROI,13368
-pyfemtet/_warning.py,sha256=FaWDmGJVgIF4oDTDSRZNvEEDt3-N5HD9WrHshLSA0zc,2052
+pyfemtet/_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfemtet/_util/excel_macro_util.py,sha256=Euxz3QmvTnnQCkWnbnPhvX7xXxppRONX69VlFxNCojA,7540
+pyfemtet/_warning.py,sha256=TSOj8mOhuyfOUJB24LsW6GNhTA3IzIEevJw_hLKTrq8,2205
 pyfemtet/core.py,sha256=3lqfBGJ5IuKz2Nqj5pRo7YQqKwx_0ZDL72u95Ur_1p0,1386
 pyfemtet/dispatch_extensions/__init__.py,sha256=MI9b6oIS2IXnTNHy8jvZ4QURdTHQd9PN-gifYxqVvk4,272
 pyfemtet/dispatch_extensions/_impl.py,sha256=HU7rKRAzEe5yYukWrKtdi1aIbUas_kLyaa_KZZGCELE,16244
@@ -24,19 +26,19 @@ pyfemtet/opt/_test_utils/hyper_sphere.py,sha256=nQhw8EIY0DwvcTqrbKhkxiITLZifr4-n
 pyfemtet/opt/_test_utils/record_history.py,sha256=JCNJLZMCNTpJ6VT7iwEt2DIbwmsuQmgC0ClQSfcatj4,3915
 pyfemtet/opt/interface/__init__.py,sha256=5hel-mP6tuxzIEJFMZJZWUEWEbFSsskzCWlQ3HORTYI,466
 pyfemtet/opt/interface/_base.py,sha256=aPJ55dTp4-Q4KMkUZVRlquuBBWWOIOdC6yQsYZR4Jy0,2626
-pyfemtet/opt/interface/_excel_interface.py,sha256=ms-o31hZ6dM_gUqlXWoeodRvwZwNMnRuVuM-x6JJh9E,16483
+pyfemtet/opt/interface/_excel_interface.py,sha256=7wJ8SOJaCyl6rVnmjLjw67Yv95bO1gwFBThc-cDLRYE,16649
 pyfemtet/opt/interface/_femtet.py,sha256=dmKyRG8sWuX2JHjcXpvJ2q632oZh4I94iVo4u7Z7w_M,34742
 pyfemtet/opt/interface/_femtet_parametric.py,sha256=KDG8SB43AgwuhpCStjvx10G0RzyHhga6k4dfvp0gvYU,2175
 pyfemtet/opt/interface/_femtet_with_nx/__init__.py,sha256=-6W2g2FDEcKzGHmI5KAKQe-4U5jDpMj0CXuma-GZca0,83
 pyfemtet/opt/interface/_femtet_with_nx/_interface.py,sha256=BXWdzIFcId1EovpbRD5DmkW0BwqhpDvOuGBv9kdCGy8,5994
 pyfemtet/opt/interface/_femtet_with_nx/update_model.py,sha256=P7VH0i_o-X9OUe6AGaLF1fACPeHNrMjcrOBCA3MMrI4,3092
-pyfemtet/opt/interface/_femtet_with_sldworks.py,sha256=4QvwcHP_L4QMHcwKf_vnuWIV-68uIqmtDh0NNaavJjg,6853
+pyfemtet/opt/interface/_femtet_with_sldworks.py,sha256=A9o-IY8Npq0CHK7yGxBw47wmOtNv5IYR80U2XAabSWM,11019
 pyfemtet/opt/optimizer/__init__.py,sha256=Ia6viowECkG0IFXtFef0tJ4jDKsoDzJLqMJ9xLFH2LQ,543
 pyfemtet/opt/optimizer/_base.py,sha256=0jX68VEfLI08Qr01BvfPCHKKlr3Bj6gWQ0T81qpX0y4,12507
 pyfemtet/opt/optimizer/_optuna/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyfemtet/opt/optimizer/_optuna/_botorch_patch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyfemtet/opt/optimizer/_optuna/_botorch_patch/enable_nonlinear_constraint.py,sha256=2hUP2c8mokkRaSQ8nXxgCCmz8e0JKvEz8R2qIGnTGm0,8863
-pyfemtet/opt/optimizer/_optuna/_optuna.py,sha256=kdEi7N-ELWNgciD212h_afWFSO6kiRd960K9JJirVfc,16105
+pyfemtet/opt/optimizer/_optuna/_optuna.py,sha256=nKlEYizSu6BQu8OMhRWRJxk5eXJ0LAPR7h6CQOjbdxE,16460
 pyfemtet/opt/optimizer/_optuna/_pof_botorch.py,sha256=yVyg1V3trqirSDtbRepgftvS02AEkAhrgjou21JS124,72717
 pyfemtet/opt/optimizer/_scipy.py,sha256=_2whhMNq6hC1lr5PlYhpZ8Zlh6-DkAjz8SVB5qHIpYg,4766
 pyfemtet/opt/optimizer/_scipy_scalar.py,sha256=rGvrLjrgfYzxK9GA0-r2Hhoaqt6A0TQsT_1M3moyklc,3615
@@ -116,8 +118,8 @@ pyfemtet/opt/visualization/result_viewer/.gitignore,sha256=ryvb4aqbbsHireHWlPQfx
 pyfemtet/opt/visualization/result_viewer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyfemtet/opt/visualization/result_viewer/application.py,sha256=WcHBx_J5eNLKSaprpk9BGifwhO04oN8FiNGYTWorrXA,1691
 pyfemtet/opt/visualization/result_viewer/pages.py,sha256=laEAKHAtdshCAHxgXo-zMNg3RP6lCxfszO3XwLnF1dU,32156
-pyfemtet-0.6.3.dist-info/LICENSE,sha256=sVQBhyoglGJUu65-BP3iR6ujORI6YgEU2Qm-V4fGlOA,1485
-pyfemtet-0.6.3.dist-info/METADATA,sha256=l89gTkV_ub72Kqh496W02gf0nmGVwcYC-8w2-Us9zNk,3287
-pyfemtet-0.6.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pyfemtet-0.6.3.dist-info/entry_points.txt,sha256=ZfYqRaoiPtuWqFi2_msccyrVF0LurMn-IHlYamAegZo,104
-pyfemtet-0.6.3.dist-info/RECORD,,
+pyfemtet-0.6.5.dist-info/LICENSE,sha256=sVQBhyoglGJUu65-BP3iR6ujORI6YgEU2Qm-V4fGlOA,1485
+pyfemtet-0.6.5.dist-info/METADATA,sha256=04L0xEjP4MQaiIYEV0YZ6rXzf2P1ruOZzyW4hvhsXts,3287
+pyfemtet-0.6.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pyfemtet-0.6.5.dist-info/entry_points.txt,sha256=ZfYqRaoiPtuWqFi2_msccyrVF0LurMn-IHlYamAegZo,104
+pyfemtet-0.6.5.dist-info/RECORD,,