gss-bi-udfs 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

gss_bi_udfs/io.py

@@ -1,5 +1,48 @@
+from pathlib import Path
+from datetime import datetime
 from .utils import get_env, get_table_info
 
+
+class _LocalFileInfo:
+    # univamentemente para uso de la libreria en entornos locales
+    def __init__(self, path: str):
+        self.path = path
+        p = Path(path)
+        self.name = p.name
+        self.size = p.stat().st_size if p.exists() else 0
+        self.modificationTime = int(p.stat().st_mtime * 1000) if p.exists() else 0
+
+    def isFile(self) -> bool:
+        return Path(self.path).is_file()
+
+    def __repr__(self) -> str:
+        return (
+            "FileInfo("
+            f"path='{self.path}', "
+            f"name='{self.name}', "
+            f"size={self.size}, "
+            f"modificationTime={self.modificationTime}"
+            ")"
+        )
+
+def _normalize_path(path):
+    if path.startswith("dbfs:"):
+        return path.replace("dbfs:", "", 1)
+    return path
+
+
+def _ls_path(base_path):
+    try:
+        # Databricks runtime provides dbutils in globals.
+        files = dbutils.fs.ls(base_path)  # type: ignore
+        return files
+    except Exception:
+        local_path = _normalize_path(base_path)
+        p = Path(local_path)
+        if not p.exists():
+            return []
+        return [_LocalFileInfo(str(child)) for child in p.iterdir()]
+
 # def load_latest_file_bronze(spark, data_base, schema, table, env=None):
 def load_latest_parquet(spark, data_base, schema, table, env=None):
     """
@@ -18,9 +61,10 @@ def load_latest_parquet(spark, data_base, schema, table, env=None):
     """
     env = env or get_env()
     base_path = f"/Volumes/bronze/{data_base}_{schema}/{env}/{table}/"
+    print("Ruta base:", base_path)
 
     try:
-        files = dbutils.fs.ls(base_path) # type: ignore
+        files = _ls_path(base_path)
 
         parquet_files = [f for f in files if table in f.name]
         
@@ -178,7 +222,7 @@ def load_latest_excel(spark, source_file, env=None):
     print("Ruta base:", base_path)
     
     try:
-        files = dbutils.fs.ls(base_path) # type: ignore
+        files = _ls_path(base_path)
         print("Archivos encontrados:", [f.name for f in files])     
         excel_candidates = [f for f in files if f.isFile()]
 
@@ -330,12 +374,13 @@ def load_and_materialize_views(action, **kwargs):
     return results
 
 
-def save_table_to_delta(df, catalog, schema, table_name):
+def save_table_to_delta(spark, df, catalog, schema, table_name):
     """
     Guarda un DataFrame en formato Delta en la ubicación y tabla especificadas,
     sobrescribiendo los datos existentes y el esquema si es necesario.
 
     Parámetros:
+      spark (SparkSession): Sesión activa de Spark.
       df (DataFrame): DataFrame de Spark que se desea guardar.
       db_name (str): Nombre del catálogo o base de datos destino.
       schema (str): Nombre del esquema, capa o entorno destino (ejemplo: 'silver', 'gold').
@@ -363,7 +408,7 @@ def save_table_to_delta(df, catalog, schema, table_name):
       - Si ambas opciones se usan al mismo tiempo, solo una tendrá efecto (se aplicará la última indicada).
 
     """
