feat: created util functions for initial setup

Author: opensaucerer

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  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/

__init__.py

@@ -0,0 +1,59 @@
+from io import BufferedReader
+from typing import Dict, List
+import requests as req
+
+
+class Axios:
+    def __init__(self, url: str):
+        self.url = url
+
+    def parse_url_params(self, params: Dict[str, str]):
+        try:
+            if params is not None and isinstance(params, dict):
+                for key, value in params.items():
+                    self.url += f"&{key}={value}"
+        except Exception as e:
+            print(e)
+            return e
+
+    def get(self, headers: Dict[str, str] = None, **kwargs) -> dict | Exception:
+        try:
+            self.parse_url_params(kwargs.get("params", None))
+            r = req.get(self.url, headers=headers)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            print(e)
+            return e
+
+    def post(
+        self, body=None, headers: Dict[str, str] = None, **kwargs
+    ) -> dict | Exception:
+        try:
+            self.parse_url_params(kwargs.get("params", None))
+            r = req.post(self.url, data=body, headers=headers)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            print(e)
+            return e
+
+    def read_files(self, files: List[str]) -> List[BufferedReader]:
+        file_list = []
+        for file in files:
+            with open(file, "rb") as f:
+                file_list.append(f)
+        return file_list
+
+    def post_file(
+        self, file: List[str], headers: Dict[str, str] = None, **kwargs
+    ) -> dict | Exception:
+        try:
+            self.parse_url_params(kwargs.get("params", None))
+            files = self.read_files(file)
+            r = req.post(self.url, files=files, headers=headers)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            print(e)
+            return e

axios.py

@@ -0,0 +1,5 @@
+# configuration file for project
+class Config:
+    lighthouse_api = "https://api.lighthouse.storage"
+    lighthouse_node = "https://node.lighthouse.storage"
+    lighthouse_bls_node = "https://encryption.lighthouse.storage"

config.py

@@ -0,0 +1,40 @@
+from axios import Axios
+from utils import is_dir, walk_dir_tree
+from config import Config
+
+
+def deploy(source: str, token: str):
+    """
+    Deploy a file or directory to the lighthouse network
+    @params {source}: str, path to file or directory
+    @params {token}: str, lighthouse api token
+    """
+    try:
+        # create http object
+        axios = Axios(Config.lighthouse_node)
+        # create list of files to upload
+        file_list = []
+        # check if source is a directory
+        if is_dir(source):
+            # walk directory tree and add files to list
+            walk_dir_tree(source, file_list)
+        else:
+            # add file to list
+            file_list.append(source)
+
+        # create headers
+        """
+        "Content-type": `multipart/form-data; boundary= ${data._boundary}`,
+        "Encryption": false,
+        "Mime-Type": mimeType,
+        """
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "multipart/form-data",
+            "Encryption": "false",
+            "Mime-Type": "application/octet-stream",
+        }
+        # upload files
+        axios.post_file(file_list, headers)
+    except Exception as e:
+        print(e)

deploy.py

@@ -0,0 +1,9 @@
+# Lighthouse.py
+
+Lighthouse is a permanent decentralized file storage protocol that allows the ability to pay once and store forever. While traditionally, users need to repeatedly keep track and pay for their storage after every fixed amount of time, Lighthouse manages this for them and makes sure that user files are stored forever. The aim is to move users from a rent-based cost model where they are renting their own files on cloud storage to a permanent ownership model. It is built on top of IPFS, Filecoin, and Polygon. It uses the existing miner network and storage capacity of the filecoin network.
+
+# Installation
+
+```
+pip install lighthouse.py
+```

readme.md

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+
+import os
+from typing import List
+
+# walk path and return list of file paths
+def walk_dir_tree(path: str) -> List[str]:
+    file_list = []
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            file_list.append(os.path.join(root, file))
+    return file_list
+
+
+# check if file is a directory
+def is_dir(path: str) -> bool:
+    return os.path.isdir(path)