pyfemtet 0.6.4__tar.gz → 0.6.5__tar.gz

{pyfemtet-0.6.4 → pyfemtet-0.6.5}/PKG-INFO

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

pyfemtet-0.6.5/pyfemtet/__init__.py

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

pyfemtet-0.6.5/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-0.6.4 → pyfemtet-0.6.5}/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-0.6.4 → pyfemtet-0.6.5}/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-0.6.5/pyfemtet/opt/interface/_femtet_with_sldworks.py

@@ -0,0 +1,298 @@
+import os
+import re
+from time import sleep, time
+
+import pandas as pd
+from dask.distributed import get_worker, Lock
+
+from win32com.client import DispatchEx
+# noinspection PyUnresolvedReferences
+from pythoncom import CoInitialize, CoUninitialize, com_error
+
+from pyfemtet.core import ModelError
+from pyfemtet.opt.interface import FemtetInterface, logger
+from pyfemtet._message import Msg
+
+
+class FemtetWithSolidworksInterface(FemtetInterface):
+    """Control Femtet and Solidworks.
+
+    Using this class, you can import CAD files created
+    in Solidworks through the Parasolid format into a
+    Femtet project. It allows you to pass design
+    variables to Solidworks, update the model, and
+    perform analysis using the updated model in Femtet.
+
+
+    Args:
+        sldprt_path (str):
+            The path to .sldprt file containing the
+            CAD data from which the import is made.
+        **kwargs:
+            For other arguments, please refer to the
+            :class:`FemtetInterface` class.
+
+    """
+
+
+    # 定数の宣言
+    swThisConfiguration = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
+    swAllConfiguration = 2
+    swSpecifyConfiguration = 3  # use with ConfigName argument
+    swSaveAsCurrentVersion = 0
+    swSaveAsOptions_Copy = 2  #
+    swSaveAsOptions_Silent = 1  # https://help.solidworks.com/2021/english/api/swconst/solidworks.interop.swconst~solidworks.interop.swconst.swsaveasoptions_e.html
+    swSaveWithReferencesOptions_None = 0  # https://help-solidworks-com.translate.goog/2023/english/api/swconst/SolidWorks.Interop.swconst~SolidWorks.Interop.swconst.swSaveWithReferencesOptions_e.html?_x_tr_sl=auto&_x_tr_tl=ja&_x_tr_hl=ja&_x_tr_pto=wapp
+    swDocPART = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swDocumentTypes_e.html
+
+    def __init__(
+            self,
+            sldprt_path,
+            quit_sldworks_on_terminate=False,
+            **kwargs
+    ):
+        # 引数の処理
+        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
+
+        # 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().
+
+        Do nothing because the parameter can be registered
+        to not only .femprj but also .SLDPRT.
+
+        """
+        pass
+
+    def _setup_before_parallel(self, client):
+        client.upload_file(
+            self.kwargs['sldprt_path'],
+            False
+        )
+        super()._setup_before_parallel(client)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+        CoInitialize()
+        self.initialize_sldworks_connection()
+
+    def update_model(self, parameters: pd.DataFrame, with_warning=False):
+        """Update .x_t"""
+
+        self.parameters = parameters.copy()
+
+        # 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 のモデルの更新
+        try:
+            with Lock('update-model-sldworks'):
+                sleep(0.5)  # 並列処理でクラッシュすることが多かったため試験的に導入
+                self.update_sw_model(parameters, x_t_path)
+
+        # femopt を使わない場合
+        except RuntimeError:  # <class 'distributed.lock.Lock'> object not properly initialized. ...
+            self.update_sw_model(parameters, x_t_path)
+
+        # 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(
+            self.Femtet.Gaudi.ReExecute,
+            False,
+            ModelError,  # 生きてるのに失敗した場合
+            error_message=Msg.ERR_RE_EXECUTE_MODEL_FAILED,
+            is_Gaudi_method=True,
+        )
+
+        # 処理を確定
+        self._call_femtet_api(
+            self.Femtet.Redraw,
+            False,  # 戻り値は常に None なのでこの変数に意味はなく None 以外なら何でもいい
+            ModelError,  # 生きてるのに失敗した場合
+            error_message=Msg.ERR_MODEL_REDRAW_FAILED,
+            is_Gaudi_method=True,
+        )
+
+        # femprj モデルの変数も更新
+        super().update_model(parameters)
+
+    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']
+
+        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*$'
+        matched = re.match(pattern, equation.split('=')[0])
+        if matched:
+            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}')