pyseiskit 0.1.0__py3-none-any.whl

pyseiskit/__init__.py

@@ -0,0 +1,7 @@
+from .modules import gain
+from .modules import palettes
+from .modules import sourceData
+from .modules import clip
+
+# Expose the applyGains function directly at the root
+from .modules.applyGains.applyGains import applyGains, GainType

pyseiskit/modules/applyGains/adapters/__init__.py

@@ -0,0 +1 @@
+from .clipAdapter import createClipAdapter

pyseiskit/modules/applyGains/adapters/clipAdapter.py

@@ -0,0 +1,16 @@
+from typing import Callable
+import numpy.typing as np_types
+
+def createClipAdapter(func: Callable) -> Callable:
+    """
+    Wraps a 2-parameter clipping function to safely accept 
+    the 3-parameter strategy caller signature.
+    """
+    def clipAdapter(
+        gatherAmplitudes: np_types.NDArray,
+        gainValue: float,
+        intervalTimeSamples: float
+    ) -> np_types.NDArray:
+        return func(gatherAmplitudes, gainValue)
+    
+    return clipAdapter

pyseiskit/modules/applyGains/applyGains.py

@@ -0,0 +1,42 @@
+from typing import TypedDict
+from numpy import typing as np_types
+
+from .gainStrategies import gainStrategies
+
+class GainType(TypedDict):
+    """
+    A dictionary defining the supported types of gain that can 
+    be applied to seismic data.
+    """
+    AGC: float
+    GAUSSIAN_AGC: float
+    PERCENTILE_CLIPPING: float
+
+def applyGains(
+    data: np_types.NDArray,
+    gains: GainType,
+    intervalTimeSamples: float,
+) -> np_types.NDArray:
+    """
+    Applies the specified gain to the input data.
+    \nChecks for gain values, not keys.
+    \nIn case of None or 0 values, the gain will be skipped.
+
+    Parameters
+    ----------
+    data: np_types.NDArray
+        Input data array [2D array]
+    gains: GainType [dict]
+        Dictionary containing the gain values.
+    intervalTimeSamples: float
+        Time step between samples in seconds.
+
+    Returns: np_types.NDArray
+        The gained data array.
+    """
+    newData = data.copy()
+
+    for gainType, gainValue in gains.items():
+        newData = gainStrategies[gainType](newData, gainValue, intervalTimeSamples)
+
+    return newData

pyseiskit/modules/applyGains/gainStrategies.py

@@ -0,0 +1,11 @@
+from .adapters import createClipAdapter
+
+from ..gain.contracts import GenericGainProtocol
+from ..gain import applyAGC, applyGAGC
+from ..clip import applyPercentileClip
+
+gainStrategies: dict[str, GenericGainProtocol] = {
+    'AGC': applyAGC,
+    'GAUSSIAN_AGC': applyGAGC,
+    'PERCENTILE_CLIPPING': createClipAdapter(applyPercentileClip)
+}

pyseiskit/modules/clip/__init__.py

@@ -0,0 +1 @@
+from .percentileClip import applyPercentileClip

pyseiskit/modules/clip/contracts/PercentileClip.py

@@ -0,0 +1,19 @@
+import numpy.typing as np_types
+from typing import Protocol
+
+class PercentileClipProtocol(Protocol):
+    def __call__(
+        self,
+        gatherAmplitudes: np_types.NDArray,
+        percentile: float,
+    ) -> np_types.NDArray:
+        """
+        Clip functions must exactly match these parameter names, order, and types.
+        """
+        ...
+
+def PercentileClipContract(function: PercentileClipProtocol) -> PercentileClipProtocol:
+    """
+    Decorator that forces type checkers to verify the function matches ClipProtocol.
+    """
+    return function

pyseiskit/modules/clip/contracts/__init__.py

@@ -0,0 +1 @@
+from .PercentileClip import PercentileClipContract

pyseiskit/modules/clip/percentileClip.py

@@ -0,0 +1,31 @@
+import numpy as np
+from numpy import typing as np_types
+
+from .contracts.PercentileClip import PercentileClipContract
+
+@PercentileClipContract
+def applyPercentileClip(
+	gatherAmplitudes: np_types.NDArray,
+    percentile: float
+) -> np_types.NDArray:
+    """
+    Apply a percentile-based clipping to input data.
+
+    Parameters
+    ----------
+    gatherAmplitudes : np_types.NDArray
+        Input data array.
+    percentile : float
+        Percentile value for clipping.
+
+    Returns
+    -------
+    np_types.NDArray
+        Clipped data array.
+    """
+    maxTraceAmplitude = np.percentile(
+        np.absolute(gatherAmplitudes),
+        percentile
+    )
+    clippedTraces = np.clip(gatherAmplitudes, a_min=-maxTraceAmplitude, a_max=maxTraceAmplitude)
+    return clippedTraces

