fix some recursive imports

hiaselhans · hiaselhans · commit fcc4a04708e0 · 2025-10-20T23:00:53.000+02:00
diff --git a/openglider/__init__.py b/openglider/__init__.py
@@ -1,3 +1,4 @@
+import os
 import logging
 from pathlib import Path
 from typing import Any
@@ -27,9 +28,10 @@ def load(filename: str) -> Any:
 
     return res
 
+
 def load_demokite() -> openglider.glider.GliderProject:
-    import os
-    filename = os.path.join(os.path.dirname(os.path.dirname(__file__)), "tests/common/demokite.ods")
+    import openglider.tests
+    filename =  openglider.tests.get_demokite_path()
 
     if not os.path.isfile(filename):
         raise FileNotFoundError()
diff --git a/openglider/config.py b/openglider/config.py
@@ -3,7 +3,7 @@
 import platform
 from typing import Any
 
-from openglider.utils.config import Config
+from openglider.utils.config_old import Config
 
 
 class GlobalConfig(Config):
diff --git a/openglider/glider/ballooning/base.py b/openglider/glider/ballooning/base.py
@@ -8,13 +8,14 @@
 import euklid
 
 import openglider
+from openglider.config import config
 from pyfoil import Airfoil
 
 class ArcSinc:
     def __init__(self) -> None:
         self.start = 0.
         self.end = math.pi
-        self.interpolate(openglider.config['asinc_interpolation_points'])
+        self.interpolate(config['asinc_interpolation_points'])
 
     def __call__(self, val: float) -> float:
         return self.arsinc.get_value(val)
diff --git a/openglider/gui/app/main_window.py b/openglider/gui/app/main_window.py
@@ -66,8 +66,10 @@ class MainWindow(QtWidgets.QMainWindow):
     def __init__(self, app: GliderApp):
         super().__init__()
         self.setWindowTitle("Glider Schneider")
-        og_dir = os.path.dirname(openglider.__file__)
-        self.setWindowIcon(QtGui.QIcon(os.path.join(og_dir, "gui/openglider.png")))
+        gui_dir = os.path.dirname(os.path.dirname(__file__))
+        filepath = os.path.join(gui_dir, "openglider.png")
+        print(filepath)
+        self.setWindowIcon(QtGui.QIcon(filepath))
         
         self.app = app
         self.state = app.state
