weac 3.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

weac/utils/misc.py

@@ -0,0 +1,127 @@
+"""
+This module contains miscellaneous utility functions.
+"""
+
+from typing import Literal
+
+import numpy as np
+
+from weac.components import Layer
+from weac.constants import G_MM_S2, LSKI_MM
+
+
+def decompose_to_normal_tangential(f: float, phi: float) -> tuple[float, float]:
+    """
+    Resolve a gravity-type force/line-load into its tangential (downslope) and
+    normal (into-slope) components with respect to an inclined surface.
+
+    Parameters
+    ----------
+    f : float
+        is interpreted as a vertical load magnitude
+        acting straight downward (global y negative).
+    phi : float
+        Surface dip angle `in degrees`, measured from horizontal.
+        Positive `phi` means the surface slopes upward in +x.
+
+    Returns
+    -------
+    f_norm, f_tan : float
+        Magnitudes of the tangential ( + downslope ) and normal
+        ( + into-slope ) components, respectively.
+    """
+    # Convert units
+    phi = np.deg2rad(phi)  # Convert inclination to rad
+    # Split into components
+    f_norm = f * np.cos(phi)  # Normal direction
+    f_tan = -f * np.sin(phi)  # Tangential direction
+    return f_norm, f_tan
+
+
+def get_skier_point_load(m: float) -> float:
+    """
+    Calculate skier point load.
+
+    Arguments
+    ---------
+    m : float
+        Skier weight [kg].
+
+    Returns
+    -------
+    f : float
+        Skier load [N/mm].
+    """
+    F = 1e-3 * m * G_MM_S2 / LSKI_MM  # Total skier
+    return F
+
+
+def load_dummy_profile(
+    profile_id: Literal[
+        "a", "b", "c", "d", "e", "f", "h", "soft", "medium", "hard", "comp"
+    ],
+) -> list[Layer]:
+    """Define standard layering types for comparison."""
+    soft_layer = Layer(rho=180, h=120, E=5)
+    medium_layer = Layer(rho=270, h=120, E=30)
+    hard_layer = Layer(rho=350, h=120, E=93.8)
+
+    tested_layers = [
+        Layer(rho=350, h=120),
+        Layer(rho=270, h=120),
+        Layer(rho=180, h=120),
+    ]
+
+    # Database (top to bottom)
+    database = {
+        # Layered
+        "a": [hard_layer, medium_layer, soft_layer],
+        "b": [soft_layer, medium_layer, hard_layer],
+        "c": [hard_layer, soft_layer, hard_layer],
+        "d": [soft_layer, hard_layer, soft_layer],
+        "e": [hard_layer, soft_layer, soft_layer],
+        "f": [soft_layer, soft_layer, hard_layer],
+        "tested": tested_layers,
+        # Homogeneous
+        "h": [medium_layer, medium_layer, medium_layer],
+        "soft": [soft_layer, soft_layer, soft_layer],
+        "medium": [medium_layer, medium_layer, medium_layer],
+        "hard": [hard_layer, hard_layer, hard_layer],
+        # Comparison
+        "comp": [
+            Layer(rho=240, h=200, E=5.23),
+        ],
+    }
+
+    # Load profile
+    try:
+        profile = database[profile_id.lower()]
+    except KeyError:
+        raise ValueError(f"Profile {profile_id} is not defined.") from None
+    return profile
+
+
+def isnotebook() -> bool:
+    """
+    Check if code is running in a Jupyter notebook environment.
+
+    Returns
+    -------
+    bool
+        True if running in Jupyter notebook, False otherwise.
+    """
+    try:
+        # Check if we're in IPython
+        from IPython import get_ipython  # pylint: disable=import-outside-toplevel
+
+        if get_ipython() is None:
+            return False
+
+        # Check if we're specifically in a notebook (not just IPython terminal)
+        if get_ipython().__class__.__name__ == "ZMQInteractiveShell":
+            return True  # Jupyter notebook
+        if get_ipython().__class__.__name__ == "TerminalInteractiveShell":
+            return False  # IPython terminal
+        return False  # Other IPython environments
+    except ImportError:
+        return False  # IPython not available

weac/utils/snow_types.py

