[feature]🧰 Upload with Tag

Author: xlassix

setup.py

@@ -24,6 +24,7 @@
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
     ],
     keywords="lighthouse storage sdk python filecoin ipfs web3 perpetual",
     long_description=(

src/lighthouseweb3/__init__.py

@@ -14,19 +14,19 @@ def __init__(self, token: str = ""):
                 "No token provided: Please provide a token or set the LIGHTHOUSE_TOKEN environment variable"
             )
 
-    def upload(self, source: str) -> t.Upload:
+    def upload(self, source: str, tag: str = '') -> t.Upload:
         """
         Upload a file or directory to the Lighthouse.
 
         :param source: str, path to file or directory
         :return: t.Upload, the upload result
         """
         try:
-            return d.upload(source, self.token)
+            return d.upload(source, self.token, tag)
         except Exception as e:
             raise e
 
-    def uploadBlob(self, source: io.BufferedReader, filename: str) -> t.Upload:
+    def uploadBlob(self, source: io.BufferedReader, filename: str, tag: str = '') -> t.Upload:
         """
         Upload Blob a file or directory to the Lighthouse.
 
@@ -36,17 +36,20 @@ def uploadBlob(self, source: io.BufferedReader, filename: str) -> t.Upload:
         if not (hasattr(source, 'read') and hasattr(source, 'close')):
             raise TypeError("source must have 'read' and 'close' methods")
         try:
-            return d.uploadBlob(source, filename, self.token)
+            return d.uploadBlob(source, filename, self.token, tag)
         except Exception as e:
             raise e
 
     @staticmethod
     def downloadBlob(dist: io.BufferedWriter, cid: str, chunk_size=1024*1024*10) -> t.Upload:
         """
-        Download Blob a file or directory to the Lighthouse.
+        Download a Blob (file or directory) from the Lighthouse.
 
-        :param source: str, path to file or directory
-        :return: t.Upload, the upload result
+        :param dist: BufferedWriter, destination to write the downloaded data
+        :param cid: str, Content Identifier for the data to be downloaded
+        :param chunk_size: int, size of chunks in which the file will be downloaded (default: 10MB)
+        :param useCidAsTag: bool, flag to use CID as a tag (default: False)
+        :return: t.Upload, the download result
         """
         if not (hasattr(dist, 'read') and hasattr(dist, 'close')):
             raise TypeError("source must have 'read' and 'close' methods")
@@ -85,13 +88,25 @@ def getUploads(publicKey: str, pageNo: int = 1) -> List[t.DealData]:
     @staticmethod
     def download(cid: str) -> bytes:
         """
-        Get uploads from the Lighthouse.
+        Download content from the Lighthouse using its Content Identifier (CID).
 
-        :param publicKey: str, public key
-        :param pageNo: int, page number (default: 1)
-        :return: List[t.DealData], list of deal data
+        :param cid: str, Content Identifier for the data to be downloaded
+        :param useCidAsTag: bool, flag to use CID as a tag (default: False)
+        :return: bytes, the downloaded content
         """
         try:
             return _download.get_file(cid)
         except Exception as e:
             raise e
+
+    def getTagged(self, tag: str) -> t.Upload:
+        """
+        Retrieve an upload from the Lighthouse using its tag.
+
+        :param tag: str, tag associated with the file or directory
+        :return: t.Upload, the upload result
+        """
+        try:
+            return _download.getTaggedCid(tag, self.token)
+        except Exception as e:
+            raise e

src/lighthouseweb3/functions/config.py

@@ -6,5 +6,7 @@ class Config:
 
     # lighthouse_api = "http://13.234.35.183:5050"  # "https://api.lighthouse.storage"
     lighthouse_api = 'https://api.lighthouse.storage'
+    lighthouse_api_test = "http://34.131.52.103"
     lighthouse_node = "https://node.lighthouse.storage"
     lighthouse_bls_node = "https://encryption.lighthouse.storage"
+    lighthouse_gateway = "https://gateway.lighthouse.storage/ipfs"

src/lighthouseweb3/functions/upload.py

@@ -8,7 +8,7 @@
 from . import types as t
 
 
-def upload(source: str | BufferedReader | NamedBufferedReader, token: str) -> t.Upload:
+def upload(source: str | BufferedReader | NamedBufferedReader, token: str, tag: str = "") -> t.Upload:
     """
     Deploy a file or directory to the lighthouse network
     @params {source}: str, path to file or directory
@@ -40,15 +40,24 @@ def upload(source: str | BufferedReader | NamedBufferedReader, token: str) -> t.
                 file_dict["files"] = [source]
                 file_dict["is_dir"] = False
                 file_dict["path"] = source
-            return {"data": axios.post_files(file_dict, headers)}
+            hashData = axios.post_files(file_dict, headers)
         else:
-            return {"data": axios.post_blob(source, source.name, headers)}
+            hashData = axios.post_blob(source, source.name, headers)
+
+        if len(tag):
+            _axios = Axios(Config.lighthouse_api_test + "/api/user/create_tag")
+            data = _axios.post({
+                "tag": tag,
+                "cid": hashData.get("Hash")
+            }, {
+                "Authorization": f"Bearer {token}", })
+        return {"data": hashData}
     except Exception as e:
         print(e)
         raise e
 
 
