assaycalc 0.1.0__tar.gz

assaycalc-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/

assaycalc-0.1.0/LICENSE

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

assaycalc-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: assaycalc
+Version: 0.1.0
+Summary: Librería para leer, validar y procesar datos de ensayos geológicos (assay) de sondajes mineros.
+Author-email: Rodrigo <martinhq30@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mining-assay-toolkit
+
+Herramientas en Python para el procesamiento y validación de datos de assay geológico (sondajes de exploración minera).
+
+## Instalación
+
+```bash
+pip install mining-assay-toolkit
+```
+
+## Uso rápido
+
+```python
+from mining_assay_toolkit import leer_csv_assay, validar_assay, componer_assay, guardar_csv
+
+# 1. Leer datos de assay desde un CSV
+df = leer_csv_assay("assay_original.csv")
+
+# 2. Validar integridad de los datos
+validar_assay(df)
+
+# 3. Generar compósitos de 2 metros ponderados por ley de Cu
+df_compositos = componer_assay(df, longitud_composito=2.0)
+
+# 4. Guardar el resultado
+guardar_csv(df_compositos, "assay_compuesto.csv")
+```
+
+## Formato de entrada esperado
+
+El CSV debe contener, como mínimo, estas columnas:
+
+| Columna    | Descripción                          |
+|------------|---------------------------------------|
+| `hole_id`  | Identificador del sondaje             |
+| `from`     | Profundidad inicial del intervalo (m) |
+| `to`       | Profundidad final del intervalo (m)   |
+| `Cu_pct`   | Ley de cobre (%) en el intervalo      |
+
+## Validaciones incluidas
+
+`validar_assay()` verifica automáticamente:
+
+- Que no existan `hole_id` vacíos
+- Que todos los intervalos tengan `from < to`
+- Que no existan leyes de `Cu_pct` negativas
+- Que no existan intervalos solapados dentro de un mismo sondaje
+
+Si alguna validación falla, se lanza un `ValueError` con el detalle del problema.
+
+## Compositado
+
+`componer_assay()` divide cada sondaje en intervalos de longitud fija (por ejemplo, cada 2 metros) y calcula la ley promedio ponderada por la longitud de cada intervalo original que cae dentro del compósito.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE) para más detalles.

assaycalc-0.1.0/README.md

@@ -0,0 +1,57 @@
+# mining-assay-toolkit
+
+Herramientas en Python para el procesamiento y validación de datos de assay geológico (sondajes de exploración minera).
+
+## Instalación
+
+```bash
+pip install mining-assay-toolkit
+```
+
+## Uso rápido
+
+```python
+from mining_assay_toolkit import leer_csv_assay, validar_assay, componer_assay, guardar_csv
+
+# 1. Leer datos de assay desde un CSV
+df = leer_csv_assay("assay_original.csv")
+
+# 2. Validar integridad de los datos
+validar_assay(df)
+
+# 3. Generar compósitos de 2 metros ponderados por ley de Cu
+df_compositos = componer_assay(df, longitud_composito=2.0)
+
+# 4. Guardar el resultado
+guardar_csv(df_compositos, "assay_compuesto.csv")
+```
+
+## Formato de entrada esperado
+
+El CSV debe contener, como mínimo, estas columnas:
+
+| Columna    | Descripción                          |
+|------------|---------------------------------------|
+| `hole_id`  | Identificador del sondaje             |
+| `from`     | Profundidad inicial del intervalo (m) |
+| `to`       | Profundidad final del intervalo (m)   |
+| `Cu_pct`   | Ley de cobre (%) en el intervalo      |
+
+## Validaciones incluidas
+
+`validar_assay()` verifica automáticamente:
+
+- Que no existan `hole_id` vacíos
+- Que todos los intervalos tengan `from < to`
+- Que no existan leyes de `Cu_pct` negativas
+- Que no existan intervalos solapados dentro de un mismo sondaje
+
+Si alguna validación falla, se lanza un `ValueError` con el detalle del problema.
+
+## Compositado
+
+`componer_assay()` divide cada sondaje en intervalos de longitud fija (por ejemplo, cada 2 metros) y calcula la ley promedio ponderada por la longitud de cada intervalo original que cae dentro del compósito.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE) para más detalles.

assaycalc-0.1.0/assay_compuesto.csv

@@ -0,0 +1,6 @@
+hole_id,from,to,Cu_pct
+DDH-001,0.0,2.0,0.493
+DDH-001,2.0,4.0,0.5
+DDH-001,4.0,6.0,0.38
+DDH-002,0.0,2.0,0.55
+DDH-002,2.0,4.0,0.7

assaycalc-0.1.0/assay_original.csv

