pyroll-core 3.0.0.post3__tar.gz → 3.0.1__tar.gz

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

@@ -1,13 +1,12 @@
 Metadata-Version: 2.3
 Name: pyroll-core
-Version: 3.0.0.post3
+Version: 3.0.1
 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
+License: BSD-3-Clause
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Hatch
 Classifier: Framework :: IPython
@@ -25,10 +24,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.1}/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.1}/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.1}/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 *
@@ -10,9 +11,9 @@ from .rotator import Rotator
 from .sequence import PassSequence
 from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
-from .config import Config, config
+from .config import Config, config, PlottingBackend
 
-VERSION = "3.0.0post3"
+VERSION = "3.0.1"
 
 root_hooks.extend(
     [
@@ -31,6 +32,7 @@ root_hooks.extend(
         BaseRollPass.OutProfile.filling_error,
         BaseRollPass.OutProfile.cross_section_error,
         BaseRollPass.OutProfile.velocity,
+        BaseRollPass.InProfile.velocity,
         PassSequence.log_elongation,
         BaseRollPass.OutProfile.technologically_orientated_cross_section,
         BaseRollPass.technologically_orientated_contour_lines,

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/pyroll/core/config.py

@@ -1,19 +1,20 @@
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Optional, Iterable, Mapping, Any, Callable
 
 
 class ConfigValue:
     """Helper descriptor for storing configuration values, able to determine the value from explictly set values,
-     environment variables and default values."""
+    environment variables and default values."""
 
     def __init__(
-            self,
-            default,
-            *,
-            env_var: Optional[str] = None,
-            env_var_prefix: Optional[str] = None,
-            parser: Optional[Callable[[str], Any]] = None
+        self,
+        default,
+        *,
+        env_var: Optional[str] = None,
+        env_var_prefix: Optional[str] = None,
+        parser: Optional[Callable[[str], Any]] = None,
     ):
         self.default = default
         self.type = type(default)
@@ -26,7 +27,7 @@ class ConfigValue:
         self.owner = owner
         self.name = name
         if not self._env_var_prefix:
-            self._env_var_prefix = self.owner.__module__.upper().replace('.', '_')
+            self._env_var_prefix = self.owner.__module__.upper().replace(".", "_")
 
     @property
     def env_var(self):
@@ -83,11 +84,7 @@ class ConfigValue:
 class ConfigMeta(type):
     def to_dict(cls):
         """Return the config values of this class as dict."""
-        return {
-            n: v
-            for n, v in type(cls).__dict__.items()
-            if isinstance(v, ConfigValue)
-        }
+        return {n: v for n, v in type(cls).__dict__.items() if isinstance(v, ConfigValue)}
 
     def update(cls, d: dict[str, Any]):
         """
@@ -138,10 +135,7 @@ def config(env_var_prefix):
                 else:
                     # noinspection PyProtectedMember
                     meta_dict[n] = ConfigValue(
-                        default=v.default,
-                        env_var_prefix=env_var_prefix,
-                        env_var=v._env_var,
-                        parser=v.parser
+                        default=v.default, env_var_prefix=env_var_prefix, env_var=v._env_var, parser=v.parser
                     )
 
         meta = type(cls.__name__ + "Meta", (ConfigMeta,), meta_dict)
@@ -151,9 +145,15 @@ def config(env_var_prefix):
     return dec
 
 
+class PlottingBackend(Enum):
+    PLOTLY = 1
+    MATPLOTLIB = 2
+
+
 @config("PYROLL_CORE")
 class Config:
     """Configuration class for ``pyroll.core``."""
+
     ROLL_PASS_AUTO_ROTATION = True
     """Whether to enable automatic rotation of incoming profiles in roll passes by default."""
 
@@ -199,3 +199,6 @@ class Config:
 
     PLOT_RESOLUTION = 100
     """Resolution of plots in dots per inches (dpi)."""
+
+    PREFERRED_PLOTTING_BACKEND = PlottingBackend.PLOTLY
+    """Sets the preferred plotting backend to use when both matplotlib and plotly are installed."""

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/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.1}/pyroll/core/repr.py

@@ -1,8 +1,8 @@
 import html
 from abc import ABC, abstractmethod
 from io import StringIO
-from .config import Config
-from .log import global_logger
+
+from .config import Config, PlottingBackend
 
 
 class ReprMixin(ABC):
@@ -49,11 +49,18 @@ class ReprMixin(ABC):
 
         :returns: either a plotly or matplotlib figure object
         """
-
-        try:
-            return self.plot_plotly()
-        except (NotImplementedError, ImportError):
-            return self.plot_matplotlib()
+        if Config.PREFERRED_PLOTTING_BACKEND == PlottingBackend.PLOTLY:
+            try:
+                return self.plot_plotly()
+            except (NotImplementedError, ImportError):
+                return self.plot_matplotlib()
+        elif Config.PREFERRED_PLOTTING_BACKEND == PlottingBackend.MATPLOTLIB:
+            try:
+                return self.plot_matplotlib()
+            except (NotImplementedError, ImportError):
+                return self.plot_plotly()
+
+        raise ValueError("Invalid value given for 'Config.PREFERRED_PLOTTING_BACKEND'. Value must be a member of the pyroll.core.PlottingBackend enumeration.")
 
     def __str__(self):
         return type(self).__qualname__

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/pyroll/core/roll/hookimpls.py

@@ -25,18 +25,27 @@ def roll_power(self: Roll):
 
 
 @Roll.working_velocity
-def working_velocity(self: Roll):
-    return self.rotational_frequency * self.working_radius * 2 * np.pi
+def working_velocity(self: Roll, cycle):
+    if not cycle:
+        return self.rotational_frequency * self.working_radius * 2 * np.pi
 
 
 @Roll.surface_velocity
-def surface_velocity(self: Roll):
-    return self.rotational_frequency * self.nominal_radius * 2 * np.pi
+def surface_velocity(self: Roll, cycle):
+    if not cycle:
+        return self.rotational_frequency * self.nominal_radius * 2 * np.pi
 
 
 @Roll.rotational_frequency
-def rotational_frequency(self: Roll):
-    return self.surface_velocity / (2 * np.pi * self.nominal_radius)
+def rotational_frequency(self: Roll, cycle):
+    if not cycle:
+        return self.surface_velocity / (2 * np.pi * self.nominal_radius)
+
+
+@Roll.rotational_frequency
+def rotational_frequency(self: Roll, cycle):
+    if not cycle:
+        return self.working_velocity / (2 * np.pi * self.working_radius)
 
 
 @Roll.width

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/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.1}/pyroll/core/roll_pass/hookimpls/profile.py

@@ -88,6 +88,11 @@ def classifiers(self: BaseRollPass.OutProfile):
     return set(self.roll_pass.classifiers)
 
 
+@BaseRollPass.InProfile.velocity
+def in_velocity(self: BaseRollPass.InProfile):
+    return self.roll_pass.out_profile.velocity * self.unit.out_profile.cross_section.area / self.cross_section.area
+
+
 @BaseRollPass.OutProfile.velocity
-def velocity(self: BaseRollPass.OutProfile):
+def out_velocity(self: BaseRollPass.OutProfile):
     return self.roll_pass.velocity

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/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.1}/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.1}/pyroll/core/shapes.py

@@ -91,23 +91,21 @@ def multi_polygon_plot_matplotlib(self: MultiPolygon):
     ax.set_aspect("equal", "datalim")
     ax.grid(lw=0.5)
 
-    for g, c in zip(self.geoms, plt.color_sequences["default"]):
-        ax.plot(*g.boundary.xy, color=c)
-        ax.fill(*g.boundary.xy, alpha=0.5, color=c)
+    for g in self.geoms:
+        l = ax.plot(*g.boundary.xy)
+        ax.fill(*g.boundary.xy, alpha=0.5, color=l[0].get_color())
     return fig
 
 
 def multi_polygon_plot_plotly(self: MultiPolygon):
     import plotly.graph_objects as pgo
-    from pandas import DataFrame
 
     fig = pgo.Figure()
 
     for g in self.geoms:
-        fig.add_trace(pgo.line(
-            x=[g.boundary.xy[0] for g in self.geoms],
-            y=[g.boundary.xy[1] for g in self.geoms],
-            labels={"y": "y", "x": "z"},
+        fig.add_trace(pgo.Line(
+            x=np.array(g.boundary.xy[0]),
+            y=np.array(g.boundary.xy[1]),
         ))
 
     fig.update_traces(
@@ -116,9 +114,12 @@ def multi_polygon_plot_plotly(self: MultiPolygon):
 
     fig.update_yaxes(
         scaleanchor="x",
-        scaleratio=1
+        scaleratio=1,
+        title="y"
     )
 
+    fig.update_xaxes(title="z")
+
     return fig
 
 
@@ -134,7 +135,7 @@ def line_string_plot_matplotlib(self: LineString):
     ax.set_aspect("equal", "datalim")
     ax.grid(lw=0.5)
 
-    ax.plot(*self.xy, color="k")
+    ax.plot(*self.xy)
     return fig
 
 
@@ -147,8 +148,6 @@ def line_string_plot_plotly(self: LineString):
         labels={"y": "y", "x": "z"},
     )
 
-    fig.update_traces(line_color="black")
-
     fig.update_yaxes(
         scaleanchor="x",
         scaleratio=1
@@ -157,6 +156,45 @@ def line_string_plot_plotly(self: LineString):
     return fig
 
 
+def multi_line_string_plot_matplotlib(self: MultiLineString):
+    import matplotlib.pyplot as plt
+
+    fig: plt.Figure = plt.figure()
+    ax: plt.Axes = fig.subplots()
+
+    ax.set_ylabel("y")
+    ax.set_xlabel("z")
+
+    ax.set_aspect("equal", "datalim")
+    ax.grid(lw=0.5)
+
+    for g in self.geoms:
+        ax.plot(*g.xy)
+    return fig
+
+
+def multi_line_string_plot_plotly(self: MultiLineString):
+    import plotly.graph_objects as pgo
+
+    fig = pgo.Figure()
+
+    for g in self.geoms:
+        fig.add_trace(pgo.Line(
+            x=np.array(g.xy[0]),
+            y=np.array(g.xy[1]),
+        ))
+
+    fig.update_yaxes(
+        scaleanchor="x",
+        scaleratio=1,
+        title="y"
+    )
+
+    fig.update_xaxes(title="z")
+
+    return fig
+
+
 for cls in [
     LineString,
     MultiLineString,
@@ -203,6 +241,11 @@ LineString._plot_matplotlib_ = line_string_plot_matplotlib
 # noinspection PyProtectedMember
 LineString._plot_plotly_ = line_string_plot_plotly
 
+# noinspection PyProtectedMember
+MultiLineString._plot_matplotlib_ = multi_line_string_plot_matplotlib
+# noinspection PyProtectedMember
+MultiLineString._plot_plotly_ = multi_line_string_plot_plotly
+
 _RECTANGLE_CORNERS = np.asarray(
     [
         (-0.5, -0.5),

{pyroll_core-3.0.0.post3 → pyroll_core-3.0.1}/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)