@@ -0,0 +1,82 @@
+"""
+Snow grain types and hand hardness values.
+
+These values are used in Pydantic models for validation and correspond to the
+parameterizations available in `geldsetzer.py`.
+"""
+
+from enum import Enum
+
+
+class GrainType(str, Enum):
+    """SnowPilot grain type codes (see `geldsetzer.GRAIN_TYPE`)."""
+
+    DF = "DF"
+    DFbk = "DFbk"
+    DFdc = "DFdc"
+    DH = "DH"
+    DHch = "DHch"
+    DHcp = "DHcp"
+    DHla = "DHla"
+    DHpr = "DHpr"
+    DHxr = "DHxr"
+    FC = "FC"
+    FCsf = "FCsf"
+    FCso = "FCso"
+    FCxr = "FCxr"
+    IF = "IF"
+    IFbi = "IFbi"
+    IFic = "IFic"
+    IFil = "IFil"
+    IFrc = "IFrc"
+    IFsc = "IFsc"
+    MF = "MF"
+    MFcl = "MFcl"
+    MFcr = "MFcr"
+    MFpc = "MFpc"
+    MFsl = "MFsl"
+    PP = "PP"
+    PPco = "PPco"
+    PPgp = "PPgp"
+    PPhl = "PPhl"
+    PPip = "PPip"
+    PPir = "PPir"
+    PPnd = "PPnd"
+    PPpl = "PPpl"
+    PPrm = "PPrm"
+    PPsd = "PPsd"
+    RG = "RG"
+    RGlr = "RGlr"
+    RGsr = "RGsr"
+    RGwp = "RGwp"
+    RGxf = "RGxf"
+    SH = "SH"
+    SHcv = "SHcv"
+    SHsu = "SHsu"
+    SHxr = "SHxr"
+
+
+class HandHardness(str, Enum):
+    """Field hand hardness codes (see `geldsetzer.HAND_HARDNESS`).
+
+    Enum member names avoid starting with digits and special characters.
+    """
+
+    Fm = "F-"
+    F = "F"
+    Fp = "F+"
+    _4Fm = "4F-"
+    _4F = "4F"
+    _4Fp = "4F+"
+    _1Fm = "1F-"
+    _1F = "1F"
+    _1Fp = "1F+"
+    Pm = "P-"
+    P = "P"
+    Pp = "P+"
+    Km = "K-"
+    K = "K"
+    Kp = "K+"
+    Im = "I-"
+    I = "I"
+    Ip = "I+"

weac/utils/snowpilot_parser.py

