pyfemtet 0.9.5__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

pyfemtet/_util/femtet_exit.py

@@ -0,0 +1,105 @@
+from time import time, sleep
+from packaging.version import Version
+
+from win32com.client import CDispatch
+from femtetutils import util
+import psutil
+
+from pyfemtet._i18n import _
+
+from pyfemtet._util.helper import *
+from pyfemtet._util.process_util import _get_pid
+from pyfemtet._util.femtet_version import _version
+
+from pyfemtet.logger import get_module_logger
+
+
+__all__ = ['_exit_or_force_terminate']
+
+
+logger = get_module_logger('util.femtet.exit', False)
+
+
+def _exit_or_force_terminate(timeout, Femtet: CDispatch, force=True):
+
+    # Femtet がすでに終了しているかどうかを判断する
+    hwnd = Femtet.hWnd
+    pid = _get_pid(hwnd)
+
+    # pid が 0 ならすでに終了しているものと見做して何もしない
+    if pid == 0:
+        return
+
+    # Exit() メソッドを定義している最小の Femtet バージョン
+    minimum_version = Version('2024.0.1')
+
+    # 現在の Femtet のバージョン
+    current_version = _version(Femtet=Femtet)
+
+    # 現在のバージョン >= minimum version なら Exit を実行
+    if current_version >= minimum_version:
+        # gracefully termination method without save project available from 2024.0.1
+        try:
+            with time_counting(
+                name='Femtet.Exit()',
+                warning_time_sec=timeout,
+                warning_fun=lambda: logger.warning(
+                    _(
+                        en_message='Femtet.Exit() does not finished in '
+                                   '{timeout} sec. Most common reason is '
+                                   'that a dialog is opening in Femtet '
+                                   'and waiting user input. Please close '
+                                   'the dialog if it exists.',
+                        jp_message='Femtet.Exit() は {timeout} 秒以内に終了できませんでした。'
+                                   '考えられる理由として、Femtet で予期せずダイアログが開いており'
+                                   'ユーザーの入力を待っている場合があります。'
+                                   'もしダイアログが存在すれば閉じてください。',
+                        timeout=timeout
+                    ),
+                    # f'Femtet.Exit() が {timeout} 以内に終了していません。'
+                    # f'Femtet で予期せずダイアログ等が開いている場合、'
+                    # f'入力待ちのため処理が終了しない場合があります。'
+                    # f'確認してください。'
+                )
+            ):
+                succeeded = Femtet.Exit(force)
+
+        except AttributeError:
+            raise AttributeError(
+                _(
+                    en_message='Macro version is not consistent to '
+                               'the one of Femtet.exe. Please consider to'
+                               'execute ``Enable Macros`` of current Femtet '
+                               'version to fix it.',
+                    jp_message='Femtet.exe のバージョンとマクロのバージョンが一致していません。'
+                               '使用中の Femtet.exe と同じバージョンの「マクロ機能を有効化する」'
+                               'コマンドを実行してください。',
+                )
+            )
+
+    # そうでなければ強制終了する
+    else:
+        # terminate
+        util.close_femtet(Femtet.hWnd, timeout, force)
+
+        try:
+            succeeded = True
+            pid = _get_pid(hwnd)
+            start = time()
+            while psutil.pid_exists(pid):
+                if time() - start > 30:  # 30 秒経っても存在するのは何かおかしい
+                    logger.error(_('Failed to close Femtet in '
+                                   '30 seconds.',
+                                   '30 秒以内に Femtet を終了することが'
+                                   'できませんでした。'
+                                   ))
+                    succeeded = False
+                    break
+                sleep(1)
+            sleep(1)
+
+        # dead
+        except (AttributeError, OSError):
+            pass
+
+    return succeeded

pyfemtet/_util/femtet_version.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+
+__all__ = [
+    '_version'
+]
+
+
+def _version(
+        main=None,
+        major=None,
+        minor=None,
+        Femtet=None,
+):
+    if Femtet is not None:
+        assert (main is None) and (major is None) and (minor is None), 'バージョンを指定しないでください'
+        main, major, minor = Femtet.Version.split('.')[:3]
+    else:
+        assert (main is not None) and (major is not None) and (minor is not None), 'バージョンを指定してください'
+
+    return Version('.'.join((str(main), str(major), str(minor))))

