everyrow 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

everyrow/generated/models/dedupe_query_params.py

@@ -1,174 +0,0 @@
-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 ..models.dedupe_mode import DedupeMode
-from ..models.embedding_models import EmbeddingModels
-from ..models.llm_enum import LLMEnum
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="DedupeQueryParams")
-
-
-@_attrs_define
-class DedupeQueryParams:
-    """Service-specific parameters for the deduplication service.
-
-    Attributes:
-        equivalence_relation (str): Description of what makes items equivalent
-        llm (LLMEnum | Unset):
-        chunk_size (int | Unset): Maximum number of items to process in a single LLM call Default: 25.
-        mode (DedupeMode | Unset):
-        preview (bool | Unset): When true, process only the first few items Default: False.
-        embedding_model (EmbeddingModels | Unset):
-        validate_groups (bool | Unset): Validate equivalence classes and split incorrectly merged groups before
-            selecting representatives Default: False.
-        use_clustering (bool | Unset): When true, cluster items by embedding similarity and only compare neighboring
-            clusters. When false, use sequential chunking and compare all chunks (O(n²)) Default: True.
-        early_stop_threshold (int | None | Unset): Stop cross-chunk comparisons for a row after this many consecutive
-            comparisons with no matches. None disables early stopping.
-    """
-
-    equivalence_relation: str
-    llm: LLMEnum | Unset = UNSET
-    chunk_size: int | Unset = 25
-    mode: DedupeMode | Unset = UNSET
-    preview: bool | Unset = False
-    embedding_model: EmbeddingModels | Unset = UNSET
-    validate_groups: bool | Unset = False
-    use_clustering: bool | Unset = True
-    early_stop_threshold: int | None | Unset = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        equivalence_relation = self.equivalence_relation
-
-        llm: str | Unset = UNSET
-        if not isinstance(self.llm, Unset):
-            llm = self.llm.value
-
-        chunk_size = self.chunk_size
-
-        mode: str | Unset = UNSET
-        if not isinstance(self.mode, Unset):
-            mode = self.mode.value
-
-        preview = self.preview
-
-        embedding_model: str | Unset = UNSET
-        if not isinstance(self.embedding_model, Unset):
-            embedding_model = self.embedding_model.value
-
-        validate_groups = self.validate_groups
-
-        use_clustering = self.use_clustering
-
-        early_stop_threshold: int | None | Unset
-        if isinstance(self.early_stop_threshold, Unset):
-            early_stop_threshold = UNSET
-        else:
-            early_stop_threshold = self.early_stop_threshold
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "equivalence_relation": equivalence_relation,
-            }
-        )
-        if llm is not UNSET:
-            field_dict["llm"] = llm
-        if chunk_size is not UNSET:
-            field_dict["chunk_size"] = chunk_size
-        if mode is not UNSET:
-            field_dict["mode"] = mode
-        if preview is not UNSET:
-            field_dict["preview"] = preview
-        if embedding_model is not UNSET:
-            field_dict["embedding_model"] = embedding_model
-        if validate_groups is not UNSET:
-            field_dict["validate_groups"] = validate_groups
-        if use_clustering is not UNSET:
-            field_dict["use_clustering"] = use_clustering
-        if early_stop_threshold is not UNSET:
-            field_dict["early_stop_threshold"] = early_stop_threshold
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        d = dict(src_dict)
-        equivalence_relation = d.pop("equivalence_relation")
-
-        _llm = d.pop("llm", UNSET)
-        llm: LLMEnum | Unset
-        if isinstance(_llm, Unset):
-            llm = UNSET
-        else:
-            llm = LLMEnum(_llm)
-
-        chunk_size = d.pop("chunk_size", UNSET)
-
-        _mode = d.pop("mode", UNSET)
-        mode: DedupeMode | Unset
-        if isinstance(_mode, Unset):
-            mode = UNSET
-        else:
-            mode = DedupeMode(_mode)
-
-        preview = d.pop("preview", UNSET)
-
-        _embedding_model = d.pop("embedding_model", UNSET)
-        embedding_model: EmbeddingModels | Unset
-        if isinstance(_embedding_model, Unset):
-            embedding_model = UNSET
-        else:
-            embedding_model = EmbeddingModels(_embedding_model)
-
-        validate_groups = d.pop("validate_groups", UNSET)
-
-        use_clustering = d.pop("use_clustering", UNSET)
-
-        def _parse_early_stop_threshold(data: object) -> int | None | Unset:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(int | None | Unset, data)
-
-        early_stop_threshold = _parse_early_stop_threshold(d.pop("early_stop_threshold", UNSET))
-
-        dedupe_query_params = cls(
-            equivalence_relation=equivalence_relation,
-            llm=llm,
-            chunk_size=chunk_size,
-            mode=mode,
-            preview=preview,
-            embedding_model=embedding_model,
-            validate_groups=validate_groups,
-            use_clustering=use_clustering,
-            early_stop_threshold=early_stop_threshold,
-        )
-
-        dedupe_query_params.additional_properties = d
-        return dedupe_query_params
-
-    @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

everyrow/generated/models/embedding_models.py

@@ -1,9 +0,0 @@
-from enum import Enum
-
-
-class EmbeddingModels(str, Enum):
-    TEXT_EMBEDDING_3_LARGE = "text-embedding-3-large"
-    TEXT_EMBEDDING_3_SMALL = "text-embedding-3-small"
-
-    def __str__(self) -> str:
-        return str(self.value)