@@ -0,0 +1,332 @@
+"""
+Utilizes the snowpylot library to convert a CAAML file to a WEAC ModelInput.
+
+The snowpylot library is used to parse the CAAML file and extract the snowpit.
+The snowpit is then converted to a List of WEAC ModelInput.
+
+Based on the different stability tests performed, several scenarios are created.
+Each scenario is a WEAC ModelInput.
+
+The scenarios are created based on the following logic:
+- For each PropSawTest, a scenario is created with `the cut length` and `a standard segment.`
+- For each ExtColumnTest, a scenario is created with `a standard segment.`
+- For each ComprTest, a scenario is created with `a standard segment.`
+- For each RBlockTest, a scenario is created with `a standard segment.`
+
+The `a standard segment` is a segment with a length of 1000 mm and a foundation of True.
+
+The `the cut length` is the cut length of the PropSawTest.
+The `the column length` is the column length of the PropSawTest.
+"""
+
+import logging
+from typing import List, Tuple
+
+import numpy as np
+from snowpylot import caaml_parser
+from snowpylot.layer import Layer as SnowpylotLayer
+from snowpylot.snow_pit import SnowPit
+from snowpylot.snow_profile import DensityObs
+
+# Import WEAC components
+from weac.components import (
+    Layer,
+    WeakLayer,
+)
+from weac.utils.geldsetzer import compute_density
+
+logger = logging.getLogger(__name__)
+
+convert_to_mm = {"cm": 10, "mm": 1, "m": 1000, "dm": 100}
+convert_to_deg = {"deg": 1, "rad": 180 / np.pi}
+
+
+class SnowPilotParser:
+    """Parser for SnowPilot files using the snowpylot library."""
+
+    def __init__(self, file_path: str):
+        self.snowpit: SnowPit = caaml_parser(file_path)
+
+    def extract_layers(self) -> Tuple[List[Layer], List[str]]:
+        """Extract layers from snowpit."""
+        snowpit = self.snowpit
+        # Extract layers from snowpit: List[SnowpylotLayer]
+        sp_layers: List[SnowpylotLayer] = [
+            layer
+            for layer in snowpit.snow_profile.layers
+            if layer.depth_top is not None
+        ]
+        sp_layers = sorted(sp_layers, key=lambda x: x.depth_top[0])  # type: ignore
+
+        # Extract density layers from snowpit: List[DensityObs]
+        sp_density_layers: List[DensityObs] = [
+            layer
+            for layer in snowpit.snow_profile.density_profile
+            if layer.depth_top is not None
+        ]
+        sp_density_layers = sorted(sp_density_layers, key=lambda x: x.depth_top[0])  # type: ignore
+
+        # Populate WEAC layers: List[Layer]
+        layers: List[Layer] = []
+        density_methods: List[str] = []
+        for _i, layer in enumerate(sp_layers):
+            # Parameters
+            grain_type = None
+            grain_size = None
+            hand_hardness = None
+            density = None
+            thickness = None
+
+            # extract THICKNESS
+            if layer.thickness is not None:
+                thickness, unit = layer.thickness
+                thickness = thickness * convert_to_mm[unit]  # Convert to mm
+            else:
+                raise ValueError("Thickness not found")
+
+            # extract GRAIN TYPE and SIZE
+            if layer.grain_form_primary:
+                if layer.grain_form_primary.grain_form:
+                    grain_type = layer.grain_form_primary.grain_form
+                    if layer.grain_form_primary.grain_size_avg:
+                        grain_size = (
+                            layer.grain_form_primary.grain_size_avg[0]
+                            * convert_to_mm[layer.grain_form_primary.grain_size_avg[1]]
+                        )
+                    elif layer.grain_form_primary.grain_size_max:
+                        grain_size = (
+                            layer.grain_form_primary.grain_size_max[0]
+                            * convert_to_mm[layer.grain_form_primary.grain_size_max[1]]
+                        )
+
+            # extract DENSITY
+            # Get layer depth range in mm for density matching
+            layer_depth_top_mm = layer.depth_top[0] * convert_to_mm[layer.depth_top[1]]
+            layer_depth_bottom_mm = layer_depth_top_mm + thickness
+            # Try to find density measurement that overlaps with this layer
+            measured_density = self.get_density_for_layer_range(
+                layer_depth_top_mm, layer_depth_bottom_mm, sp_density_layers
+            )
+
+            # Handle hardness and create layers accordingly
+            if layer.hardness_top is not None and layer.hardness_bottom is not None:
+                hand_hardness_top = layer.hardness_top
+                hand_hardness_bottom = layer.hardness_bottom
+
+                # Two hardness values - split into two layers
+                half_thickness = thickness / 2
+                layer_mid_depth_mm = layer_depth_top_mm + half_thickness
+
+                # Create top layer (first half)
+                if measured_density is not None:
+                    density_top = self.get_density_for_layer_range(
+                        layer_depth_top_mm, layer_mid_depth_mm, sp_density_layers
+                    )
+                    if density_top is None:
+                        density_methods.append("geldsetzer")
+                        density_top = compute_density(grain_type, hand_hardness_top)
+                    else:
+                        density_methods.append("density_obs")
+                else:
+                    density_methods.append("geldsetzer")
+                    density_top = compute_density(grain_type, hand_hardness_top)
+
+                layers.append(
+                    Layer(
+                        rho=density_top,
+                        h=half_thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness_top,
+                    )
+                )
+
+                # Create bottom layer (second half)
+                if measured_density is not None:
+                    density_bottom = self.get_density_for_layer_range(
+                        layer_mid_depth_mm, layer_depth_bottom_mm, sp_density_layers
+                    )
+                    if density_bottom is None:
+                        density_methods.append("geldsetzer")
+                        density_bottom = compute_density(
+                            grain_type, hand_hardness_bottom
+                        )
+                    else:
+                        density_methods.append("density_obs")
+                else:
+                    try:
+                        density_methods.append("geldsetzer")
+                        density_bottom = compute_density(
+                            grain_type, hand_hardness_bottom
+                        )
+                    except Exception as exc:
+                        raise AttributeError(
+                            "Layer is missing density information; density profile, "
+                            "hand hardness and grain type are all missing. "
+                            "Excluding SnowPit from calculations."
+                        ) from exc
+
+                layers.append(
+                    Layer(
+                        rho=density_bottom,
+                        h=half_thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness_bottom,
+                    )
+                )
+            else:
+                # Single hardness value - create one layer
+                hand_hardness = layer.hardness
+
+                if measured_density is not None:
+                    density = measured_density
+                    density_methods.append("density_obs")
+                else:
+                    try:
+                        density_methods.append("geldsetzer")
+                        density = compute_density(grain_type, hand_hardness)
+                    except Exception as exc:
+                        raise AttributeError(
+                            "Layer is missing density information; density profile, "
+                            "hand hardness and grain type are all missing. "
+                            "Excluding SnowPit from calculations."
+                        ) from exc
+
+                layers.append(
+                    Layer(
+                        rho=density,
+                        h=thickness,
+                        grain_type=grain_type,
+                        grain_size=grain_size,
+                        hand_hardness=hand_hardness,
+                    )
+                )
+
+        if len(layers) == 0:
+            raise AttributeError(
+                "No layers found for snowpit. Excluding SnowPit from calculations."
+            )
+        return layers, density_methods
+
+    def get_density_for_layer_range(
+        self,
+        layer_top_mm: float,
+        layer_bottom_mm: float,
+        sp_density_layers: List[DensityObs],
+    ) -> float | None:
+        """Find density measurements that overlap with the given layer depth range.
+
+        Args:
+            layer_top_mm: Top depth of layer in mm
+            layer_bottom_mm: Bottom depth of layer in mm
+            sp_density_layers: List of density observations
+
+        Returns:
+            Average density from overlapping measurements, or None if no overlap
+        """
+        if not sp_density_layers:
+            return None
+
+        overlapping_densities = []
+        overlapping_weights = []
+
+        for density_obs in sp_density_layers:
+            if density_obs.depth_top is None or density_obs.thickness is None:
+                continue
+
+            # Convert density observation depth range to mm
+            density_top_mm = (
+                density_obs.depth_top[0] * convert_to_mm[density_obs.depth_top[1]]
+            )
+            density_thickness_mm = (
+                density_obs.thickness[0] * convert_to_mm[density_obs.thickness[1]]
+            )
+            density_bottom_mm = density_top_mm + density_thickness_mm
+
+            # Check for overlap between layer and density measurement
+            overlap_top = max(layer_top_mm, density_top_mm)
+            overlap_bottom = min(layer_bottom_mm, density_bottom_mm)
+
+            if overlap_top < overlap_bottom:  # There is overlap
+                overlap_thickness = overlap_bottom - overlap_top
+
+                # Extract density value
+                if density_obs.density is not None:
+                    density_value = density_obs.density[0]  # (value, unit)
+
+                    overlapping_densities.append(density_value)
+                    overlapping_weights.append(overlap_thickness)
+
+        if overlapping_densities:
+            # Calculate weighted average based on overlap thickness
+            total_weight = sum(overlapping_weights)
+            if total_weight > 0:
+                weighted_density = (
+                    sum(
+                        d * w
+                        for d, w in zip(overlapping_densities, overlapping_weights)
+                    )
+                    / total_weight
+                )
+                return float(weighted_density)
+        return None
+
+    def extract_weak_layer_and_layers_above(
+        self, weak_layer_depth: float, layers: List[Layer]
+    ) -> Tuple[WeakLayer, List[Layer]]:
+        """Extract weak layer and layers above the weak layer for the given
+        depth_top extracted from the stability test."""
+        depth = 0
+        layers_above = []
+        weak_layer_rho = None
+        weak_layer_hand_hardness = None
+        weak_layer_grain_type = None
+        weak_layer_grain_size = None
+        if weak_layer_depth <= 0:
+            raise ValueError(
+                "The depth of the weak layer is not positive. "
+                "Excluding SnowPit from calculations."
+            )
+        if weak_layer_depth > sum(layer.h for layer in layers):
+            raise ValueError(
+                "The depth of the weak layer is below the recorded layers. "
+                "Excluding SnowPit from calculations."
+            )
+        layers = [layer.model_copy(deep=True) for layer in layers]
+        for i, layer in enumerate(layers):
+            if depth + layer.h < weak_layer_depth:
+                layers_above.append(layer)
+                depth += layer.h
+            elif depth < weak_layer_depth < depth + layer.h:
+                layer.h = weak_layer_depth - depth
+                layers_above.append(layer)
+                weak_layer_rho = layers[i].rho
+                weak_layer_hand_hardness = layers[i].hand_hardness
+                weak_layer_grain_type = layers[i].grain_type
+                weak_layer_grain_size = layers[i].grain_size
+                break
+            elif depth + layer.h == weak_layer_depth:
+                if i + 1 < len(layers):
+                    layers_above.append(layer)
+                    weak_layer_rho = layers[i + 1].rho
+                    weak_layer_hand_hardness = layers[i + 1].hand_hardness
+                    weak_layer_grain_type = layers[i + 1].grain_type
+                    weak_layer_grain_size = layers[i + 1].grain_size
+                else:
+                    weak_layer_rho = layers[i].rho
+                    weak_layer_hand_hardness = layers[i].hand_hardness
+                    weak_layer_grain_type = layers[i].grain_type
+                    weak_layer_grain_size = layers[i].grain_size
+                break
+
+        weak_layer = WeakLayer(
+            rho=weak_layer_rho,
+            h=20.0,
+            hand_hardness=weak_layer_hand_hardness,
+            grain_type=weak_layer_grain_type,
+            grain_size=weak_layer_grain_size,
+        )
+        if len(layers_above) == 0:
+            raise ValueError("No layers above weak layer found")
+        return weak_layer, layers_above