-def uploadBlob(source:  BufferedReader, filename: str, token: str) -> t.Upload:
+def uploadBlob(source:  BufferedReader, filename: str, token: str, tag: str = "") -> t.Upload:
     """
     Upload a Buffer or readable Object
     @params {source}: str, path to file or directory
@@ -65,7 +74,16 @@ def uploadBlob(source:  BufferedReader, filename: str, token: str) -> t.Upload:
         # create http object
         axios = Axios(Config.lighthouse_node + "/api/v0/add")
         # create list of files to upload
-        return {"data": axios.post_blob(source, filename, headers)}
+
+        hashData = axios.post_blob(source, filename, headers)
+        if len(tag):
+            _axios = Axios(Config.lighthouse_api_test + "/api/user/create_tag")
+            data = _axios.post({
+                "tag": tag,
+                "cid": hashData.get("Hash")
+            }, {
+                "Authorization": f"Bearer {token}", })
+        return {"data": hashData}
     except Exception as e:
         print(e)
         raise e

tests/test_download.py

@@ -33,23 +33,14 @@ def test_download_file(self):
         self.assertIsInstance(res, bytes, "type doesn't match")
         self.assertEqual(res, b'tests/testdir/', "data doesn't match")
 
-    # def test_download_blob(self):
-    #     """test Upload function"""
-    #     l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
-    #     res = l.uploadBlob(
-    #         io.BytesIO(b"tests/testdir/"), f"{generate_random_string(16)}.txt")
-    #     self.assertNotEqual(res.get("data"), None, "data is None")
-    #     self.assertIsInstance(res.get("data"), dict, "data is a dict")
-    #     self.assertNotEqual(res.get("data").get("Hash"), None, "data is None")
-
     def test_download_blob_file(self):
         """test download_blob function"""
         l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
         with open("./image.png", "wb") as file:
             res = l.downloadBlob(
                 file, "QmPT11PFFQQD3mT6BdwfSHQGHRdF8ngmRmcvxtSBiddWEa", chunk_size=1024*100)
-            self.assertEqual(file.tell(), 123939, "File Size dont match")
-            self.assertEqual(res, True, "data doesn't match")
+            self.assertEqual(res.get("data").get("Size"),
+                             123939, "File Size dont match")
 
 
 if __name__ == "__main__":

tests/test_upload.py

@@ -25,22 +25,25 @@ def test_env(self):
             os.environ.get("LIGHTHOUSE_TOKEN"), None, "token is not None"
         )
 
-    def test_Upload_file(self):
+    def test_upload_file(self):
         """test Upload function"""
         l = Lighthouse()  # will use env var
         res = l.upload("tests/testdir/testfile.txt")
         self.assertNotEqual(res.get("data"), None, "data is None")
         self.assertNotEqual(res.get("data").get("Hash"), None, "data is None")
 
-    def test_Upload_dir(self):
+    def test_upload_dir(self):
         """test Upload function"""
         l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
-        res = l.upload("tests/testdir/")
+        res = l.upload("tests/")
         self.assertNotEqual(res.get("data"), None, "data is None")
         self.assertIsInstance(res.get("data"), dict, "data is a dict")
-        self.assertNotEqual(res.get("data").get("Hash"), None, "data is None")
+        self.assertIsInstance(res.get("data").get(
+            "Hash"), str, "Instance is not of type String")
+        self.assertIsInstance(res.get("data").get(
+            "Size"), str, "Instance is not of type String")
 
-    def test_Upload_Blob(self):
+    def test_upload_Blob(self):
         """test Upload function"""
         l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
         res = l.uploadBlob(
@@ -49,7 +52,7 @@ def test_Upload_Blob(self):
         self.assertIsInstance(res.get("data"), dict, "data is a dict")
         self.assertNotEqual(res.get("data").get("Hash"), None, "data is None")
 
-    def test_Upload_File(self):
+    def test_upload_File(self):
         """test Upload function"""
         l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
         with open("./.gitignore", "rb") as file:
@@ -59,6 +62,30 @@ def test_Upload_File(self):
             self.assertNotEqual(res.get("data").get(
                 "Hash"), None, "data is None")
 
+    def test_upload_with_tag(self):
+        """test Upload with tag function"""
+        l = Lighthouse(os.environ.get("LIGHTHOUSE_TOKEN"))
+        tag = generate_random_string(8)
+        res = l.uploadBlob(
+            io.BytesIO(b"tests/testdir/"+generate_random_string(80).encode("utf-8")), f"{generate_random_string(16)}.txt", tag)
+        self.assertNotEqual(res.get("data"), None, "data is None")
+        self.assertIsInstance(res.get("data"), dict, "data is a dict")
+        self.assertIsInstance(res.get("data").get(
+            "Hash"), str, "Hash is not of type string")
+
+        tagData = l.getTagged(tag)
+        self.assertEqual(tag, tagData.get("data").get("tag"), "Tag dont match")
+        self.assertEqual(res.get("data").get("Hash"), tagData.get(
+            "data").get("cid"), "Tag dont match")
+
+        # overWrite tag
+        res = l.uploadBlob(
+            io.BytesIO(b"tests/testdir/"+generate_random_string(80).encode("utf-8")), f"{generate_random_string(16)}.txt", tag)
+        tagData = l.getTagged(tag)
+        self.assertEqual(tag, tagData.get("data").get("tag"), "Tag dont match")
+        self.assertEqual(res.get("data").get("Hash"), tagData.get(
+            "data").get("cid"), "Tag dont match")
+
 
 if __name__ == "__main__":
     unittest.main()