pyextrusion 0.17.0__py3-none-any.whl

pyextrusion/__init__.py

@@ -0,0 +1,124 @@
+"""PyExtrusion - engineering calculation toolkit for aluminium extrusion."""
+from ._meta import __author__, __description__, __license__, __title__, __url__, __version__
+from .api import calculate_case, calculate_process, calculate_simple, compare_presses
+from .comparison import (
+    ProcessComparisonResult, PlanningComparisonResult, ProductionSequenceComparisonResult,
+    compare_processes, compare_planning, compare_production_sequences,
+)
+from .demand import (
+    AnnualDemandSpec, NormalizedAnnualDemand, AnnualCalculationResult,
+    normalize_annual_demand, calculate_annual_demand,
+)
+from .planning import (
+    PlanningMode, PlanningRequest, PlanningResult,
+    validate_planning_request, calculate_planning,
+)
+from .sequence import (
+    ProductionOrder, ProductionSequenceEntry, ProductionSequenceResult,
+    calculate_production_sequence,
+)
+from .core import calculate, section_from_linear_weight, extrusion_ratio, extrusion_ratio_status, ram_speed
+from .io import (
+    case_from_dict,
+    case_to_dict,
+    load_case_json,
+    load_press_json,
+    load_study_json,
+    press_from_dict,
+    press_to_dict,
+    process_from_dict,
+    planning_case_from_dict,
+    planning_case_to_dict,
+    load_planning_case_json,
+    save_planning_case_json,
+    save_case_json,
+    save_press_json,
+    save_study_json,
+    study_from_dict,
+    study_to_dict,
+    annual_demand_from_dict, annual_demand_to_dict,
+    load_annual_demand_json, save_annual_demand_json,
+    production_order_from_dict, production_order_to_dict,
+    production_sequence_from_dict, production_sequence_to_dict,
+    load_production_sequence_json, save_production_sequence_json,
+)
+from .models import (
+    PressSpec, ProfileSpec, ProcessSpec, PlanningCase, ProductionSpec, StudyCase, StudyInput,
+    CalculationResult, ProcessResult, ComparisonResult, ConfigurationResult,
+    StatusResult, GeometryResult, BilletResult, ProductionResult, ScrapResult,
+    ProductivityResult, TimingResult, ProcessTraceResult,
+    SawSpec, ButtRule, ProfileType, CanonicalProfileType, PROFILE_TYPE_ALIASES,
+    PROFILE_TYPE_VALID_VALUES, normalize_profile_type,
+)
+from .reporting import (
+    format_annual_result, format_comparison, format_press, format_result,
+    format_planning_result, format_production_sequence,
+    format_process_comparison, format_planning_comparison,
+    format_production_sequence_comparison,
+)
+from .fields import FieldInfo, FIELD_GLOSSARY, RESULT_SECTIONS, describe_field, list_fields
+from .errors import (
+    ErrorInfo, ERROR_CATALOG, PyExtrusionError, InvalidPressConfigurationError,
+    InvalidProfileInputError, InvalidProductionInputError, UnknownResultFieldError,
+    UnsupportedSchemaVersionError, InvalidAnnualDemandError, InputFileError,
+    UnknownResultSectionError, InvalidResultSelectionError, InvalidStudyAdjustmentError,
+    InvalidPlanningRequestError, InvalidProductionSequenceError, InvalidComparisonError,
+    get_error_info, list_error_info,
+)
+from .validation import (
+    ValidationMessage,
+    validate_case,
+    validate_case_json,
+    validate_planning_case,
+    validate_planning_case_json,
+    validate_press,
+    validate_press_json,
+    validate_study,
+    validate_study_json,
+    validate_annual_demand, validate_annual_demand_json,
+    validate_production_sequence_json,
+)
+
+Press = PressSpec
+Profile = ProfileSpec
+Process = ProcessSpec
+Production = ProductionSpec
+
+__all__ = [
+    "calculate", "calculate_case", "calculate_process", "calculate_simple", "compare_presses",
+    "compare_processes", "compare_planning", "compare_production_sequences",
+    "normalize_annual_demand", "calculate_annual_demand", "calculate_planning",
+    "validate_planning_request", "calculate_production_sequence",
+    "section_from_linear_weight", "extrusion_ratio", "extrusion_ratio_status", "ram_speed",
+    "Press", "Profile", "Process", "Production", "PressSpec", "ProfileSpec", "ProcessSpec", "PlanningCase", "ProductionSpec",
+    "StudyCase", "StudyInput", "CalculationResult", "ProcessResult", "ComparisonResult", "ConfigurationResult",
+    "StatusResult", "GeometryResult", "BilletResult", "ProductionResult", "ScrapResult",
+    "ProductivityResult", "TimingResult", "ProcessTraceResult",
+    "SawSpec", "ButtRule", "ProfileType", "CanonicalProfileType", "PROFILE_TYPE_ALIASES",
+    "PROFILE_TYPE_VALID_VALUES", "normalize_profile_type",
+    "AnnualDemandSpec", "NormalizedAnnualDemand", "AnnualCalculationResult",
+    "PlanningMode", "PlanningRequest", "PlanningResult",
+    "ProductionOrder", "ProductionSequenceEntry", "ProductionSequenceResult",
+    "ProcessComparisonResult", "PlanningComparisonResult", "ProductionSequenceComparisonResult",
+    "load_press_json", "load_case_json", "load_planning_case_json", "load_study_json",
+    "save_press_json", "save_case_json", "save_planning_case_json", "save_study_json",
+    "load_annual_demand_json", "save_annual_demand_json",
+    "load_production_sequence_json", "save_production_sequence_json",
+    "press_from_dict", "process_from_dict", "planning_case_from_dict", "case_from_dict", "study_from_dict", "annual_demand_from_dict",
+    "production_order_from_dict", "production_sequence_from_dict",
+    "press_to_dict", "planning_case_to_dict", "case_to_dict", "study_to_dict", "annual_demand_to_dict",
+    "production_order_to_dict", "production_sequence_to_dict",
+    "format_press", "format_result", "format_comparison", "format_annual_result", "format_planning_result", "format_production_sequence",
+    "format_process_comparison", "format_planning_comparison", "format_production_sequence_comparison",
+    "FieldInfo", "FIELD_GLOSSARY", "RESULT_SECTIONS", "describe_field", "list_fields",
+    "ErrorInfo", "ERROR_CATALOG", "PyExtrusionError", "InvalidPressConfigurationError",
+    "InvalidProfileInputError", "InvalidProductionInputError", "UnknownResultFieldError",
+    "UnsupportedSchemaVersionError", "InvalidAnnualDemandError", "InputFileError",
+    "UnknownResultSectionError", "InvalidResultSelectionError", "InvalidStudyAdjustmentError",
+    "InvalidPlanningRequestError", "InvalidProductionSequenceError", "InvalidComparisonError",
+    "get_error_info", "list_error_info",
+    "ValidationMessage", "validate_press", "validate_case", "validate_planning_case", "validate_study",
+    "validate_press_json", "validate_case_json", "validate_planning_case_json", "validate_study_json",
+    "validate_annual_demand", "validate_annual_demand_json", "validate_production_sequence_json",
+    "__title__", "__version__", "__description__", "__author__", "__license__", "__url__",
+]

