databricks-modules-vy 1.3.0__tar.gz → 1.4.0__tar.gz

{databricks_modules_vy-1.3.0 → databricks_modules_vy-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks_modules_vy
-Version: 1.3.0
+Version: 1.4.0
 Summary: Databricks modules for Vy
 Author-email: Sindre Kjetså <sindre.kjetsa@vy.no>
 Project-URL: Homepage, https://github.com/nsbno/

databricks_modules_vy-1.4.0/databricks_modules_vy/sap_rfc.py

@@ -0,0 +1,531 @@
+from __future__ import annotations
+
+import ctypes
+import glob
+import importlib
+import importlib.util
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import zipfile
+from datetime import datetime, timedelta
+
+import pandas as pd
+import pyspark.sql.functions as F
+import pyspark.sql.types as T
+from pyspark.dbutils import DBUtils
+from pyspark.sql import DataFrame, SparkSession
+
+
+from .logging import lp, utc_to_oslo
+from .unity_catalog import upsert_to_uc, write_to_uc
+
+spark = SparkSession.builder.appName("module").getOrCreate()
+dbutils = DBUtils(spark)
+
+# RFC_READ_TABLE limits
+_DELIMITER = "^"
+_MAX_ROW_WIDTH = 500  # the limit is 512 characters including delimiters
+_OPTIONS_WIDTH = 72  # max length of one OPTIONS (WHERE) line
+
+_SDK_VOLUME_SCHEMA_AND_NAME = "shared/sap_sdk"
+_WORKSPACE_CATALOGS = {
+    "3034386312914956": "dataplattform_test",
+    "3366033470006123": "dataplattform",
+}
+
+
+def _sdk_volume() -> str:
+    from dbruntime.databricks_repl_context import get_context
+
+    workspace_id = str(get_context().workspaceId)
+    catalog = _WORKSPACE_CATALOGS.get(workspace_id)
+    if not catalog:
+        raise RuntimeError(f"No SAP SDK volume configured for workspace {workspace_id}. Pass sdk_source and wheel_dir.")
+    return f"/Volumes/{catalog}/{_SDK_VOLUME_SCHEMA_AND_NAME}"
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# SAP NW RFC SDK + pyrfc
+# ----------------------------------------------------------------------------------------------------------------------
+def _find_sdk_lib(root):
+    hits = glob.glob(os.path.join(root, "**", "libsapnwrfc.so"), recursive=True)
+    return os.path.dirname(hits[0]) if hits else None
+
+
+def _copy_tree(src, dst):
+    """
+    Copies a folder with file contents only. shutil.copytree also copies permissions and timestamps, which fails
+    on volume paths (chmod/utime are not allowed there).
+    """
+    for root, _dirs, files in os.walk(src):
+        target = os.path.join(dst, os.path.relpath(root, src))
+        os.makedirs(target, exist_ok=True)
+        for f in files:
+            shutil.copyfile(os.path.join(root, f), os.path.join(target, f))
+    for root, _dirs, files in os.walk(dst):
+        os.chmod(root, 0o755)
+        for f in files:
+            os.chmod(os.path.join(root, f), 0o755)
+
+
+def _copy_sdk(sdk_source, sdk_dir):
+    """Copies (or unpacks) the NW RFC SDK to local disk and returns the lib folder."""
+    lib_dir = _find_sdk_lib(sdk_dir)
+    if lib_dir:
+        return lib_dir
+
+    if os.path.exists(sdk_dir):  # left over from a failed copy
+        shutil.rmtree(sdk_dir, ignore_errors=True)
+    try:
+        os.makedirs(sdk_dir, exist_ok=True)
+        if os.path.exists(sdk_dir) and not os.access(sdk_dir, os.W_OK):
+            raise PermissionError(sdk_dir)
+    except PermissionError:
+        sdk_dir = tempfile.mkdtemp(prefix="sapnwrfc_")
+        lp(f"Cannot write to the SDK folder, using {sdk_dir} instead")
+
+    if os.path.isdir(sdk_source):
+        lp(f"Copying SAP NW RFC SDK from {sdk_source} to {sdk_dir} ...")
+        _copy_tree(sdk_source, sdk_dir)
+    else:
+        if sdk_source.lower().endswith(".zip"):
+            with zipfile.ZipFile(sdk_source) as z:
+                z.extractall(sdk_dir)
+        elif sdk_source.lower().endswith((".tar.gz", ".tgz")):
+            with tarfile.open(sdk_source) as t:
+                t.extractall(sdk_dir)
+        else:
+            raise ValueError("sdk_source must be a folder, .zip or .tar.gz (a .SAR needs SAPCAR to unpack first)")
+
+    lib_dir = _find_sdk_lib(sdk_dir)
+    if not lib_dir:
+        raise FileNotFoundError(f"libsapnwrfc.so not found under {sdk_source}. Is it the Linux x86_64 SDK?")
+    return lib_dir
+
+
+def _install_pyrfc(home, pyrfc_spec, wheel_dir):
+    """Installs pyrfc from a prebuilt wheel in wheel_dir, builds (and saves) the wheel if there is none."""
+    wheels = sorted(glob.glob(os.path.join(wheel_dir, "pyrfc-*.whl"))) if wheel_dir else []
+    if not wheels:
+        lp(f"No pyrfc wheel found, building {pyrfc_spec} ...")
+        build_dir = "/tmp/pyrfc_wheels"
+        os.makedirs(build_dir, exist_ok=True)
+        r = subprocess.run(
+            [sys.executable, "-m", "pip", "wheel", pyrfc_spec, "--no-deps", "-w", build_dir],
+            env=dict(os.environ, SAPNWRFC_HOME=home),
+            capture_output=True,
+            text=True,
+        )
+        if r.returncode != 0:
+            raise RuntimeError(f"pyrfc wheel build failed:\n{r.stderr[-1500:]}")
+        built = sorted(glob.glob(os.path.join(build_dir, "pyrfc-*.whl")))
+        if wheel_dir:
+            os.makedirs(wheel_dir, exist_ok=True)
+            for f in built:
+                shutil.copyfile(f, os.path.join(wheel_dir, os.path.basename(f)))  # copy() also chmods, not allowed on volumes
+            wheels = sorted(glob.glob(os.path.join(wheel_dir, "pyrfc-*.whl")))
+        else:
+            wheels = built
+    lp(f"Installing {wheels[-1]}")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "--no-deps", wheels[-1]])
+    importlib.invalidate_caches()
+
+
+def _patch_rpath(lib_dir):
+    """
+    LD_LIBRARY_PATH is only read when the Python process starts, so it cannot be set from a notebook.
+    Instead the compiled pyrfc module gets an RPATH to the SDK lib folder.
+    """
+    pkg_dir = list(importlib.util.find_spec("pyrfc").submodule_search_locations)[0]
+    so_files = glob.glob(os.path.join(pkg_dir, "_cyrfc*.so"))
+    if not so_files:
+        raise FileNotFoundError(f"No compiled _cyrfc*.so in {pkg_dir}")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "patchelf"])
+    patchelf = shutil.which("patchelf") or os.path.join(os.path.dirname(sys.executable), "patchelf")
+    for so in so_files:
+        # --force-rpath: DT_RPATH (not RUNPATH) also applies to the dependencies of libsapnwrfc.so
+        subprocess.check_call([patchelf, "--force-rpath", "--set-rpath", lib_dir, so])
+        lp(f"Patched RPATH of {so}")
+
+
+def _import_connection():
+    for m in [m for m in sys.modules if m == "pyrfc" or m.startswith("pyrfc.")]:
+        del sys.modules[m]  # drop a half-imported pyrfc from an earlier failed attempt
+    importlib.invalidate_caches()
+    # pyrfc/__init__.py swallows the real error of its compiled module, so import _cyrfc directly
+    from pyrfc._cyrfc import Connection
+
+    return Connection
+
+
+def sap_setup_rfc(
+    sdk_source: str,
+    sdk_dir: str = "/tmp/sapnwrfc",
+    wheel_dir: str | None = None,
+    pyrfc_spec: str = "pyrfc==3.3.1",
+):
+    """
+    Makes the SAP NW RFC SDK and pyrfc usable on the cluster and returns the pyrfc Connection class.
+
+    The SDK is copied to local disk (/tmp), pyrfc is installed from a prebuilt wheel (built and saved the first time),
+    and the compiled pyrfc module gets an RPATH to the SDK libraries. Dedicated (single user) clusters are recommended.
+
+    Parameters:
+        sdk_source (str): The extracted nwrfcsdk folder (with lib/ and include/), or a .zip/.tar.gz of it, e.g. in a volume.
+        sdk_dir (str): Local copy of the SDK on the driver. Defaults to /tmp/sapnwrfc.
+        wheel_dir (str, optional): Folder with a prebuilt pyrfc wheel, e.g. in a volume. The wheel is saved here if missing.
+        pyrfc_spec (str, optional): What to build if there is no wheel. Defaults to pyrfc==3.3.1.
+
+    Returns:
+        The pyrfc Connection class.
+    """
+    lib_dir = _copy_sdk(sdk_source, sdk_dir)
+    home = os.path.dirname(lib_dir)
+    lp(f"SAP NW RFC SDK libs: {lib_dir}")
+
+    os.environ["SAPNWRFC_HOME"] = home
+    os.environ["LD_LIBRARY_PATH"] = lib_dir + ":" + os.environ.get("LD_LIBRARY_PATH", "")
+    for name in ["libicudata", "libicuuc", "libicui18n", "libsapucum", "libsapnwrfc"]:
+        found = sorted(glob.glob(os.path.join(lib_dir, name + ".so*")))
+        if found:
+            ctypes.CDLL(found[0], mode=ctypes.RTLD_GLOBAL)
+
+    if importlib.util.find_spec("pyrfc") is None:
+        _install_pyrfc(home, pyrfc_spec, wheel_dir)
+
+    try:
+        return _import_connection()
+    except ImportError as e:
+        lp(f"pyrfc failed to load ({e}), patching RPATH ...")
+        _patch_rpath(lib_dir)
+        return _import_connection()
+
+
+def sap_connect(
+    scope: str = "VL_SAPMRO",
+    *,
+    host: str | None = None,
+    sysnr: str | None = None,
+    client: str | None = None,
+    user: str | None = None,
+    password: str | None = None,
+    sdk_source: str | None = None,
+    sdk_dir: str = "/tmp/sapnwrfc",
+    wheel_dir: str | None = None,
+):
+    """
+    Opens an RFC connection to an SAP system.
+
+    Values that are not given are read from the Databricks secret scope VL_SAPMRO
+    with the keys: hostname, sysnr, client, username, password.
+
+    Parameters:
+        scope (str): Databricks secret scope with the SAP credentials.
+        host, sysnr, client, user, password (str, optional): Override the values from the secret scope.
+        sdk_source (str, optional): Override the SDK location. See sap_setup_rfc.
+        sdk_dir (str, optional): See sap_setup_rfc.
+        wheel_dir (str, optional): Override the wheel location. See sap_setup_rfc.
+
+    Returns:
+        A pyrfc Connection. Close it with .close() when done.
+    """
+    host = host or dbutils.secrets.get(scope, "hostname")
+    sysnr = sysnr or dbutils.secrets.get(scope, "sysnr")
+    client = client or dbutils.secrets.get(scope, "client")
+    user = user or dbutils.secrets.get(scope, "username")
+    password = password or dbutils.secrets.get(scope, "password")
+
+    if not (sdk_source and wheel_dir):
+        volume = _sdk_volume()
+        sdk_source = sdk_source or f"{volume}/nwrfcsdk"
+        wheel_dir = wheel_dir or f"{volume}/wheels"
+    Connection = sap_setup_rfc(sdk_source, sdk_dir=sdk_dir, wheel_dir=wheel_dir)
+
+    lp(f"Connecting to SAP ({host}, sysnr {sysnr}, client {client}) as {user}")
+    return Connection(ashost=host, sysnr=sysnr, client=client, user=user, passwd=password, lang="EN")
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# RFC_READ_TABLE helpers
+# ----------------------------------------------------------------------------------------------------------------------
+def _window_condition(
+    lookback_days: int | None,
+    change_dates: list[str] | None,
+    delta_period: dict | None,
+) -> str | None:
+    """
+    The delta window as a WHERE condition, or None for full reads.
+
+    delta_period: {year: LFGJA, month: LFMON, mode: current_month}   this year and month
+                  {year: LFGJA, month: LFMON, mode: lookback, days: 70}   from that month and later
+    otherwise:    change_dates >= today - lookback_days
+    """
+    today = utc_to_oslo(datetime.now()).date()
+
+    if delta_period:
+        y, m = delta_period["year"], delta_period["month"]
+        if delta_period.get("mode", "current_month") == "current_month":
+            return f"{y} = '{today:%Y}' AND {m} = '{today:%m}'"
+        cutoff = today - timedelta(days=int(delta_period["days"]))
+        return f"{y} > '{cutoff:%Y}' OR ({y} = '{cutoff:%Y}' AND {m} >= '{cutoff:%m}')"
+
+    if lookback_days and change_dates:
+        cutoff = today - timedelta(days=int(lookback_days))
+        return " OR ".join(f"{c} >= '{cutoff:%Y%m%d}'" for c in change_dates)
+
+    return None
+
+
+def _expand_in(condition: str) -> str:
+    """The dynamic WHERE parser of this SAP rejects IN ('a', 'b'). Rewrites it to (f = 'a' OR f = 'b')."""
+
+    def repl(m):
+        values = re.findall(r"'[^']*'", m.group(2))
+        return "(" + " OR ".join(f"{m.group(1)} = {v}" for v in values) + ")"
+
+    return re.sub(r"\b(\w+)\s+IN\s*\(([^)]*)\)", repl, condition)
+
+
+def _build_options(conditions: list[str | None]) -> list[dict]:
+    """
+    ANDs the conditions and splits them into RFC_READ_TABLE OPTIONS lines of max 72 characters.
+    Continuation lines start with a space because trailing spaces are trimmed in transit.
+    """
+    conds = [_expand_in(c) for c in conditions if c]
+    if len(conds) > 1:
+        conds = [f"({c})" for c in conds]
+    text = " AND ".join(conds)
+    if not text:
+        return []
+
+    lines, cur = [], ""
+    for word in text.split(" "):
+        candidate = f"{cur} {word}" if cur else word
+        if len(candidate) > _OPTIONS_WIDTH:
+            lines.append(cur)
+            cur = f" {word}"
+        else:
+            cur = candidate
+    lines.append(cur)
+    return [{"TEXT": line} for line in lines]
+
+
+def _field_lengths(conn, table: str, fields: list[str]) -> dict:
+    """Field lengths from the RFC_READ_TABLE metadata (NO_DATA). DDIF_FIELDS_GET does not exist on this SAP."""
+    r = conn.call(
+        "RFC_READ_TABLE",
+        QUERY_TABLE=table.upper(),
+        DELIMITER=_DELIMITER,
+        FIELDS=[{"FIELDNAME": f} for f in fields],
+        NO_DATA="X",
+    )
+    meta = {f["FIELDNAME"]: int(f["LENGTH"]) for f in r["FIELDS"]}
+    return {f: meta[f] for f in fields}
+
+
+def _make_groups(fields: list[str], keys: list[str], lengths: dict) -> list[list[str]]:
+    """Splits the fields into groups that fit in one RFC_READ_TABLE row. The keys are repeated in every group."""
+
+    def width(fs):
+        return sum(lengths[f] + 1 for f in fs)
+
+    if width(fields) <= _MAX_ROW_WIDTH:
+        return [fields]
+
+    groups, cur = [], list(keys)
+    for f in fields:
+        if f in keys:
+            continue
+        if width(cur + [f]) > _MAX_ROW_WIDTH:
+            groups.append(cur)
+            cur = list(keys)
+        cur.append(f)
+    groups.append(cur)
+    return groups
+
+
+def _read_rfc(conn, table: str, fields: list[str], options: list[dict], row_limit: int | None):
+    res = conn.call(
+        "RFC_READ_TABLE",
+        QUERY_TABLE=table.upper(),
+        DELIMITER=_DELIMITER,
+        FIELDS=[{"FIELDNAME": f} for f in fields],
+        OPTIONS=options,
+        ROWCOUNT=row_limit or 0,
+    )
+    rows, bad = [], 0
+    for r in res["DATA"]:
+        parts = r["WA"].split(_DELIMITER)
+        if len(parts) != len(fields):  # e.g. a value that contains the delimiter
+            bad += 1
+            continue
+        rows.append(parts)
+    return pd.DataFrame(rows, columns=fields, dtype=str), bad
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Public functions
+# ----------------------------------------------------------------------------------------------------------------------
+def sap_table(
+    conn,
+    table: str,
+    *,
+    fields: list[str],
+    keys: list[str],
+    where: str | None = None,
+    lookback_days: int | None = None,
+    change_dates: list[str] | None = None,
+    delta_period: dict | None = None,
+    outputs: list[dict | str] | None = None,
+    row_limit: int | None = None,
+    clean: bool = True,
+) -> DataFrame | None:
+    """
+    Reads a SAP table with RFC_READ_TABLE and returns it as a Spark DataFrame with all columns as string
+    (dates as YYYYMMDD, 00000000 = unset), like the SnapLogic landing files.
+
+    Wide tables are read in several field groups (max 512 characters per row) and joined on the keys.
+
+    Parameters:
+        conn: pyrfc Connection from sap_connect.
+        table (str): SAP table name, e.g. 'caufv'.
+        fields (list): Columns to read.
+        keys (list): Key columns. Must be in fields. Used to join field groups.
+        where (str, optional): Static filter, ANDed with the delta window.
+        lookback_days (int, optional): Delta window in days. Without it (and without delta_period) the table is read in full.
+        change_dates (list, optional): Date columns the window is applied to, OR'ed.
+        delta_period (dict, optional): Posting period window, see _window_condition.
+        outputs (list, optional): One query per entry (extra WHERE), all results are appended.
+            Entries are strings or dicts with the key 'where'.
+        row_limit (int, optional): Max rows per query, for testing. Defaults to no limit.
+        clean (bool, optional): Trim strings and convert empty strings to null. Defaults to True.
+
+    Returns:
+        A Spark DataFrame, or None if no rows were returned (nothing should be written then, same as SnapLogic).
+    """
+    missing = set(keys) - set(fields)
+    if missing:
+        raise ValueError(f"{table}: keys not in fields: {sorted(missing)}")
+
+    groups = _make_groups(fields, keys, _field_lengths(conn, table, fields))
+    window = _window_condition(lookback_days, change_dates, delta_period)
+    lp(f"{table}: {len(groups)} field group(s), window: {window}")
+
+    frames = []
+    for output in outputs or [None]:
+        output_where = output.get("where") if isinstance(output, dict) else output
+        options = _build_options([where, window, output_where])
+        lp(f"{table}: WHERE {' '.join(o['TEXT'] for o in options) or '(none)'}")
+
+        parts = []
+        for g in groups:
+            pdf, bad = _read_rfc(conn, table, g, options, row_limit)
+            lp(f"{table}: {len(pdf)} rows, {len(g)} fields" + (f", {bad} bad rows skipped" if bad else ""))
+            parts.append(pdf)
+
+        merged = parts[0]
+        for p in parts[1:]:
+            merged = merged.merge(p, on=keys, how="inner")
+        if len(parts) > 1 and len(merged) < min(len(p) for p in parts):
+            lp(f"{table}: WARNING rows lost when joining field groups (row_limit gives different rows per group)")
+        frames.append(merged[fields])
+
+    pdf = pd.concat(frames, ignore_index=True)
+    if pdf.empty:
+        return None
+
+    schema = T.StructType([T.StructField(c, T.StringType(), True) for c in pdf.columns])
+    df = spark.createDataFrame(pdf, schema=schema)
+    if clean:
+        for c in df.columns:
+            df = df.withColumn(c, F.when(F.trim(F.col(c)) == "", None).otherwise(F.trim(F.col(c))))
+    return df
+
+
+def sap_tables_to_uc(
+    conn,
+    tables: dict[str, dict],
+    target_schema: str,
+    *,
+    table_prefix: str = "",
+    mode: str = "auto",
+    only: list[str] | None = None,
+    row_limit: int | None = None,
+    lookback_override: int | None = None,
+    raise_on_error: bool = True,
+    vacuum: bool = True,
+) -> list[dict]:
+    """
+    Extracts several SAP tables and writes each one to <target_schema>.<table_prefix><table> in Unity Catalog.
+
+    Parameters:
+        conn: pyrfc Connection from sap_connect.
+        tables (dict): table name -> spec, same format as tables.yml:
+            keys, fields, load (full|delta), where, lookback_days, change_dates, delta_period, outputs.
+        target_schema (str): catalog.schema to write to.
+        table_prefix (str, optional): Prefix for the target table names. Defaults to ''.
+        mode (str, optional): 'auto' = upsert delta tables and overwrite full tables, 'write' = overwrite everything.
+        only (list, optional): Only run these tables from `tables`.
+        row_limit (int, optional): Max rows per query, for testing.
+        lookback_override (int, optional): Replace lookback_days for all tables, e.g. 2 for a quick test.
+        raise_on_error (bool, optional): Run all tables, then raise if any failed. Defaults to True.
+        vacuum (bool, optional): Whether to vacuum after writing. Defaults to True.
+
+    Returns:
+        A list with one dict per table: table, status (ok | no rows | failed), rows, target, error.
+    """
+    if mode not in ("auto", "write"):
+        raise ValueError("mode must be 'auto' or 'write'")
+    unknown = [t for t in (only or []) if t not in tables]
+    if unknown:
+        raise ValueError(f"Not in tables: {unknown}")
+
+    results = []
+    for name, spec in tables.items():
+        if only and name not in only:
+            continue
+        target = f"{target_schema}.{table_prefix}{name}"
+        lp(f"== {name} ({spec.get('load', 'full')})")
+        try:
+            df = sap_table(
+                conn,
+                name,
+                fields=spec["fields"],
+                keys=spec["keys"],
+                where=spec.get("where"),
+                lookback_days=lookback_override or spec.get("lookback_days"),
+                change_dates=spec.get("change_dates"),
+                delta_period=spec.get("delta_period"),
+                outputs=spec.get("outputs"),
+                row_limit=row_limit,
+            )
+            if df is None:
+                lp(f"{name}: no rows, nothing written")
+                results.append({"table": name, "status": "no rows", "rows": 0, "target": None, "error": None})
+                continue
+
+            rows = df.count()
+            description = f"SAP MRO {name.upper()} via RFC_READ_TABLE"
+            if mode == "auto" and spec.get("load") == "delta":
+                upsert_to_uc(df, target=target, upsert_keys=spec["keys"], table_description=description, vacuum=vacuum)
+            else:
+                write_to_uc(df, target=target, overwrite_schema=True, table_description=description, vacuum=vacuum)
+
+            results.append({"table": name, "status": "ok", "rows": rows, "target": target, "error": None})
+        except Exception as e:
+            lp(f"{name}: FAILED {e}")
+            results.append({"table": name, "status": "failed", "rows": 0, "target": None, "error": str(e)})
+
+    lp("Summary")
+    for r in results:
+        lp(f"  {r['table']:10} {r['status']:8} {r['rows']:>9} {r['target'] or ''}")
+
+    failed = [r["table"] for r in results if r["status"] == "failed"]
+    if failed and raise_on_error:
+        raise Exception(f"SAP extract failed for: {failed}")
+    return results