{weac-3.0.0.dist-info → weac-3.0.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: weac
-Version: 3.0.0
+Version: 3.0.1
 Summary: Weak layer anticrack nucleation model
 Author-email: 2phi GbR <mail@2phi.de>
-License: Proprietary
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/2phi/weac
 Project-URL: Demo, https://github.com/2phi/weac/blob/main/demo/demo.ipynb
 Project-URL: Documentation, https://2phi.github.io/weac
@@ -11,7 +11,6 @@ Project-URL: Issues and feature requests, https://github.com/2phi/weac/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.12
@@ -55,7 +54,8 @@ Requires-Dist: pylint>=3.2.0; extra == "dev"
 Requires-Dist: pycodestyle>=2.11.1; extra == "dev"
 Requires-Dist: black>=24.4.0; extra == "dev"
 Requires-Dist: isort>=5.13.0; extra == "dev"
-Requires-Dist: bump2version>=1.0.1; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Requires-Dist: build; extra == "dev"
 Dynamic: license-file
 
 <!-- LOGO AND TITLE-->

weac-3.0.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+weac/__init__.py,sha256=YrbBczmXbMc2L2DRklNEOFxlfY0Z9FLDnpW8ZhbaIww,76
+weac/constants.py,sha256=BX8ifZhFciCuzzako1p-2Wh5CWWzR3cPdvyu501UtUs,1194
+weac/logging_config.py,sha256=BFphsxo5s_7E6rPOO2PbOfu0Wy8zHD4AUnnJdqvrn5I,1134
+weac/analysis/__init__.py,sha256=twF9OYrZiVmBtw6Lyzf5QUhLZNtqFFM2H3OuaYCog1k,486
+weac/analysis/analyzer.py,sha256=AR1yxM5trK1c-_lTEVn9e6e96IhWVWSRgHgQcaLy4Io,27089
+weac/analysis/criteria_evaluator.py,sha256=oIVL7Mq3fjyiVx_ms-miULdHE4-EYE2OXoMalM9eU1Q,43458
+weac/analysis/plotter.py,sha256=UdiPZKb8vzZAdB1tjVUNfV2INtZaqEiJ7EA8Y-dzxoM,66056
+weac/components/__init__.py,sha256=94WIUVjPI3U-grN_7v0oi9bZB3Z8rCBcx9wJPOwJBAQ,439
+weac/components/config.py,sha256=tnOnJ0M-_knZBhdr052nDyyFFAZN0f2hQ68XRuXG6d8,869
+weac/components/criteria_config.py,sha256=f2agU7nXWURFAw8_68igiSk5aICUxwaB9u3Qasit-Q0,2909
+weac/components/layer.py,sha256=sF47006ORRmNnHW7QMk9h-M0vQQR6TL_PKOvInjdNsk,10560
+weac/components/model_input.py,sha256=dp695ZMXkSXzJaD-ih9XO0QhnFRPKn8zUJY7g-bomhE,3354
+weac/components/scenario_config.py,sha256=Tam-m9DQtdjmTm-lKQ8Dcjqje04ttJS2X3v_Nn7AUHQ,2563
+weac/components/segment.py,sha256=F279KcAAkRuJKWav_BZ4BanO96WZm4KXtKHinFZki7s,941
+weac/core/__init__.py,sha256=pRyCKD8XD3qXVUWtFG7N3cS91P5x5d8Jpr1hMEgxQ2U,233
+weac/core/eigensystem.py,sha256=I4AIGD_uDVKIGv_sv9AXbIXhJ4Eol64BLB-lZF8X3jw,13735
+weac/core/field_quantities.py,sha256=ci7MvhJ4aYdbW6xxH8vHVgWtk5iypCYv6dZ6KjFNvt8,8964
+weac/core/scenario.py,sha256=f5EZaeFJWMFN_JNOrzVDv5_CeRruHn6jSjGbV9fdxhY,6076
+weac/core/slab.py,sha256=nidM3FvTwtj30LmM4OxOfPwqm5TpPzJrH5UvQR6w4no,5150
+weac/core/slab_touchdown.py,sha256=D0mVVeRktFpjywuhEiIZHOVJflslfKX3oesx1mMQGxg,14025
+weac/core/system_model.py,sha256=XMovKslSTvoNHyxeL7zTFMhAqVOTHnXD7MUPkaGSl9Q,15577
+weac/core/unknown_constants_solver.py,sha256=cDXMVKIdhA8AWZQbJnNpM19pvLllvIVc6Mw6xaZGqYw,17839
+weac/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+weac/utils/geldsetzer.py,sha256=DxvpqmWulBacl-mGeAmAuJcv2xqFBx92PEfNC3aeDzk,3500
+weac/utils/misc.py,sha256=lGz0IDDJ_3nvYjSkivPJ5Xscl1D_AmvQLSjaL7SUbKs,3674
+weac/utils/snow_types.py,sha256=eX9-5La6Oom7zh6pg5JZ4MZ6nLdWdc7RoUzm5e6b9w8,1483
+weac/utils/snowpilot_parser.py,sha256=5fKC0FKcEJvfFQfZbPW5cHqb_nyzIltweq7Bdz5-a0A,13713
+weac-3.0.1.dist-info/licenses/LICENSE,sha256=ojZPWKFHbFGDrlNOvuAKGH9WcKhpLHWZPcQ4SzhK91M,1082
+weac-3.0.1.dist-info/METADATA,sha256=-14ZLdvT2GKGX5n8XLJbd3wxPUHvj8Fi5hg85GfdJPs,23666
+weac-3.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+weac-3.0.1.dist-info/top_level.txt,sha256=8tyXUHPFU4Ba_5kPtpwvXo5l6GjJmOnODVBJFygpdeE,5
+weac-3.0.1.dist-info/RECORD,,

weac-3.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 2phi GbR and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weac-3.0.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-weac/__init__.py,sha256=dv7A3r-vIVUaQJDEt5pxC8IJq_Lej2camGA7fIhTsmc,76
-weac/constants.py,sha256=BX8ifZhFciCuzzako1p-2Wh5CWWzR3cPdvyu501UtUs,1194
-weac/logging_config.py,sha256=BFphsxo5s_7E6rPOO2PbOfu0Wy8zHD4AUnnJdqvrn5I,1134
-weac-3.0.0.dist-info/licenses/LICENSE,sha256=CZlY87tZ1Kq7QxKLVrMknnDXGpc1yEZ8SKoXMAk-d4k,1463
-weac-3.0.0.dist-info/METADATA,sha256=lDtqRgn6B42TJM7ju83uFvlzzjkFm93qFIIa99-vI-g,23679
-weac-3.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-weac-3.0.0.dist-info/top_level.txt,sha256=8tyXUHPFU4Ba_5kPtpwvXo5l6GjJmOnODVBJFygpdeE,5
-weac-3.0.0.dist-info/RECORD,,

weac-3.0.0.dist-info/licenses/LICENSE

@@ -1,24 +0,0 @@
-Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
-
-WEAC (c) 2024 is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/.
-
-You are free to:
-
-- Share — copy and redistribute the material in any medium or format
-- Adapt — remix, transform, and build upon the material.
-
-Under the following terms:
-
-- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
-
-- NonCommercial — You may not use the material for commercial purposes.
-
-- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
-
-No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
-
-Notices:
-
-You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
-
-No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.