pyseiskit/modules/gain/__init__.py

@@ -0,0 +1,2 @@
+from .agc import applyAGC
+from .gagc import applyGAGC

pyseiskit/modules/gain/agc.py

@@ -0,0 +1,52 @@
+import numpy as np
+import numpy.typing as np_types
+from scipy import ndimage
+
+from .contracts import AutomaticGainContract
+
+@AutomaticGainContract
+def applyAGC(
+    gatherAmplitudes: np_types.NDArray,
+    wagc: float,
+    intervalTimeSamples: float
+) -> np_types.NDArray:
+    """
+    Calculates Simple Automatic Gain Control (AGC) of a seismic gather.
+
+    Parameters
+    ----------
+    gatherAmplitudes : np_types.NDArray
+        Array of gather amplitudes [2D array]
+    wagc : float
+        Window length for AGC in seconds.
+    intervalTimeSamples : float
+        Time step between samples in seconds.
+    """
+    half_window_samples = round(wagc / intervalTimeSamples)
+    
+    # *** Define the physical window dimensions
+    fullWindowSamples = 2 * half_window_samples
+
+    # *** Rectangular filter (weights sum to 1.0 to compute a true mean)
+    averagingWeights = np.ones(fullWindowSamples) / fullWindowSamples
+
+    # *** Moving energy average
+    # *** Apply the 1D filter down the time axis (axis=0) 
+    # *** mode='constant' with cval=0.0 safely pads the top and bottom with zeros
+    localMeanSquaredEnergy = ndimage.convolve1d(
+        gatherAmplitudes**2,
+        averagingWeights,
+        mode='constant',
+        cval=0.0,
+        axis=0
+    )
+
+    # *** Extract RMS and apply gain
+    rootMeanSquareEnergy = np.sqrt(localMeanSquaredEnergy)
+
+    return np.divide(
+        gatherAmplitudes, 
+        rootMeanSquareEnergy, 
+        out=np.zeros_like(gatherAmplitudes), 
+        where=rootMeanSquareEnergy!=0
+    )

pyseiskit/modules/gain/contracts/AutomaticGain.py

@@ -0,0 +1,21 @@
+import numpy.typing as np_types
+
+from .GenericGain import GenericGainProtocol
+
+class AutomaticGainProtocol(GenericGainProtocol):
+    def __call__(
+        self,
+        gatherAmplitudes: np_types.NDArray,
+        wagc: float,
+        intervalTimeSamples: float
+    ) -> np_types.NDArray:
+        """
+        Automatic gain functions must exactly match these parameter names, order, and types.
+        """
+        ...
+
+def AutomaticGainContract(function: AutomaticGainProtocol) -> AutomaticGainProtocol:
+    """
+    Decorator that forces type checkers to verify the function matches AutomaticGainProtocol.
+    """
+    return function

pyseiskit/modules/gain/contracts/GenericGain.py

@@ -0,0 +1,19 @@
+import numpy.typing as np_types
+from typing import Protocol
+
+class GenericGainProtocol(Protocol):
+    def __call__(
+        self,
+        data: np_types.NDArray,
+        value: float,
+        # *** The '= ...' makes the third parameter optional.
+        timeSamples: float = ...,
+        # *** '/' means this protocol is positional-only. 
+        /
+    ) -> np_types.NDArray:
+        """
+        Functions can name their variables wagc, percentile, threshold, etc., 
+        and it will still be valid.
+        The third parameter is optional.
+        """
+        ...

pyseiskit/modules/gain/contracts/__init__.py

@@ -0,0 +1,2 @@
+from .GenericGain import GenericGainProtocol
+from .AutomaticGain import AutomaticGainContract

pyseiskit/modules/gain/gagc.py

