feat: support v0 pin meta in pin_search

Author: machow

pins/boards.py

@@ -416,7 +416,7 @@ def pin_search(self, search=None, as_df=True):
             import pandas as pd
 
             # TODO(question): was the pulling of specific fields out a v0 thing?
-            extracted = list(map(self._extract_meta_results, res))
+            extracted = list(map(self._extract_search_meta, res))
             return pd.DataFrame(extracted)
 
         # TODO(compat): double check on the as_df=True convention
@@ -540,7 +540,7 @@ def prepare_pin_version(
     def _extract_search_meta(self, meta):
         keep_fields = ["name", "type", "title", "created", "file_size"]
 
-        d = {k: getattr(meta, k) for k in keep_fields}
+        d = {k: getattr(meta, k, None) for k in keep_fields}
         d["meta"] = meta
         return d
 
@@ -593,7 +593,7 @@ def pin_meta(self, name, version=None):
         path_to_pin = self.construct_path([pin_name])
         if self.fs.protocol == "http" and not path_to_pin.rstrip().endswith("/"):
             # create metadata, rather than read from a file
-            return self.meta_factory.create_raw(path_to_pin, type="file",)
+            return self.meta_factory.create_raw(path_to_pin, type="file", name=pin_name)
 
         path_meta = self.construct_path([pin_name, meta_name])
         f = self.fs.open(path_meta)
@@ -661,10 +661,8 @@ def pin_search(self, search=None, as_df=True):
                 # verify code is for inadequate permission to access
                 if e.args[0]["code"] != 19:
                     raise e
-                # TODO(question): should this be a MetaRaw class or something?
-                #                 that fixes our isinstance Meta below.
                 # TODO(compatibility): R pins errors instead, see #27
-                res.append({"name": pin_name, "meta": None})
+                res.append(self.meta_factory.create_raw(None, type=None, name=pin_name))
 
         # extract specific fields out ----
 
@@ -674,11 +672,7 @@ def pin_search(self, search=None, as_df=True):
 
             extract = []
             for entry in res:
-                extract.append(
-                    self._extract_search_meta(entry)
-                    if isinstance(entry, Meta)
-                    else entry
-                )
+                extract.append(self._extract_search_meta(entry))
 
             return pd.DataFrame(extract)
 

pins/meta.py

@@ -1,3 +1,4 @@
+from typing import ClassVar
 from dataclasses import dataclass, asdict, field
 
 import yaml
@@ -24,8 +25,9 @@ class MetaRaw:
         The type of pin data stored. This is used to determine how to read / write it.
     """
 
-    file: Union[str, Sequence[str]]
+    file: "str | Sequence[str] | None"
     type: str
+    name: str
 
 
 @dataclass
@@ -57,7 +59,7 @@ class Meta:
 
     """
 
-    title: str
+    title: Optional[str]
     description: Optional[str]
 
     # TODO(defer): different from R pins, which has a local field
@@ -93,19 +95,58 @@ def to_pin_dict(self):
     @classmethod
     def from_pin_dict(cls, data, pin_name, version) -> "Meta":
 
-        # version_fields = {"created", "pin_hash"}
-
-        # #get items necessary for re-creating meta data
-        # meta_data = {k: v for k, v in data.items() if k not in version_fields}
-        # version = version_cls.from_meta_fields(data["created"], data["pin_hash"])
-        return cls(**data, name=pin_name, version=version)
+        # TODO: re-arrange Meta argument positions to reflect what's been
+        # learned about default arguments. e.g. title was not used at some
+        # point in api_version 1
+        extra = {"title": None} if "title" not in data else {}
+        return cls(**data, **extra, name=pin_name, version=version)
 
     def to_pin_yaml(self, f: Optional[IOBase] = None) -> "str | None":
         data = self.to_pin_dict()
 
         return yaml.dump(data, f)
 
 
+@dataclass
+class MetaV0:
+    file: Union[str, Sequence[str]]
+    type: str
+
+    description: str
+    name: str
+
+    version: VersionRaw
+
+    # holds raw data.txt contents
+    original_fields: dict = field(default_factory=dict)
+    user: dict = field(default_factory=dict, init=False)
+
+    title: ClassVar[None] = None
+    created: ClassVar[None] = None
+    pin_hash: ClassVar[None] = None
+    file_size: ClassVar[None] = None
+    api_version: ClassVar[None] = None
+
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_pin_dict(cls, data, pin_name, version) -> "MetaV0":
+        # could infer from dataclasses.fields(), but seems excessive.
+        req_fields = {"type", "description", "name"}
+
+        req_inputs = {k: v for k, v in data.items() if k in req_fields}
+        req_inputs["file"] = data["path"]
+
+        return cls(**req_inputs, name=pin_name, original_fields=data, version=version)
+
+    def to_pin_dict(self):
+        raise NotImplementedError("v0 pins metadata are read only.")
+
+    def to_pin_yaml(self, *args, **kwargs):
+        self.to_pin_dict()
+
+
 class MetaFactory:
     """Responsible for creating and loading (e.g. from yaml) of meta objects.
 
@@ -168,8 +209,8 @@ def create(
             version=version,
         )
 
-    def create_raw(self, files: Sequence[StrOrFile], type: str = "file",) -> MetaRaw:
-        return MetaRaw(files, type)
+    def create_raw(self, files: Sequence[StrOrFile], type: str, name: str) -> MetaRaw:
+        return MetaRaw(files, type, name)
 
     def read_pin_yaml(
         self, f: IOBase, pin_name: str, version: "str | VersionRaw"
@@ -181,4 +222,14 @@ def read_pin_yaml(
 
         data = yaml.safe_load(f)
 
-        return Meta.from_pin_dict(data, pin_name, version=version_obj)
+        api_version = data.get("api_version", 0)
+        if api_version >= 2:
+            raise NotImplementedError(
+                f"api_version {api_version} by this version of the pins library"
+            )
+        elif api_version == 0:
+            cls_meta = MetaV0
+        else:
+            cls_meta = Meta
+
+        return cls_meta.from_pin_dict(data, pin_name, version=version_obj)

pins/tests/test_boards.py

@@ -5,6 +5,7 @@
 
 from pins.tests.helpers import DEFAULT_CREATION_DATE
 from pins.errors import PinsError
+from pins.meta import MetaRaw
 
 from datetime import datetime, timedelta
 from time import sleep
@@ -283,13 +284,13 @@ def test_board_pin_search_admin_user(df, fs_short, fs_admin):  # noqa
     search_res = board_admin.pin_search("susan", as_df=False)
 
     assert len(search_res) == 1
-    assert search_res[0]["name"] == "susan/some_df"
-    assert search_res[0]["meta"] is None
+    assert search_res[0].name == "susan/some_df"
+    assert isinstance(search_res[0], MetaRaw)
 
     search_res2 = board_admin.pin_search("susan", as_df=True)
-    assert search_res2.shape == (1, 2)
+    assert search_res2.shape == (1, 6)
     assert search_res2.loc[0, "name"] == "susan/some_df"
-    assert search_res2.loc[0, "meta"] is None
+    assert isinstance(search_res2.loc[0, "meta"], MetaRaw)
 
 
 # Manual Board Specific =======================================================