-    dim_destino = get_table_info(catalog=catalog, schema=schema, table=table_name)
+    dim_destino = get_table_info(spark=spark, catalog=catalog, schema=schema, table=table_name)
     (
         df.write
         .format("delta")

{gss_bi_udfs-0.1.1.dist-info → gss_bi_udfs-0.1.3.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: gss-bi-udfs
-Version: 0.1.1
+Version: 0.1.3
 Summary: Utilidades reutilizables para Spark y Delta Lake en arquitecturas Lakehouse.
 Author: Geronimo Forconi
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: pyspark>=3.0.0
 
 # gss-bi-udfs
 

gss_bi_udfs-0.1.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+gss_bi_udfs/__init__.py,sha256=VNj2_l7MHiRGF497XVM4KtU7p6JOX1xddkvFJLG1vUQ,152
+gss_bi_udfs/io.py,sha256=yneOHVcHbcSOuAy02jS3_qm7YXGyeDpXFk9e-5VJ36A,17246
+gss_bi_udfs/merges.py,sha256=4YHfw6TWU08ZWEMKBtFlMqj_tzXzjqkuM_CJn0uRNUI,7977
+gss_bi_udfs/transforms.py,sha256=yDg7uvPFSTrGXgy5rOUKDdSrRBBZSubfi9K-6rATCWY,1876
+gss_bi_udfs/utils.py,sha256=ryyqrzhybC6mZFTUWsnnrQXReUcLkVqw6e2gIf4Id_g,5982
+scripts/run_tests.py,sha256=6yG35rkURojbHmEnLKkPnHSn5bmViP7yJwng5hXj9xs,4407
+tests/test_io.py,sha256=oFTJK6UZJXec53lPoArWSHKPRpNGbhI8ZVb1ZjfXW8U,4847
+tests/test_merges.py,sha256=_PHYRU0DwRn5Vg05clz8jL7_d8QutWiiTACHLiNPrZo,2221
+tests/test_transforms.py,sha256=4fqKyemSV-4nfMzhTamaE5mWXnglV08uvw67sWj84Og,2206
+tests/test_utils.py,sha256=FUap5pqqEDvmBmBLeSBN39FoQDQSz3hpN4qCQrUniEU,4541
+workspace/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workspace/prueba.py,sha256=n-zGeMhFRrMLp9cx-vvJYTSFMZHCYm_R-xmGiQvj1Fk,223
+workspace/prueba_calculadora.py,sha256=4pu4Wg-h_aALbqDsfSeJlPbyx9FpODIbHGNAse5Mz5M,512
+workspace/tests/test_prueba_calculadora.py,sha256=9cHXunht_EVwBgBELv5YlazkJMWSi97A5VnB9Mvs-kU,257
+gss_bi_udfs-0.1.3.dist-info/METADATA,sha256=u4tbdf_peTRGGTMzIMlsle_BRrQ56uTPEHs63GmfFm8,393
+gss_bi_udfs-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gss_bi_udfs-0.1.3.dist-info/top_level.txt,sha256=NzlGPsUajFQDfmDbDhTCgu4LBvrm0d1shuPSJIBpLfw,36
+gss_bi_udfs-0.1.3.dist-info/RECORD,,

{gss_bi_udfs-0.1.1.dist-info → gss_bi_udfs-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gss_bi_udfs-0.1.3.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+gss_bi_udfs
+scripts
+tests
+workspace

scripts/run_tests.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import html
+import os
+import sys
+import unittest
+
+
+class _CollectingTextTestResult(unittest.TextTestResult):
+    def __init__(self, stream, descriptions, verbosity):
+        super().__init__(stream, descriptions, verbosity)
+        self.successes = []
+
+    def addSuccess(self, test):
+        super().addSuccess(test)
+        self.successes.append(test)
+
+
+def _run_tests(start_dir: str, pattern: str, verbosity: int) -> unittest.TestResult:
+    suite = unittest.defaultTestLoader.discover(start_dir=start_dir, pattern=pattern)
+    runner = unittest.TextTestRunner(verbosity=verbosity, resultclass=_CollectingTextTestResult)
+    return runner.run(suite)
+
+
+def _timestamped_path(path: str) -> str:
+    ts = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
+    base, ext = os.path.splitext(path)
+    if ext:
+        return f"{base}_{ts}{ext}"
+    return f"{path}_{ts}"
+
+
+def _render_html(result: unittest.TestResult, output_path: str) -> None:
+    rows = []
+    for test in getattr(result, "successes", []):
+        rows.append(("PASS", str(test), ""))
+
+    for test, tb in result.failures + result.errors:
+        rows.append(
+            (
+                "FAIL" if (test, tb) in result.failures else "ERROR",
+                str(test),
+                tb,
+            )
+        )
+
+    for test, reason in result.skipped:
+        rows.append(("SKIP", str(test), reason))
+
+    status = "PASSED" if result.wasSuccessful() else "FAILED"
+    now = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    html_body = [
+        "<!doctype html>",
+        "<html lang='en'>",
+        "<head>",
+        "  <meta charset='utf-8'/>",
+        "  <title>Unit Test Report</title>",
+        "  <style>",
+        "    body { font-family: Arial, sans-serif; margin: 24px; }",
+        "    .ok { color: #0f5132; }",
+        "    .bad { color: #842029; }",
+        "    table { border-collapse: collapse; width: 100%; margin-top: 16px; }",
+        "    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: top; }",
+        "    th { background: #f5f5f5; }",
+        "    pre { white-space: pre-wrap; margin: 0; }",
+        "  </style>",
+        "</head>",
+        "<body>",
+        f"  <h1>Unit Test Report</h1>",
+        f"  <p><strong>Generated:</strong> {html.escape(now)}</p>",
+        f"  <p><strong>Status:</strong> <span class='{'ok' if result.wasSuccessful() else 'bad'}'>{status}</span></p>",
+        f"  <p><strong>Ran:</strong> {result.testsRun} tests</p>",
+        f"  <p><strong>Pass:</strong> {len(getattr(result, 'successes', []))} | <strong>Failures:</strong> {len(result.failures)} | <strong>Errors:</strong> {len(result.errors)} | <strong>Skipped:</strong> {len(result.skipped)}</p>",
+        "  <table>",
+        "    <thead><tr><th>Type</th><th>Test</th><th>Details</th></tr></thead>",
+        "    <tbody>",
+    ]
+
+    if rows:
+        for row_type, test_name, details in rows:
+            html_body.append(
+                "      <tr>"
+                f"<td>{html.escape(row_type)}</td>"
+                f"<td>{html.escape(test_name)}</td>"
+                f"<td><pre>{html.escape(details)}</pre></td>"
+                "</tr>"
+            )
+    else:
+        html_body.append("      <tr><td colspan='3'>No failures, errors or skipped tests.</td></tr>")
+
+    html_body += [
+        "    </tbody>",
+        "  </table>",
+        "</body>",
+        "</html>",
+    ]
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(html_body))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run unittests and optionally write HTML report.")
+    parser.add_argument("--start-dir", default="tests")
+    parser.add_argument("--pattern", default="test*.py")
+    parser.add_argument("--verbosity", type=int, default=2)
+    parser.add_argument("--html", default="")
+    parser.add_argument("--timestamped", action="store_true")
+    args = parser.parse_args()
+
+    result = _run_tests(args.start_dir, args.pattern, args.verbosity)
+
+    if args.html:
+        output_path = _timestamped_path(args.html) if args.timestamped else args.html
+        _render_html(result, output_path)
+        print(f"HTML report written to: {output_path}")
+
+    return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tests/test_io.py

@@ -0,0 +1,128 @@
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import io
+
+
+class TestIO(unittest.TestCase):
+    def test_normalize_path(self):
+        self.assertEqual(io._normalize_path("dbfs:/tmp/a.parquet"), "/tmp/a.parquet")
+        self.assertEqual(io._normalize_path("/tmp/a.parquet"), "/tmp/a.parquet")
+
+    def test_ls_path_local(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "file.txt"
+            file_path.write_text("x", encoding="utf-8")
+            (Path(tmpdir) / "folder").mkdir()
+
+            files = io._ls_path(tmpdir)
+            names = sorted([f.name for f in files])
+            self.assertEqual(names, ["file.txt", "folder"])
+
+        self.assertEqual(io._ls_path("/path/that/does/not/exist"), [])
+
+    @patch("gss_bi_udfs.io._ls_path")
+    def test_load_latest_parquet_returns_latest_match(self, mock_ls_path):
+        mock_ls_path.return_value = [
+            SimpleNamespace(name="clientes_20240101.parquet", path="/tmp/1"),
+            SimpleNamespace(name="clientes_20240102.parquet", path="/tmp/2"),
+            SimpleNamespace(name="otra_tabla_20240103.parquet", path="/tmp/3"),
+        ]
+        spark = MagicMock()
+        expected_df = object()
+        spark.read.parquet.return_value = expected_df
+
+        out = io.load_latest_parquet(spark, "db", "sch", "clientes", env="dev")
+
+        self.assertIs(out, expected_df)
+        spark.read.parquet.assert_called_once_with("/tmp/2")
+
+    @patch("gss_bi_udfs.io._ls_path")
+    def test_load_latest_parquet_returns_none_without_matches(self, mock_ls_path):
+        mock_ls_path.return_value = [SimpleNamespace(name="x.parquet", path="/tmp/x")]
+        spark = MagicMock()
+
+        out = io.load_latest_parquet(spark, "db", "sch", "clientes", env="dev")
+
+        self.assertIsNone(out)
+        spark.read.parquet.assert_not_called()
+
+    @patch("gss_bi_udfs.io.load_latest_parquet")
+    def test_return_parquets_and_register_temp_views(self, mock_load_latest):
+        df = MagicMock()
+        mock_load_latest.return_value = df
+        spark = MagicMock()
+        tables_load = {
+            "db1": {
+                "sch1": [
+                    {"table": "t1", "view": "vw_t1"},
+                    {"table": "t2", "view": "vw_t2"},
+                ]
+            }
+        }
+
+        out = io.return_parquets_and_register_temp_views(spark, tables_load, env="dev")
+
+        self.assertEqual(set(out.keys()), {"db1.sch1.t1", "db1.sch1.t2"})
+        self.assertEqual(mock_load_latest.call_count, 2)
+        self.assertEqual(df.createOrReplaceTempView.call_count, 2)
+
+    @patch("gss_bi_udfs.io.load_latest_parquet")
+    def test_parquets_register_temp_views(self, mock_load_latest):
+        df = MagicMock()
+        mock_load_latest.return_value = df
+        spark = MagicMock()
+        tables_load = {"db1": {"sch1": [{"table": "t1", "view": "vw_t1"}]}}
+
+        io.parquets_register_temp_views(spark, tables_load, env="dev")
+
+        df.createOrReplaceTempView.assert_called_once_with("vw_t1")
+
+    @patch("gss_bi_udfs.io._ls_path")
+    @patch("pandas.read_excel")
+    def test_load_latest_excel(self, mock_read_excel, mock_ls_path):
+        mock_ls_path.return_value = [
+            SimpleNamespace(name="a_old", path="dbfs:/tmp/a_old", isFile=lambda: True),
+            SimpleNamespace(name="b_new", path="dbfs:/tmp/b_new", isFile=lambda: True),
+        ]
+        mock_pdf = object()
+        mock_read_excel.return_value = mock_pdf
+        spark = MagicMock()
+        expected_df = object()
+        spark.createDataFrame.return_value = expected_df
+
+        out = io.load_latest_excel(spark, "dom/sub/file", env="dev")
+
+        self.assertIs(out, expected_df)
+        mock_read_excel.assert_called_once_with("/tmp/b_new", header=0, engine="xlrd")
+        spark.createDataFrame.assert_called_once_with(mock_pdf)
+
+    def test_load_and_materialize_views_unknown_action(self):
+        out = io.load_and_materialize_views("accion_inexistente")
+        self.assertEqual(out, {})
+
+    @patch("gss_bi_udfs.io.get_table_info")
+    def test_save_table_to_delta_writes_delta(self, mock_get_table_info):
+        mock_get_table_info.return_value = {
+            "path": "/tmp/tbl",
+            "full_table_name": "cat.sch.tbl",
+        }
+        df = MagicMock()
+        writer = MagicMock()
+        writer.format.return_value = writer
+        writer.option.return_value = writer
+        writer.mode.return_value = writer
+        df.write = writer
+
+        io.save_table_to_delta(df, "cat", "sch", "tbl")
+
+        writer.format.assert_called_once_with("delta")
+        writer.mode.assert_called_once_with("overwrite")
+        writer.saveAsTable.assert_called_once_with("cat.sch.tbl")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_merges.py

@@ -0,0 +1,65 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import merges
+
+
+class TestMerges(unittest.TestCase):
+    def test_merge_scd2_raises_if_business_key_is_missing(self):
+        spark = MagicMock()
+        df_dim_src = MagicMock()
+        df_dim_src.columns = ["id", "descripcion"]
+
+        with self.assertRaises(ValueError):
+            merges.merge_scd2(
+                spark=spark,
+                df_dim_src=df_dim_src,
+                table_name="cat.sch.dim",
+                business_keys="codigo_negocio",
+                surrogate_key="sk_dim",
+            )
+
+    @patch("gss_bi_udfs.merges.save_table_to_delta")
+    @patch("gss_bi_udfs.merges.add_hashid")
+    @patch("gss_bi_udfs.merges.get_table_info")
+    def test_merge_scd2_full_load_path(self, mock_get_table_info, mock_add_hashid, mock_save_table):
+        spark = MagicMock()
+        spark.catalog.tableExists.return_value = False
+        mock_get_table_info.return_value = {
+            "catalog": "cat_dev",
+            "schema": "sch",
+            "table": "dim_cliente",
+            "full_table_name": "cat_dev.sch.dim_cliente",
+        }
+
+        df_dim_src = MagicMock()
+        df_dim_src.columns = ["codigo_negocio", "descripcion"]
+        df_dim_src.withColumn.return_value = df_dim_src
+
+        df_hashed = MagicMock()
+        writer = MagicMock()
+        writer.format.return_value = writer
+        writer.mode.return_value = writer
+        writer.option.return_value = writer
+        df_hashed.write = writer
+        mock_add_hashid.return_value = df_hashed
+
+        merges.merge_scd2(
+            spark=spark,
+            df_dim_src=df_dim_src,
+            table_name="cat.sch.dim_cliente",
+            business_keys="codigo_negocio",
+            surrogate_key="sk_dim_cliente",
+        )
+
+        mock_add_hashid.assert_called_once()
+        add_hashid_args = mock_add_hashid.call_args.args
+        self.assertEqual(add_hashid_args[1], ["codigo_negocio", "valid_from"])
+        self.assertEqual(add_hashid_args[2], "sk_dim_cliente")
+
+        self.assertEqual(mock_save_table.call_count, 1)
+        writer.saveAsTable.assert_called_once_with("cat.sch.dim_cliente")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_transforms.py

@@ -0,0 +1,66 @@
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import transforms
+
+
+class _FakeCol:
+    def __init__(self, name):
+        self.name = name
+
+    def cast(self, dtype):
+        return f"{self.name}:{dtype}"
+
+
+class TestTransforms(unittest.TestCase):
+    def test_add_hashid_raises_when_columns_empty(self):
+        with self.assertRaises(ValueError):
+            transforms.add_hashid(MagicMock(), [])
+
+    @patch("gss_bi_udfs.transforms.xxhash64")
+    @patch("gss_bi_udfs.transforms.concat_ws")
+    @patch("gss_bi_udfs.transforms.col")
+    def test_add_hashid_builds_hash_and_reorders_columns(self, mock_col, mock_concat_ws, mock_xxhash64):
+        mock_col.side_effect = lambda name: _FakeCol(name)
+        mock_concat_ws.return_value = "concat_expr"
+        mock_xxhash64.return_value = "hash_expr"
+
+        df = MagicMock()
+        df.columns = ["id", "name"]
+        df_with_hash = MagicMock()
+        df.withColumn.return_value = df_with_hash
+        df_with_hash.select.return_value = "result_df"
+
+        out = transforms.add_hashid(df, ["id", "name"], "hash_pk")
+
+        self.assertEqual(out, "result_df")
+        df.withColumn.assert_called_once_with("hash_pk", "hash_expr")
+        df_with_hash.select.assert_called_once_with("hash_pk", "id", "name")
+
+    @patch("gss_bi_udfs.transforms.get_default_value_by_type")
+    def test_get_default_record_builds_single_row_with_schema_defaults(self, mock_defaults):
+        mock_defaults.side_effect = lambda dtype: f"default_for_{dtype}"
+        spark = MagicMock()
+        expected = object()
+        spark.createDataFrame.return_value = expected
+
+        df = MagicMock()
+        df.schema = SimpleNamespace(
+            fields=[
+                SimpleNamespace(name="id", dataType="int"),
+                SimpleNamespace(name="desc", dataType="string"),
+            ]
+        )
+
+        out = transforms.get_default_record(spark, df)
+
+        self.assertIs(out, expected)
+        spark.createDataFrame.assert_called_once_with(
+            [{"id": "default_for_int", "desc": "default_for_string"}],
+            schema=df.schema,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_utils.py

@@ -0,0 +1,119 @@
+import os
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from pyspark.sql.types import (
+    BooleanType,
+    DateType,
+    DecimalType,
+    DoubleType,
+    FloatType,
+    IntegerType,
+    LongType,
+    StringType,
+    TimestampType,
+)
+
+from gss_bi_udfs import utils
+
+
+class TestUtils(unittest.TestCase):
+    def test_get_env_uses_default_and_env_var(self):
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertEqual(utils.get_env(), "dev")
+            self.assertEqual(utils.get_env(default="qa"), "qa")
+
+        with patch.dict(os.environ, {"ENV": "prod"}, clear=True):
+            self.assertEqual(utils.get_env(), "prod")
+
+    def test_get_env_catalog(self):
+        with patch.dict(os.environ, {"ENV": "pro"}, clear=True):
+            self.assertEqual(utils.get_env_catalog("fi_comunes"), "fi_comunes")
+        with patch.dict(os.environ, {"ENV": "dev"}, clear=True):
+            self.assertEqual(utils.get_env_catalog("fi_comunes"), "fi_comunes_dev")
+
+    def test_get_env_table_path(self):
+        with patch("gss_bi_udfs.utils.get_env_catalog", return_value="cat_dev"):
+            self.assertEqual(
+                utils.get_env_table_path("cat", "silver.dim_cliente"),
+                "cat_dev.silver.dim_cliente",
+            )
+
+    @patch("gss_bi_udfs.utils.get_env_catalog", return_value="cat_dev")
+    def test_get_schema_root_location(self, _mock_catalog):
+        spark = MagicMock()
+        df = MagicMock()
+        df.filter.return_value = df
+        df.select.return_value = df
+        df.collect.return_value = [["s3://bucket/root"]]
+        spark.sql.return_value = df
+
+        out = utils.get_schema_root_location(spark, "cat", "silver")
+
+        self.assertEqual(out, "s3://bucket/root")
+        spark.sql.assert_called_once_with("DESCRIBE SCHEMA EXTENDED cat_dev.silver")
+
+    def test_get_table_info_validations(self):
+        spark = MagicMock()
+        with self.assertRaises(ValueError):
+            utils.get_table_info(spark, full_table_name="solo.dos")
+        with self.assertRaises(ValueError):
+            utils.get_table_info(spark)
+
+    @patch("gss_bi_udfs.utils.get_schema_root_location", return_value="s3://bucket/root/silver")
+    @patch("gss_bi_udfs.utils.get_env_catalog", return_value="cat_dev")
+    def test_get_table_info_when_table_does_not_exist(self, _mock_env_catalog, _mock_root):
+        spark = MagicMock()
+        spark.catalog.tableExists.return_value = False
+
+        info = utils.get_table_info(spark, full_table_name="cat.silver.dim_cliente")
+
+        self.assertEqual(info["catalog"], "cat_dev")
+        self.assertEqual(info["schema"], "silver")
+        self.assertEqual(info["table"], "dim_cliente")
+        self.assertEqual(info["full_table_name"], "cat_dev.silver.dim_cliente")
+        self.assertEqual(info["path"], "s3://bucket/root/silver/dim_cliente")
+        self.assertFalse(info["exists"])
+
+    @patch("gss_bi_udfs.utils.get_schema_root_location", return_value="s3://bucket/root/silver")
+    @patch("gss_bi_udfs.utils.get_env_catalog", return_value="cat_dev")
+    def test_get_table_info_when_table_exists(self, _mock_env_catalog, _mock_root):
+        spark = MagicMock()
+        spark.catalog.tableExists.return_value = True
+        desc_df = MagicMock()
+        desc_df.filter.return_value = desc_df
+        desc_df.collect.return_value = [
+            SimpleNamespace(col_name="Location", data_type="s3://bucket/real/location"),
+            SimpleNamespace(col_name="Provider", data_type="delta"),
+            SimpleNamespace(col_name="Type", data_type="MANAGED"),
+        ]
+        spark.sql.return_value = desc_df
+
+        info = utils.get_table_info(spark, full_table_name="cat.silver.dim_cliente")
+
+        self.assertTrue(info["exists"])
+        self.assertEqual(info["path"], "s3://bucket/real/location")
+        self.assertEqual(info["provider"], "delta")
+        self.assertEqual(info["table_type"], "MANAGED")
+
+    def test_get_default_value_by_type_returns_column(self):
+        dtypes = [
+            IntegerType(),
+            LongType(),
+            DecimalType(10, 2),
+            DoubleType(),
+            FloatType(),
+            DateType(),
+            TimestampType(),
+            BooleanType(),
+            StringType(),
+        ]
+        for dtype in dtypes:
+            with self.subTest(dtype=dtype):
+                out = utils.get_default_value_by_type(dtype)
+                self.assertEqual(out.__class__.__name__, "Column")
+
+
+if __name__ == "__main__":
+    unittest.main()

workspace/prueba.py

@@ -0,0 +1,10 @@
+from pyspark.sql import SparkSession
+
+spark = SparkSession.getActiveSession()
+if spark is None:
+    spark = SparkSession.builder.appName("MiApp").getOrCreate()
+
+df = spark.range(1000 * 1000)
+print(df.count())
+
+spark.stop()

workspace/prueba_calculadora.py

@@ -0,0 +1,20 @@
+class Calculadora:
+    """Clase calculadora con operaciones básicas"""
+    
+    def sumar(self, a, b):
+        """Suma dos números"""
+        return a + b
+    
+    def restar(self, a, b):
+        """Resta dos números"""
+        return a - b
+    
+    def multiplicar(self, a, b):
+        """Multiplica dos números"""
+        return a * b
+    
+    def dividir(self, a, b):
+        """Divide dos números"""
+        if b == 0:
+            raise ValueError("No se puede dividir entre cero")
+        return a / b

workspace/tests/test_prueba_calculadora.py

@@ -0,0 +1,14 @@
+import pytest
+import sys
+sys.path.append("/workspace")
+
+from .prueba_calculadora import sumar, restar
+
+def test_sumar():
+    assert sumar(2, 3) == 5
+
+def test_restar():
+    assert restar(5, 3) == 2
+
+def test_sumar_negativos():
+    assert sumar(-1, -2) == -3

gss_bi_udfs-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-gss_bi_udfs/__init__.py,sha256=VNj2_l7MHiRGF497XVM4KtU7p6JOX1xddkvFJLG1vUQ,152
-gss_bi_udfs/io.py,sha256=yEqQvpyBod9kIv7p-_5yLtINuIwsi-piWy5rKI3BgQk,15939
-gss_bi_udfs/merges.py,sha256=4YHfw6TWU08ZWEMKBtFlMqj_tzXzjqkuM_CJn0uRNUI,7977
-gss_bi_udfs/transforms.py,sha256=yDg7uvPFSTrGXgy5rOUKDdSrRBBZSubfi9K-6rATCWY,1876
-gss_bi_udfs/utils.py,sha256=ryyqrzhybC6mZFTUWsnnrQXReUcLkVqw6e2gIf4Id_g,5982
-gss_bi_udfs-0.1.1.dist-info/METADATA,sha256=q241xBvvuhhJRUL1wIGB_JKCkTxXAF9HY13yYjV3Ae8,423
-gss_bi_udfs-0.1.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-gss_bi_udfs-0.1.1.dist-info/top_level.txt,sha256=jLjGHQoep6-wLbW6wFV611Zx4ak42Q9hKtH_3sUzX9o,12
-gss_bi_udfs-0.1.1.dist-info/RECORD,,

gss_bi_udfs-0.1.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-gss_bi_udfs