@@ -0,0 +1,57 @@
+import numpy as np
+import numpy.typing as np_types
+from scipy import ndimage
+
+from .contracts import AutomaticGainContract
+
+EPS: float = 3.8090232
+
+@AutomaticGainContract
+def applyGAGC(
+    gatherAmplitudes: np_types.NDArray,
+    wagc: float,
+    intervalTimeSamples: float
+) -> np_types.NDArray:
+    """
+    Calculates Gaussian Automatic Gain Control (GAGC) of a seismic gather.
+
+    Parameters
+    ----------
+    gatherAmplitudes : np_types.NDArray
+        Array of gather amplitudes [2D array]
+    wagc : float
+        Window length for AGC in seconds.
+    intervalTimeSamples : float
+        Time step between samples in seconds.
+    """
+    halfWindowSamples = round(wagc / intervalTimeSamples)
+
+    # *** Define the variance/decay of the Gaussian curve based on the window size
+    decayScalar = EPS / halfWindowSamples
+
+    # *** Array of relative distances from the center of the window
+    sampleOffsets = np.arange(-halfWindowSamples + 1, halfWindowSamples)
+
+    # *** Bell curve weights using the decay scalar and distances
+    gaussianWeights = np.exp(
+        -((decayScalar**2) * sampleOffsets * sampleOffsets)
+    )
+
+    # *** Moving energy average weighted by the Gaussian curve
+    localWeightedEnergy = ndimage.convolve1d(
+        gatherAmplitudes**2,
+        gaussianWeights,
+        mode='constant',
+        cval=0.0,
+        axis=0
+    )
+
+    # *** Extract Root Weighted Energy and apply gain
+    rootWeightedEnergy = np.sqrt(localWeightedEnergy)
+
+    return np.divide(
+        gatherAmplitudes, 
+        rootWeightedEnergy, 
+        out=np.zeros_like(gatherAmplitudes), 
+        where=rootWeightedEnergy!=0
+    )

pyseiskit/modules/palettes/PALETTES.py

@@ -0,0 +1,12 @@
+from bokeh.palettes import Greys256, viridis
+from colorcet import rainbow4
+
+
+from .getFadingPalette import getFadingPalette
+
+PALETTES = {
+	"Greys256": Greys256,
+	"FadingGreys": getFadingPalette(Greys256),
+	"viridis": viridis(256),
+	"rainbow": rainbow4,
+}

pyseiskit/modules/palettes/__init__.py

@@ -0,0 +1 @@
+from .PALETTES import PALETTES

pyseiskit/modules/palettes/getFadingPalette.py

@@ -0,0 +1,19 @@
+def getFadingPalette(base_palette):
+    """
+    Takes a palette (list of hex strings) and applies an alpha gradient.
+    The first color becomes 100% opaque, fading to 100% transparent at the last color.
+    """
+    palette_length = len(base_palette)
+    fading_palette = []
+    
+    for index, color in enumerate(base_palette):
+        # *** index=0 -> alpha=255 (opaque)
+        # *** index=(length-1) -> alpha=0 (transparent)
+        alpha = int(255 * (1 - (index / (palette_length - 1))))
+        # *** Grab just the #RRGGBB part
+        #   *** in case the original palette already had alpha
+        base_hex = color[:7]
+        # *** Append the calculated alpha as a 2-character hex string
+        fading_palette.append(f"{base_hex}{alpha:02x}")
+        
+    return fading_palette

pyseiskit/modules/sourceData/__init__.py

@@ -0,0 +1,3 @@
+from .rescaleDataForWiggle import rescaleDataForWiggle
+from .wiggleLinesDataFactory import wiggleLinesDataFactory
+from .wigglePatchesDataFactory import wigglePatchesDataFactory

pyseiskit/modules/sourceData/rescaleDataForWiggle.py

