bifrostsdk 1.0.0__py3-none-any.whl

byfrost/s3/s3.py

@@ -0,0 +1,188 @@
+"""Bifrost interface for Amazon Simple Storage Service"""
+
+from byfrost.shared import errors
+from byfrost.shared.config import provider
+from ..shared.types.dataclass import file as bfile
+from ..shared.types.dataclass import bridge
+from typing import List, Tuple
+from ..shared.errors.interface import BifrostError
+from ..shared.config import option, url
+from ..shared.errors import loga
+import boto3
+import os
+
+
+class SimpleStorageService:
+    def __init__(self, bc: bridge.BridgeConfig, client: boto3.client):
+        self.provider = provider.providers[bc.provider]
+        self.default_bucket = bc.default_bucket
+        self.region = bc.region
+        self.access_key = bc.access_key
+        self.secret_key = bc.secret_key
+        self.default_timeout = bc.default_timeout
+        self.client = client
+        self.enable_debug = bc.enable_debug
+        self.public_read = bc.public_read
+        self.use_async = bc.use_async
+
+    def upload_file(
+        self, file_face: bfile.File
+    ) -> Tuple[bfile.UploadedFile, BifrostError]:
+        """upload_file uploads a file to Amazon Simple Storage Service and returns an error if one occurs."""
+        if file_face is None:
+            return None, BifrostError("file is none", errors.ErrBadRequest)
+
+        # verify that the file is derived from File
+        if not isinstance(file_face, bfile.File):
+            return None, BifrostError(
+                "invalid file type: {}".format(type(file_face)), errors.ErrBadRequest
+            )
+
+        # verify that the file has a valid path
+        if file_face.path is None or file_face.path == "":
+            return None, BifrostError("no path specified", errors.ErrBadRequest)
+
+        if file_face.filename is None or file_face.filename == "":
+            file_face.filename = os.path.basename(file_face.path)
+        else:
+            base_name, ext = os.path.splitext(file_face.filename)
+            if ext == "":  # If the provided filename has no extension
+                # Extract the extension from the path and append it to the filename
+                _, ext_from_path = os.path.splitext(file_face.path)
+                file_face.filename += ext_from_path
+
+        # verify that the file has a valid options
+        if file_face.options is None:
+            file_face.options = bfile.Options()
+
+        # verify the connection
+        if not self.is_connected():
+            return None, BifrostError(
+                "no active Amazon Simple Storage Service client", errors.ErrClientError
+            )
+        # verify that the file has a valid acl
+        if (
+            file_face.options.acl is None
+            or file_face.options.acl == ""
+            and self.public_read
+        ):
+            file_face.options.acl = option.ACLPublicRead
+
+        # verify that the file has a valid metadata
+        if file_face.options.metadata is None:
+            file_face.options.metadata = {}
+
+        # upload file to Amazon Simple Storage Service
+        obj = self.client.Object(self.default_bucket, file_face.filename)
+        with open(file_face.path, "rb") as f:
+            obj.put(
+                Body=f,
+                ACL=file_face.options.acl,
+                Metadata=file_face.options.metadata,
+            )
+        obj = obj.get()
+
+        return (
+            bfile.UploadedFile(
+                name=file_face.filename,
+                bucket=self.default_bucket,
+                path=file_face.path,
+                size=obj["ContentLength"],
+                url=url.URLSimpleStorageService.format(
+                    self.default_bucket, self.region, file_face.filename
+                ),
+                preview=url.URLSimpleStorageService.format(
+                    self.default_bucket, self.region, file_face.filename
+                ),
+                provider_object=obj,
+            ),
+            None,
+        )
+
+    def upload_multi_file(
+        self,
+        multi_face: bfile.MultiFile,
+    ) -> Tuple[List[bfile.UploadedFile], BifrostError]:
+        """upload multi file uploads multiple files to Amazon Simple Storage Service and returns an error if one occurs."""
+        if multi_face is None:
+            return None, BifrostError("multi file is none", errors.ErrBadRequest)
+
+        # verify that the multi file is derived from MultiFile
+        if not isinstance(multi_face, bfile.MultiFile):
+            return None, BifrostError(
+                "invalid multi file type: {}".format(type(multi_face)),
+                errors.ErrBadRequest,
+            )
+
+        # verify that the multi file has a valid files
+        if multi_face.files is None or len(multi_face.files) == 0:
+            return None, BifrostError("no files specified", errors.ErrBadRequest)
+
+        # verify the connection
+        if not self.is_connected():
+            return None, BifrostError(
+                "no active Amazon Simple Storage Service client", errors.ErrClientError
+            )
+
+        # upload files to Amazon Simple Storage Service
+        uploaded_files = []
+
+        for file_face in multi_face.files:
+            # verify that the multi file has a valid global options
+            if multi_face.global_options is not None:
+                # for each option in the global option dataclass, if it is not present in the file option dataclass, then add it to the file option dataclass
+                for option in multi_face.global_options.__dataclass_fields__:
+                    if not hasattr(file_face.options, option):
+                        setattr(
+                            file_face.options,
+                            option,
+                            getattr(multi_face.global_options, option),
+                        )
+
+            uploaded_file, err = self.upload_file(file_face)
+
+            if err is not None:
+                if self.enable_debug:
+                    loga.error(
+                        "Upload for file at path %s failed with err: %s",
+                        file_face.path,
+                        err.message,
+                    )
+                uploaded_files.append(
+                    bfile.UploadedFile(
+                        error=err, name=file_face.filename, path=file_face.path
+                    )
+                )
+                continue
+            uploaded_files.append(uploaded_file)
+        return uploaded_files, None
+
+    def disconnect(self) -> BifrostError:
+        """disconnect closes the Amazon Simple Storage Service client connection and returns an error if one occurs."""
+        if self.is_connected():
+            self.client = None
+
+    def config(self) -> bridge.BridgeConfig:
+        """config returns the provider configuration."""
+        return bridge.BridgeConfig(
+            provider=self.provider,
+            region=self.region,
+            default_bucket=self.default_bucket,
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            default_timeout=self.default_timeout,
+            enable_debug=self.enable_debug,
+            public_read=self.public_read,
+            use_async=self.use_async,
+        )
+
+    def is_connected(self) -> bool:
+        """is_connected returns true if there is an active connection to the provider."""
+        return self.client is not None
+
+    def upload_folder(
+        self,
+        fold_face: bfile.MultiFile,
+    ) -> Tuple[List[bfile.UploadedFile], BifrostError]:
+        """upload_folder uploads a folder to the Simple Storage Service and returns an error if one occurs."""
+        ...

