csvpath 0.0.532__tar.gz → 0.0.533__tar.gz

{csvpath-0.0.532 → csvpath-0.0.533}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.532
+Version: 0.0.533
 Summary: A data preboarding framework for managing and validating CSV, Excel, and other tabular data files using a Collect, Store, Validate, Publish pattern to create a trusted publisher for downstream data consumers.
 Author: David Kershaw
 Author-email: dk107dk@hotmail.com
@@ -25,6 +25,7 @@ Requires-Dist: azure-storage-blob (>=12.24.1,<13.0.0)
 Requires-Dist: boto3 (>=1.35.91,<2.0.0)
 Requires-Dist: ckanapi (>=4.8,<5.0)
 Requires-Dist: email-validator (>=2.2.0,<3.0.0)
+Requires-Dist: google-cloud-storage (>=3.1.0,<4.0.0)
 Requires-Dist: inflect (>=7.4.0,<8.0.0)
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: lark (>=1.2.2,<2.0.0)

csvpath-0.0.533/assets/config/jenkins-local-gcs.ini

@@ -0,0 +1,129 @@
+[csvpath_files]
+extensions = txt, csvpath, csvpaths
+
+[csv_files]
+extensions = txt, csv, tsv, dat, tab, psv, ssv
+
+[errors]
+csvpath = raise, collect, stop, fail, print
+csvpaths = raise, collect
+use_format = full
+pattern = {time}:{file}:{line}:{paths}:{instance}:{chain}:  {message}
+
+[logging]
+csvpath = debug
+csvpaths = debug
+log_file = logs/csvpath.log
+log_files_to_keep = 100
+log_file_size = 52428800
+
+[config]
+path = assets/config/jenkins-local-azure.ini
+
+[cache]
+path = cache
+use_cache = no
+
+[functions]
+imports = config/functions.imports
+
+[results]
+archive = gs://csvpath_dev/archive
+
+[inputs]
+files = gs://csvpath_dev/inputs/named_files
+csvpaths = gs://csvpath_dev/inputs/named_paths
+on_unmatched_file_fingerprints = halt
+
+#
+# integrations activation
+#
+
+[listeners]
+groups =
+#slack, marquez, ckan, sftp, sftpplus, otlp, default, sqlite
+
+# add sqlite to capture staging, loads, and results in a local sqlite db
+sqlite.result = from csvpath.managers.integrations.sqlite.sqlite_result_listener import SqliteResultListener
+sqlite.results = from csvpath.managers.integrations.sqlite.sqlite_results_listener import SqliteResultsListener
+
+# these simple default listeners track all files staged and all paths loaded in
+# central manifests. unlike other manifest writers, if they have multiple
+# concurrent users they have potential a race condition. users that do not
+# share inputs directories do not need to worry about this. you should vet
+# using them against your use case; potential utility vs. the modest but non-0
+# risk of lost updates. they can be disabled with little loss of function.
+# alternatively a database-backed version may be more suitable.
+default.file = from csvpath.managers.files.files_listener import FilesListener
+default.paths = from csvpath.managers.paths.paths_listener import PathsListener
+
+# add otlp to support any OpenTelemetry backend
+otlp.result = from csvpath.managers.integrations.otlp.otlp_result_listener import OpenTelemetryResultListener
+otlp.results = from csvpath.managers.integrations.otlp.otlp_results_listener import OpenTelemetryResultsListener
+otlp.errors = from csvpath.managers.integrations.otlp.otlp_error_listener import OpenTelemetryErrorListener
+
+# add sftpplus to the list of groups above to automate registration and named-paths group runs on file arrival at an SFTPPlus server
+sftpplus.paths = from csvpath.managers.integrations.sftpplus.sftpplus_listener import SftpPlusListener
+
+# add sftp to the list of groups above to push results to an sftp account
+sftp.results = from csvpath.managers.integrations.sftp.sftp_listener import SftpListener
+
+# add ckan to the list of groups above for alerts to slack webhooks
+ckan.results = from csvpath.managers.integrations.ckan.ckan_listener import CkanListener
+
+#add marquez to the list of groups above for OpenLineage events to a Marquez server
+marquez.file = from csvpath.managers.integrations.ol.file_listener_ol import OpenLineageFileListener
+marquez.paths = from csvpath.managers.integrations.ol.paths_listener_ol import OpenLineagePathsListener
+marquez.result = from csvpath.managers.integrations.ol.result_listener_ol import OpenLineageResultListener
+marquez.results = from csvpath.managers.integrations.ol.results_listener_ol import OpenLineageResultsListener
+
+# add slack to the list of groups above for alerts to slack webhooks
+slack.file = from csvpath.managers.integrations.slack.sender import SlackSender
+slack.paths = from csvpath.managers.integrations.slack.sender import SlackSender
+slack.result = from csvpath.managers.integrations.slack.sender import SlackSender
+slack.results = from csvpath.managers.integrations.slack.sender import SlackSender
+
+#
+# integrations setup
+#
+
+[sftp]
+server = 172.17.0.3
+port = 10022
+username = tinpenny
+password = tinpenny
+
+[sqlite]
+db = archive/csvpath.db
+
+[sftpplus]
+# these are only needed by the csvpath writer
+mailbox_user = MAILBOX_USER
+mailbox_password = MAILBOX_PASSWORD
+server = SFTPPLUS_SERVER
+port = SFTPPLUS_PORT
+# these are only needed on the server
+admin_username = SFTPPLUS_ADMIN_USERNAME
+admin_password = SFTPPLUS_ADMIN_PASSWORD
+api_url = https://localhost:10020/json
+scripts_dir =
+execute_timeout = 300
+
+[ckan]
+server = http://localhost:80
+api_token = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI3akJwc1ZuSkVrZm1aNnBtVTJfTW5CNlJXZ211YjdOOHVXZ1l1cUFDa0Q4IiwiaWF0IjoxNzM0NzE4NDQ3fQ.QXWXoJoSxVES4NwXYBteYUD7enX9D5T2htmETLGFzrs
+
+[marquez]
+base_url = http://localhost:5000
+endpoint = api/v1/lineage
+api_key = "none"
+timeout = 5
+verify = False
+
+[slack]
+# add your main webhook here. to set webhooks on a csvpath-by-csvpath basis add
+# on-valid-slack: webhook-minus-'https://' and/or
+# on-invalid-slack: webhook-minus-'https://'
+webhook_url =
+
+

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/csvpaths.py