@@ -0,0 +1,52 @@
+import numpy as np
+from numpy import typing as np_types
+
+def rescaleDataForWiggle(
+    data: np_types.NDArray,
+    offsetPosition: np_types.NDArray,
+    overlap: float = 1.0,
+    percentile: float = 100.0
+) -> np_types.NDArray:
+    """
+    Rescales seismic data amplitudes to physical horizontal offsets for wiggle trace plotting.
+
+    Args:
+        data: 2D array of amplitudes (samples x traces).
+        offsetPosition: 1D array of horizontal trace locations.
+        overlap: Controls the maximum horizontal swing. A value of 1.0 (Seismic Unix 'xcur' equivalent)
+            means a maximum amplitude peak will swing exactly 1.0 trace spacing, touching the baseline
+            of the adjacent trace.
+        percentile: Percentile of absolute amplitudes used as the maximum for scaling.
+            Values < 100.0 (e.g., 99.0) ignore extreme outlier spikes when determining the
+            normalization reference, mirroring the behavior of Seismic Unix's 'perc' parameter.
+    """
+    # Determine maximum scale reference using the specified percentile
+    if percentile < 100.0:
+        dataMax = np.percentile(np.abs(data), percentile)
+    else:
+        dataMax = np.max(np.abs(data))
+
+    if dataMax == 0:
+        return data.copy()
+
+    dataNormalized = data / dataMax
+
+    # For a single trace there is no inter-trace spacing to reference,
+    # so the normalized data is already the final result.
+    if data.shape[1] == 1:
+        return dataNormalized
+
+    # Calculate trace spacing robustly (median of non-zero absolute differences)
+    abs_diffs = np.abs(np.diff(offsetPosition))
+    valid_diffs = abs_diffs[abs_diffs > 0]
+    
+    if len(valid_diffs) == 0:
+        # Fallback if all traces are literally on the exact same physical offset
+        minTraceSpacing = 1.0
+    else:
+        minTraceSpacing = np.min(valid_diffs)
+        
+    # Scale normalized data so the maximum deflection equals overlap * trace spacing
+    dataRescaled = dataNormalized * (minTraceSpacing * overlap)
+
+    return dataRescaled

pyseiskit/modules/sourceData/wiggleLinesDataFactory.py

@@ -0,0 +1,19 @@
+import numpy as np
+from numpy import typing as np_types
+
+
+def wiggleLinesDataFactory(
+    data: np_types.NDArray,
+    offsetPosition: np_types.NDArray,
+    timeSampleInstants: np_types.NDArray,
+):
+    tracesAmount = data.shape[1]
+
+    # *** Positioning each trace at its corresponding X-axis offset
+    broadcastOffsetPosition = np.broadcast_to(offsetPosition, data.shape)
+    dataRepositioned = data + broadcastOffsetPosition
+
+    dataPositioned = dataRepositioned.T.tolist()
+    timesPositioned = [timeSampleInstants for _ in range(tracesAmount)]
+
+    return {"xs": dataPositioned, "ys": timesPositioned}

pyseiskit/modules/sourceData/wigglePatchesDataFactory.py