{databricks_modules_vy-1.3.0 → databricks_modules_vy-1.4.0}/databricks_modules_vy/sharepoint.py

@@ -70,13 +70,16 @@ def _execute_query_with_backoff(
 
 
 def df_from_sharepoint_masterdata(
-    list_name, row_limit=5000, site_name="VyMasterdata", internal_name=True
+    list_name, row_limit=5000, site_name="VyMasterdata", internal_name=True, get_by_id=False
 ) -> DataFrame:
     # Connect and fetch data
     ctx = _get_sharepoint_ctx(site_name)
 
     # Get the list and metadata
-    s_list = ctx.web.lists.get_by_title(list_name)
+    if get_by_id:
+        s_list = ctx.web.lists.get_by_id(list_name)
+    else:
+        s_list = ctx.web.lists.get_by_title(list_name)
     s_list_fields = s_list.fields
     ctx.load(s_list_fields)
     _execute_query_with_backoff(ctx)

{databricks_modules_vy-1.3.0 → databricks_modules_vy-1.4.0}/databricks_modules_vy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks_modules_vy
-Version: 1.3.0
+Version: 1.4.0
 Summary: Databricks modules for Vy
 Author-email: Sindre Kjetså <sindre.kjetsa@vy.no>
 Project-URL: Homepage, https://github.com/nsbno/

{databricks_modules_vy-1.3.0 → databricks_modules_vy-1.4.0}/databricks_modules_vy.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ databricks_modules_vy/logging.py
 databricks_modules_vy/oracle.py
 databricks_modules_vy/qlik.py
 databricks_modules_vy/s3.py
+databricks_modules_vy/sap_rfc.py
 databricks_modules_vy/service_platform.py
 databricks_modules_vy/sharepoint.py
 databricks_modules_vy/snaplogic.py

{databricks_modules_vy-1.3.0 → databricks_modules_vy-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "databricks_modules_vy"
-version = "1.3.0"
+version = "1.4.0"
 authors = [
   { name="Sindre Kjetså", email="sindre.kjetsa@vy.no" },
 ]