@@ -319,8 +321,8 @@ def add_glider(self, glider: GliderProject, focus: bool=True, increase_revision:
         self.top_panel.setCurrentIndex(0)
 
     def load_demokite(self) -> None:
-        og_dir = os.path.dirname(openglider.__file__)
-        filename = os.path.join(og_dir, "tests/common/demokite.ods")
+        import openglider.tests
+        filename = openglider.tests.get_demokite_path()
         asyncio.ensure_future(self.load_glider(filename))
 
 
diff --git a/openglider/jsonify/__init__.py b/openglider/jsonify/__init__.py
@@ -6,8 +6,8 @@
 import datetime
 from typing import Any, Dict, Type
 
-import pydantic
-import openglider.config
+from openglider.version import __version__
+from openglider.config import config
 from openglider.jsonify.encoder import Encoder
 from openglider.jsonify.migration import Migration
 from openglider.utils import recursive_getattr
@@ -22,12 +22,12 @@
 datetime_format_regex = re.compile(r'^\d{2}\.\d{2}\.\d{4} \d{2}:\d{2}$')
 
 def get_element(_module: str, _name: str) -> type[Any]:
-    for rex in openglider.config["json_forbidden_modules"]:
+    for rex in config["json_forbidden_modules"]:
         if re.match(rex, _module):
             raise Exception
         elif re.match(rex, _name):
             raise Exception
-    for rex in openglider.config["json_allowed_modules"]:
+    for rex in config["json_allowed_modules"]:
         match = re.match(rex, _module)
         if match:
             fromlist = [str(w) for w in _module.split(".")]
@@ -85,8 +85,8 @@ def add_metadata(data: Any) -> dict[str, Any]:
         return data
     else:
         return {'MetaData': {'application': 'openglider',
-                             'version': openglider.__version__,
-                             'author': openglider.config["user"],
+                             'version': __version__,
+                             'author': config["user"],
                              'date_created': time.strftime("%d.%m.%y %H:%M"),
                              'date_modified': time.strftime("%d.%m.%y %H:%M")},
                 'data': data}
diff --git a/openglider/jsonify/migration/migrate_0_0_8_tables.py b/openglider/jsonify/migration/migrate_0_0_8_tables.py
@@ -1,15 +1,19 @@
+from __future__ import annotations
+
 import logging
 import json
 import copy
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from openglider.jsonify.encoder import Encoder
 from openglider.jsonify.migration.migration import Migration
-from openglider.glider.parametric.table.rib.holes import HolesTable
-from openglider.glider.parametric.table.cell.diagonals import DiagonalTable, StrapTable
 from openglider.materials import cloth
 from openglider.utils.table import Table
 
+if TYPE_CHECKING:
+    from openglider.glider.parametric.table.rib.holes import HolesTable
+    from openglider.glider.parametric.table.cell.diagonals import DiagonalTable, StrapTable
+
 logger = logging.getLogger(__name__)
 
 @Migration.add("0.0.8")
@@ -56,6 +60,7 @@ def migrate_diagonals(cls: Migration, jsondata: Any) -> Any:
 
 
 def get_hole_table(holes: list[Any]) -> HolesTable:
+    from openglider.glider.parametric.table.rib.holes import HolesTable
     table = Table()
 
     for hole in holes:
@@ -75,6 +80,7 @@ def get_hole_table(holes: list[Any]) -> HolesTable:
 
 
 def get_diagonals_table(diagonals: list[Any]) -> DiagonalTable:
+    from openglider.glider.parametric.table.cell.diagonals import DiagonalTable
     from openglider.glider.cell.diagonals import DiagonalRib
 
 
@@ -117,6 +123,7 @@ def get_diagonals_table(diagonals: list[Any]) -> DiagonalTable:
     return DiagonalTable(table)
 
 def get_straps_table(straps: list[Any], simple: bool=False) -> StrapTable:
+    from openglider.glider.parametric.table.cell.diagonals import StrapTable
     table = Table()
     cell_num = max([max(strap["cells"]) for strap in straps], default=0)
     straps_per_cell: list[list[list[float]]] = []
diff --git a/openglider/jsonify/migration/migrate_0_0_9_cuts_table.py b/openglider/jsonify/migration/migrate_0_0_9_cuts_table.py
@@ -1,21 +1,26 @@
+from __future__ import annotations
+
 import logging
 from typing import TYPE_CHECKING, Any, Literal
-from openglider.glider.parametric.table.curve import CurveTable
-from openglider.glider.parametric.table.rigidfoil import CellRigidTable, RibRigidTable
-from openglider.glider.parametric.table.material import CellClothTable, RibClothTable
-from openglider.glider.parametric.table.cell.miniribs import MiniRibTable
 
 from openglider.jsonify.migration.migration import Migration
-from openglider.glider.parametric.table.cell.cuts import CutTable
 from openglider.utils.table import Table
 
 if TYPE_CHECKING:
-    from openglider.jsonify.migration.migration import Migration
+    from openglider.glider.parametric.table.curve import CurveTable
+    from openglider.glider.parametric.table.rigidfoil import CellRigidTable, RibRigidTable
+    from openglider.glider.parametric.table.material import CellClothTable, RibClothTable
+    from openglider.glider.parametric.table.cell.miniribs import MiniRibTable
+    from openglider.glider.parametric.table.cell.cuts import CutTable
 
 logger = logging.getLogger(__name__)
 
 @Migration.add("0.0.9")
 def migrate_diagonals(cls: type[Migration], jsondata: Any) -> Any:
+    from openglider.glider.parametric.table.curve import CurveTable
+    from openglider.glider.parametric.table.material import CellClothTable, RibClothTable
+    from openglider.glider.parametric.table.cell.miniribs import MiniRibTable
+
     nodes = cls.find_nodes(jsondata, name=r"ParametricGlider")
     if not nodes:
         return jsondata
@@ -75,6 +80,7 @@ def migrate_diagonals(cls: type[Migration], jsondata: Any) -> Any:
     return jsondata
 
 def get_cell_rigidfoil_table(rigidfoils: list[dict[str, Any]]) -> CellRigidTable:
+    from openglider.glider.parametric.table.rigidfoil import CellRigidTable
     table = Table()
     rigidfoils.sort(key=lambda r: r["x_start"])
     for rigidfoil in rigidfoils:
@@ -92,6 +98,7 @@ def get_cell_rigidfoil_table(rigidfoils: list[dict[str, Any]]) -> CellRigidTable
 
 
 def get_rib_rigidfoil_table(rigidfoils: list[dict[str, Any]]) -> RibRigidTable:
+    from openglider.glider.parametric.table.rigidfoil import RibRigidTable
     table = Table()
 
     rigidfoils.sort(key=lambda r: r["start"])
@@ -126,6 +133,7 @@ def get_materials_table(materials: list[list[dict[str, Any]]], _cls: Any) -> Any
     return _cls(material_table)
 
 def get_cuts_table(cuts: list[dict[str, Any]]) -> CutTable:
+    from openglider.glider.parametric.table.cell.cuts import CutTable
     cuts_table = Table()
     cuts_per_cell: list[list[tuple[float, float, str]]] = []
 
diff --git a/openglider/plots/glider/minirib.py b/openglider/plots/glider/minirib.py
@@ -2,8 +2,9 @@
 
 from typing import TYPE_CHECKING
 
+import logging
 import euklid
-from openglider import logging
+
 from openglider.plots.config import PatternConfig
 from openglider.utils.config import Config
 from openglider.vector.drawing import PlotPart
diff --git a/openglider/plots/glider/ribs.py b/openglider/plots/glider/ribs.py
@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import logging
 import math
 from typing import TYPE_CHECKING, Literal
 from collections.abc import Callable
 
 import euklid
-from openglider import logging
+
 from openglider.airfoil import get_x_value
 from openglider.glider.cell.diagonals import DiagonalSide
 from openglider.glider.cell.panel import PANELCUT_TYPES
diff --git a/openglider/tests/__init__.py b/openglider/tests/__init__.py
@@ -0,0 +1,7 @@
+import os
+
+def get_demokite_path() -> str:
+    import os
+    filename = os.path.join(os.path.dirname(__file__), "common/demokite.ods")
+
+    return filename
diff --git a/openglider/utils/cache.py b/openglider/utils/cache.py
@@ -10,6 +10,7 @@
 from typing import TYPE_CHECKING
 
 import openglider
+from openglider.config import config
 
 
 logger = logging.getLogger(__name__)
@@ -105,7 +106,7 @@ def __repr__(self) -> str:
         return f"<CachedProperty {self.function.__qualname__}>"
 
     def __get__(self, parentclass: CLS, type: Any=None) -> Result:
-        if not openglider.config["caching"]:
+        if not config["caching"]:
             return self.function(parentclass)
         
         hash_value = hash_attributes(parentclass, self.hashlist)
diff --git a/openglider/utils/config.py b/openglider/utils/config.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import inspect
 import json
 import html
 from pathlib import Path
@@ -14,97 +13,7 @@
 
 logger = logging.getLogger(__name__)
 
-class Config:
-    def __init__(self, dct: dict[str, Any] | Config | None=None):
-        self.__dict__ = {}
-
-        items = inspect.getmembers(self.__class__, lambda a:not(inspect.isroutine(a)))
-        annotations = self.get_annotations()
-        for key, value in items:
-            if key in annotations and type(annotations[key]) == type:
-                try:
-                    value = annotations[key](value)
-                except Exception:
-                    pass
-            if not key.startswith('_') and key != "get":
-                self.__dict__[key] = value
-
-        self.update(dct)
-
-    
-    @classmethod
-    def get_annotations(cls) -> dict[str, Any]:
-        d: dict[str, Any] = {}
-        for c in cls.mro():
-            try:
-                d.update(**c.__annotations__)
-            except AttributeError:
-                # object, at least, has no __annotations__ attribute.
-                pass
-        return d
-
-    def __json__(self) -> dict[str, Any]:
-        return {
-            "dct": self.__dict__
-        }
-
-    def __repr__(self) -> str:
-        repr_str = f"{self.__class__}\n"
-        width = max([len(x) for x in self.__dict__])
-        for key, value in self.__dict__.items():
-            repr_str += "    -{0: <{width}} -> {value}\n".format(key, value=value, width=width)
-
-        return repr_str
-
-    def _repr_html_(self) -> str:
-        html_str = """<table>\n"""
-        for key, value in self.__dict__.items():
-            html_str += f"""    <tr>
-                <td>{key}</td>
-                <td>{html.escape(repr(value))}</td>
-                </tr>
-            """
-        
-        html_str += "</table>"
-
-        return html_str
-
-
-    def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for key, value in self.__dict__.items():
-            if key != "get":
-                yield key, value
-        for key, value in self.__class__.__dict__.items():
-            if not key.startswith("_"):
-                yield key, value
-
-    def __getitem__(self, item: str) -> Any:
-        return self.__getattribute__(item)
-
-    def get(self, key: str, default: Any=None) -> Any:
-        if hasattr(self, key):
-            return self.__getattribute__(key)
-        else:
-            return default
-
-    def update(self, dct: dict[str, Any] | Config | None) -> None:
-        if dct is None:
-            return
-
-        self.__dict__.update(dct)
-
-    def write(self, filename: str) -> None:
-        import openglider.jsonify
-        with open(filename, "w") as jsonfile:
-            openglider.jsonify.dump(self, jsonfile)
-
-    @classmethod
-    def read(cls, filename: str) -> Config:
-        with open(filename) as jsonfile:
-            data = json.load(jsonfile)
-
-        return cls(data["data"]["data"]["dct"])
-
+from openglider.utils.config_old import Config
 
 class ConfigNew(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
diff --git a/openglider/utils/config_old.py b/openglider/utils/config_old.py
diff --git a/openglider/utils/plugin.py b/openglider/utils/plugin.py