pyfemtet/_util/helper.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Callable
+import warnings
+from time import time, sleep
+from threading import Thread
+
+from pyfemtet._i18n import _
+
+__all__ = [
+    'float_',
+    'time_counting',
+]
+
+
+def float_(value: str | None | float) -> str | float | None:
+    if value is None:
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+class _TimeCounting:
+
+    _thread: Thread
+    _should_exit: bool
+    name: str
+    warning_time_sec: float
+    warning_message: str | None
+    warning_fun: Callable[[], ...] | None
+
+    def __init__(
+            self,
+            name: str,
+            warning_time_sec: float = None,
+            warning_message: str = None,
+            warning_fun: Callable[[], ...] = None,
+    ):
+        self.name = name
+        self.warning_time_sec = warning_time_sec
+        self.warning_message = warning_message
+        self.warning_fun = warning_fun
+        if self.warning_time_sec is not None:
+            if warning_message is None and warning_fun is None:
+                self.warning_message = _(
+                    '{name} does not finished in {timeout} seconds.',
+                    '{name} が {timeout} 秒以内に終了しませんでした。',
+                    name=self.name,
+                    timeout=self.warning_time_sec
+                )
+
+        self._thread = Thread(target=self._time_count, daemon=True)
+        self._should_exit = False
+
+    def _time_count(self):
+        start = time()
+
+        while True:
+
+            if self._should_exit:
+                break
+
+            elif time() - start > self.warning_time_sec:
+                if self.warning_fun is None:
+                    warnings.warn(self.warning_message)
+                else:
+                    self.warning_fun()
+                break
+
+            sleep(0.5)
+
+    def __enter__(self):
+        self._thread.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._should_exit = True
+        self._thread.join()
+
+
+def time_counting(
+        name: str,
+        warning_time_sec: float = None,
+        warning_message: str = None,
+        warning_fun: Callable[[], ...] = None,
+):
+
+    return _TimeCounting(
+        name,
+        warning_time_sec,
+        warning_message,
+        warning_fun,
+    )

pyfemtet/_util/process_util.py

@@ -0,0 +1,107 @@
+import os
+
+import psutil
+
+import win32process
+import win32gui
+
+# noinspection PyUnresolvedReferences
+from multiprocessing.context import BaseContext, SpawnProcess, _concrete_contexts
+# noinspection PyUnresolvedReferences
+from multiprocessing.process import _children, _cleanup
+from multiprocessing.managers import SyncManager
+
+
+__all__ = [
+    '_NestableSyncManager',
+    '_NestableSpawnProcess',
+    '_get_hwnds',
+    '_get_pid',
+    '_get_pids',
+]
+
+
+# noinspection PyPep8Naming
+def _NestableSyncManager():
+    m = SyncManager(ctx=_NestableSpawnContext())  # このへんが時間のかかる処理
+    m.start()
+    return m
+
+
+def _get_hwnds(pid) -> list[int]:
+    """Proces ID から window handle を取得します."""
+    def callback(hwnd, _hwnds):
+        if win32gui.IsWindowVisible(hwnd) and win32gui.IsWindowEnabled(hwnd):
+            _, found_pid = win32process.GetWindowThreadProcessId(hwnd)
+            if found_pid == pid:
+                _hwnds.append(hwnd)
+        return True
+    hwnds = []
+    win32gui.EnumWindows(callback, hwnds)
+    return hwnds
+
+
+def _get_pid(hwnd) -> int:
+    """Window handle から process ID を取得します."""
+    if hwnd > 0:
+        _, pid = win32process.GetWindowThreadProcessId(hwnd)
+    else:
+        pid = 0
+    return pid
+
+
+def _get_pids(process_name) -> list[int]:
+    """Process のイメージ名から実行中の process ID を取得します."""
+    pids = [p.info["pid"] for p in psutil.process_iter(attrs=["pid", "name"]) if p.info["name"] == process_name]
+    return pids
+
+
+# noinspection PyUnresolvedReferences,PyAttributeOutsideInit
+class _NestableSpawnProcess(SpawnProcess):
+    _start_method = 'nestable_spawn'
+
+    def start(self):
+        """This method is modified version of multiprocess.process.BaseProcess.start().
+
+        By using this class, it may become a zombie process.
+
+        """
+
+        #
+        # multiprocessing/process.py
+        #
+        # Copyright (c) 2006-2008, R Oudkerk
+        # Licensed to PSF under a Contributor Agreement.
+        #
+
+        self._check_closed()
+        assert self._popen is None, 'cannot start a process twice'
+        assert self._parent_pid == os.getpid(), \
+               'can only start a process object created by current process'
+        # assert not _current_process._config.get('daemon'), \
+        #        'daemonic processes are not allowed to have children'
+        _cleanup()
+        self._popen = self._Popen(self)
+        self._sentinel = self._popen.sentinel
+        # Avoid a refcycle if the target function holds an indirect
+        # reference to the process object (see bpo-30775)
+        del self._target, self._args, self._kwargs
+        _children.add(self)
+
+
+class _NestableSpawnContext(BaseContext):
+
+    #
+    # multiprocessing/process.py
+    #
+    # Copyright (c) 2006-2008, R Oudkerk
+    # Licensed to PSF under a Contributor Agreement.
+    #
+
+    _name = 'nestable_spawn'
+    Process = _NestableSpawnProcess
+
+
+_concrete_contexts.update(
+    dict(nestable_spawn=_NestableSpawnContext())
+)

