antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/web_search_config.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="WebSearchConfig")
+
+
+@_attrs_define
+class WebSearchConfig:
+    """A unified configuration for web search providers.
+
+    Each provider has specific configuration requirements. Use the appropriate
+    provider-specific config or set common options at the top level.
+
+    **Environment Variables (fallbacks):**
+    - GOOGLE_CSE_API_KEY, GOOGLE_CSE_ID
+    - BING_SEARCH_API_KEY
+    - SERPER_API_KEY
+    - TAVILY_API_KEY
+    - BRAVE_API_KEY
+
+        Attributes:
+            provider (WebSearchProvider): The web search provider to use.
+
+                - **google**: Google Custom Search API (requires CSE setup)
+                - **bing**: Microsoft Bing Web Search API
+                - **serper**: Serper.dev Google Search API (simpler setup)
+                - **tavily**: Tavily AI Search API (optimized for RAG)
+                - **brave**: Brave Search API
+                - **duckduckgo**: DuckDuckGo Instant Answer API (limited, no API key)
+            max_results (int | Unset): Maximum number of search results to return Default: 5.
+            timeout_ms (int | Unset): Request timeout in milliseconds Default: 10000.
+            safe_search (bool | Unset): Enable safe search filtering Default: True.
+            language (str | Unset): Preferred language for results (e.g., 'en', 'es', 'fr') Example: en.
+            region (str | Unset): Preferred region for results (e.g., 'us', 'uk', 'de') Example: us.
+    """
+
+    provider: WebSearchProvider
+    max_results: int | Unset = 5
+    timeout_ms: int | Unset = 10000
+    safe_search: bool | Unset = True
+    language: str | Unset = UNSET
+    region: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider.value
+
+        max_results = self.max_results
+
+        timeout_ms = self.timeout_ms
+
+        safe_search = self.safe_search
+
+        language = self.language
+
+        region = self.region
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "provider": provider,
+            }
+        )
+        if max_results is not UNSET:
+            field_dict["max_results"] = max_results
+        if timeout_ms is not UNSET:
+            field_dict["timeout_ms"] = timeout_ms
+        if safe_search is not UNSET:
+            field_dict["safe_search"] = safe_search
+        if language is not UNSET:
+            field_dict["language"] = language
+        if region is not UNSET:
+            field_dict["region"] = region
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        provider = WebSearchProvider(d.pop("provider"))
+
+        max_results = d.pop("max_results", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        safe_search = d.pop("safe_search", UNSET)
+
+        language = d.pop("language", UNSET)
+
+        region = d.pop("region", UNSET)
+
+        web_search_config = cls(
+            provider=provider,
+            max_results=max_results,
+            timeout_ms=timeout_ms,
+            safe_search=safe_search,
+            language=language,
+            region=region,
+        )
+
+        web_search_config.additional_properties = d
+        return web_search_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/web_search_provider.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class WebSearchProvider(str, Enum):
+    BING = "bing"
+    BRAVE = "brave"
+    DUCKDUCKGO = "duckduckgo"
+    GOOGLE = "google"
+    SERPER = "serper"
+    TAVILY = "tavily"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/wildcard_query.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="WildcardQuery")
+
+
+@_attrs_define
+class WildcardQuery:
+    """
+    Attributes:
+        wildcard (str):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    wildcard: str
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        wildcard = self.wildcard
+
+        field = self.field
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "wildcard": wildcard,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        wildcard = d.pop("wildcard")
+
+        field = d.pop("field", UNSET)
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        wildcard_query = cls(
+            wildcard=wildcard,
+            field=field,
+            boost=boost,
+        )
+
+        wildcard_query.additional_properties = d
+        return wildcard_query
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

antfly/client_generated/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

antfly/exceptions.py

@@ -0,0 +1,19 @@
+"""Exception classes for Antfly SDK."""
+
+
+class AntflyException(Exception):
+    """Base exception for Antfly SDK."""
+
+    pass
+
+
+class AntflyConnectionError(AntflyException):
+    """Raised when connection to Antfly server fails."""
+
+    pass
+
+
+class AntflyAuthError(AntflyException):
+    """Raised when authentication fails."""
+
+    pass

antfly/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "antfly"
+version = "0.0.1"
+description = "A client library for accessing Antfly Public API"
+authors = []
+readme = "README.md"
+packages = [
+    { include = "client_generated" },
+]
+include = ["client_generated/py.typed"]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+httpx = ">=0.23.0,<0.29.0"
+attrs = ">=22.2.0"
+python-dateutil = "^2.8.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["F", "I", "UP"]

antfly_sdk-0.0.2.dev2.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: antfly-sdk
+Version: 0.0.2.dev2
+Summary: Python SDK for Antfly distributed key-value store and search engine
+Project-URL: Homepage, https://github.com/antflydb/antfly-py
+Project-URL: Documentation, https://antfly-sdk-python.readthedocs.io
+Project-URL: Repository, https://github.com/antflydb/antfly-py
+Project-URL: Issues, https://github.com/antflydb/antfly-py/issues
+Author-email: "Antfly, Inc." <ajroetker@antfly.io>
+License: Apache-2.0
+Keywords: antfly,database,distributed,key-value,search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: attrs>=22.2.0
+Requires-Dist: httpx<0.29.0,>=0.23.0
+Requires-Dist: python-dateutil<3.0.0,>=2.8.0
+Description-Content-Type: text/markdown
+
+# Antfly Python SDK
+
+[![PyPI version](https://badge.fury.io/py/antfly.svg)](https://badge.fury.io/py/antfly)
+[![Python](https://img.shields.io/pypi/pyversions/antfly.svg)](https://pypi.org/project/antfly/)
+
+Python SDK for [Antfly](https://github.com/antflydb/antfly) - a distributed key-value store and search engine.
+
+For the nightly version, visit the [TestPyPI page](https://test.pypi.org/project/antfly-sdk/).
+
+## Installation
+
+```bash
+pip install antfly-sdk
+```
+
+## Quick Start
+
+```python
+from antfly import AntflyClient
+
+# Initialize client
+client = AntflyClient(
+    base_url="http://localhost:8080",
+    username="admin",
+    password="password"
+)
+
+# Create a table
+client.create_table(
+    name="users",
+    num_shards=4,
+    schema={
+        "key": "user_id",
+        "document_types": {
+            "user": {
+                "fields": {
+                    "name": {"type": "string"},
+                    "email": {"type": "keyword"},
+                    "age": {"type": "int"},
+                    "created_at": {"type": "time"}
+                }
+            }
+        }
+    }
+)
+
+# Insert data
+client.batch(
+    table="users",
+    inserts={
+        "user:1": {
+            "name": "John Doe",
+            "email": "john@example.com",
+            "age": 30
+        },
+        "user:2": {
+            "name": "Jane Smith",
+            "email": "jane@example.com",
+            "age": 25
+        }
+    }
+)
+
+# Query data
+results = client.query(
+    table="users",
+    full_text_search={"query": "John"},
+    limit=10
+)
+
+# Get specific record
+user = client.get(table="users", key="user:1")
+```
+
+## Features
+
+- **Simple API**: Intuitive interface for all Antfly operations
+- **Type Safety**: Full type hints for better IDE support
+- **Authentication**: Built-in support for basic authentication
+- **Error Handling**: Comprehensive error handling with custom exceptions
+- **Auto-generated Client**: Based on OpenAPI specification for accuracy
+
+## Development
+
+### Setup
+
+1. Clone the repository
+2. Install development dependencies:
+
+```bash
+uv sync
+```
+
+
+### Generate Client
+
+The SDK uses an auto-generated client based on the Antfly OpenAPI specification:
+
+```bash
+make generate
+```
+
+### Run Tests
+
+```bash
+make test
+```
+
+### Build Package
+
+```bash
+make build
+```
+
+## Documentation
+
+`make docs` will generate the documentation in the `docs/` folder.
+
+Full documentation is available at [https://antfly-sdk-python.readthedocs.io](https://antfly-sdk-python.readthedocs.io)
+
+## License
+
+Apache License 2.0
+
+## Warning
+
+[Some models cannot be autogenerated from the spec](https://github.com/openapi-generators/openapi-python-client/issues/1123)