Versioning removed

Author: jitu5

kedro-datasets/kedro_datasets_experimental/pypdf/pdf_dataset.py

@@ -10,15 +10,14 @@
 import fsspec
 import pypdf
 from kedro.io.core import (
-    AbstractVersionedDataset,
+    AbstractDataset,
     DatasetError,
-    Version,
     get_filepath_str,
     get_protocol_and_path,
 )
 
 
-class PDFDataset(AbstractVersionedDataset[NoReturn, list[str]]):
+class PDFDataset(AbstractDataset[NoReturn, list[str]]):
     """``PDFDataset`` loads data from PDF files using an underlying
     filesystem (e.g.: local, S3, GCS). It uses pypdf to read and extract text from PDF files.
 
@@ -58,12 +57,11 @@ class PDFDataset(AbstractVersionedDataset[NoReturn, list[str]]):
 
     DEFAULT_LOAD_ARGS: dict[str, Any] = {"strict": False}
 
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
         *,
         filepath: str,
         load_args: dict[str, Any] | None = None,
-        version: Version | None = None,
         credentials: dict[str, Any] | None = None,
         fs_args: dict[str, Any] | None = None,
         metadata: dict[str, Any] | None = None,
@@ -75,18 +73,13 @@ def __init__(  # noqa: PLR0913
             filepath: Filepath in POSIX format to a PDF file prefixed with a protocol like `s3://`.
                 If prefix is not provided, `file` protocol (local filesystem) will be used.
                 The prefix should be any protocol supported by ``fsspec``.
-                Note: `http(s)` doesn't support versioning.
             load_args: Pypdf options for loading PDF files (arguments passed
                 into ``pypdf.PdfReader``). Here you can find all available arguments:
                 https://pypdf.readthedocs.io/en/stable/modules/PdfReader.html
                 All defaults are preserved, except "strict", which is set to False.
                 Common options include:
                 - password (str): Password for encrypted PDFs
                 - strict (bool): Whether to raise errors on malformed PDFs (default: False)
-            version: If specified, should be an instance of
-                ``kedro.io.core.Version``. If its ``load`` attribute is
-                None, the latest version will be loaded. If its ``save``
-                attribute is None, save version will be autogenerated.
             credentials: Credentials required to get access to the underlying filesystem.
                 E.g. for ``GCSFileSystem`` it should look like `{"token": None}`.
             fs_args: Extra arguments to pass into underlying filesystem class constructor
@@ -103,22 +96,17 @@ def __init__(  # noqa: PLR0913
         _fs_open_args_load = _fs_args.pop("open_args_load", {})
         _credentials = deepcopy(credentials) or {}
 
-        protocol, path = get_protocol_and_path(filepath, version)
+        super().__init__()
+
+        protocol, path = get_protocol_and_path(filepath)
         if protocol == "file":
             _fs_args.setdefault("auto_mkdir", True)
 
         self._protocol = protocol
         self._fs = fsspec.filesystem(self._protocol, **_credentials, **_fs_args)
-
+        self._filepath = PurePosixPath(path)
         self.metadata = metadata
 
-        super().__init__(
-            filepath=PurePosixPath(path),
-            version=version,
-            exists_function=self._fs.exists,
-            glob_function=self._fs.glob,
-        )
-
         # Handle default load and fs arguments
         self._load_args = {**self.DEFAULT_LOAD_ARGS, **(load_args or {})}
         self._fs_open_args_load = _fs_open_args_load or {}
@@ -128,7 +116,6 @@ def _describe(self) -> dict[str, Any]:
             "filepath": self._filepath,
             "protocol": self._protocol,
             "load_args": self._load_args,
-            "version": self._version,
         }
 
     def load(self) -> list[str]:
@@ -137,7 +124,7 @@ def load(self) -> list[str]:
         Returns:
             list[str]: A list of strings, where each string contains the text extracted from one page.
         """
-        load_path = get_filepath_str(self._get_load_path(), self._protocol)
+        load_path = get_filepath_str(self._filepath, self._protocol)
 
         with self._fs.open(load_path, mode="rb", **self._fs_open_args_load) as fs_file:
             pdf_reader = pypdf.PdfReader(stream=fs_file, **self._load_args)