@@ -672,6 +672,10 @@ class CsvPaths(CsvPathsCoordinator, ErrorCollector):
     ):  # pylint: disable=R0914
         """Does a CsvPath.next() on filename for every line against every named path in sequence"""
         paths = self.paths_manager.get_named_paths(pathsname)
+        if paths is None:
+            print(
+                f"PathsManager.get_named_paths for {pathsname} must return a set of named-paths"
+            )
         file = self.file_manager.get_named_file(filename)
         self.logger.info("Prepping %s and %s", filename, pathsname)
         self.clean(paths=pathsname)

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/managers/files/file_registrar.py

@@ -33,7 +33,7 @@ class FileRegistrar(Registrar, Listener):
 
     def manifest_path(self, home) -> str:
         nos = Nos(home)
-        if not nos.dir_exists():
+        if nos.physical_dirs() and not nos.dir_exists():
             raise InputException(f"Named file home does not exist: {home}")
         mf = os.path.join(home, "manifest.json")
         nos.path = mf

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/managers/results/results_manager.py

@@ -592,13 +592,19 @@ class ResultsManager:  # pylint: disable=C0115
         self.csvpaths.logger.debug(
             "Attempting to load results for %s from %s", name, path
         )
-        if Nos(path).dir_exists():
-            runs = Nos(path).listdir()
-            runs.sort()
-            run = runs[len(runs) - 1]
-            rs = self.get_named_results_for_run(name=name, run=run)
-            if rs is not None:
-                return rs
+        nos = Nos(path)
+        exists = nos.dir_exists()
+        nonphy = nos.physical_dirs()
+        # is not nonphy needed?
+        if exists or not nonphy:
+            runs = nos.listdir()
+            if len(runs) > 0:
+                runs.sort()
+                run = runs[len(runs) - 1]
+                rs = self.get_named_results_for_run(name=name, run=run)
+                if rs is not None:
+                    return rs
+
         #
         # we treat this as a recoverable error because typically the user
         # has complete control of the csvpaths environment, making the

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/azure/azure_data_reader.py