everyrow-0.1.0.dist-info/METADATA

@@ -1,238 +0,0 @@
-Metadata-Version: 2.4
-Name: everyrow
-Version: 0.1.0
-Summary: An SDK for everyrow.io: agent ops at spreadsheet scale
-License-File: LICENSE.txt
-Requires-Python: >=3.12
-Requires-Dist: attrs>=25.4.0
-Requires-Dist: pandas>=2.3.3
-Requires-Dist: pydantic>=2.12.5
-Requires-Dist: python-dotenv>=1.2.1
-Description-Content-Type: text/markdown
-
-# everyrow SDK
-
-The everyrow SDK provides intelligent data processing utilities powered by AI agents. Transform, dedupe, merge, rank, and screen your dataframes using natural language instructions. Whether you're deduplicating research papers, merging complex datasets, ranking organizations, or screening vendors, the SDK handles the heavy lifting by combining AI research capabilities with structured data operations.
-
-## Installation
-
-```bash
-uv pip install -e .
-```
-
-Or install dependencies:
-
-```bash
-uv sync
-```
-
-## Requirements
-
-- Python >= 3.12
-
-## Configuration
-
-Get an API key from https://everyrow.io and set it to get started:
-
-```bash
-# Set in your environment or .env file
-EVERYROW_API_KEY=your_api_key_here
-```
-
-## Usage
-
-### Quick Start
-
-```python
-from everyrow import create_session
-from everyrow.ops import dedupe
-from pandas import DataFrame
-
-async with create_session() as session:
-    data = DataFrame([...])
-    result = await dedupe(
-        session=session,
-        input=data,
-        equivalence_relation="Two items are duplicates if...",
-    )
-    print(result.data)
-```
-
-### Core Utilities
-
-#### Rank: `rank`
-
-Extract and rank rows based on AI-generated scores:
-
-```python
-from everyrow.ops import rank
-
-result = await rank(
-    session=session,
-    task="Score this organization by their contribution to AI research",
-    input=dataframe,
-    field_name="contribution_score",
-    ascending_order=False,
-)
-```
-
-#### Dedupe: `dedupe`
-
-Intelligently deduplicate your data using AI-powered equivalence detection:
-
-```python
-from everyrow.ops import dedupe
-
-result = await dedupe(
-    session=session,
-    input=dataframe,
-    equivalence_relation="Two entries are duplicates if they represent the same research work",
-)
-```
-
-#### Merge: `merge`
-
-Merge two tables using AI to match related rows:
-
-```python
-from everyrow.ops import merge
-
-result = await merge(
-    session=session,
-    task="Match clinical trial sponsors with parent companies",
-    left_table=trial_data,
-    right_table=company_data,
-    merge_on_left="sponsor",
-    merge_on_right="company",
-)
-```
-
-#### Screen: `screen`
-
-Evaluate and filter rows based on criteria that require research:
-
-```python
-from everyrow.ops import screen
-from pydantic import BaseModel
-
-class Assessment(BaseModel):
-    risk_level: str
-    recommendation: str
-
-result = await screen(
-    session=session,
-    task="Evaluate vendor security and financial stability",
-    input=vendors,
-    response_model=Assessment,
-)
-```
-
-### Viewing Sessions
-
-Every session has a web interface URL:
-
-```python
-async with create_session(name="My Session") as session:
-    print(f"View session at: {session.get_url()}")
-    # ... use session for operations
-```
-
-### Agent Tasks
-
-For single-input tasks, use `single_agent`:
-
-```python
-from everyrow.ops import single_agent
-from pydantic import BaseModel
-
-class Input(BaseModel):
-    country: str
-
-result = await single_agent(
-    session=session,
-    task="What is the capital of the given country?",
-    input=Input(country="India"),
-)
-```
-
-For batch processing, use `agent_map`:
-
-```python
-from everyrow.ops import agent_map
-
-result = await agent_map(
-    session=session,
-    task="What is the capital of the given country?",
-    input=DataFrame([{"country": "India"}, {"country": "USA"}]),
-)
-```
-
-### Async Operations
-
-All utilities have async variants for background processing:
-
-```python
-from everyrow.ops import rank_async
-
-task = await rank_async(
-    session=session,
-    task="Score this organization",
-    input=dataframe,
-    field_name="score",
-)
-
-# Continue with other work...
-
-result = await task.await_result(session.client)
-```
-
-## Case Studies
-
-The `case_studies/` directory contains example workflows demonstrating real-world usage of the SDK. To run case studies, install the optional dependencies:
-
-```bash
-uv sync --group case-studies
-```
-
-Then you can run the case study scripts or open the Jupyter notebooks in your preferred environment.
-
-## Development
-
-### Setup
-
-```bash
-uv sync
-lefthook install
-```
-
-### Running Tests
-
-```bash
-uv run pytest
-```
-
-### Linting & Formatting
-
-```bash
-uv run ruff check .
-uv run ruff check --fix .
-uv run ruff format .
-```
-
-### Type Checking
-
-```bash
-uv run basedpyright
-```
-
-### Generating OpenAPI Client
-
-```bash
-./generate_openapi.sh
-```
-
-Note: The `everyrow/generated/` directory is excluded from linting as it contains auto-generated code.
-
-## License
-
-This project is licensed under the MIT License - see LICENSE.txt file for details.