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

pyfemtet/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.11"
+__version__ = "0.4.12"

pyfemtet/_test_util.py

@@ -15,6 +15,32 @@ from femtetutils import util
 from pyfemtet.opt import FEMOpt
 
 
+class SuperSphere:
+    def __init__(self, n):
+        self.n = n
+
+    def x(self, radius, *angles):
+        assert len(angles) == self.n - 1, 'invalid angles length'
+
+        out = []
+
+        for i in range(self.n):
+            if i == 0:
+                out.append(radius * np.cos(angles[0]))
+            elif i < self.n - 1:
+                product = radius
+                for j in range(i):
+                    product *= np.sin(angles[j])
+                product *= np.cos(angles[i])
+                out.append(product)
+            else:
+                product = radius
+                for j in range(i):
+                    product *= np.sin(angles[j])
+                out.append(product)
+        return out
+
+
 def _open_femprj(femprj_path):
     Femtet = Dispatch('FemtetMacro.Femtet')
     for _ in tqdm(range(5), 'wait for dispatch Femtet'):

pyfemtet/opt/__init__.py

@@ -4,7 +4,7 @@ from pyfemtet.opt.interface import FemtetInterface
 from pyfemtet.opt.interface import FemtetWithNXInterface
 from pyfemtet.opt.interface import FemtetWithSolidworksInterface
 
-from pyfemtet.opt.opt import OptunaOptimizer
+from pyfemtet.opt.opt import OptunaOptimizer, ScipyOptimizer
 from pyfemtet.opt.opt import AbstractOptimizer
 
 from pyfemtet.opt._femopt import FEMOpt

pyfemtet/opt/_femopt.py

@@ -107,6 +107,7 @@ class FEMOpt:
             initial_value: float or None = None,
             lower_bound: float or None = None,
             upper_bound: float or None = None,
+            step: float or None = None,
             memo: str = ''
     ):
         """Adds a parameter to the optimization problem.
@@ -133,8 +134,9 @@ class FEMOpt:
         d = {
             'name': name,
             'value': float(initial_value),
-            'lb': float(lower_bound),
-            'ub': float(upper_bound),
+            'lb': float(lower_bound) if lower_bound is not None else None,
+            'ub': float(upper_bound) if upper_bound is not None else None,
+            'step': float(step) if step is not None else None,
             'memo': memo,
         }
         pdf = pd.DataFrame(d, index=[0], dtype=object)
@@ -314,6 +316,34 @@ class FEMOpt:
 
         """
 
+        # method checker
+        if n_parallel > 1:
+            self.opt.method_checker.check_parallel()
+
+        if timeout is not None:
+            self.opt.method_checker.check_timeout()
+
+        if len(self.opt.objectives) > 1:
+            self.opt.method_checker.check_multi_objective()
+
+        if len(self.opt.constraints) > 0:
+            self.opt.method_checker.check_constraint()
+
+        for key, value in self.opt.constraints.items():
+            if value.strict:
+                self.opt.method_checker.check_strict_constraint()
+                break
+
+        if self.opt.seed is not None:
+            self.opt.method_checker.check_seed()
+
+        is_incomplete_bounds = False
+        for _, row in self.opt.parameters.iterrows():
+            lb, ub = row['lb'], row['ub']
+            is_incomplete_bounds = is_incomplete_bounds + (lb is None) + (ub is None)
+        if is_incomplete_bounds:
+            self.opt.method_checker.check_incomplete_bounds()
+
         # 共通引数
         self.opt.n_trials = n_trials
         self.opt.timeout = timeout

pyfemtet/opt/interface/_base.py

@@ -43,7 +43,12 @@ class FEMInterface(ABC):
         pass
 
     def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
-        """Updates only FEM variables (if implemented in concrete class)."""
+        """Updates only FEM variables (if implemented in concrete class).
+
+        If this method is implemented,
+        it is able to get parameter via FEMInterface.
+
+        """
         pass
 
     def _setup_before_parallel(self, client) -> None:

pyfemtet/opt/opt/__init__.py

