pyroll-core 3.0.0.post3__tar.gz → 3.0.0.post4__tar.gz

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.3
 Name: pyroll-core
-Version: 3.0.0.post3
+Version: 3.0.0.post4
 Summary: PyRoll rolling simulation framework - core library.
 Project-URL: Homepage, https://pyroll-project.github.io
 Project-URL: Repository, https://github.com/pyroll-project/pyroll-core
 Project-URL: Documentation, https://pyroll.readthedocs.io/en/latest
 Author-email: Max Weiner <max.weiner@imf.tu-freiberg.de>, Christoph Renzing <christoph.renzing@imf.tu-freiberg.de>, Matthias Schmidtchen <matthias.schmidtchen@imf.tu-freiberg.de>, Max Stirl <max.stirl@imf.tu-freiberg.de>
-License-Expression: BSD-3-Clause
-License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Hatch
 Classifier: Framework :: IPython
@@ -25,10 +23,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
-Requires-Dist: ezdxf
-Requires-Dist: numpy~=1.19
-Requires-Dist: scipy~=1.9
-Requires-Dist: shapely~=2.0
+Requires-Dist: numpy~=2.0
+Requires-Dist: scipy~=1.13
+Requires-Dist: shapely<3.0,>=2.0.6
+Provides-Extra: dxf
+Requires-Dist: ezdxf-shapely~=1.0; extra == 'dxf'
 Provides-Extra: matplotlib
 Requires-Dist: matplotlib~=3.7; extra == 'matplotlib'
 Provides-Extra: plot

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/hatch.toml

@@ -11,16 +11,16 @@ path = ".venv"
 dependencies = [
     "ipython ~= 8.0",
     "pytest ~= 7.0",
-    "pyroll-report ~= 2.0",
+    "pyroll-report ~= 3.0",
     "jupyter",
 ]
-features = ["plotly", "matplotlib"]
+features = ["plotly", "matplotlib", "dxf"]
 
 [envs.test]
 path = ""
 dependencies = [
     "pytest ~= 7.0",
-    "pyroll-report ~= 2.0",
+    "pyroll-report ~= 3.0",
 ]
 
 [[envs.test.matrix]]

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyproject.toml