@@ -0,0 +1,126 @@
+import numpy as np
+from numpy import typing as np_types
+from typing import Tuple, List
+
+MIDPOINT_INDEX_OFFSET = 0.5
+
+def _interpolateLobeCoordinates(
+    timeSampleInstants: np_types.NDArray,
+    traceAmplitudes: np_types.NDArray,
+    traceOffset: float
+) -> Tuple[List[float], List[float]]:
+    """
+    Finds all active amplitudes and calculates the exact zero-crossing interpolation 
+    points, returning the sorted boundary coordinates for the filled lobes of a single trace.
+    Expects data to be pre-flipped if positive lobes are desired.
+    """
+    currentAmplitudes = traceAmplitudes[:-1]
+    nextAmplitudes = traceAmplitudes[1:]
+    currentTime = timeSampleInstants[:-1]
+    nextTime = timeSampleInstants[1:]
+
+    # Capture strictly negative values (since we flip the data if filling positive)
+    negativeMask = currentAmplitudes <= 0
+    negativeIndices = np.where(negativeMask)[0]
+
+    xs_neg = traceOffset + currentAmplitudes[negativeMask]
+    ys_neg = currentTime[negativeMask]
+
+    # Capture exact zero crossings
+    crossingMask = (
+        (currentAmplitudes < 0) & (nextAmplitudes > 0)
+    ) | (
+        (currentAmplitudes > 0) & (nextAmplitudes < 0)
+    )
+    crossingIndices = np.where(crossingMask)[0]
+
+    # Linear interpolation to find the exact time at zero
+    # Handle potential divide by zero just in case
+    diffAmp = nextAmplitudes[crossingMask] - currentAmplitudes[crossingMask]
+    safeDiffAmp = np.where(diffAmp == 0, 1e-10, diffAmp)
+    
+    crossingTimes = (
+        currentTime[crossingMask] + (
+            nextTime[crossingMask] - currentTime[crossingMask]
+        ) * (0 - currentAmplitudes[crossingMask]) / safeDiffAmp
+    )
+
+    xs_cross = np.full(len(crossingIndices), traceOffset)
+    ys_cross = crossingTimes
+
+    # Combine and sort to preserve the chronological order
+    sortOrder = np.argsort(np.concatenate(
+        [negativeIndices, crossingIndices + MIDPOINT_INDEX_OFFSET]
+    ))
+
+    new_xs = np.concatenate([xs_neg, xs_cross])[sortOrder].tolist()
+    new_ys = np.concatenate([ys_neg, ys_cross])[sortOrder].tolist()
+
+    # Add the last point if it is part of the lobe
+    if traceAmplitudes[-1] <= 0:
+        new_xs.append(float(traceOffset + traceAmplitudes[-1]))
+        new_ys.append(float(timeSampleInstants[-1]))
+        
+    return new_xs, new_ys
+
+
+def wigglePatchesDataFactory(
+    data: np_types.NDArray,
+    offsetPosition: np_types.NDArray,
+    timeSampleInstants: np_types.NDArray,
+    fill_mode: str = "positive"
+) -> Tuple[List[List[float]], List[List[float]]]:
+    """
+    Generates polygon coordinates for rendering filled wiggle lobes.
+    
+    This function calculates sub-sample exact zero-crossings using linear interpolation 
+    to create mathematically smooth filled areas. It is plotting-library agnostic.
+    
+    Args:
+        data: 2D array of rescaled amplitudes (samples x traces).
+        offsetPosition: 1D array of horizontal trace locations.
+        timeSampleInstants: 1D array of time/depth values for the vertical axis.
+        fill_mode: "positive" to fill right-swinging lobes, "negative" for left-swinging.
+        
+    Returns:
+        A dictionary `{"xs": [...], "ys": [...]}` where:
+            xs: List of lists containing the X coordinates for each trace's filled polygon.
+            ys: List of lists containing the Y coordinates for each trace's filled polygon.
+    """
+    if fill_mode not in ["positive", "negative"]:
+        raise ValueError("fill_mode must be 'positive' or 'negative'")
+
+    # The internal algorithm extracts negative values. 
+    # If the user wants to fill positive lobes, we simply flip the polarity of the data.
+    working_data = -data if fill_mode == "positive" else data
+
+    xs_patches = []
+    ys_patches = []
+
+    for traceOffset, traceAmplitude in zip(offsetPosition, working_data.T):
+        lobeAmplitudes, lobeTimes = _interpolateLobeCoordinates(
+            timeSampleInstants,
+            traceAmplitude,
+            traceOffset
+        )
+    
+        # Skip if the trace has no lobes of the requested polarity
+        if not lobeAmplitudes:
+            xs_patches.append([])
+            ys_patches.append([])
+            continue
+
+        # Build the single continuous polygon: Lobe path + return path along the baseline
+        # Note: We must invert the amplitude back to normal if we flipped it earlier
+        if fill_mode == "positive":
+            actualAmplitudes = [traceOffset - (amp - traceOffset) for amp in lobeAmplitudes]
+        else:
+            actualAmplitudes = lobeAmplitudes
+            
+        polygonOffsetCoordinates = [traceOffset] * len(actualAmplitudes) + actualAmplitudes[::-1]
+        polygonTimeCoordinates = lobeTimes + lobeTimes[::-1]
+
+        xs_patches.append(polygonOffsetCoordinates)
+        ys_patches.append(polygonTimeCoordinates)
+
+    return {"xs": xs_patches, "ys": ys_patches}

pyseiskit-0.1.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.5
+Name: pyseiskit
+Version: 0.1.0
+Summary: A Python library for seismic data processing and pre-visualization.
+Project-URL: Homepage, https://github.com/PETROGEO-UFRN/pyseiskit
+Project-URL: Repository, https://github.com/PETROGEO-UFRN/pyseiskit
+Author-email: JorbFreire <jorbfreire@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: SU,data processing,geophysics,seismic,seismic unix,wiggle
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# pyseiskit
+
+A Python library for seismic data processing.
+
+Includes *wiggle* helpers, wich can be used together with common plot libraries such as:
+
+ - Matplotlib
+ - Bokeh
+ - Plotly 
+
+## Installation
+```bash
+pip install pyseiskit
+```
+
+## [Available Demos](/demos) 
+  - [Wiggle plotting with common libraries](/demos/wiggle.ipynb)
+  - [Gain methods](/demos/gain.ipynb)