pyfemtet/_util/str_enum.py

@@ -0,0 +1,44 @@
+"""Copy of StrEnum for python <= 3.10 support."""
+
+
+from enum import Enum
+
+
+class ReprEnum(Enum):
+    """
+    Only changes the repr(), leaving str() and format() to the mixed-in type.
+    """
+
+
+# noinspection PyMethodParameters,PySingleQuotedDocstring
+class StrEnum(str, ReprEnum):
+    """
+    Enum where members are also (and must be) strings
+    """
+
+    def __new__(cls, *values):
+        "values must already be of type `str`"
+        if len(values) > 3:
+            raise TypeError('too many arguments for str(): %r' % (values, ))
+        if len(values) == 1:
+            # it must be a string
+            if not isinstance(values[0], str):
+                raise TypeError('%r is not a string' % (values[0], ))
+        if len(values) >= 2:
+            # check that encoding argument is a string
+            if not isinstance(values[1], str):
+                raise TypeError('encoding must be a string, not %r' % (values[1], ))
+        if len(values) == 3:
+            # check that errors argument is a string
+            if not isinstance(values[2], str):
+                raise TypeError('errors must be a string, not %r' % (values[2]))
+        value = str(*values)
+        member = str.__new__(cls, value)
+        member._value_ = value
+        return member
+
+    def _generate_next_value_(name, start, count, last_values):
+        """
+        Return the lower-cased version of the member name.
+        """
+        return name.lower()

pyfemtet/core.py

@@ -1,52 +1,20 @@
-class ModelError(Exception):
-    """Exception raised for errors in the model update.
-    
-    If this exception is thrown during an optimization calculation, the process attempts to skip that attempt if possible.
-
-    """
-    pass
-
-
-class MeshError(Exception):
-    """Exception raised for errors in the meshing.
-    
-    If this exception is thrown during an optimization calculation, the process attempts to skip that attempt if possible.
-
-    """
-    pass
-
-
-class SolveError(Exception):
-    """Exception raised for errors in the solver.
-    
-    If this exception is thrown during an optimization calculation, the process attempts to skip that attempt if possible.
-
-    """
-    pass
-
-
-# class PostError(Exception):
-#     pass
-
-
-# class FEMCrash(Exception):
-#     pass
+from pyfemtet._i18n import _
 
 
-class FemtetAutomationError(Exception):
-    """Exception raised for errors in automating Femtet."""
+class DeprecationError(Exception):
     pass
 
 
-def _version(
-        main=None,
-        major=None,
-        minor=None,
-        Femtet=None,
-):
-    if Femtet is not None:
-        assert (main is None) and (major is None) and (minor is None), 'バージョンを指定しないでください'
-        main, major, minor = [int(v) for v in Femtet.Version.split('.')[:3]]
-    else:
-        assert (main is not None) and (major is not None) and (minor is not None), 'バージョンを指定してください'
-    return main*10000 + major*100 + minor
+raise DeprecationError(_(
+    en_message='Starting from version 1.0, the import '
+               'method for the Error classes has changed. '
+               'Please change imports such as '
+               '`from pyfemtet.core import ModelError` '
+               'to `from pyfemtet.opt.exceptions import ModelError`. '
+               'For more details, please see https://pyfemtet.readthedocs.io/en/stable/pages/migration_to_v1.html.',
+    jp_message='バージョン 1.0.0 からは、Error クラスのインポート方法が'
+               '変わりました。`from pyfemtet.core import ModelError` '
+               'などは、 `from pyfemtet.opt.exceptions import ModelError` '
+               'としてください。'
+               '詳しくは、https://pyfemtet.readthedocs.io/ja/stable/pages/migration_to_v1.html をご覧ください。',
+))

pyfemtet/dispatch_extensions/__init__.py

@@ -1,11 +1,8 @@
-from pyfemtet.dispatch_extensions._impl import (
-    dispatch_femtet,
-    dispatch_specific_femtet,
-    launch_and_dispatch_femtet,
-    DispatchExtensionException,
-    FemtetNotFoundException,
-    FemtetConnectionTimeoutError,
-    IFemtet,
-    _get_pid,
-    _get_pids,
-)
+from ._impl import *
+
+__all__ = [
+    'launch_and_dispatch_femtet',
+    'dispatch_femtet',
+    'dispatch_specific_femtet',
+    'DispatchExtensionException',
+]