@@ -158,15 +145,16 @@ def save(self, data: NoReturn) -> None:
         raise DatasetError("Saving to PDFDataset is not supported.")
 
     def _exists(self) -> bool:
-        try:
-            load_path = get_filepath_str(self._get_load_path(), self._protocol)
-        except DatasetError:
-            return False
+        """Check if the PDF file exists.
 
+        Returns:
+            bool: True if the file exists, False otherwise.
+        """
+        load_path = get_filepath_str(self._filepath, self._protocol)
         return self._fs.exists(load_path)
 
     def _release(self) -> None:
-        super()._release()
+        """Release any cached filesystem information."""
         self._invalidate_cache()
 
     def _invalidate_cache(self) -> None:

kedro-datasets/kedro_datasets_experimental/tests/pypdf/test_pdf_dataset.py

@@ -1,12 +1,12 @@
 import shutil
-from pathlib import Path, PurePosixPath
+from pathlib import PurePosixPath
 
 import pypdf
 import pytest
 from fsspec.implementations.http import HTTPFileSystem
 from fsspec.implementations.local import LocalFileSystem
 from gcsfs import GCSFileSystem
-from kedro.io.core import PROTOCOL_DELIMITER, DatasetError, Version
+from kedro.io.core import PROTOCOL_DELIMITER, DatasetError
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 from s3fs.core import S3FileSystem
@@ -24,13 +24,6 @@ def pdf_dataset(filepath_pdf, load_args, fs_args):
     return PDFDataset(filepath=filepath_pdf, load_args=load_args, fs_args=fs_args)
 
 
-@pytest.fixture
-def versioned_pdf_dataset(filepath_pdf, load_version, save_version):
-    return PDFDataset(
-        filepath=filepath_pdf, version=Version(load_version, save_version)
-    )
-
-
 @pytest.fixture
 def dummy_pdf_data(tmp_path):
     """Create a simple PDF file for testing."""
@@ -157,45 +150,3 @@ def test_catalog_release(self, mocker):
         dataset = PDFDataset(filepath=filepath)
         dataset.release()
         fs_mock.invalidate_cache.assert_called_once_with(filepath)
-
-
-class TestPDFDatasetVersioned:
-    def test_version_str_repr(self, load_version, save_version):
-        """Test that version is in string representation of the class instance
-        when applicable."""
-        filepath = "test.pdf"
-        ds = PDFDataset(filepath=filepath)
-        ds_versioned = PDFDataset(
-            filepath=filepath, version=Version(load_version, save_version)
-        )
-        assert filepath in str(ds)
-        assert "version" not in str(ds)
-
-        assert filepath in str(ds_versioned)
-        ver_str = f"version=Version(load={load_version}, save='{save_version}')"
-        assert ver_str in str(ds_versioned)
-        assert "PDFDataset" in str(ds_versioned)
-        assert "PDFDataset" in str(ds)
-        assert "protocol" in str(ds_versioned)
-        assert "protocol" in str(ds)
-        # Default load_args
-        assert "load_args={'strict': False}" in str(ds)
-        assert "load_args={'strict': False}" in str(ds_versioned)
-
-    def test_no_versions(self, versioned_pdf_dataset):
-        """Check the error if no versions are available for load."""
-        pattern = r"Did not find any versions for kedro_datasets_experimental.pypdf.pdf_dataset.PDFDataset\(.+\)"
-        with pytest.raises(DatasetError, match=pattern):
-            versioned_pdf_dataset.load()
-
-    def test_exists(self, versioned_pdf_dataset, dummy_pdf_data):
-        """Test `exists` method invocation for versioned dataset."""
-        assert not versioned_pdf_dataset.exists()
-
-    def test_http_filesystem_no_versioning(self):
-        pattern = "Versioning is not supported for HTTP protocols."
-
-        with pytest.raises(DatasetError, match=pattern):
-            PDFDataset(
-                filepath="https://example.com/file.pdf", version=Version(None, None)
-            )