pyseiskit-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+pyseiskit/__init__.py,sha256=AwTaxxl5N9qCrb6ZyjOYBkmwv8v1NWV-3biR0m4mVVU,233
+pyseiskit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyseiskit/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyseiskit/modules/applyGains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyseiskit/modules/applyGains/applyGains.py,sha256=U4ZiK86gb84xYl6oqDaodP8crj-AX6DvjrTRHgbHDZg,1092
+pyseiskit/modules/applyGains/gainStrategies.py,sha256=ezZRmy7jU8D83MCPKO-nHCvn-q174uEmVVl3bAVuSw4,340
+pyseiskit/modules/applyGains/adapters/__init__.py,sha256=A1-rqVJZR6deGC0DbYlhJqMp7ov2_cPMFAJPUSV0HsY,43
+pyseiskit/modules/applyGains/adapters/clipAdapter.py,sha256=7CxVhsR_n7xCnil_AIYDdzJI1oLEAWn0jSDr0mVps8s,465
+pyseiskit/modules/clip/__init__.py,sha256=AJT90JbIk-bdYLygqI84S2EbshJ8mUIsMVH0tbH62Vc,48
+pyseiskit/modules/clip/percentileClip.py,sha256=s2G7VU8CrkODOXbEoFZrckleY0YaKirge-zeRdRQi2o,777
+pyseiskit/modules/clip/contracts/PercentileClip.py,sha256=HgFvARg8KLN9QE6viNiGZyqIY3iQVlmHOzeaD7yzIQ8,560
+pyseiskit/modules/clip/contracts/__init__.py,sha256=yN1CT2zDL-_cu0m9S6z8N2TE3RzZK_VrPTexUBQQBJg,51
+pyseiskit/modules/gain/__init__.py,sha256=Qks9VshxyA_OH8BpUQerxeg_7IGWf01BPOnBcvlBvDo,54
+pyseiskit/modules/gain/agc.py,sha256=RrWQXd0d2O1DoLe6MugoYZY6DG0_RoWZ3G3OWX9ilqY,1529
+pyseiskit/modules/gain/gagc.py,sha256=EgxiwFSUuxeuDOaGq98g_h7CQpNdtjMeelGuD8MFMTk,1635
+pyseiskit/modules/gain/contracts/AutomaticGain.py,sha256=ngE_djLcV0sokG7lEhFKWwPKXQLJoHDJxLRMRu4oeS0,633
+pyseiskit/modules/gain/contracts/GenericGain.py,sha256=fQqOgOql16QJi_AgWL_V0-JoJGoEndXBgcs7q4qFvHQ,568
+pyseiskit/modules/gain/contracts/__init__.py,sha256=5d5y6DdJ98S70_wRtp6ql_1t5bsM0hHy6UgKP0gI7D4,94
+pyseiskit/modules/palettes/PALETTES.py,sha256=6TM7ZYqGNzc97l1dLUOMFyUaQUvDgO0y9gQj7KDfETw,255
+pyseiskit/modules/palettes/__init__.py,sha256=Mv_bF0y13eguj98wI9rz_LcL0jEeCjBPlpfvYL5oCk8,31
+pyseiskit/modules/palettes/getFadingPalette.py,sha256=Rcmiece8xxAECJKg9KN3-xKBd4Tgnj9I_blsfyFNrsk,787
+pyseiskit/modules/sourceData/__init__.py,sha256=upeayOuOXNzJpEg-DY8ex4gY6C-RVdr8f9RHUlXK9_E,177
+pyseiskit/modules/sourceData/rescaleDataForWiggle.py,sha256=Z8ZLz5VVjOIoOlTtnoPGkHBlM6GBYmIktNVgiu8eA74,2023
+pyseiskit/modules/sourceData/wiggleLinesDataFactory.py,sha256=JAP0LQuol0dop-O0D7ueoksrwhpkCwpW1ddP2EtijSs,607
+pyseiskit/modules/sourceData/wigglePatchesDataFactory.py,sha256=rKMGpumCXIZBk0o8qSgTNi8NGM4ifTYkVQxKd_b3k3s,4856
+pyseiskit-0.1.0.dist-info/METADATA,sha256=dalBtDtyHOvQLsuUoiZu8GJ2xpeHRm1ynz48aIbzO4U,1388
+pyseiskit-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pyseiskit-0.1.0.dist-info/licenses/LICENSE,sha256=Nb2j7KkrzjaGNwtyEBAOIZHOqlVlyxML27s62sVL-hA,1065
+pyseiskit-0.1.0.dist-info/RECORD,,

pyseiskit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyseiskit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PETROGEO
+
+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.