@@ -47,20 +47,6 @@ class AzureDataReader(CsvDataReader):
         dest_container, dest_blob = self.path_to_parts(new_path)
         AzureUtility.rename(source_container, source_blob, dest_container, dest_blob)
 
-    """
-    #
-    # these may happen, but S3 and this code isn't right, so let's see who needs it.
-    #
-    def read(self) -> str:
-        with open(uri=self._path, mode="r", encoding="utf-8") as file:
-            return file.read()
-
-    def next_raw(self) -> str:
-        with open(uri=self._path, mode="rb") as file:
-            for line in file:
-                yield line
-    """
-
     def file_info(self) -> dict[str, str | int | float]:
         # TODO: what can/should we provide here for cloud services? Can leave for now.
         return {}

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/azure/azure_nos.py

@@ -39,6 +39,9 @@ class AzureDo:
         #
         return bool(lst)
 
+    def physical_dirs(self) -> bool:
+        return False
+
     def rename(self, new_path: str) -> None:
         container, blob = AzureUtility.path_to_parts(self.path)
         new_container, new_blob = AzureUtility.path_to_parts(new_path)

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/box.py

@@ -17,6 +17,7 @@ class Box:
     SSH_CLIENT = "ssh_client"
     SFTP_CLIENT = "sftp_client"
     AZURE_BLOB_CLIENT = "azure_blob_client"
+    GCS_STORAGE_CLIENT = "gcs_storage_client"
 
     STUFF = {}
 

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/config.py

@@ -338,6 +338,8 @@ webhook_url =
                 return
             if self.inputs_files_path.strip().lower().startswith("sftp://"):
                 return
+            if self.inputs_files_path.strip().lower().startswith("gs://"):
+                return
             if not path.exists(self.inputs_files_path):
                 os.makedirs(self.inputs_files_path)
 
@@ -354,6 +356,8 @@ webhook_url =
                 return
             if self.inputs_csvpaths_path.strip().lower().startswith("sftp://"):
                 return
+            if self.inputs_csvpaths_path.strip().lower().startswith("gs://"):
+                return
             if not path.exists(self.inputs_csvpaths_path):
                 os.makedirs(self.inputs_csvpaths_path)
 

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/file_readers.py

@@ -146,6 +146,17 @@ class DataFileReader(ABC):
                         },
                     )
                     return instance
+                if path.find("gs://") > -1:
+                    instance = ClassLoader.load(
+                        "from csvpath.util.gcs.gcs_xlsx_data_reader import GcsXlsxDataReader",
+                        args=[path],
+                        kwargs={
+                            "sheet": sheet if sheet != path else None,
+                            "delimiter": delimiter,
+                            "quotechar": quotechar,
+                        },
+                    )
+                    return instance
                 return XlsxDataReader(
                     path,
                     sheet=sheet if sheet != path else None,
@@ -183,6 +194,13 @@ class DataFileReader(ABC):
                     kwargs={"delimiter": delimiter, "quotechar": quotechar},
                 )
                 return instance
+            if path.startswith("gs://"):
+                instance = ClassLoader.load(
+                    "from csvpath.util.gcs.gcs_data_reader import GcsDataReader",
+                    args=[path],
+                    kwargs={"delimiter": delimiter, "quotechar": quotechar},
+                )
+                return instance
             return CsvDataReader(path, delimiter=delimiter, quotechar=quotechar)
         else:
             instance = super().__new__(cls)

{csvpath-0.0.532 → csvpath-0.0.533}/csvpath/util/file_writers.py

@@ -74,6 +74,12 @@ class DataFileWriter(ABC):
                     kwargs={"path": path, "mode": mode},
                 )
                 return instance
+            if path.startswith("gs://"):
+                instance = ClassLoader.load(
+                    "from csvpath.util.gcs.gcs_data_writer import GcsDataWriter",
+                    kwargs={"path": path, "mode": mode},
+                )
+                return instance
             return GeneralDataWriter(path=path, mode=mode)
         else:
             instance = super().__new__(cls)

