Merge pull request #25 from machow/feat-pin-delete

feat: implement pin_delete, pin_version_delete

Author: machow

docs/api/boards.rst

@@ -23,6 +23,9 @@ Methods (Implemented)
    ~BaseBoard.pin_versions
    ~BaseBoard.pin_list
    ~BaseBoard.pin_exists
+   ~BaseBoard.pin_version_delete
+   ~BaseBoard.pin_versions_prune
+   ~BaseBoard.pin_delete
 
 Methods (Planned)
 -----------------
@@ -31,8 +34,5 @@ Methods (Planned)
 
    ~BaseBoard.pin_download
    ~BaseBoard.pin_upload
-   ~BaseBoard.pin_version_delete
-   ~BaseBoard.pin_versions_prune
    ~BaseBoard.pin_search
-   ~BaseBoard.pin_delete
    ~BaseBoard.pin_browse

pins/boards.py

@@ -1,11 +1,12 @@
 import tempfile
 import shutil
+import inspect
 
 from io import IOBase
 from functools import cached_property
 from pathlib import Path
 from importlib_resources import files
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from typing import Protocol, Sequence, Optional, Mapping
 
@@ -253,7 +254,14 @@ def pin_write(
                     "but that directory already exists."
                 )
 
-            self.fs.put(tmp_dir, dst_version_path, recursive=True)
+            res = self.fs.put(tmp_dir, dst_version_path, recursive=True)
+
+        if dst_version_path == dst_pin_path:
+            # TODO(refactor): this is a RSConnect specific hack
+            # since we don't know the bundle id ahead of time, the meta version
+            # object is incorrect. Could fix through the meta_factory
+            bundle_version = VersionRaw(res.split("/")[-1])
+            meta.version = bundle_version
 
         return meta
 
