main.py

# used by OTALA written by ciscoquan--2025

import requests
import time
import json
import mimetypes


class Pinata:
    """
    A client for interacting with the Pinata IPFS API.

    This class provides methods to upload files to IPFS through Pinata and generate
    signed URLs for accessing the uploaded content.

    Attributes:
        headers (dict): Authorization headers for API requests
    """

    def __init__(self, bearer_token):
        """
        Initialize the Pinata client with authentication.

        Args:
            bearer_token (str): The Pinata Bearer token for API authentication
        """
        self.headers = {"Authorization": "Bearer {0}".format(bearer_token)}

    def upload_files(
        self, uploaded_file, filename: str, mime: str = None
    ) -> str:
        """
        Upload a file to IPFS through Pinata's API.

        Args:
            uploaded_file: A file-like object opened in binary mode
            filename (str): The name of the file to be uploaded
            mime (str, optional): The MIME type of the file. If not provided,
                                it will be automatically detected

        Returns:
            str: The CID (Content Identifier) of the uploaded file if successful,
                 None if the upload fails

        Examples:
            >>> with open('image.jpg', 'rb') as f:
            ...     cid = pinata.upload_files(f, 'image.jpg', 'image/jpeg')
            >>> print(cid)
            'QmX...'
        """
        api_url = "https://uploads.pinata.cloud/v3/files"

        # Guess MIME type if not provided
        if mime is None:
            mime, _ = mimetypes.guess_type(filename)
            if mime is None:
                mime = "application/octet-stream"  # Fallback MIME type

        try:
            files = [
                ("file", (filename, uploaded_file, mime))
            ]  # Directly use the file-like object

            # Debugging: Print request details
            print(f"Filename: {filename}")
            print(f"MIME type: {mime}")
            print(f"File object: {uploaded_file}")

            response = requests.post(
                api_url,
                headers=self.headers,
                data={},  # Explicitly set data to an empty dictionary
                files=files,
            )
            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)

            print("File uploaded successfully!")
            data = response.json()
            cid = data["data"]["cid"]
            return cid

        except requests.exceptions.RequestException as e:
            print(f"Error uploading file: {e}")
            if response is not None:
                print(
                    f"Response content: {response.text}"
                )  # Print response for debugging
            return None
        except Exception as e:
            print(f"A general error occurred: {e}")
            return None

    def retrieve_file_url(
        self,
        gateway_url: str,
        cid: str,
        method: str = "GET",
        expires: int = 31536000,
    ) -> str:
        """
        Generate a signed URL for accessing an uploaded file.

        Args:
            gateway_url (str): The base gateway URL for accessing the file
            cid (str): The Content Identifier (CID) of the uploaded file
            method (str, optional): HTTP method for the signed URL. Defaults to "GET"
            expires (int, optional): URL expiration time in seconds. Defaults to 1 year

        Returns:
            str: A signed URL if successful, None if the operation fails

        Examples:
            >>> url = pinata.retrieve_file_url(
            ...     "https://gateway.pinata.cloud/",
            ...     "QmX...",
            ...     expires=3600
            ... )
            >>> print(url)
            'https://gateway.pinata.cloud/QmX...?signature=...'
        """

        self.headers.update({"Content-Type": "application/json"})

        current_timestamp = int(time.time())
        api_url = "https://api.pinata.cloud/v3/files/sign"
        try:
            data = json.dumps(
                {
                    "url": gateway_url + cid,
                    "method": method,
                    "expires": expires,
                    "date": current_timestamp,
                }
            )
            response = requests.post(api_url, data=data, headers=self.headers)

            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
            print("File uploaded successfully!")
            data = response.json()
            return data["data"]

        except requests.exceptions.RequestException as e:
            print(f"Error uploading file: {e}")
            if response is not None:
                print(
                    f"Response content: {response.text}"
                )  # Print response for debugging
            return None
        except Exception as e:
            print(f"A general error occurred: {e}")
            return None