csvpath-0.0.533/csvpath/util/gcs/gcs_data_reader.py

@@ -0,0 +1,52 @@
+# pylint: disable=C0114
+import csv
+from smart_open import open
+from csvpath.util.hasher import Hasher
+from ..file_readers import CsvDataReader
+from .gcs_utils import GcsUtility
+from .gcs_fingerprinter import GcsFingerprinter
+
+
+class GcsDataReader(CsvDataReader):
+    def load_if(self) -> None:
+        if self.source is None:
+            client = GcsUtility.make_client()
+            try:
+                self.source = open(self.path, "r", transport_params={"client": client})
+            except DeprecationWarning:
+                ...
+
+    def next(self) -> list[str]:
+        with open(
+            uri=self.path,
+            mode="r",
+            transport_params={"client": GcsUtility.make_client()},
+        ) as file:
+            reader = csv.reader(
+                file, delimiter=self._delimiter, quotechar=self._quotechar
+            )
+            for line in reader:
+                yield line
+
+    def fingerprint(self) -> str:
+        self.load_if()
+        h = GcsFingerprinter().fingerprint(self.path)
+        h = Hasher.percent_encode(h)
+        self.close()
+        return h
+
+    def exists(self, path: str) -> bool:
+        return GcsUtility.exists(path)
+
+    def remove(self, path: str) -> None:
+        bucket, blob = self.path_to_parts(path)
+        GcsUtility.remove(bucket, blob)
+
+    def rename(self, path: str, new_path: str) -> None:
+        source_bucket, source_blob = self.path_to_parts(path)
+        dest_bucket, dest_blob = self.path_to_parts(new_path)
+        GcsUtility.rename(source_bucket, source_blob, dest_bucket, dest_blob)
+
+    def file_info(self) -> dict[str, str | int | float]:
+        # TODO: what can/should we provide here for cloud services? Can leave for now.
+        return {}

csvpath-0.0.533/csvpath/util/gcs/gcs_data_writer.py

@@ -0,0 +1,33 @@
+# pylint: disable=C0114
+
+import os
+from smart_open import open
+from ..file_writers import DataFileWriter
+from csvpath.util.gcs.gcs_utils import GcsUtility
+
+
+class GcsDataWriter(DataFileWriter):
+    _write_file_count = 0
+
+    def load_if(self) -> None:
+        if self.sink is None:
+            client = GcsUtility.make_client()
+            self.sink = open(
+                self.path,
+                self._mode,
+                transport_params={"client": client},
+            )
+            GcsDataWriter._write_file_count += 1
+
+    def write(self, data) -> None:
+        """This is a one-and-done write in mode 'w'. You don't use the data writer
+        as a context manager for this method. For multiple write calls to the same
+        file handle, use append().
+        """
+        client = GcsUtility.make_client()
+        with open(self.path, "wb", transport_params={"client": client}) as file:
+            file.write(data.encode("utf-8"))
+
+    def file_info(self) -> dict[str, str | int | float]:
+        # TODO: what can/should we provide here?
+        return {}

csvpath-0.0.533/csvpath/util/gcs/gcs_fingerprinter.py

@@ -0,0 +1,44 @@
+import hashlib
+from google.cloud import storage
+from .gcs_utils import GcsUtility
+from ..hasher import Hasher
+
+
+class GcsFingerprinter:
+    def fingerprint(self, path: str) -> str:
+        bucket, blob = GcsUtility.path_to_parts(path)
+        return self.fingerprint_object(bucket, blob)
+
+    def fingerprint_object(self, bucket: str, blob: str) -> str:
+        h = self.get_sha(bucket, blob)
+        if h is None:
+            h = self.generate_fingerprint(bucket, blob)
+            #
+            # Set the properties for future use
+            #
+            blob_obj = GcsUtility.make_client().bucket(bucket).blob(blob)
+            blob_obj.metadata = {"sha256": h}
+            blob_obj.patch()  # Update metadata in GCS
+        return h
+
+    def get_sha(self, bucket: str, blob: str) -> str:
+        blob_obj = GcsUtility.make_client().bucket(bucket).blob(blob)
+        blob_obj.reload()  # Ensure metadata is up-to-date
+        if blob_obj.metadata and "sha256" in blob_obj.metadata:
+            return blob_obj.metadata["sha256"]
+        return None
+
+    def generate_fingerprint(self, bucket: str, blob: str) -> str:
+        """Downloads the blob and calculates its SHA256 hash."""
+        client = GcsUtility.make_client()
+        blob_obj = client.bucket(bucket).blob(blob)
+        sha256 = hashlib.sha256()
+        try:
+            with blob_obj.open("rb") as download_stream:
+                for chunk in download_stream:
+                    sha256.update(chunk)
+            h = sha256.hexdigest()
+            h = Hasher.percent_encode(h)
+            return h
+        except Exception as e:
+            raise e