pyextrusion/_meta.py

@@ -0,0 +1,8 @@
+"""Public project metadata for PyExtrusion."""
+
+__title__ = "PyExtrusion"
+__version__ = "0.17.0"
+__description__ = "Engineering calculation toolkit for aluminium extrusion"
+__author__ = "Enrique Calvo Ordonez"
+__license__ = "Apache-2.0"
+__url__ = "https://pyextrusion.com"

pyextrusion/_strict.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import math
+from typing import Any, TypeVar
+
+E = TypeVar("E", bound=Exception)
+
+
+def _raise(exc_type: type[E], message: str) -> None:
+    raise exc_type(message)
+
+
+def require_number(
+    value: Any,
+    field: str,
+    exc_type: type[E],
+    *,
+    minimum: float | None = None,
+    maximum: float | None = None,
+    exclusive_minimum: bool = False,
+    allow_none: bool = False,
+) -> float | None:
+    if value is None:
+        if allow_none:
+            return None
+        _raise(exc_type, f"{field} is required")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        _raise(exc_type, f"{field} must be a number, not {type(value).__name__}")
+    result = float(value)
+    if not math.isfinite(result):
+        _raise(exc_type, f"{field} must be a finite number")
+    if minimum is not None:
+        if exclusive_minimum:
+            if not result > minimum:
+                _raise(exc_type, f"{field} must be > {minimum:g}")
+        elif result < minimum:
+            _raise(exc_type, f"{field} must be >= {minimum:g}")
+    if maximum is not None and result > maximum:
+        _raise(exc_type, f"{field} must be <= {maximum:g}")
+    return result
+
+
+def require_int(
+    value: Any,
+    field: str,
+    exc_type: type[E],
+    *,
+    minimum: int | None = None,
+    maximum: int | None = None,
+    allow_none: bool = False,
+) -> int | None:
+    if value is None:
+        if allow_none:
+            return None
+        _raise(exc_type, f"{field} is required")
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(exc_type, f"{field} must be an integer")
+    if minimum is not None and value < minimum:
+        _raise(exc_type, f"{field} must be >= {minimum}")
+    if maximum is not None and value > maximum:
+        _raise(exc_type, f"{field} must be <= {maximum}")
+    return value
+
+
+def require_bool(value: Any, field: str, exc_type: type[E]) -> bool:
+    if not isinstance(value, bool):
+        _raise(exc_type, f"{field} must be true or false")
+    return value
+
+
+def require_string(value: Any, field: str, exc_type: type[E], *, nonempty: bool = True) -> str:
+    if not isinstance(value, str):
+        _raise(exc_type, f"{field} must be a string")
+    if nonempty and not value.strip():
+        _raise(exc_type, f"{field} must not be empty")
+    return value
+
+
+def require_kerf(value: Any, field: str, exc_type: type[E]) -> float:
+    result = require_number(value, field, exc_type, minimum=0.0)
+    assert result is not None
+    if result == 0.0:
+        return 0.0
+    if result < 3.0 or result > 10.0:
+        _raise(exc_type, f"{field} must be 0 mm or between 3 and 10 mm")
+    return result
+
+
+def finite_product(a: float, b: float, field: str, exc_type: type[E]) -> float:
+    value = a * b
+    if not math.isfinite(value):
+        _raise(exc_type, f"{field} is outside the supported finite numeric range")
+    return value