@@ -289,7 +297,7 @@ def pin_upload(self, paths, name=None, title=None, description=None, metadata=No
         raise NotImplementedError()
 
     def pin_version_delete(self, name: str, version: str):
-        """TODO: Delete a single version of a pin.
+        """Delete a single version of a pin.
 
         Parameters
         ----------
@@ -298,10 +306,16 @@ def pin_version_delete(self, name: str, version: str):
         version:
             Version identifier.
         """
-        raise NotImplementedError()
 
-    def pin_versions_prune(self, name, n=None, days=None):
-        """TODO: Delete old versions of a pin.
+        pin_name = self.path_to_pin(name)
+
+        pin_version_path = self.construct_path([pin_name, version])
+        self.fs.rm(pin_version_path, recursive=True)
+
+    def pin_versions_prune(
+        self, name, n: "int | None" = None, days: "int | None" = None
+    ):
+        """Delete old versions of a pin.
 
         Parameters
         ----------
@@ -318,7 +332,33 @@ def pin_versions_prune(self, name, n=None, days=None):
         the most recent version.
 
         """
-        raise NotImplementedError()
+
+        if n is None and days is None:
+            raise ValueError("Cannot specify both n and days.")
+
+        versions = self.pin_versions(name, as_df=False)
+        if n is not None:
+            if n <= 0:
+                raise ValueError("Argument n is {n}, but must be greater than 0.")
+
+            to_delete = versions[:-n]
+        if days is not None:
+            if days <= 0:
+                raise ValueError("Argument days is {days}, but must be greater than 0.")
+
+            date_cutoff = datetime.today() - timedelta(days=days)
+            to_delete = [v for v in versions if v.created < date_cutoff]
+
+        # message user about deletions ----
+        # TODO(question): how to pin_inform? Log or warning?
+        if to_delete:
+            str_vers = ", ".join([v.version for v in to_delete])
+            print(f"Deleting versions: {str_vers}.")
+        if not to_delete:
+            print("No old versions to delete")
+
+        for version in to_delete:
+            self.pin_version_delete(name, version.version)
 
     def pin_search(self, search=None):
         """TODO: Search for pins.
@@ -334,15 +374,24 @@ def pin_search(self, search=None):
         """
         raise NotImplementedError()
 
-    def pin_delete(self, names):
+    def pin_delete(self, names: "str | Sequence[str]"):
         """TODO: Delete a pin (or pins), removing it from the board.
 
         Parameters
         ----------
         names:
             The names of one or more pins to delete.
         """
-        raise NotImplementedError()
+
+        if isinstance(names, str):
+            names = [names]
+
+        for name in names:
+            if not self.pin_exists(name):
+                raise PinsError("Cannot delete pin, since pin %s does not exist" % name)
+
+            pin_name = self.path_to_pin(name)
+            self.fs.rm(pin_name, recursive=True)
 
     def pin_browse(self, name, version=None, local=False):
         """TODO: Navigate to the home of a pin, either on the internet or locally.
@@ -460,6 +509,25 @@ def pin_list(self):
         names = [f"{cont['owner_username']}/{cont['name']}" for cont in results]
         return names
 
+    def pin_version_delete(self, *args, **kwargs):
+        from pins.rsconnect.api import RsConnectApiRequestError
+
+        try:
+            super().pin_version_delete(*args, **kwargs)
+        except RsConnectApiRequestError as e:
+            if e.args[0]["code"] != 75:
+                raise e
+
+            raise PinsError("RStudio Connect cannot delete the latest pin version.")
+
+    def pin_versions_prune(self, *args, **kwargs):
+        sig = inspect.signature(super().pin_versions_prune)
+        if sig.bind(*args, **kwargs).arguments.get("days") is not None:
+            raise NotImplementedError(
+                "RStudio Connect board cannot prune versions using days."
+            )
+        super().pin_versions_prune(*args, **kwargs)
+
     def validate_pin_name(self, name) -> None:
         if name.count("/") > 1:
             raise ValueError(f"Invalid pin name: {name}")

pins/drivers.py

@@ -1,5 +1,8 @@
+import builtins
+
 from .meta import Meta
 
+
 # TODO: move IFileSystem out of boards, to fix circular import
 # from .boards import IFileSystem
 
@@ -71,7 +74,7 @@ def default_title(obj, type):
             shape_str = " x ".join(map(str, obj.shape))
             return f"A pinned {shape_str} CSV"
         raise NotImplementedError(
-            f"No default csv title support for class: {type(obj)}"
+            f"No default csv title support for class: {builtins.type(obj)}"
         )
 
     raise NotImplementedError(f"Cannot create default title for type: {type}")

pins/tests/test_boards.py

@@ -1,7 +1,12 @@
 import pytest
 import pandas as pd
+import uuid
 
 from pins.tests.helpers import DEFAULT_CREATION_DATE
+from pins.errors import PinsError
+
+from datetime import datetime, timedelta
+from time import sleep
 
 # using pytest cases, so that we can pass in fixtures as parameters
 from pytest_cases import fixture, parametrize
@@ -18,7 +23,7 @@ def df():
     return pd.DataFrame({"x": [1, 2, 3], "y": ["a", "b", "c"]})
 
 
-# High level pins functionality -----------------------------------------------
+# pin_write ===================================================================
 
 
 def test_board_pin_write_default_title(board):
@@ -110,3 +115,106 @@ def test_board_pin_write_type(board, obj, type_, request):
         assert obj.equals(dst_obj)
 
     obj == dst_obj
+
+
+# pin_delete ==================================================================
+
+
+@pytest.fixture
+def pin_name():
+    return str(uuid.uuid4())
+
+
+@pytest.fixture
+def pin_del(board, df, pin_name):
+    meta_old = board.pin_write(df, pin_name, type="csv", title="some title")
+    sleep(1)
+    meta_new = board.pin_write(df, pin_name, type="csv", title="some title")
+
+    assert len(board.pin_versions(pin_name)) == 2
+    assert meta_old.version.version != meta_new.version.version
+
+    return meta_old, meta_new
+
+
+@pytest.fixture
+def pin_prune(board, df, pin_name):
+    today = datetime.now()
+    day_ago = today - timedelta(days=1, minutes=1)
+    two_days_ago = today - timedelta(days=2, minutes=1)
+
+    board.pin_write(df, pin_name, type="csv", title="some title", created=today)
+    board.pin_write(df, pin_name, type="csv", title="some title", created=day_ago)
+    board.pin_write(df, pin_name, type="csv", title="some title", created=two_days_ago)
+
+    versions = board.pin_versions(pin_name, as_df=False)
+    assert len(versions) == 3
+
+    return versions
+
+
+def test_board_pin_delete(board, df, pin_name, pin_del):
+    board.pin_delete(pin_name)
+
+    assert board.pin_exists(pin_name) is False
+
+
+def test_board_pin_version_delete_older(board, pin_name, pin_del):
+    meta_old, meta_new = pin_del
+
+    board.pin_version_delete(pin_name, meta_old.version.version)
+    df_versions = board.pin_versions(pin_name)
+
+    # Note that using `in` on a pandas Series checks against the index :/
+    assert meta_old.version.version not in df_versions.version.values
+    assert meta_new.version.version in df_versions.version.values
+
+
+def test_board_pin_version_delete_latest(board, pin_name, pin_del):
+    meta_old, meta_new = pin_del
+
+    if board.fs.protocol == "rsc":
+        with pytest.raises(PinsError) as exc_info:
+            board.pin_version_delete(pin_name, meta_new.version.version)
+
+            "cannot delete the latest pin version" in exc_info.value.args[0]
+        return
+
+    board.pin_version_delete(pin_name, meta_new.version.version)
+    df_versions = board.pin_versions(pin_name)
+
+    # Note that using `in` on a pandas Series checks against the index :/
+    assert meta_old.version.version in df_versions.version.values
+    assert meta_new.version.version not in df_versions.version.values
+
+
+@pytest.mark.parametrize("n", [1, 2])
+def test_board_pin_versions_prune_n(board, pin_prune, pin_name, n):
+
+    board.pin_versions_prune(pin_name, n=n)
+    new_versions = board.pin_versions(pin_name, as_df=False)
+
+    assert len(new_versions) == n
+
+    # TODO(compat): versions are currently reversed from R pins, with latest last
+    # so we need to reverse to check the n latest versions
+    rev_vers = list(reversed(pin_prune))
+    for ii, v in enumerate(reversed(new_versions)):
+        assert rev_vers[ii].version == v.version
+
+
+@pytest.mark.parametrize("days", [1, 2])
+def test_board_pin_versions_prune_days(board, pin_prune, pin_name, days):
+
+    # RStudio cannot handle days, since it involves pulling metadata
+    if board.fs.protocol == "rsc":
+        with pytest.raises(NotImplementedError):
+            board.pin_versions_prune(pin_name, days=days)
+        return
+
+    board.pin_versions_prune(pin_name, days=days)
+
+    new_versions = board.pin_versions(pin_name, as_df=False)
+
+    # each of the 3 versions adds an 1 more day + 1 min
+    assert len(new_versions) == days

pins/tests/test_meta.py

@@ -25,6 +25,7 @@ def meta():
     return Meta(**META_DEFAULTS)
 
 
+@pytest.mark.xfail
 def test_meta_to_dict_is_recursive(meta):
     d_meta = meta.to_dict()
     assert d_meta["version"] == meta.version.to_dict()

pins/versions.py

@@ -28,7 +28,11 @@ class Version(_VersionBase):
     hash: str
 
     def to_dict(self) -> Mapping:
-        return asdict(self)
+        # properties not automatically added, so need to handle manually
+        res = asdict(self)
+        res["version"] = self.version
+
+        return res
 
     @property
     def version(self) -> str: