Merge pull request #3 from lighthouse-web3/v0.1.2

V0.1.2- File Download Feature

Author: ravish1729

.gitignore

@@ -158,4 +158,7 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+src/lighthouseweb3/functions/download.py
+
+image.png

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

@@ -3,7 +3,7 @@
 import os
 import io
 from typing import List
-from .functions import upload as d, types as t, deal_status, get_uploads as getUploads
+from .functions import upload as d, types as t, deal_status, get_uploads as getUploads, download as _download
 
 
 class Lighthouse:
@@ -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,7 +36,40 @@ 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 a Blob (file or directory) from the Lighthouse.
+
+        :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")
+        try:
+            return _download.download_file_into_writable(cid, dist, chunk_size)
+        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.
+
+        :param source: str, path to file or directory
+        :return: t.Upload, the upload result
+        """
+        if not (hasattr(dist, 'read') and hasattr(dist, 'close')):
+            raise TypeError("source must have 'read' and 'close' methods")
+        try:
+            return _download.download_file_into_writable(cid, dist, chunk_size)
         except Exception as e:
             raise e
 
@@ -66,3 +99,30 @@ def getUploads(publicKey: str, pageNo: int = 1) -> List[t.DealData]:
             return getUploads.get_uploads(publicKey, pageNo)
         except Exception as e:
             raise e
+
+    @staticmethod
+    def download(cid: str) -> bytes:
+        """
+        Download content from the Lighthouse using its Content Identifier (CID).
+
+        :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

@@ -8,3 +8,4 @@ class Config:
     lighthouse_api = 'https://api.lighthouse.storage'
     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 + "/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 + "/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_deal_status.py

@@ -14,7 +14,7 @@ def test_deal_status(self):
         res = Lighthouse.getDealStatus(
             "QmT9shXpKcn4HRbJhXJ1ZywzwjEo2QWbxAx4SVgW4eYKjG")
         self.assertIsInstance(res, list, "data is a list")
-        self.assertNotEqual(res[0].get(
+        self.assertIsInstance(res[0].get(
             "dealId"), int, "dealId is Int")
 
     def test_deal_status_init(self):
@@ -24,5 +24,5 @@ def test_deal_status_init(self):
         res = l.getDealStatus(
             "QmT9shXpKcn4HRbJhXJ1ZywzwjEo2QWbxAx4SVgW4eYKjG")
         self.assertIsInstance(res, list, "data is a list")
-        self.assertNotEqual(res[0].get(
+        self.assertIsInstance(res[0].get(
             "dealId"), int, "dealId is Int")

tests/test_download.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+import os
+import io
+import unittest
+from src.lighthouseweb3 import Lighthouse
+from src.lighthouseweb3.functions.utils import NamedBufferedReader
+from .setup import parse_env
+import string
+import secrets
+
+
+def generate_random_string(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+
+class TestDownload(unittest.TestCase):
+    def setUp(self) -> None:
+        """setup test environment"""
+        parse_env()
+
+    def test_env(self):
+        """test env var"""
+        self.assertNotEqual(
+            os.environ.get("LIGHTHOUSE_TOKEN"), None, "token is not None"
+        )
+
+    def test_download_file(self):
+        """test Upload function"""
+        l = Lighthouse()  # will use env var
+        res, _ = l.download(
+            "Qmd5MBBScDUV3Ly8qahXtZFqyRRfYSmUwEcxpYcV4hzKfW")
+        self.assertIsInstance(res, bytes, "type doesn't match")
+        self.assertEqual(res, b'tests/testdir/', "data doesn't match")
+
+    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(res.get("data").get("Size"),
+                             123939, "File Size dont match")
+
+
+
+if __name__ == "__main__":
+    unittest.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()