jigsawstack 0.1.26__py3-none-any.whl

jigsawstack/__init__.py

@@ -0,0 +1,232 @@
+from typing import Union
+import os
+from .audio import Audio, AsyncAudio
+from .vision import Vision, AsyncVision
+from .search import Search
+from .prediction import Prediction, AsyncPrediction
+from .sql import SQL, AsyncSQL
+from .store import Store, AsyncStore
+from .translate import Translate, AsyncTranslate
+from .web import Web, AsyncWeb
+from .sentiment import Sentiment, AsyncSentiment
+from .validate import Validate, AsyncValidate
+from .summary import Summary, AsyncSummary
+from .geo import Geo, AsyncGeo
+from .prompt_engine import PromptEngine, AsyncPromptEngine
+from .embedding import Embedding, AsyncEmbedding
+from .exceptions import JigsawStackError
+
+
+class JigsawStack:
+    audio: Audio
+    vision: Vision
+    file: Store
+    web: Web
+    search: Search
+    geo: Geo
+    prompt_engine: PromptEngine
+    api_key: str
+    api_url: str
+    disable_request_logging: bool
+
+    def __init__(
+        self,
+        api_key: Union[str, None] = None,
+        api_url: Union[str, None] = None,
+        disable_request_logging: Union[bool, None] = None,
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get("JIGSAWSTACK_API_KEY")
+
+        if api_key is None:
+            raise ValueError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the JIGSAWSTACK_API_KEY environment variable"
+            )
+
+        if api_url is None:
+            api_url = os.environ.get("JIGSAWSTACK_API_URL")
+        if api_url is None:
+            api_url = f"https://api.jigsawstack.com/v1"
+
+        self.api_key = api_key
+        self.api_url = api_url
+
+        self.audio = Audio(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.web = Web(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.sentiment = Sentiment(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).analyze
+        self.validate = Validate(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.summary = Summary(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).summarize
+        self.vision = Vision(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.prediction = Prediction(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).predict
+        self.text_to_sql = SQL(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).text_to_sql
+        self.store = Store(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.translate = Translate(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).translate
+        self.geo = Geo(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.prompt_engine = PromptEngine(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.embedding = Embedding(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).execute
+
+
+class AsyncJigsawStack:
+    geo: AsyncGeo
+    validate: AsyncValidate
+    web: AsyncWeb
+    audio: AsyncAudio
+    vision: AsyncVision
+    store: AsyncStore
+    prompt_engine: AsyncPromptEngine
+    api_key: str
+    api_url: str
+    disable_request_logging: bool
+
+    def __init__(
+        self,
+        api_key: Union[str, None] = None,
+        api_url: Union[str, None] = None,
+        disable_request_logging: Union[bool, None] = None,
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get("JIGSAWSTACK_API_KEY")
+
+        if api_key is None:
+            raise ValueError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the JIGSAWSTACK_API_KEY environment variable"
+            )
+
+        if api_url is None:
+            api_url = os.environ.get("JIGSAWSTACK_API_URL")
+        if api_url is None:
+            api_url = f"https://api.jigsawstack.com/v1"
+
+        self.api_key = api_key
+        self.api_url = api_url
+
+        self.web = AsyncWeb(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+
+        self.geo = AsyncGeo(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+
+        self.validate = AsyncValidate(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.audio = AsyncAudio(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+
+        self.vision = AsyncVision(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+
+        self.store = AsyncStore(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+
+        self.summary = AsyncSummary(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).summarize
+
+        self.prediction = AsyncPrediction(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).predict
+        self.text_to_sql = AsyncSQL(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).text_to_sql
+
+        self.sentiment = AsyncSentiment(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).analyze
+
+        self.translate = AsyncTranslate(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).translate
+
+        self.prompt_engine = AsyncPromptEngine(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        )
+        self.embedding = AsyncEmbedding(
+            api_key=api_key,
+            api_url=api_url,
+            disable_request_logging=disable_request_logging,
+        ).execute
+
+
+# Create a global instance of the Web class
+__all__ = ["JigsawStack", "Search", "JigsawStackError", "AsyncJigsawStack"]

jigsawstack/_client.py

@@ -0,0 +1,62 @@
+from typing import Union
+import os
+from .audio import Audio
+from .vision import Vision
+from .search import Search
+from .prediction import Prediction
+from .sql import SQL
+from .store import KV, File
+from .translate import Translate
+from .web import Web
+from .sentiment import Sentiment
+from .validate import Validate
+from .summary import Summary
+
+
+class JigsawStack:
+    audio: Audio
+    vision: Vision
+    prediction: Prediction
+    sql: SQL
+    file: File
+    kv: KV
+    translate: Translate
+    web: Web
+    sentiment: Sentiment
+    validate: Validate
+    summary: Summary
+    search: Search
+    api_key: str
+    api_url: str
+
+    def __init__(
+        self, api_key: Union[str, None] = None, api_url: Union[str, None] = None
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get("JIGSAWSTACK_API_KEY")
+
+        if api_key is None:
+            raise ValueError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the JIGSAWSTACK_API_KEY environment variable"
+            )
+
+        if api_url is None:
+            api_url = os.environ.get("JIGSAWSTACK_API_URL")
+        if api_url is None:
+            api_url = f"https://api.jigsawstack.com/v1"
+
+        self.api_key = api_key
+        self.api_url = api_url
+
+        self.audio = Audio(api_key=api_key, api_url=api_url)
+        self.web = Web(api_key=api_key, api_url=api_url)
+        self.search = Search(api_key=api_key, api_url=api_url)
+        self.sentiment = Sentiment(api_key=api_key, api_url=api_url)
+        self.validate = Validate(api_key=api_key, api_url=api_url)
+        self.summary = Summary(api_key=api_key, api_url=api_url)
+        self.vision = Vision(api_key=api_key, api_url=api_url)
+        self.prediction = Prediction(api_key=api_key, api_url=api_url)
+        self.sql = SQL(api_key=api_key, api_url=api_url)
+        self.file = File(api_key=api_key, api_url=api_url)
+        self.kv = KV(api_key=api_key, api_url=api_url)
+        self.translate = Translate(api_key=api_key, api_url=api_url)

jigsawstack/_config.py

@@ -0,0 +1,17 @@
+from typing import Union
+
+
+class ClientConfig:
+    base_url: str
+    api_key: str
+    disable_request_logging: Union[bool, None] = None
+
+    def __init__(
+        self,
+        api_key: str,
+        api_url: str,
+        disable_request_logging: Union[bool, None] = None,
+    ):
+        self.api_key = api_key
+        self.api_url = api_url
+        self.disable_request_logging = disable_request_logging

jigsawstack/async_request.py

@@ -0,0 +1,266 @@
+from typing import Any, Dict, Generic, List, Union, cast, TypedDict, AsyncGenerator
+import aiohttp
+from typing_extensions import Literal, TypeVar
+from .exceptions import NoContentError, raise_for_code_and_type
+import json
+
+RequestVerb = Literal["get", "post", "put", "patch", "delete"]
+
+T = TypeVar("T")
+
+
+class AsyncRequestConfig(TypedDict):
+    api_url: str
+    api_key: str
+    disable_request_logging: Union[bool, None] = False
+
+
+class AsyncRequest(Generic[T]):
+    def __init__(
+        self,
+        config: AsyncRequestConfig,
+        path: str,
+        params: Union[Dict[Any, Any], List[Dict[Any, Any]]],
+        verb: RequestVerb,
+        headers: Dict[str, str] = {"Content-Type": "application/json"},
+        data: Union[bytes, None] = None,
+        stream: Union[bool, None] = False,
+    ):
+        self.path = path
+        self.params = params
+        self.verb = verb
+        self.api_url = config.get("api_url")
+        self.api_key = config.get("api_key")
+        self.data = data
+        self.headers = headers
+        self.disable_request_logging = config.get("disable_request_logging")
+        self.stream = stream
+
+    async def perform(self) -> Union[T, None]:
+        """
+        Async method to make an HTTP request to the JigsawStack API.
+
+        Returns:
+            Union[T, None]: A generic type of the Request class or None
+
+        Raises:
+            aiohttp.ClientResponseError: If the request fails
+        """
+        async with self.__get_session() as session:
+            resp = await self.make_request(session, url=f"{self.api_url}{self.path}")
+
+            # delete calls do not return a body
+            if await resp.text() == "" and resp.status == 200:
+                return None
+
+            # safety net for non-JSON responses
+            content_type = resp.headers.get("content-type", "")
+            if "application/json" not in content_type:
+                raise_for_code_and_type(
+                    code=500,
+                    message="Failed to parse JigsawStack API response. Please try again.",
+                )
+
+            # handle error responses
+            if resp.status != 200:
+                error = await resp.json()
+                raise_for_code_and_type(
+                    code=resp.status,
+                    message=error.get("message"),
+                    err=error.get("error"),
+                )
+
+            return cast(T, await resp.json())
+
+    async def perform_file(self) -> Union[aiohttp.ClientResponse, None]:
+        """
+        Async method to make an HTTP request and return the raw response.
+
+        Returns:
+            Union[aiohttp.ClientResponse, None]: The raw response object
+        """
+        async with self.__get_session() as session:
+            resp = await self.make_request(session, url=f"{self.api_url}{self.path}")
+
+            # delete calls do not return a body
+            if await resp.text() == "" and resp.status == 200:
+                return None
+
+            # handle error responses
+            if (
+                "application/json" not in resp.headers.get("content-type", "")
+                and resp.status != 200
+            ):
+                raise_for_code_and_type(
+                    code=500,
+                    message="Failed to parse JigsawStack API response. Please try again.",
+                    error_type="InternalServerError",
+                )
+
+            if resp.status != 200:
+                error = await resp.json()
+                raise_for_code_and_type(
+                    code=resp.status,
+                    message=error.get("message"),
+                    err=error.get("error"),
+                )
+            return resp
+
+    async def perform_with_content(self) -> T:
+        """
+        Perform an async HTTP request and return the response content.
+
+        Returns:
+            T: The content of the response
+
+        Raises:
+            NoContentError: If the response content is `None`.
+        """
+        resp = await self.perform()
+        if resp is None:
+            raise NoContentError()
+        return resp
+
+    async def perform_with_content_file(self) -> Union[aiohttp.ClientResponse, None]:
+        """
+        Perform an async HTTP request and return the raw response.
+
+        Returns:
+            Union[aiohttp.ClientResponse, None]: The raw response
+
+        Raises:
+            NoContentError: If the response content is `None`.
+        """
+        resp = await self.perform_file()
+        if resp is None:
+            raise NoContentError()
+        return resp
+
+    def __get_headers(self) -> Dict[str, str]:
+        """
+        Prepare HTTP headers for the request.
+
+        Returns:
+            Dict[str, str]: Configured HTTP Headers
+        """
+        h = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "x-api-key": f"{self.api_key}",
+        }
+
+        if self.disable_request_logging:
+            h["x-jigsaw-no-request-log"] = "true"
+
+        _headers = h.copy()
+        _headers.update(self.headers)
+
+        return _headers
+
+    async def perform_streaming(self) -> AsyncGenerator[Union[T, str], None]:
+        """
+        Async method to stream response from JigsawStack API.
+
+        Returns:
+            AsyncGenerator[Union[T, str], None]: A generator of response chunks
+        """
+        async with self.__get_session() as session:
+            resp = await self.make_request(session, url=f"{self.api_url}{self.path}")
+
+            # delete calls do not return a body
+            if await resp.text() == "":
+                return
+
+            if resp.status != 200:
+                error = await resp.json()
+                raise_for_code_and_type(
+                    code=resp.status,
+                    message=error.get("message"),
+                    err=error.get("error"),
+                )
+
+            async for chunk in resp.content.iter_chunked(1024):  # 1KB chunks
+                if chunk:
+                    yield await self.__try_parse_data(chunk)
+
+    async def perform_with_content_streaming(
+        self,
+    ) -> AsyncGenerator[Union[T, str], None]:
+        """
+        Perform an async HTTP request and return the response content as a streaming response.
+
+        Returns:
+            AsyncGenerator[Union[T, str], None]: Streaming response content
+
+        Raises:
+            NoContentError: If the response content is `None`.
+        """
+        resp = await self.perform_streaming()
+        if resp is None:
+            raise NoContentError()
+        return resp
+
+    async def make_request(
+        self, session: aiohttp.ClientSession, url: str
+    ) -> aiohttp.ClientResponse:
+        """
+        Make the actual async HTTP request.
+
+        Args:
+            session (aiohttp.ClientSession): The client session
+            url (str): The URL to make the request to
+
+        Returns:
+            aiohttp.ClientResponse: The response object from the request
+        """
+        headers = self.__get_headers()
+        params = self.params
+        verb = self.verb
+        data = self.data
+
+        request_params = None if verb.lower() not in ["get", "delete"] else params
+
+        try:
+            return await session.request(
+                verb,
+                url,
+                params=request_params,
+                json=params,
+                headers=headers,
+                data=data,
+            )
+        except aiohttp.ClientError as e:
+            raise e
+
+    def __get_session(self) -> aiohttp.ClientSession:
+        """
+        Create and return an async client session.
+
+        Returns:
+            aiohttp.ClientSession: An async client session
+        """
+        return aiohttp.ClientSession()
+
+    @staticmethod
+    async def __try_parse_data(chunk: bytes) -> Union[T, str]:
+        """
+        Attempt to parse a chunk of data as JSON or return as text.
+
+        Args:
+            chunk (bytes): The data chunk to parse
+
+        Returns:
+            Union[T, str]: Parsed JSON or raw text
+        """
+        if not chunk:
+            return chunk
+
+        # Decode bytes to text
+        text = chunk.decode("utf-8")
+
+        try:
+            # Try to parse as JSON
+            return json.loads(text)
+        except json.JSONDecodeError:
+            # Return as text if not valid JSON
+            return text