csvpath-0.0.533/csvpath/util/gcs/gcs_nos.py

@@ -0,0 +1,98 @@
+# pylint: disable=C0114
+import os
+from google.cloud import storage
+from .gcs_utils import GcsUtility
+from ..path_util import PathUtility as pathu
+
+
+class GcsDo:
+    def __init__(self, path, client=None):
+        self._path = path
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @path.setter
+    def path(self, path: str) -> None:
+        path = pathu.resep(path)
+        self._path = path
+
+    def remove(self) -> None:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        lst = self.listdir()
+        for item in lst:
+            self.path = f"gs://{bucket}/{blob}/{item}"
+            self.remove()
+        if GcsUtility.exists(bucket, blob):
+            GcsUtility.remove(bucket, blob)
+
+    def exists(self) -> bool:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        return GcsUtility.exists(bucket, blob)
+
+    def rename(self, new_path: str) -> None:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        new_bucket, new_blob = GcsUtility.path_to_parts(new_path)
+        return GcsUtility.rename(bucket, blob, new_bucket, new_blob)
+
+    def copy(self, new_path: str) -> None:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        new_bucket, new_blob = GcsUtility.path_to_parts(new_path)
+        return GcsUtility.copy(bucket, blob, new_bucket, new_blob)
+
+    def isfile(self) -> bool:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        client = GcsUtility.make_client()
+        try:
+            bucket_obj = client.bucket(bucket)
+            blob_obj = bucket_obj.blob(blob)
+            return blob_obj.exists()
+        except Exception:
+            return False
+
+    def dir_exists(self) -> bool:
+        lst = self.listdir()
+        #
+        # Similar to Azure, we consider a directory to exist if there are blobs under its prefix.
+        #
+        return bool(lst)
+
+    def physical_dirs(self) -> bool:
+        return False
+
+    def listdir(self) -> list[str]:
+        bucket, blob = GcsUtility.path_to_parts(self.path)
+        # print(f"\ngcs_nos: listdir: bucket: {bucket}, blob: {blob}")
+        if not blob.endswith("/"):
+            blob = f"{blob}/"
+        client = GcsUtility.make_client()
+        bucket_obj = client.bucket(bucket)
+        # print(f"gcs_nos: listdir: bucket_obj: {bucket_obj}")
+        # blobs = client.list_blobs(bucket_obj, prefix=blob)
+        blobs = client.list_blobs(bucket_obj, prefix=blob, delimiter="/")
+        lst = [blob.name for blob in blobs]
+        # print(f"gcs_nos: listdir: lst: {lst}")
+        prefixes = [blob for blob in blobs.prefixes]
+        # print(f"gcs_nos: listdir: prefixes: {prefixes}")
+        allnames = lst + prefixes
+        # print(f"gcs_nos: listdir: allnames: {allnames}")
+        names = []
+        for name in allnames:
+            # print(f"gcs_nos: listdir: name 1: {name}")
+            name = name[len(blob) :]
+            # print(f"gcs_nos: listdir: name 2: {name}")
+            if "/" not in name:
+                names.append(name)
+            else:
+                names.append(name[0 : name.find("/")])
+        # print(f"gcsnos: listdir: returning: {names}")
+        return names
+
+    def makedirs(self) -> None:
+        # Not required for GCS
+        ...
+
+    def makedir(self) -> None:
+        # Not required for GCS
+        ...