@@ -0,0 +1,6 @@
+hole_id;from;to;Cu_pct
+DDH-001;0;1.5;0.45
+DDH-001;1.5;3;0.62
+DDH-001;3;4.2;0.38
+DDH-002;0;2;0.55
+DDH-002;2;4;0.7

assaycalc-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "assaycalc"
+version = "0.1.0"
+description = "Librería para leer, validar y procesar datos de ensayos geológicos (assay) de sondajes mineros."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Rodrigo", email = "martinhq30@gmail.com" }
+]
+requires-python = ">=3.9"
+
+dependencies = [
+    "pandas>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "mypy>=1.10",
+    "ruff>=0.5",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mining_assay_toolkit"]

assaycalc-0.1.0/src/mining_assay_toolkit/__init__.py

@@ -0,0 +1,17 @@
+"""Mining Assay Toolkit: procesamiento de datos de ensayos geológicos."""
+
+from mining_assay_toolkit.core import (
+    componer_assay,
+    guardar_csv,
+    leer_csv_assay,
+    validar_assay,
+)
+
+__all__ = [
+    "componer_assay",
+    "guardar_csv",
+    "leer_csv_assay",
+    "validar_assay",
+]
+
+__version__ = "0.1.0"

assaycalc-0.1.0/src/mining_assay_toolkit/core.py

@@ -0,0 +1,81 @@
+"""Procesamiento básico de datos de assay geológico (v0)."""
+
+import pandas as pd
+
+
+REQUIRED_COLUMNS = {"hole_id", "from", "to", "Cu_pct"}
+
+
+def leer_csv_assay(ruta: str) -> pd.DataFrame:
+    """Lee un archivo CSV de assay y devuelve un DataFrame."""
+    df = pd.read_csv(
+        ruta,
+        sep=None,
+        engine="python",
+        encoding="utf-8-sig"
+    )
+
+    columnas_faltantes = REQUIRED_COLUMNS - set(df.columns)
+
+    if columnas_faltantes:
+        raise ValueError(f"Faltan columnas requeridas: {columnas_faltantes}")
+
+    return df
+
+
+def validar_assay(df: pd.DataFrame) -> None:
+    """Valida reglas mínimas de integridad sobre los datos de assay."""
+    if df["hole_id"].isna().any():
+        raise ValueError("Existen filas con hole_id vacío.")
+
+    if (df["from"] >= df["to"]).any():
+        raise ValueError("Existen intervalos donde 'from' >= 'to'.")
+
+    if (df["Cu_pct"] < 0).any():
+        raise ValueError("Existen leyes de Cu_pct negativas.")
+
+    for hole_id, grupo in df.groupby("hole_id"):
+        grupo_ordenado = grupo.sort_values("from")
+        solapes = (
+            grupo_ordenado["from"].iloc[1:].to_numpy()
+            < grupo_ordenado["to"].iloc[:-1].to_numpy()
+        )
+        if solapes.any():
+            raise ValueError(f"Intervalos solapados en el sondaje {hole_id}.")
+
+
+def componer_assay(df: pd.DataFrame, longitud_composito: float) -> pd.DataFrame:
+    """Genera compósitos de longitud fija ponderando la ley por longitud del intervalo."""
+    resultados = []
+
+    for hole_id, grupo in df.groupby("hole_id"):
+        grupo = grupo.sort_values("from").reset_index(drop=True)
+        profundidad_max = grupo["to"].max()
+        inicio = 0.0
+
+        while inicio < profundidad_max:
+            fin = inicio + longitud_composito
+            interseccion = grupo[(grupo["from"] < fin) & (grupo["to"] > inicio)]
+
+            if not interseccion.empty:
+                largos = (
+                    interseccion["to"].clip(upper=fin)
+                    - interseccion["from"].clip(lower=inicio)
+                )
+                ley_ponderada = (interseccion["Cu_pct"] * largos).sum() / largos.sum()
+
+                resultados.append({
+                    "hole_id": hole_id,
+                    "from": inicio,
+                    "to": fin,
+                    "Cu_pct": round(ley_ponderada, 3),
+                })
+
+            inicio = fin
+
+    return pd.DataFrame(resultados)
+
+
+def guardar_csv(df: pd.DataFrame, ruta: str) -> None:
+    """Guarda un DataFrame como archivo CSV."""
+    df.to_csv(ruta, index=False)

assaycalc-0.1.0/tests/test_core.py

@@ -0,0 +1,133 @@
+"""Tests para mining_assay_toolkit.core"""
+
+import pandas as pd
+import pytest
+
+from mining_assay_toolkit.core import (
+    leer_csv_assay,
+    validar_assay,
+    componer_assay,
+    guardar_csv,
+)
+
+
+# ---------- Fixtures ----------
+
+@pytest.fixture
+def df_valido():
+    return pd.DataFrame({
+        "hole_id": ["DDH-01", "DDH-01", "DDH-01"],
+        "from": [0.0, 2.0, 4.0],
+        "to": [2.0, 4.0, 6.0],
+        "Cu_pct": [0.5, 1.0, 0.3],
+    })
+
+
+# ---------- Tests: leer_csv_assay ----------
+
+def test_leer_csv_assay_lee_correctamente(tmp_path, df_valido):
+    ruta = tmp_path / "assay.csv"
+    df_valido.to_csv(ruta, index=False)
+
+    resultado = leer_csv_assay(str(ruta))
+
+    assert list(resultado.columns) == list(df_valido.columns)
+    assert len(resultado) == 3
+
+
+def test_leer_csv_assay_falla_si_faltan_columnas(tmp_path):
+    df_incompleto = pd.DataFrame({"hole_id": ["DDH-01"], "from": [0.0]})
+    ruta = tmp_path / "assay_incompleto.csv"
+    df_incompleto.to_csv(ruta, index=False)
+
+    with pytest.raises(ValueError, match="Faltan columnas requeridas"):
+        leer_csv_assay(str(ruta))
+
+
+# ---------- Tests: validar_assay ----------
+
+def test_validar_assay_pasa_con_datos_correctos(df_valido):
+    # No debe lanzar ninguna excepción
+    validar_assay(df_valido)
+
+
+def test_validar_assay_falla_con_hole_id_vacio(df_valido):
+    df_valido.loc[0, "hole_id"] = None
+
+    with pytest.raises(ValueError, match="hole_id vacío"):
+        validar_assay(df_valido)
+
+
+def test_validar_assay_falla_con_from_mayor_igual_to(df_valido):
+    df_valido.loc[0, "from"] = 5.0
+    df_valido.loc[0, "to"] = 2.0
+
+    with pytest.raises(ValueError, match="'from' >= 'to'"):
+        validar_assay(df_valido)
+
+
+def test_validar_assay_falla_con_ley_negativa(df_valido):
+    df_valido.loc[0, "Cu_pct"] = -0.1
+
+    with pytest.raises(ValueError, match="Cu_pct negativas"):
+        validar_assay(df_valido)
+
+
+def test_validar_assay_falla_con_intervalos_solapados():
+    df_solapado = pd.DataFrame({
+        "hole_id": ["DDH-01", "DDH-01"],
+        "from": [0.0, 1.0],
+        "to": [2.0, 3.0],
+        "Cu_pct": [0.5, 0.8],
+    })
+
+    with pytest.raises(ValueError, match="solapados"):
+        validar_assay(df_solapado)
+
+
+# ---------- Tests: componer_assay ----------
+
+def test_componer_assay_genera_compositos_correctos(df_valido):
+    resultado = componer_assay(df_valido, longitud_composito=2.0)
+
+    assert len(resultado) == 3
+    assert list(resultado["from"]) == [0.0, 2.0, 4.0]
+    assert list(resultado["to"]) == [2.0, 4.0, 6.0]
+    # El primer intervalo coincide exactamente con un compósito de 2m
+    assert resultado.loc[0, "Cu_pct"] == 0.5
+
+
+def test_componer_assay_pondera_correctamente_intervalo_parcial():
+    # Un intervalo de 0 a 3m con ley 1.0, compositado cada 2m
+    df = pd.DataFrame({
+        "hole_id": ["DDH-01"],
+        "from": [0.0],
+        "to": [3.0],
+        "Cu_pct": [1.0],
+    })
+
+    resultado = componer_assay(df, longitud_composito=2.0)
+
+    # Ambos compósitos (0-2 y 2-4) deben tener ley 1.0,
+    # ya que todo el intervalo original tiene la misma ley
+    assert resultado["Cu_pct"].tolist() == [1.0, 1.0]
+
+
+def test_componer_assay_devuelve_dataframe_vacio_si_no_hay_datos():
+    df_vacio = pd.DataFrame(columns=["hole_id", "from", "to", "Cu_pct"])
+
+    resultado = componer_assay(df_vacio, longitud_composito=2.0)
+
+    assert resultado.empty
+
+
+# ---------- Tests: guardar_csv ----------
+
+def test_guardar_csv_crea_archivo_correctamente(tmp_path, df_valido):
+    ruta = tmp_path / "salida.csv"
+
+    guardar_csv(df_valido, str(ruta))
+
+    assert ruta.exists()
+    df_leido = pd.read_csv(ruta)
+    assert len(df_leido) == len(df_valido)