@@ -34,10 +34,9 @@ classifiers = [
 requires-python = ">=3.9"
 
 dependencies = [
-    "numpy ~= 1.19",
-    "scipy ~= 1.9",
-    "shapely ~= 2.0",
-    "ezdxf"
+    "numpy ~= 2.0",
+    "scipy ~= 1.13",
+    "shapely >= 2.0.6, <3.0",
 ]
 
 dynamic = ["version"]
@@ -53,6 +52,9 @@ plotly = [
     "plotly ~= 5.18",
     "pandas ~= 2.0",
 ]
+dxf = [
+    "ezdxf-shapely ~= 1.0",
+]
 
 [project.urls]
 Homepage = "https://pyroll-project.github.io"

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/__init__.py

@@ -2,7 +2,8 @@ from . import shapes as _
 
 from .grooves import *
 from .transport import Transport, CoolingPipe
-from .roll_pass import BaseRollPass, RollPass, DeformationUnit, ThreeRollPass, SymmetricRollPass
+from .roll_pass import BaseRollPass, DeformationUnit, ThreeRollPass, SymmetricRollPass, TwoRollPass
+from .roll_pass import TwoRollPass as RollPass
 from .unit import Unit
 from .roll import Roll
 from .profile import *
@@ -12,7 +13,7 @@ from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
 from .config import Config, config
 
-VERSION = "3.0.0post3"
+VERSION = "3.0.0post4"
 
 root_hooks.extend(
     [

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/grooves/spline.py

@@ -1,7 +1,6 @@
 import numpy as np
 import scipy.interpolate
 from pathlib import Path
-from ezdxf import readfile
 from shapely.geometry import Polygon, LineString
 from typing import Union, Tuple, Iterable, Optional
 
@@ -12,10 +11,10 @@ class SplineGroove(GrooveBase):
     """Represents a groove defined by a linear spline contour."""
 
     def __init__(
-            self,
-            contour_points: Union[Iterable[Tuple[float, float]], np.ndarray],
-            classifiers: Iterable[str],
-            usable_width: Optional[float] = None,
+        self,
+        contour_points: Union[Iterable[Tuple[float, float]], np.ndarray],
+        classifiers: Iterable[str],
+        usable_width: Optional[float] = None,
     ):
         """
         :param contour_points: an iterable of contour points to be used for the spline
@@ -34,9 +33,11 @@ class SplineGroove(GrooveBase):
             raise ValueError("first and last element of contour_points should have y coordinate equal to 0")
 
         # strip boundary
-        contour_points = contour_points[np.logical_not(
-            (np.isclose(np.roll(contour_points[:, 1], 1), 0)) & (np.isclose(np.roll(contour_points[:, 1], -1), 0))
-        )]
+        contour_points = contour_points[
+            np.logical_not(
+                (np.isclose(np.roll(contour_points[:, 1], 1), 0)) & (np.isclose(np.roll(contour_points[:, 1], -1), 0))
+            )
+        ]
 
         # shift center to 0,0
         contour_points[:, 0] -= np.mean(contour_points[:, 0])
@@ -56,8 +57,7 @@ class SplineGroove(GrooveBase):
         self._depth = np.max(contour_points[:, 1])
 
         self._local_depth = scipy.interpolate.interp1d(
-            contour_points[:, 0], contour_points[:, 1],
-            fill_value="extrapolate"
+            contour_points[:, 0], contour_points[:, 1], fill_value="extrapolate"
         )
         self._classifiers = tuple(classifiers)
 
@@ -93,46 +93,36 @@ class SplineGroove(GrooveBase):
         return self._local_depth(z)
 
     @classmethod
-    def from_dxf_drawing(cls, filepath: Path, classifiers: Iterable[str], usable_width: Optional[float] = None,
-                         arc_discretization: int = 1000) -> 'SplineGroove':
+    def from_dxf_drawing(
+        cls,
+        filepath: Path,
+        classifiers: Iterable[str],
+        usable_width: Optional[float] = None,
+        arc_degrees_per_segment: float = 0.5,
+        spline_delta: float = 0.1,
+        dxf_query: str = '* [layer=="0"]',
+    ) -> "SplineGroove":
         """
         Creates a spline groove with a given contour line as defined inside the .dxf drawing.
 
         :param filepath: the filepath to the drawing
         :param classifiers: an iterable of string keys used as type classifiers
         :param usable_width: the usable width to assume for this instance, if None, the maximum width will be used
-        :param arc_discretization: discretization of arcs of the dxf drawing, default is 1000.
+        :param arc_degrees_per_segment: discretization width in degrees for arcs and circles
+        :param dxf_query: query to filter the wanted geometries out of the dxf, see the ezdxf docs for details
         """
 
-        doc = readfile(filepath)
-        msp = doc.modelspace()
+        try:
+            from ezdxf import readfile
+            from ezdxf_shapely import convert_all, line_merge
+        except ImportError as e:
+            raise RuntimeError("ezdxf-shapely is required for DXF import, you may install it with the dxf extra") from e
+        from shapely.affinity import translate
 
-        points = []
-        for entity in msp:
-            if entity.dxftype() == 'LINE':
-                points.append((entity.dxf.start[0], entity.dxf.start[1]))
-                points.append((entity.dxf.end[0], entity.dxf.end[1]))
+        dxf_doc = readfile(filepath)
+        msp = dxf_doc.modelspace().query(dxf_query)
+        geoms = convert_all(msp, spline_delta=spline_delta, degrees_per_segment=arc_degrees_per_segment)
+        geom = line_merge(geoms)
+        geom = translate(geom, -geom.centroid.x, -geom.bounds[1])
 
-            elif entity.dxftype() == 'ARC':
-                center = (entity.dxf.center[0], entity.dxf.center[1])
-                radius = entity.dxf.radius
-                start_angle = np.radians(entity.dxf.start_angle)
-                end_angle = np.radians(entity.dxf.end_angle)
-
-                arc_points = [
-                    (
-                        center[0] + radius * np.cos(start_angle + (end_angle - start_angle) * i / arc_discretization),
-                        center[1] + radius * np.sin(start_angle + (end_angle - start_angle) * i / arc_discretization),
-                    )
-                    for i in range(arc_discretization + 1)
-                ]
-                points.extend(arc_points)
-
-        points.sort(key=lambda p: p[0])
-
-        distance_to_y_0 = -points[0][1]
-
-        shifted_points = [(x, y + distance_to_y_0) for x, y in points]
-        shifted_points.sort(key=lambda p: p[0])
-
-        return SplineGroove(contour_points=shifted_points, classifiers=classifiers, usable_width=usable_width)
+        return SplineGroove(contour_points=geom.coords, classifiers=classifiers, usable_width=usable_width)

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/roll_pass/__init__.py

@@ -5,8 +5,3 @@ from .deformation_unit import DeformationUnit
 from .symmetric_roll_pass import SymmetricRollPass
 
 from . import hookimpls
-
-RollPass = TwoRollPass
-
-
-

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/rotator/hookimpls.py

@@ -52,6 +52,13 @@ def box_diamond_45(self: Rotator):
         return 45
 
 
+@Rotator.rotation
+def flat_flat_0(self: Rotator):
+    if "3fold" not in self.next_roll_pass.classifiers:
+        if "flat" in self.in_profile.classifiers and "flat" in self.next_roll_pass.classifiers:
+            return 0
+
+
 @Rotator.rotation
 def box_flat_0(self: Rotator):
     if "box" in self.in_profile.classifiers and "flat" in self.next_roll_pass.classifiers:

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/sequence/sequence.py

@@ -4,7 +4,7 @@ from collections.abc import Sequence
 from typing import overload, List, cast
 
 from ..unit import Unit
-from ..roll_pass import RollPass
+from ..roll_pass import BaseRollPass
 from ..transport import Transport
 from ..hooks import Hook
 
@@ -104,9 +104,9 @@ class PassSequence(Unit, Sequence[Unit]):
         return list(self._subunits)
 
     @property
-    def roll_passes(self) -> List[RollPass]:
+    def roll_passes(self) -> List[BaseRollPass]:
         """Returns a list of all roll passes in this sequence."""
-        return list(u for u in self._subunits if isinstance(u, RollPass))
+        return list(u for u in self._subunits if isinstance(u, BaseRollPass))
 
     @property
     def transports(self) -> List[Transport]:
@@ -135,7 +135,7 @@ class PassSequence(Unit, Sequence[Unit]):
             for i in range(len(cross_sections_areas) - 2, -1, -1):
                 velocities[i] = velocities[i + 1] * cross_sections_areas[i + 1] / cross_sections_areas[i]
 
-        def set_velocities_to_roll_passes(roll_passes: List[RollPass], velocities: np.ndarray[float]):
+        def set_velocities_to_roll_passes(roll_passes: List[BaseRollPass], velocities: np.ndarray[float]):
             for roll_pass, velocity in zip(roll_passes, velocities):
                 roll_pass.velocity = velocity
 
@@ -179,7 +179,7 @@ class PassSequence(Unit, Sequence[Unit]):
             for i in range(1, len(usable_cross_section_areas)):
                 velocities[i] = velocities[i - 1] * cross_sections_areas[i - 1] / cross_sections_areas[i]
 
-        def set_velocities_to_roll_passes(roll_passes: List[RollPass], velocities: np.ndarray[float]):
+        def set_velocities_to_roll_passes(roll_passes: List[BaseRollPass], velocities: np.ndarray[float]):
             for roll_pass, velocity in zip(roll_passes, velocities):
                 roll_pass.velocity = velocity
 

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.0.post4}/pyroll/core/transport/hookimpls/transport.py

@@ -31,7 +31,7 @@ def length_from_roll_pass_positions(self: Transport, cycle):
     if cycle:
         return None
 
-    from ...roll_pass import RollPass
+    from pyroll.core import RollPass
     next_pass = self.next_of(RollPass)
     prev_pass = self.prev_of(RollPass)