csvpath-0.0.533/csvpath/util/gcs/gcs_utils.py

@@ -0,0 +1,73 @@
+import os
+from google.cloud import storage
+from csvpath.util.box import Box
+
+
+class GcsUtility:
+    _client_count = 0
+    GCS_CREDENTIALS_PATH = "GCS_CREDENTIALS_PATH"
+
+    @classmethod
+    def make_client(cls):
+        """Creates a GCS Storage Client."""
+        box = Box()
+        client = box.get(Box.GCS_STORAGE_CLIENT)
+        if client is None:
+            cls._client_count += 1
+            credentials_path = os.getenv(cls.GCS_CREDENTIALS_PATH)
+            if not credentials_path:
+                raise ValueError(
+                    f"{cls.GCS_CREDENTIALS_PATH} environment variable not set."
+                )
+            client = storage.Client.from_service_account_json(credentials_path)
+            box.add(Box.GCS_STORAGE_CLIENT, client)
+        return client
+
+    @classmethod
+    def path_to_parts(cls, path) -> tuple[str, str]:
+        """Splits a GCS blob path into bucket and blob parts."""
+        if not path.startswith("gs://"):
+            raise ValueError("Path must be a GCS URI with the gs protocol")
+        path = path[5:]
+        i = path.find("/", 1)
+        bucket = path[0:i]
+        blob = path[i + 1 :]
+        return bucket, blob
+
+    @classmethod
+    def exists(cls, bucket: str, blob: str) -> bool:
+        client = cls.make_client()
+        if client is None:
+            raise ValueError("Client cannot be None")
+        try:
+            bucket_obj = client.bucket(bucket)
+            blob_obj = bucket_obj.blob(blob)
+            return blob_obj.exists()
+        except Exception:
+            return False
+
+    @classmethod
+    def remove(cls, bucket: str, blob: str) -> None:
+        client = cls.make_client()
+        if client is None:
+            raise ValueError("Client cannot be None")
+        bucket_obj = client.bucket(bucket)
+        blob_obj = bucket_obj.blob(blob)
+        blob_obj.delete()
+
+    @classmethod
+    def copy(cls, bucket: str, blob: str, new_bucket: str, new_blob: str) -> None:
+        client = cls.make_client()
+        if client is None:
+            raise ValueError("Client cannot be None")
+        bucket_obj = client.bucket(bucket)
+        blob_obj = bucket_obj.blob(blob)
+        new_bucket_obj = client.bucket(new_bucket)
+        new_blob_obj = new_bucket_obj.blob(new_blob)
+        new_blob_obj.rewrite(blob_obj)
+
+    @classmethod
+    def rename(cls, bucket: str, blob: str, new_bucket: str, new_blob: str) -> None:
+        """Renames a blob by copying it to a new location and deleting the old one."""
+        cls.copy(bucket, blob, new_bucket, new_blob)
+        cls.remove(bucket, blob)

csvpath-0.0.533/csvpath/util/gcs/gcs_xlsx_data_reader.py

@@ -0,0 +1,34 @@
+# pylint: disable=C0114
+import os
+import pylightxl as xl
+from smart_open import open
+from csvpath.util.box import Box
+from csvpath.util.hasher import Hasher
+from csvpath.util.file_readers import XlsxDataReader
+from .gcs_fingerprinter import GcsFingerprinter
+from .gcs_utils import GcsUtility
+
+
+class GcsXlsxDataReader(XlsxDataReader):
+    def next(self) -> list[str]:
+        with self as file:
+            db = xl.readxl(fn=file.source)
+            if not self._sheet:
+                self._sheet = db.ws_names[0]
+            for row in db.ws(ws=self._sheet).rows:
+                yield [f"{datum}" for datum in row]
+
+    def load_if(self) -> None:
+        if self.source is None:
+            client = GcsUtility.make_client()
+            try:
+                self.source = open(self.path, "rb", transport_params={"client": client})
+            except DeprecationWarning:
+                ...
+
+    def fingerprint(self) -> str:
+        self.load_if()
+        h = GcsFingerprinter().fingerprint(self.path)
+        h = Hasher.percent_encode(h)
+        self.close()
+        return h