byfrost/s3/s3.pyi

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+    The RainbowBridge interface for Google Cloud Storage
+
+    All providers must implement this interface completely
+"""
+
+from ..shared.types.dataclass import file as bfile
+from ..shared.types.dataclass import bridge
+from typing import List, Tuple
+from ..shared.errors.interface import ByfrostError
+import boto3
+
+class SimpleStorageService:
+    """Simple Storage Service is the Google Cloud Storage class"""
+
+    def __init__(self, bc: bridge.BridgeConfig):
+        """__init__ initializes the Simple Storage Service class."""
+        ...
+    def upload_file(
+        self, file_face: bfile.File
+    ) -> Tuple[bfile.UploadedFile, ByfrostError]:
+        """
+        upload_file uploads a file to the provider storage and returns an error if one occurs.
+
+        Note: for some providers, upload_file requires that a default bucket be set in bifrosbfile.BridgeConfig.
+        """
+        ...
+    def upload_multi_file(
+        self,
+        multi_face: bfile.MultiFile,
+    ) -> Tuple[List[bfile.UploadedFile], ByfrostError]:
+        """
+        upload_multi_file uploads mutliple files to the provider storage and returns an error if one occurs. If any of the uploads fail, the error is appended to the []UploadedFile.Error and also logged when debug is enabled while the rest of the uploads continue.
+
+        Note: for some providers, UploadMultiFile requires that a default bucket be set in bifrosbfile.BridgeConfig.
+        """
+        ...
+    def disconnect(self) -> ByfrostError:
+        """
+        disconnect closes the provider client connection and returns an error if one occurs.
+
+        Disconnect should only be called when the connection is no longer needed.
+        """
+        ...
+    def config(self) -> bridge.BridgeConfig:
+        """
+        config returns the provider configuration.
+        """
+        ...
+    def is_connected(self) -> bool:
+        """
+        is_connected returns true if there is an active connection to the provider.
+        """
+        ...
+    def upload_folder(
+        self,
+        fold_face: bfile.MultiFile,
+    ) -> Tuple[List[bfile.UploadedFile], ByfrostError]:
+        """
+        upload_folder uploads a folder to the provider storage and returns an error if one occurs.
+
+        Note: for some providers, upload_folder requires that a default bucket be set in bifrosbfile.BridgeConfig.
+        """
+        ...

byfrost/shared/__init__.py

@@ -0,0 +1,3 @@
+# from byfrost.shared.errors.interface import BifrostError
+
+# __name__ = "shared"

byfrost/shared/config/__init__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+from .option import (
+    OptACL,
+    ACLPublicRead,
+    ACLPrivate,
+    OptContentType,
+    OptMetadata,
+    OptPinata,
+)
+from .provider import PinataCloud, SimpleStorageService, GoogleCloudStorage, providers
+from .request import (
+    ReqAuth,
+    ReqBearer,
+    ReqContentType,
+    MethodGet,
+    MethodPost,
+    MethodPut,
+    MethodDelete,
+)
+from .url import (
+    URLPinataPinFile,
+    URLPinataPinJSON,
+    URLPinataPinCID,
+    URLPinataAuth,
+    URLPinataGateway,
+    URLGoogleCloudStorage,
+    URLSimpleStorageService,
+)

byfrost/shared/config/__init__.pyi

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+from .option import (
+    OptACL,
+    ACLPublicRead,
+    ACLPrivate,
+    OptContentType,
+    OptMetadata,
+    OptPinata,
+)
+from .provider import PinataCloud, SimpleStorageService, GoogleCloudStorage, providers
+from .request import (
+    ReqAuth,
+    ReqBearer,
+    ReqContentType,
+    MethodGet,
+    MethodPost,
+    MethodPut,
+    MethodDelete,
+)
+from .url import (
+    URLPinataPinFile,
+    URLPinataPinJSON,
+    URLPinataPinCID,
+    URLPinataAuth,
+    URLPinataGateway,
+    URLGoogleCloudStorage,
+    URLSimpleStorageService,
+)

byfrost/shared/config/option.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+"""Options constants."""
+
+OptACL = "acl"
+"""ACL is the option to set the ACL of the file"""
+
+ACLPublicRead = "public-read"
+"""PublicRead is the option to set the ACL of the file to public read"""
+
+ACLPrivate = "private"
+"""Private is the option to set the ACL of the file to private"""
+
+OptContentType = "content-type"
+"""ContentType is the option to set the content type of the file"""
+
+OptMetadata = "metadata"
+"""Metadata is the option to set the metadata of the file"""
+
+OptPinata = "pinataOptions"
+"""OptPinata is the option to set the pinataOptions."""

byfrost/shared/config/provider.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+
+"""Provider constants"""
+
+from typing import Dict
+
+PinataCloud = "pinata"
+"""PinataCloud is the identifier of the Pinata Cloud storage."""
+
+SimpleStorageService = "s3"
+"""SimpleStorageService is the identifier of the S3 provider."""
+
+GoogleCloudStorage = "gcs"
+"""GoogleCloudStorage is the identifier of the Google Cloud Storage provider."""
+
+
+providers: Dict[str, str] = {
+    "pinata": "Pinata Cloud Storage",
+    "s3": "Simple Storage Service",
+    "gcs": "Google Cloud Storage",
+}
+"""providers is a map of the supported providers"""

byfrost/shared/config/request.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+
+"""Request constants"""
+
+ReqAuth = "Authorization"
+"""ReqAuth is the authorization header identifier."""
+
+ReqBearer = "Bearer %s"
+"""ReqBearer is the bearer token identifier."""
+
+ReqContentType = "Content-Type"
+"""ReqContentType is the content type header identifier."""
+
+MethodGet = "GET"
+"""MethodGet is the HTTP method for GET requests."""
+
+MethodPost = "POST"
+"""MethodPost is the HTTP method for POST requests."""
+
+MethodPut = "PUT"
+"""MethodPut is the HTTP method for PUT requests."""
+
+MethodDelete = "DELETE"
+"""MethodDelete is the HTTP method for DELETE requests."""

byfrost/shared/config/url.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+
+"""URL constants."""
+
+URLPinataPinFile = "https://api.pinata.cloud/pinning/pinFileToIPFS"
+"""URLPinataPinFile is the endpoint for pinning files/folders to Pinata cloud."""
+
+URLPinataPinJSON = "https://api.pinata.cloud/pinning/pinJSONToIPFS"
+"""URLPinataPinJSON is the endpoint for pinning JSON objects to Pinata cloud."""
+
+URLPinataPinCID = "https://api.pinata.cloud/pinning/pinByHash"
+"""URLPinataPinCID is the endpoint for pinning CIDs to Pinata cloud."""
+
+URLPinataAuth = "https://api.pinata.cloud/data/testAuthentication"
+"""URLPinataAuth is the endpoint for testing authentication against provided Pinata credentials."""
+
+URLPinataGateway = "https://gateway.pinata.cloud/ipfs/{}"
+"""URLPinataGateway is the public gateway for Pinata cloud."""
+
+URLGoogleCloudStorage = "https://storage.googleapis.com/{}/{}"
+"""URLGoogleCloudStorage is the public gateway for Google Cloud Storage."""
+
+URLSimpleStorageService = "https://{}.s3.{}.amazonaws.com/{}"
+"""URLSimpleStorageService is the public gateway for Simple Storage Service."""

byfrost/shared/errors/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+from .color import WARN, DEBUG, INFO, ERROR, RESET
+from .constant import (
+    ErrBadRequest,
+    ErrClientError,
+    ErrFileOperationFailed,
+    ErrIncompleteMultiFileUpload,
+    ErrInvalidBucket,
+    ErrInvalidConfig,
+    ErrInvalidCredentials,
+    ErrInvalidProvider,
+    ErrUnauthorized,
+)
+from .interface import BifrostError
+from .loga import warn, error, info, debug

byfrost/shared/errors/__init__.pyi

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+from .color import WARN, DEBUG, INFO, ERROR, RESET
+from .constant import (
+    ErrBadRequest,
+    ErrClientError,
+    ErrFileOperationFailed,
+    ErrIncompleteMultiFileUpload,
+    ErrInvalidBucket,
+    ErrInvalidConfig,
+    ErrInvalidCredentials,
+    ErrInvalidProvider,
+    ErrUnauthorized,
+)
+from .interface import BifrostError
+from .loga import warn, error, info, debug

byfrost/shared/errors/color.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+
+"""Error color codes"""
+
+WARN = "\033[0;33m"
+"""Yellow color code"""
+
+ERROR = "\033[0;31m"
+"""Red color code"""
+
+INFO = "\033[0;32m"
+"""Green color code"""
+
+DEBUG = "\033[0;34m"
+"""Blue color code"""
+
+RESET = "\033[0m"
+"""Reset color code"""

byfrost/shared/errors/constant.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+"""Error constants for Bifrost."""
+
+ErrBadRequest = "bad request"
+"""ErrBadRequest is returned when something fails due to client error."""
+
+ErrUnauthorized = "unauthorized"
+"""ErrUnauthorized is returned when something fails due to client not being authorized."""
+
+ErrInvalidConfig = "invalid config"
+"""ErrInvalidConfig is returned when the config is invalid."""
+
+ErrInvalidBucket = "invalid bucket"
+"""ErrInvalidBucket is returned when the bucket is invalid."""
+
+ErrInvalidProvider = "invalid provider"
+"""ErrInvalidProvider is returned when the provider is invalid."""
+
+ErrInvalidCredentials = "invalid credentials"
+"""ErrInvalidCredentials is returned when the authentication credentials are invalid."""
+
+ErrFileOperationFailed = "file operation failed"
+"""ErrFileOperationFailed is returned when a file operation fails."""
+
+ErrIncompleteMultiFileUpload = "incomplete files upload"
+"""ErrIncompleteMultiFileUpload is returned when a multifile upload fails on some files."""
+
+ErrClientError = "client error"
+"""ErrClientError is returned when the client returns an error."""

byfrost/shared/errors/interface.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+from typing import Any
+
+
+class BifrostError(Exception):
+    """Bifrost Error Class is the class for all Bifrost errors."""
+
+    def __init__(self, error: str = "", code: str = ""):
+        super().__init__(error)
+        self.error = error
+        self.code = code
+
+    def __str__(self) -> str:
+        return f"{self.code} :: {self.error}"
+
+    def nil(self) -> bool:
+        return self.error == "" and self.code == ""
+
+    def code(self) -> str:
+        return self.code

byfrost/shared/errors/interface.pyi

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+from typing import Any
+
+class BifrostError(Exception):
+    """BifrostError is the class for all bifrost errors."""
+
+    error: str
+    """error is the error message."""
+    code: str
+    """code is the error code."""
+
+    def __init__(self, error: str = "", code: str = ""): ...
+    def __str__(self) -> str: ...
+    """__str__ returns the error message."""
+
+    def nil(self) -> bool: ...
+    """nil returns true if the error is nil."""
+
+    def code(self) -> str: ...
+    """code returns the error code."""

byfrost/shared/errors/loga.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+from datetime import datetime
+from .color import WARN, DEBUG, INFO, ERROR, RESET
+
+
+def _get_formatted_date_time() -> str:
+    return datetime.now().isoformat(sep=" ", timespec="seconds")
+
+
+def _get_logger(level: str) -> str:
+    return _get_formatted_date_time() + " " + level + "{}" + RESET
+
+
+def warn(message: str) -> None:
+    print(_get_logger(WARN).format(message))
+
+
+def error(message: str) -> None:
+    print(_get_logger(ERROR).format(message))
+
+
+def info(message: str) -> None:
+    print(_get_logger(INFO).format(message))
+
+
+def debug(message: str) -> None:
+    print(_get_logger(DEBUG).format(message))

byfrost/shared/errors/loga.pyi

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+def _get_logger(level: str) -> str:
+    """_get_logger returns a logger with the given level"""
+    ...
+
+def warn(message: str) -> None:
+    """warn logs a warning message with color yellow"""
+    ...
+
+def error(message: str) -> None:
+    """error logs an error message with color red"""
+    ...
+
+def info(message: str) -> None:
+    """info logs an info message with color green"""
+    ...
+
+def debug(message: str) -> None:
+    """debug logs a debug message with color blue"""
+    ...

byfrost/shared/request/__init__.py

@@ -0,0 +1 @@
+from .builder import Client, new_client

byfrost/shared/request/__init__.pyi

@@ -0,0 +1 @@
+from .builder import Client, new_client

byfrost/shared/request/builder.py

@@ -0,0 +1,51 @@
+import requests
+from ..types.dataclass import file as bfile
+from requests_toolbelt import MultipartEncoder
+from typing import Any
+
+
+class Client:
+    def __init__(self, session: requests.Session, url: str):
+        self.session = session
+        self.url = url
+
+    def post_form(self, url: str, params: bfile.Param) -> (Any, Exception):
+        multipart_fields = {}
+        if params.files:
+            for pf in params.files:
+                multipart_fields[pf.key] = (
+                    pf.name,
+                    open(pf.path, "rb"),
+                    "multipart/form-data",
+                )
+
+        if params.data:
+            for pd in params.data:
+                multipart_fields[pd.key] = pd.value
+
+        encoder = MultipartEncoder(fields=multipart_fields)
+        headers = {"Content-Type": encoder.content_type}
+
+        try:
+            response = self.session.post(url, data=encoder, headers=headers)
+            response.raise_for_status()
+            return response.json(), None
+        except Exception as e:
+            return None, e
+
+
+def new_client(url, token, timeout):
+    try:
+        # Create a session object with a bearer token in the headers
+        session = requests.Session()
+        headers = {"authorization": f"Bearer {token}"}
+        session.headers.update(headers)
+
+        # Set timeout if it is greater than 0
+        if timeout > 0:
+            session.timeout = timeout
+
+        return Client(session, url)
+    except Exception as e:
+        # Handle any exceptions during client initialization
+        return f"Error during client initialization:", {e}

byfrost/shared/types/__init__.py

@@ -0,0 +1 @@
+from byfrost.shared.errors.interface import BifrostError

byfrost/shared/types/dataclass/__init__.py

@@ -0,0 +1,4 @@
+#!usr/bin/env python3
+
+from .bridge import BridgeConfig, RainbowBridge
+from .file import Options, File, MultiFile, ParamFile, ParamData, Param, UploadedFile

byfrost/shared/types/dataclass/__init__.pyi

@@ -0,0 +1,4 @@
+#!usr/bin/env python3
+
+from .bridge import BridgeConfig, RainbowBridge
+from .file import Options, File, MultiFile, ParamFile, ParamData, Param, UploadedFile