pyextrusion/api.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from .core import calculate, calculate_process as _calculate_process
+from .models import (
+    CalculationResult,
+    ComparisonResult,
+    Complexity,
+    PressSpec,
+    PlanningCase,
+    ProcessResult,
+    ProductionSpec,
+    ProfileSpec,
+    ProfileType,
+    StudyCase,
+    StudyInput,
+)
+
+
+def calculate_case(press: PressSpec, case: StudyCase) -> CalculationResult:
+    """Run a reusable StudyCase on one press."""
+    return calculate(case.to_study_input(press))
+
+
+def calculate_process(press: PressSpec, case: PlanningCase) -> ProcessResult:
+    """Evaluate Press + Profile + ProcessSpec without any production quantity."""
+    return _calculate_process(case.to_process_input(press))
+
+
+def compare_presses(presses: Iterable[PressSpec], case: StudyCase) -> ComparisonResult:
+    """Evaluate one case on several presses. Results include the orientative v2.4 productivity index; no final industrial decision is made automatically."""
+    press_tuple = tuple(presses)
+    if not press_tuple:
+        raise ValueError("compare_presses requires at least one press")
+    return ComparisonResult(tuple(calculate_case(press, case) for press in press_tuple))
+
+
+def calculate_simple(
+    press: PressSpec,
+    *,
+    linear_weight_kg_m: float,
+    exits: int,
+    exit_speed_m_min: float | None = None,
+    cut_length_mm: float,
+    bars_requested: int,
+    profile_type: ProfileType | None = None,
+    front_scrap_m: float = 0.0,
+    complexity: Complexity = "normal",
+    section_per_exit_m2: float | None = None,
+    cuts: int | None = None,
+    butt_mm: float | None = None,
+    multi_billet_front_scrap_m: float | None = None,
+    supplement_10_pct: bool = False,
+    ram_speed_mm_s: float | None = None,
+) -> CalculationResult:
+    """Low-friction API backed by the same deterministic engine as StudyInput."""
+    case = StudyCase(
+        profile=ProfileSpec(
+            linear_weight_kg_m=linear_weight_kg_m,
+            exits=exits,
+            profile_type=profile_type,
+            section_per_exit_m2=section_per_exit_m2,
+        ),
+        production=ProductionSpec(
+            exit_speed_m_min=exit_speed_m_min,
+            cut_length_mm=cut_length_mm,
+            bars_requested=bars_requested,
+            front_scrap_m=front_scrap_m,
+            complexity=complexity,
+            cuts=cuts,
+            butt_mm=butt_mm,
+            multi_billet_front_scrap_m=multi_billet_front_scrap_m,
+            supplement_10_pct=supplement_10_pct,
+            ram_speed_mm_s=ram_speed_mm_s,
+        ),
+    )
+    return calculate_case(press, case)