groundx 2.4.5__tar.gz → 2.4.10__tar.gz

{groundx-2.4.5 → groundx-2.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: groundx
-Version: 2.4.5
+Version: 2.4.10
 Summary: 
 License: MIT
 Requires-Python: >=3.8,<4.0
@@ -22,11 +22,27 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: extract
 Requires-Dist: aiohttp (>=3.8.0)
+Requires-Dist: boto3 ; extra == "extract"
+Requires-Dist: celery ; extra == "extract"
+Requires-Dist: celery-types ; extra == "extract"
+Requires-Dist: dateparser ; extra == "extract"
+Requires-Dist: fastapi ; extra == "extract"
+Requires-Dist: google-api-python-client ; extra == "extract"
+Requires-Dist: google-api-python-client-stubs ; extra == "extract"
+Requires-Dist: google-auth-stubs ; extra == "extract"
+Requires-Dist: gspread ; extra == "extract"
 Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: minio ; extra == "extract"
+Requires-Dist: pandas ; extra == "extract"
+Requires-Dist: pandas-stubs ; extra == "extract"
+Requires-Dist: pillow ; extra == "extract"
 Requires-Dist: pydantic (>=1.9.2)
 Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: redis ; extra == "extract"
 Requires-Dist: requests (>=2.4.0)
 Requires-Dist: tqdm (>=4.60.0)
+Requires-Dist: types-boto3 ; extra == "extract"
+Requires-Dist: types-dateparser ; extra == "extract"
 Requires-Dist: types-tqdm (>=4.60.0)
 Requires-Dist: typing_extensions (>=4.0.0)
 Description-Content-Type: text/markdown

{groundx-2.4.5 → groundx-2.4.10}/pyproject.toml

@@ -3,7 +3,7 @@ name = "groundx"
 
 [tool.poetry]
 name = "groundx"
-version = "2.4.5"
+version = "2.4.10"
 description = ""
 readme = "README.md"
 authors = []
@@ -37,11 +37,27 @@ Repository = 'https://github.com/eyelevelai/groundx-python'
 [tool.poetry.dependencies]
 python = "^3.8"
 aiohttp = ">=3.8.0"
+boto3 = { version = "*", optional = true}
+celery = { version = "*", optional = true}
+celery-types = { version = "*", optional = true}
+dateparser = { version = "*", optional = true}
+fastapi = { version = "*", optional = true}
+google-api-python-client = { version = "*", optional = true}
+google-api-python-client-stubs = { version = "*", optional = true}
+google-auth-stubs = { version = "*", optional = true}
+gspread = { version = "*", optional = true}
 httpx = ">=0.21.2"
+minio = { version = "*", optional = true}
+pandas = { version = "*", optional = true}
+pandas-stubs = { version = "*", optional = true}
+pillow = { version = "*", optional = true}
 pydantic = ">= 1.9.2"
 pydantic-core = "^2.18.2"
+redis = { version = "*", optional = true}
 requests = ">=2.4.0"
 tqdm = ">=4.60.0"
+types-boto3 = { version = "*", optional = true}
+types-dateparser = { version = "*", optional = true}
 types-tqdm = ">=4.60.0"
 typing_extensions = ">= 4.0.0"
 
@@ -89,22 +105,37 @@ section-order = ["future", "standard-library", "third-party", "first-party"]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
-tool.poetry.dependencies.celery = { version = "*", optional = true, extras = ["redis"] }
-tool.poetry.dependencies.celery-types = { version = "*", optional = true }
-tool.poetry.dependencies.fastapi = { version = "*", optional = true }
-tool.poetry.dependencies.google-api-python-client = { version = "*", optional = true }
-tool.poetry.dependencies.google-api-python-client-stubs = { version = "*", optional = true }
-tool.poetry.dependencies.google-auth-stubs = { version = "*", optional = true }
-tool.poetry.dependencies.gspread = { version = "*", optional = true }
-tool.poetry.dependencies.boto3 = { version = "*", optional = true }
-tool.poetry.dependencies.types-boto3 = { version = "*", optional = true }
-tool.poetry.dependencies.dateparser = { version = "*", optional = true }
-tool.poetry.dependencies.minio = { version = "*", optional = true }
-tool.poetry.dependencies.pandas = { version = "*", optional = true }
-tool.poetry.dependencies.pandas-stubs = { version = "*", optional = true }
-tool.poetry.dependencies.redis = { version = "*", optional = true }
-tool.poetry.dependencies.smolagents = { version = ">=1.19.0", optional = true, extras = ["openai"] }
-tool.poetry.dependencies.pillow = { version = "*", optional = true }
-
 [tool.poetry.extras]
-extract=["celery", "celery-types", "fastapi", "google-api-python-client", "google-api-python-client-stubs", "google-auth-stubs", "gspread", "boto3", "types-boto3", "dateparser", "minio", "pandas", "pandas-stubs", "redis", "smolagents", "pillow"]
+extract=["celery", "celery-types", "fastapi", "google-api-python-client", "google-api-python-client-stubs", "google-auth-stubs", "gspread", "boto3", "types-boto3", "dateparser", "types-dateparser", "minio", "pandas", "pandas-stubs", "redis", "pillow"]
+
+[[tool.mypy.overrides]]
+module = ["PIL.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["boto3.*", "botocore.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["minio.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["google.*", "googleapiclient.*", "gspread.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["fastapi.*", "starlette.*", "redis.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["smolagents.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["dateparser.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["groundx.extract.classes.document"]
+disable_error_code = ["call-arg"]

{groundx-2.4.5 → groundx-2.4.10}/src/groundx/core/client_wrapper.py

@@ -14,10 +14,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "groundx/2.4.5",
+            "User-Agent": "groundx/2.4.10",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "groundx",
-            "X-Fern-SDK-Version": "2.4.5",
+            "X-Fern-SDK-Version": "2.4.10",
         }
         headers["X-API-Key"] = self.api_key
         return headers

groundx-2.4.10/src/groundx/extract/__init__.py

@@ -0,0 +1,38 @@
+from .agents import AgentCode, AgentTool
+from .classes import (
+    AgentRequest,
+    AgentSettings,
+    ContainerSettings,
+    ContainerUploadSettings,
+    Document,
+    DocumentRequest,
+    ExtractedField,
+    GroundXDocument,
+    GroundXSettings,
+    ProcessResponse,
+    Prompt,
+    XRayDocument,
+)
+from .services import Logger, RateLimit, SheetsClient, Status, Upload
+
+__all__ = [
+    "AgentCode",
+    "AgentRequest",
+    "AgentSettings",
+    "AgentTool",
+    "ContainerSettings",
+    "ContainerUploadSettings",
+    "Document",
+    "DocumentRequest",
+    "ExtractedField",
+    "GroundXDocument",
+    "GroundXSettings",
+    "Logger",
+    "ProcessResponse",
+    "Prompt",
+    "RateLimit",
+    "SheetsClient",
+    "Status",
+    "Upload",
+    "XRayDocument",
+]

groundx-2.4.10/src/groundx/extract/agents/__init__.py

@@ -0,0 +1,7 @@
+from .agent import AgentCode, AgentTool
+
+
+__all__ = [
+    "AgentCode",
+    "AgentTool",
+]

groundx-2.4.10/src/groundx/extract/agents/agent.py

@@ -0,0 +1,202 @@
+import json, pytest, traceback, typing
+
+pytest.importorskip("PIL")
+
+from PIL.Image import Image
+
+from smolagents import (  # pyright: ignore[reportMissingTypeStubs]
+    CodeAgent,
+    Tool,
+    ToolCallingAgent,
+)
+from smolagents.models import (  # pyright: ignore[reportMissingTypeStubs]
+    OpenAIServerModel,
+)
+
+from ..classes.settings import AgentSettings
+from ..classes.utility import clean_json
+from ..services.logger import Logger
+
+
+prompt_suffix = """
+Return only your response using the `final_answer` tool format:
+
+```json
+{{"answer": {{"type": RESPONSE_HERE, "description": "The final answer to the problem"}}}}
+```
+"""
+
+
+def extract_response(res: typing.Dict[str, typing.Any]) -> typing.Any:
+    if "answer" in res and "type" in res["answer"]:
+        return res["answer"]["type"]
+
+    if "type" in res:
+        return res["type"]
+
+    return res
+
+
+def process_response(
+    res: typing.Any,
+    expected_types: typing.Union[type, typing.Tuple[type, ...]] = dict,
+) -> typing.Any:
+    if not isinstance(res, expected_types):
+        if (
+            isinstance(res, list)
+            and isinstance(dict(), expected_types)
+            and len(res) == 1  # pyright: ignore[reportUnknownArgumentType]
+        ):
+            return extract_response(
+                res[0]  # pyright: ignore[reportUnknownArgumentType]
+            )
+
+        if not isinstance(res, str):
+            traceback.print_stack()
+            raise TypeError(
+                f"agent process result is not of expected type(s) {expected_types!r}, got {type(res)!r}"  # type: ignore
+            )
+
+        res = clean_json(res)
+
+        loaded = json.loads(res)
+        if not isinstance(loaded, expected_types):
+            if isinstance(loaded, list) and isinstance(dict(), expected_types) and len(loaded) == 1:  # type: ignore
+                return extract_response(loaded[0])  # type: ignore
+
+            traceback.print_stack()
+            raise TypeError(
+                f"agent process result is not of expected type(s) {expected_types!r} after JSON parsing, got {type(loaded)!r}"  # type: ignore
+            )
+
+        if isinstance(loaded, typing.Dict):
+            return extract_response(loaded)  # type: ignore
+
+        return loaded
+
+    if isinstance(res, typing.Dict):
+        return extract_response(res)  # type: ignore
+
+    return res
+
+
+class AgentCode(CodeAgent):
+    def __init__(
+        self,
+        settings: AgentSettings,
+        logger: Logger,
+        name: typing.Optional[str] = None,
+        description: typing.Optional[str] = None,
+        tools: typing.Optional[typing.List[Tool]] = None,
+        verbosity: typing.Optional[int] = 0,
+    ):
+        if tools is None:
+            tools = []
+
+        model = OpenAIServerModel(
+            model_id=settings.model_id,
+            api_base=settings.api_base,
+            api_key=settings.get_api_key(),
+        )
+
+        super().__init__(  # pyright: ignore[reportUnknownMemberType]
+            name=name,
+            description=description,
+            additional_authorized_imports=settings.imports,
+            tools=tools,
+            model=model,
+            max_steps=settings.max_steps,
+            verbosity_level=verbosity,
+        )
+
+        if self.python_executor.static_tools is None:  # type: ignore
+            self.python_executor.static_tools = {}  # type: ignore
+
+        self.python_executor.static_tools.update({"open": open})  # type: ignore
+
+        self.logger = logger
+
+    def process(
+        self,
+        conflict: str,
+        images: typing.List[Image],
+        expected_types: typing.Union[type, typing.Tuple[type, ...]] = dict,
+        attempt: int = 0,
+    ) -> typing.Any:
+        res = super().run(  # pyright: ignore[reportUnknownMemberType]
+            conflict + prompt_suffix,
+            images=images,
+        )
+
+        try:
+            return process_response(res=res, expected_types=expected_types)
+
+        except Exception as e:
+            if attempt > 2:
+                raise TypeError(
+                    f"agent process result is not of expected type(s) {expected_types!r}: [{e}]\n\n{res}"
+                )
+
+            self.logger.debug_msg(
+                f"agent process result is not of expected type(s) {expected_types!r}: [{e}], attempting again [{attempt+1}]\n\n{res}"
+            )
+
+            return self.process(conflict, images, expected_types, attempt + 1)
+
+
+class AgentTool(ToolCallingAgent):
+    def __init__(
+        self,
+        settings: AgentSettings,
+        logger: Logger,
+        name: typing.Optional[str] = None,
+        description: typing.Optional[str] = None,
+        tools: typing.Optional[typing.List[Tool]] = None,
+        verbosity: typing.Optional[int] = 0,
+    ):
+        if tools is None:
+            tools = []
+
+        model = OpenAIServerModel(
+            model_id=settings.model_id,
+            api_base=settings.api_base,
+            api_key=settings.get_api_key(),
+        )
+
+        super().__init__(  # pyright: ignore[reportUnknownMemberType]
+            name=name,
+            description=description,
+            tools=tools,
+            model=model,
+            max_steps=settings.max_steps,
+            verbosity_level=verbosity,
+        )
+
+        self.logger = logger
+
+    def process(
+        self,
+        conflict: str,
+        images: typing.List[Image],
+        expected_types: typing.Union[type, typing.Tuple[type, ...]] = dict,
+        attempt: int = 0,
+    ) -> typing.Any:
+        res = super().run(  # pyright: ignore[reportUnknownMemberType]
+            conflict + prompt_suffix,
+            images=images,
+        )
+
+        try:
+            return process_response(res=res, expected_types=expected_types)
+
+        except Exception as e:
+            if attempt > 2:
+                raise TypeError(
+                    f"agent process result is not of expected type(s) {expected_types!r}: [{e}]\n\n{res}"
+                )
+
+            print(
+                f"agent process result is not of expected type(s) {expected_types!r}: [{e}], attempting again [{attempt+1}]\n\n{res}"
+            )
+
+            return self.process(conflict, images, expected_types, attempt + 1)

groundx-2.4.10/src/groundx/extract/classes/__init__.py

@@ -0,0 +1,27 @@
+from .agent import AgentRequest
+from .api import ProcessResponse
+from .document import Document, DocumentRequest
+from .field import ExtractedField
+from .groundx import GroundXDocument, XRayDocument
+from .prompt import Prompt
+from .settings import (
+    AgentSettings,
+    ContainerSettings,
+    ContainerUploadSettings,
+    GroundXSettings,
+)
+
+__all__ = [
+    "AgentRequest",
+    "AgentSettings",
+    "ContainerSettings",
+    "ContainerUploadSettings",
+    "Document",
+    "DocumentRequest",
+    "ExtractedField",
+    "GroundXDocument",
+    "GroundXSettings",
+    "ProcessResponse",
+    "Prompt",
+    "XRayDocument",
+]

groundx-2.4.10/src/groundx/extract/classes/agent.py

@@ -0,0 +1,22 @@
+import typing
+from pydantic import BaseModel, field_validator
+
+from .document import Document, DocumentRequest
+
+ReqT = typing.TypeVar("ReqT", bound=DocumentRequest)
+DocT = typing.TypeVar("DocT", bound=Document)
+
+
+class AgentRequest(BaseModel, typing.Generic[ReqT, DocT]):
+    allowed_request_types: typing.List[str] = []
+    request: ReqT
+    request_type: str
+    statement: DocT
+
+    @field_validator("request_type")
+    def validate_request_type(cls, value: str):
+        if value not in cls.allowed_request_types:
+            raise ValueError(
+                f"Invalid request_type '{value}'. Must be one of {cls.allowed_request_types}"
+            )
+        return value

groundx-2.4.10/src/groundx/extract/classes/api.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ErrorResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    code: int
+    document_id: str = Field(alias="documentID")
+    message: str
+    task_id: str = Field(alias="taskID")
+
+
+@dataclass
+class ProcessResponse:
+    message: str