@@ -1,7 +1,9 @@
-from pyfemtet.opt.opt._base import AbstractOptimizer, logger
+from pyfemtet.opt.opt._base import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.opt.opt._optuna import OptunaOptimizer
+from pyfemtet.opt.opt._scipy import ScipyOptimizer
 
 __all__ = [
+    'ScipyOptimizer',
     'OptunaOptimizer',
     'AbstractOptimizer',
     'logger',

pyfemtet/opt/opt/_base.py

@@ -20,6 +20,77 @@ logger = get_logger('opt')
 logger.setLevel(logging.INFO)
 
 
+class OptimizationMethodChecker:
+    """Check implementation of PyFemtet functions."""
+
+    def __init__(self, opt):
+        self.opt = opt
+
+    def check_parallel(self, raise_error=True):
+        function = 'parallel computing'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_timeout(self, raise_error=True):
+        function = 'timeout'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_multi_objective(self, raise_error=True):
+        function = 'multi-objective'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_strict_constraint(self, raise_error=True):
+        function = 'strict_constraint'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_constraint(self, raise_error=True):
+        function = 'strict_constraint'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_skip(self, raise_error=True):
+        function = 'skip'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_seed(self, raise_error=True):
+        function = 'random seed setting'
+        message = f'{type(self.opt)} is not implement {function}'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+    def check_incomplete_bounds(self, raise_error=True):
+        function = 'optimize with no or incomplete bounds'
+        message = f'{type(self.opt)} is not implement "{function}"'
+        if raise_error:
+            raise NotImplementedError(message)
+        else:
+            logger.warning(message)
+
+
 class AbstractOptimizer(ABC):
     """Abstract base class for an interface of optimization library.
 
@@ -45,9 +116,9 @@ class AbstractOptimizer(ABC):
         self.fem = None
         self.fem_class = None
         self.fem_kwargs = dict()
-        self.parameters = pd.DataFrame()
-        self.objectives = dict()
-        self.constraints = dict()
+        self.parameters: pd.DataFrame = pd.DataFrame()
+        self.objectives: dict = dict()
+        self.constraints: dict = dict()
         self.entire_status = None  # actor
         self.history = None  # actor
         self.worker_status = None  # actor
@@ -58,6 +129,7 @@ class AbstractOptimizer(ABC):
         self.is_cluster = False
         self.subprocess_idx = None
         self._is_error_exit = False
+        self.method_checker: OptimizationMethodChecker = OptimizationMethodChecker(self)
 
     def f(self, x):
         """Get x, update fem analysis, return objectives (and constraints)."""
@@ -199,10 +271,10 @@ class AbstractOptimizer(ABC):
         try:
             self.run()
         except Exception as e:
-            logger.error("================================")
-            logger.error("An unexpected error has occured!")
-            logger.error("================================")
-            logger.error(e)
+            logger.error("=================================")
+            logger.error("An unexpected error has occurred!")
+            logger.error("=================================")
+            logger.error(f'{type(e)}: {e}')
             self._is_error_exit = True
             self.worker_status.set(OptimizationStatus.CRASHED)
         finally:

pyfemtet/opt/opt/_optuna.py

@@ -12,7 +12,7 @@ from optuna.study import MaxTrialsCallback
 
 # pyfemtet relative
 from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.opt import AbstractOptimizer, logger
+from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.core import MeshError, ModelError, SolveError
 
 # filter warnings
@@ -25,6 +25,16 @@ optuna.logging.set_verbosity(optuna.logging.ERROR)
 warnings.filterwarnings('ignore', category=ExperimentalWarning)
 
 
+class OptunaMethodChecker(OptimizationMethodChecker):
+    def check_multi_objective(self, raise_error=True): return True
+    def check_timeout(self, raise_error=True): return True
+    def check_parallel(self, raise_error=True): return True
+    def check_constraint(self, raise_error=True): return True
+    def check_strict_constraint(self, raise_error=True): return True
+    def check_skip(self, raise_error=True): return True
+    def check_seed(self, raise_error=True): return True
+
+
 class OptunaOptimizer(AbstractOptimizer):
 
     def __init__(
@@ -42,6 +52,7 @@ class OptunaOptimizer(AbstractOptimizer):
         self.sampler_kwargs = dict() if sampler_kwargs is None else sampler_kwargs
         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)
 
     def _objective(self, trial):
 
@@ -54,7 +65,7 @@ class OptunaOptimizer(AbstractOptimizer):
         # candidate x
         x = []
         for i, row in self.parameters.iterrows():
-            v = trial.suggest_float(row['name'], row['lb'], row['ub'])
+            v = trial.suggest_float(row['name'], row['lb'], row['ub'], step=row['step'])
             x.append(v)
         x = np.array(x).astype(float)
 

pyfemtet/opt/opt/_scipy.py

@@ -0,0 +1,144 @@
+# typing
+import logging
+from typing import Iterable
+
+# built-in
+import os
+
+# 3rd-party
+import numpy as np
+import pandas as pd
+import scipy.optimize
+from scipy.optimize import minimize, OptimizeResult
+
+# pyfemtet relative
+from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
+from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
+from pyfemtet.core import MeshError, ModelError, SolveError
+
+
+class StopIteration2(Exception):
+    pass
+
+
+class StopIterationCallback:
+    def __init__(self, opt):
+        self.opt: ScipyOptimizer = opt
+        self.res: OptimizeResult = None
+
+    def stop_iteration(self):
+        # stop iteration gimmick
+        # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
+        if self.opt.minimize_kwargs['method'] == "trust-constr":
+            raise StopIteration2  # supports nothing
+        elif (
+                self.opt.minimize_kwargs['method'] == 'TNC'
+                or self.opt.minimize_kwargs['method'] == 'SLSQP'
+                or self.opt.minimize_kwargs['method'] == 'COBYLA'
+        ):
+            raise StopIteration2  # supports xk
+        else:
+            raise StopIteration  # supports xk , intermediate_result and StopIteration
+
+
+    def __call__(self, xk=None, intermediate_result=None):
+        self.res = intermediate_result
+        if self.opt.entire_status.get() == OptimizationStatus.INTERRUPTING:
+            self.opt.worker_status.set(OptimizationStatus.INTERRUPTING)
+            self.stop_iteration()
+
+
+class ScipyMethodChecker(OptimizationMethodChecker):
+    def check_incomplete_bounds(self, raise_error=True): return True
+
+
+class ScipyOptimizer(AbstractOptimizer):
+
+    def __init__(
+            self,
+            **minimize_kwargs,
+    ):
+        """
+        Args:
+            **minimize_kwargs: Kwargs of `scipy.optimize.minimize`.
+        """
+        super().__init__()
+
+        # define members
+        self.minimize_kwargs: dict = dict(
+            method='L-BFGS-B',
+        )
+        self.minimize_kwargs.update(minimize_kwargs)
+        self.res: OptimizeResult = None
+        self.method_checker: OptimizationMethodChecker = ScipyMethodChecker(self)
+        self.stop_iteration_callback = StopIterationCallback(self)
+
+    def _objective(self, x: np.ndarray):  # x: candidate parameter
+        # update parameter
+        self.parameters['value'] = x
+        self.fem.update_parameter(self.parameters)
+
+        # strict constraints
+        ...
+
+        # fem
+        try:
+            _, obj_values, cns_values = self.f(x)
+        except (ModelError, MeshError, SolveError) as e:
+            logger.info(e)
+            logger.info('以下の変数で FEM 解析に失敗しました。')
+            print(self.get_parameter('dict'))
+
+            # 現状、エラーが起きたらスキップできない
+            raise StopIteration2
+
+        # constraints
+        ...
+
+        # # check interruption command
+        # if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
+        #     self.worker_status.set(OptimizationStatus.INTERRUPTING)
+        #     raise StopOptimize
+
+        # objectives to objective
+
+        return obj_values[0]
+
+    def _setup_before_parallel(self):
+        pass
+
+    def run(self):
+
+        # create init
+        x0 = self.parameters['value'].values
+
+        # create bounds
+        if 'bounds' not in self.minimize_kwargs.keys():
+            bounds = []
+            for i, row in self.parameters.iterrows():
+                lb, ub = row['lb'], row['ub']
+                if lb is None: lb = -np.inf
+                if ub is None: ub = np.inf
+                bounds.append([lb, ub])
+            self.minimize_kwargs.update(
+                {'bounds': bounds}
+            )
+
+        # run optimize
+        try:
+            res = minimize(
+                fun=self._objective,
+                x0=x0,
+                **self.minimize_kwargs,
+                callback=self.stop_iteration_callback,
+            )
+        except StopIteration2:
+            res = None
+            logger.warn('Optimization has been interrupted. '
+                        'Note that you cannot acquire the OptimizationResult '
+                        'in case of `trust-constr`, `TNC`, `SLSQP` or `COBYLA`.')
+
+        if res is None:
+            self.res = self.stop_iteration_callback.res
+        else:
+            self.res = res

pyfemtet/opt/opt/_scipy_scalar.py

@@ -0,0 +1,104 @@
+# typing
+import logging
+from typing import Iterable
+
+# built-in
+import os
+
+# 3rd-party
+import numpy as np
+import pandas as pd
+import scipy.optimize
+from scipy.optimize import minimize_scalar, OptimizeResult
+
+# pyfemtet relative
+from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
+from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
+from pyfemtet.core import MeshError, ModelError, SolveError
+
+
+class ScipyScalarMethodChecker(OptimizationMethodChecker):
+    def check_incomplete_bounds(self, raise_error=True): return True
+
+
+class ScipyOptimizer(AbstractOptimizer):
+
+    def __init__(
+            self,
+            **minimize_kwargs,
+    ):
+        """
+        Args:
+            **minimize_kwargs: Kwargs of `scipy.optimize.minimize_scalar` __except ``fun``.__.
+        """
+        super().__init__()
+
+        # define members
+        self.minimize_kwargs: dict = dict()
+        self.minimize_kwargs.update(minimize_kwargs)
+        self.res: OptimizeResult = None
+        self.method_checker: OptimizationMethodChecker = ScipyScalarMethodChecker(self)
+
+    def _objective(self, x: float):  # x: candidate parameter
+        # update parameter
+        self.parameters['value'] = x
+        self.fem.update_parameter(self.parameters)
+
+        # strict constraints
+        ...
+
+        # fem
+        try:
+            _, obj_values, cns_values = self.f(x)
+        except (ModelError, MeshError, SolveError) as e:
+            logger.info(e)
+            logger.info('以下の変数で FEM 解析に失敗しました。')
+            print(self.get_parameter('dict'))
+
+            # 現状、エラーが起きたらスキップできない
+            raise StopIteration
+
+        # constraints
+        ...
+
+        # check interruption command
+        if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
+            self.worker_status.set(OptimizationStatus.INTERRUPTING)
+            raise StopIteration
+
+        # objectives to objective
+
+        return obj_values[0]
+
+    def _setup_before_parallel(self):
+        pass
+
+    def run(self):
+
+        # create init
+        assert len(self.parameters) == 1
+
+        # create bounds
+        if 'bounds' not in self.minimize_kwargs.keys():
+            bounds = []
+            for i, row in self.parameters.iterrows():
+                lb, ub = row['lb'], row['ub']
+                if lb is None: lb = -np.inf
+                if ub is None: ub = np.inf
+                bounds.append([lb, ub])
+            self.minimize_kwargs.update(
+                {'bounds': bounds}
+            )
+
+        # run optimize
+        try:
+            res = minimize_scalar(
+                fun=self._objective,
+                **self.minimize_kwargs,
+            )
+        except StopIteration:
+            res = None
+            logger.warn('Optimization has been interrupted. '
+                        'Note that you cannot acquire the OptimizationResult.')
+
+        self.res = res

{pyfemtet-0.4.11.dist-info → pyfemtet-0.4.12.dist-info}/METADATA

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

{pyfemtet-0.4.11.dist-info → pyfemtet-0.4.12.dist-info}/RECORD

@@ -12,13 +12,13 @@ pyfemtet/FemtetPJTSample/her_ex40_parametric.py,sha256=B5PQoh71Q3KN2CyLU1gP_Yh9g
 pyfemtet/FemtetPJTSample/wat_ex14_parallel_parametric.py,sha256=UfhJffuXyhzdIWNpOrpV6xLTK1fuVvgyhlyg4Rp-628,2148
 pyfemtet/FemtetPJTSample/wat_ex14_parametric.femprj,sha256=pxacKe0NPNUPAcxqo2cATFApsMKiVt2g2e_FOk4fpjA,172895
 pyfemtet/FemtetPJTSample/wat_ex14_parametric.py,sha256=LGbWxCek0Ad2YrDCKykiQkE3aIypM4g8P3mLd_2anEE,2052
-pyfemtet/__init__.py,sha256=tgmiUVid-UdHhYzSSof24ammeCv2MJdKLnqya5UMdps,22
-pyfemtet/_test_util.py,sha256=cxSPWvYbvAMAEoY_H3XpWlhhdS0MijwZEQgZ7aa4Fy8,3727
+pyfemtet/__init__.py,sha256=tZkJ0uJk05Wp3JKUzODcgphEkYtK6avu9HolSmeKZbk,22
+pyfemtet/_test_util.py,sha256=VLRyeLrBbaZ-tBoncyiR9-1BgT5N91SPR8u1j0AI6dU,4445
 pyfemtet/core.py,sha256=3lqfBGJ5IuKz2Nqj5pRo7YQqKwx_0ZDL72u95Ur_1p0,1386
 pyfemtet/dispatch_extensions.py,sha256=MhWiUXVt2Cq8vDeajMK4SrajjiAmb4m2fK8gXwHLrWA,16177
 pyfemtet/logger.py,sha256=JYD0FvzijMS2NvZN7VT7vZA5hqtHEkvS93AHlIMDePw,2507
-pyfemtet/opt/__init__.py,sha256=_P8unESvqCRD5pmuo6-5yo7BbrPi7c0aE6UZpqUD-_I,596
-pyfemtet/opt/_femopt.py,sha256=CLrv7-ehYR4ddGFDiahiI9majLHvptWqlGXXhT243hE,22548
+pyfemtet/opt/__init__.py,sha256=AJc1_d0sQ2_X4h_8FOcdmHvSPrFV_vfxlRrZTsqDZuE,612
+pyfemtet/opt/_femopt.py,sha256=NdqXbeH81AHnMpuq1PFKD3Bo1FTfYVji5H2kyUQR6xI,23693
 pyfemtet/opt/_femopt_core.py,sha256=zB12rNBnWN-CuqGijgKL8RuBEdoyzfbNWQBTcBiTvcU,25490
 pyfemtet/opt/femprj_sample/cad_ex01_NX.femprj,sha256=KC8JlHqHzqgyKriK911QSnQByQpRlw-SX5OSQ_GNe5M,149193
 pyfemtet/opt/femprj_sample/cad_ex01_NX.prt,sha256=3okHLeMdslrRA_wkhppZtxIe-2-ZPMfNqWCdQwUV31o,226626
@@ -62,16 +62,18 @@ pyfemtet/opt/femprj_sample_jp/wat_ex14_parametric_jp.femprj,sha256=dMwQMt6yok_Pb
 pyfemtet/opt/femprj_sample_jp/wat_ex14_parametric_jp.py,sha256=W30jobW1eEYuAsJJR14-EifQ1fxeXlS-gRSFqgCP4BM,2590
 pyfemtet/opt/femprj_sample_jp/wat_ex14_parametric_parallel_jp.py,sha256=ul2JUwlM5jfjNRELHkT7ZDuyMOq5RAHO32vAweEhCwg,2641
 pyfemtet/opt/interface/__init__.py,sha256=qz5BszPuU3jZIoDnPjkPDAgvgHLlx1sYhuqh5ID798k,480
-pyfemtet/opt/interface/_base.py,sha256=Ti2wCicyeofAZ0DzQLYoj9PBj1lyM5_lbLa0LBoypLM,2228
+pyfemtet/opt/interface/_base.py,sha256=I4pJttLeRW-6WWMuCNynwxWPwriiGZk20vHLVcfixZY,2332
 pyfemtet/opt/interface/_femtet.py,sha256=Of-O8ufbD1cjvXrJ3K7yyRTlNZYsBJGiq6okCx72B8I,34195
 pyfemtet/opt/interface/_femtet_parametric.py,sha256=X6D5KfQE5_vxOTY8gZcHXWgWAhzaUs5QfmR4TwDyAHk,2124
 pyfemtet/opt/interface/_femtet_with_nx/__init__.py,sha256=-6W2g2FDEcKzGHmI5KAKQe-4U5jDpMj0CXuma-GZca0,83
 pyfemtet/opt/interface/_femtet_with_nx/_interface.py,sha256=8ZvD6ajNmKUqXPkDsGJ4tOHrQOYwWBlO9OSPaCO3ml0,5666
 pyfemtet/opt/interface/_femtet_with_nx/update_model.py,sha256=uFf_SU96_BYUmLBBR5w3NS3WqXvEvSbOoxVnz9FA3Ug,3187
 pyfemtet/opt/interface/_femtet_with_sldworks.py,sha256=400FidHp7mBAVLyxzLlLtGYNzK_TtK61ycd4vFjHES0,6254
-pyfemtet/opt/opt/__init__.py,sha256=eQh-7PJN2YEUbHZnjinbeIyb0bk1wSh76TaEAa2l8SU,191
-pyfemtet/opt/opt/_base.py,sha256=U4lrW_r2WMqD54NN2m5pSlgP3gNk-QRwdOYA25vQp90,7953
-pyfemtet/opt/opt/_optuna.py,sha256=3S7gW-SNeK6esW7ygoZVgFpqY3Z8eDMhuYrIEA_-kdM,10050
+pyfemtet/opt/opt/__init__.py,sha256=UrfJ0oEr_ikUKfzrsBEsBC3L3mQO_hV9dejr5UfuWT4,291
+pyfemtet/opt/opt/_base.py,sha256=IBnapgEM34b9tFkwdbJMrfMWy7h-nIwby4GoLKsE6bc,10447
+pyfemtet/opt/opt/_optuna.py,sha256=IjUsAPsAp3-sc3U8OYpDs137heW0c4b3Y_bExaXdRRs,10636
+pyfemtet/opt/opt/_scipy.py,sha256=XArCRPTTqE1Cf-O_XZcsErsvP1_nXJh7YCQwL9jCeFo,4398
+pyfemtet/opt/opt/_scipy_scalar.py,sha256=bhBfAfiep8t170QDFBxGJb_wAE0viTtJHz-q8iubJM0,2964
 pyfemtet/opt/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyfemtet/opt/visualization/_create_wrapped_components.py,sha256=XpOv_iEEB3lFT3vYuCnCCbwUwRFbCYgvsZDpaiSzmZY,2511
 pyfemtet/opt/visualization/base.py,sha256=XhZodLEr5PPHmtNai6uZcPJobKurENepuGCUaqDOI7I,7588
@@ -129,8 +131,8 @@ pyfemtet/opt/visualization/wrapped_components/dbc.py,sha256=wzR1ZMOb4uwPNTMFn5up
 pyfemtet/opt/visualization/wrapped_components/dcc.py,sha256=hcW7SR6VIMn4S4-JMyohvOzdc0Aw8A4chIeHqQEUbFU,17499
 pyfemtet/opt/visualization/wrapped_components/html.py,sha256=sE2XHTDY1GvA1NW7y6SKWf-WglVXFKKvXhU9h3z53_g,95652
 pyfemtet/opt/visualization/wrapped_components/str_enum.py,sha256=NZqbh2jNEAckvJyZv__MWeRs2F2Q-dkJCWo30rU2rrM,1383
-pyfemtet-0.4.11.dist-info/LICENSE,sha256=sVQBhyoglGJUu65-BP3iR6ujORI6YgEU2Qm-V4fGlOA,1485
-pyfemtet-0.4.11.dist-info/METADATA,sha256=5z9Q1Gh0RwYRZLv5cpnkIScAvQgGD62htOUL0V4qVHw,3382
-pyfemtet-0.4.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pyfemtet-0.4.11.dist-info/entry_points.txt,sha256=ZfYqRaoiPtuWqFi2_msccyrVF0LurMn-IHlYamAegZo,104
-pyfemtet-0.4.11.dist-info/RECORD,,
+pyfemtet-0.4.12.dist-info/LICENSE,sha256=sVQBhyoglGJUu65-BP3iR6ujORI6YgEU2Qm-V4fGlOA,1485
+pyfemtet-0.4.12.dist-info/METADATA,sha256=4xS2zTozQkGcgzt53ZYgme4StBaIRVftfzVkSzotHAA,3382
+pyfemtet-0.4.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pyfemtet-0.4.12.dist-info/entry_points.txt,sha256=ZfYqRaoiPtuWqFi2_msccyrVF0LurMn-IHlYamAegZo,104
+pyfemtet-0.4.12.dist-info/RECORD,,