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

everyrow/generated/models/standalone_artifact_record_analysis_type_0.py

@@ -0,0 +1,46 @@
+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
+
+T = TypeVar("T", bound="StandaloneArtifactRecordAnalysisType0")
+
+
+@_attrs_define
+class StandaloneArtifactRecordAnalysisType0:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        standalone_artifact_record_analysis_type_0 = cls()
+
+        standalone_artifact_record_analysis_type_0.additional_properties = d
+        return standalone_artifact_record_analysis_type_0
+
+    @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/ops.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Literal, TypeVar, overload
 from uuid import UUID
 
@@ -11,8 +12,7 @@ from everyrow.generated.models import (
     CreateGroupRequest,
     CreateQueryParams,
     CreateRequest,
-    DedupeMode,
-    DedupeQueryParams,
+    DedupePublicParams,
     DedupeRequestParams,
     DeepMergePublicParams,
     DeepMergeRequest,
@@ -23,7 +23,6 @@ from everyrow.generated.models import (
     DeriveExpression,
     DeriveQueryParams,
     DeriveRequest,
-    EmbeddingModels,
     MapAgentRequestParams,
     ProcessingMode,
     ReduceAgentRequestParams,
@@ -32,7 +31,7 @@ from everyrow.generated.models import (
 from everyrow.generated.models.submit_task_body import SubmitTaskBody
 from everyrow.generated.types import UNSET
 from everyrow.result import Result, ScalarResult, TableResult
-from everyrow.session import Session
+from everyrow.session import Session, create_session
 from everyrow.task import (
     LLM,
     EffortLevel,
@@ -49,10 +48,14 @@ class DefaultAgentResponse(BaseModel):
     answer: str
 
 
+class DefaultScreenResult(BaseModel):
+    passes: bool
+
+
 @overload
 async def single_agent[T: BaseModel](
     task: str,
-    session: Session,
+    session: Session | None = None,
     input: BaseModel | UUID | Result | None = None,
     effort_level: EffortLevel = EffortLevel.LOW,
     llm: LLM | None = None,
@@ -64,7 +67,7 @@ async def single_agent[T: BaseModel](
 @overload
 async def single_agent(
     task: str,
-    session: Session,
+    session: Session | None = None,
     input: BaseModel | UUID | Result | None = None,
     effort_level: EffortLevel = EffortLevel.LOW,
     llm: LLM | None = None,
@@ -75,13 +78,25 @@ async def single_agent(
 
 async def single_agent[T: BaseModel](
     task: str,
-    session: Session,
+    session: Session | None = None,
     input: BaseModel | DataFrame | UUID | Result | None = None,
     effort_level: EffortLevel = EffortLevel.LOW,
     llm: LLM | None = None,
     response_model: type[T] = DefaultAgentResponse,
     return_table: bool = False,
 ) -> ScalarResult[T] | TableResult:
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await single_agent_async(
+                task=task,
+                session=internal_session,
+                input=input,
+                effort_level=effort_level,
+                llm=llm,
+                response_model=response_model,
+                return_table=return_table,
+            )
+            return await cohort_task.await_result()
     cohort_task = await single_agent_async(
         task=task,
         session=session,
@@ -91,7 +106,7 @@ async def single_agent[T: BaseModel](
         response_model=response_model,
         return_table=return_table,
     )
-    return await cohort_task.await_result(session.client)
+    return await cohort_task.await_result()
 
 
 async def single_agent_async[T: BaseModel](
@@ -135,17 +150,33 @@ async def single_agent_async[T: BaseModel](
 
 async def agent_map(
     task: str,
-    session: Session,
-    input: DataFrame | UUID | TableResult,
+    session: Session | None = None,
+    input: DataFrame | UUID | TableResult | None = None,
     effort_level: EffortLevel = EffortLevel.LOW,
     llm: LLM | None = None,
     response_model: type[BaseModel] = DefaultAgentResponse,
-    return_table_per_row: bool = False,
 ) -> TableResult:
+    if input is None:
+        raise EveryrowError("input is required for agent_map")
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await agent_map_async(
+                task,
+                internal_session,
+                input,
+                effort_level,
+                llm,
+                response_model,
+            )
+            result = await cohort_task.await_result()
+            if isinstance(result, TableResult):
+                return result
+            else:
+                raise EveryrowError("Agent map task did not return a table result")
     cohort_task = await agent_map_async(
-        task, session, input, effort_level, llm, response_model, return_table_per_row
+        task, session, input, effort_level, llm, response_model
     )
-    result = await cohort_task.await_result(session.client)
+    result = await cohort_task.await_result()
     if isinstance(result, TableResult):
         return result
     else:
@@ -221,7 +252,6 @@ async def agent_map_async(
     effort_level: EffortLevel = EffortLevel.LOW,
     llm: LLM | None = None,
     response_model: type[BaseModel] = DefaultAgentResponse,
-    return_table_per_row: bool = False,
 ) -> EveryrowTask[BaseModel]:
     input_artifact_ids = [await _process_agent_map_input(input, session)]
     query = AgentQueryParams(
@@ -230,7 +260,7 @@ async def agent_map_async(
         llm=llm or UNSET,
         response_schema=_convert_pydantic_to_custom_schema(response_model),
         response_schema_type=ResponseSchemaType.CUSTOM,
-        is_expand=return_table_per_row,
+        is_expand=False,
         include_provenance_and_notes=False,
     )
     request = MapAgentRequestParams(
@@ -245,7 +275,7 @@ async def agent_map_async(
     )
 
     cohort_task = EveryrowTask(
-        response_model=response_model, is_map=True, is_expand=return_table_per_row
+        response_model=response_model, is_map=True, is_expand=False
     )
     await cohort_task.submit(body, session.client)
     return cohort_task
@@ -289,9 +319,11 @@ async def create_scalar_artifact(input: BaseModel, session: Session) -> UUID:
 
 
 async def create_table_artifact(input: DataFrame, session: Session) -> UUID:
-    payload = CreateGroupRequest(
-        query=CreateGroupQueryParams(data_to_create=input.to_dict(orient="records"))
-    )
+    # Use to_json to handle NaN/NaT serialization, then parse back to Python objects
+    json_str = input.to_json(orient="records")
+    assert json_str is not None  # to_json returns str when no path_or_buf provided
+    records = json.loads(json_str)
+    payload = CreateGroupRequest(query=CreateGroupQueryParams(data_to_create=records))
     body = SubmitTaskBody(
         payload=payload,
         session_id=session.session_id,
@@ -303,29 +335,42 @@ async def create_table_artifact(input: DataFrame, session: Session) -> UUID:
 
 async def merge(
     task: str,
-    session: Session,
-    left_table: DataFrame | UUID | TableResult,
-    right_table: DataFrame | UUID | TableResult,
+    session: Session | None = None,
+    left_table: DataFrame | UUID | TableResult | None = None,
+    right_table: DataFrame | UUID | TableResult | None = None,
     merge_on_left: str | None = None,
     merge_on_right: str | None = None,
-    merge_model: LLM | None = None,
-    preview: bool = False,
 ) -> TableResult:
     """Merge two tables using merge operation.
 
     Args:
         task: The task description for the merge operation
-        session: The session to use
+        session: Optional session. If not provided, one will be created automatically.
         left_table: The left table to merge (DataFrame, UUID, or TableResult)
         right_table: The right table to merge (DataFrame, UUID, or TableResult)
         merge_on_left: Optional column name in left table to merge on
         merge_on_right: Optional column name in right table to merge on
-        merge_model: Optional LLM model to use for merge operation
-        preview: If True, process only the first few inputs
 
     Returns:
         TableResult containing the merged table
     """
+    if left_table is None or right_table is None:
+        raise EveryrowError("left_table and right_table are required for merge")
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await merge_async(
+                task=task,
+                session=internal_session,
+                left_table=left_table,
+                right_table=right_table,
+                merge_on_left=merge_on_left,
+                merge_on_right=merge_on_right,
+            )
+            result = await cohort_task.await_result()
+            if isinstance(result, TableResult):
+                return result
+            else:
+                raise EveryrowError("Merge task did not return a table result")
     cohort_task = await merge_async(
         task=task,
         session=session,
@@ -333,10 +378,8 @@ async def merge(
         right_table=right_table,
         merge_on_left=merge_on_left,
         merge_on_right=merge_on_right,
-        merge_model=merge_model,
-        preview=preview,
     )
-    result = await cohort_task.await_result(session.client)
+    result = await cohort_task.await_result()
     if isinstance(result, TableResult):
         return result
     else:
@@ -350,8 +393,6 @@ async def merge_async(
     right_table: DataFrame | UUID | TableResult,
     merge_on_left: str | None = None,
     merge_on_right: str | None = None,
-    merge_model: LLM | None = None,
-    preview: bool = False,
 ) -> EveryrowTask[BaseModel]:
     """Submit a merge task asynchronously."""
     left_artifact_id = await _process_agent_map_input(left_table, session)
@@ -361,8 +402,6 @@ async def merge_async(
         task=task,
         merge_on_left=merge_on_left or UNSET,
         merge_on_right=merge_on_right or UNSET,
-        merge_model=merge_model or UNSET,
-        preview=preview,
     )
     request = DeepMergeRequest(
         query=query,
@@ -381,29 +420,45 @@ async def merge_async(
 
 async def rank[T: BaseModel](
     task: str,
-    session: Session,
-    input: DataFrame | UUID | TableResult,
-    field_name: str,
+    session: Session | None = None,
+    input: DataFrame | UUID | TableResult | None = None,
+    field_name: str | None = None,
     field_type: Literal["float", "int", "str", "bool"] = "float",
     response_model: type[T] | None = None,
     ascending_order: bool = True,
-    preview: bool = False,
 ) -> TableResult:
     """Rank rows in a table using rank operation.
 
     Args:
         task: The task description for ranking
-        session: The session to use
+        session: Optional session. If not provided, one will be created automatically.
         input: The input table (DataFrame, UUID, or TableResult)
         field_name: The name of the field to extract and sort by
         field_type: The type of the field (default: "float", ignored if response_model is provided)
         response_model: Optional Pydantic model for the response schema
         ascending_order: If True, sort in ascending order
-        preview: If True, process only the first few inputs
 
     Returns:
         TableResult containing the ranked table
     """
+    if input is None or field_name is None:
+        raise EveryrowError("input and field_name are required for rank")
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await rank_async(
+                task=task,
+                session=internal_session,
+                input=input,
+                field_name=field_name,
+                field_type=field_type,
+                response_model=response_model,
+                ascending_order=ascending_order,
+            )
+            result = await cohort_task.await_result()
+            if isinstance(result, TableResult):
+                return result
+            else:
+                raise EveryrowError("Rank task did not return a table result")
     cohort_task = await rank_async(
         task=task,
         session=session,
@@ -412,9 +467,8 @@ async def rank[T: BaseModel](
         field_type=field_type,
         response_model=response_model,
         ascending_order=ascending_order,
-        preview=preview,
     )
-    result = await cohort_task.await_result(session.client)
+    result = await cohort_task.await_result()
     if isinstance(result, TableResult):
         return result
     else:
@@ -429,7 +483,6 @@ async def rank_async[T: BaseModel](
     field_type: Literal["float", "int", "str", "bool"] = "float",
     response_model: type[T] | None = None,
     ascending_order: bool = True,
-    preview: bool = False,
 ) -> EveryrowTask[T]:
     """Submit a rank task asynchronously."""
     input_artifact_id = await _process_agent_map_input(input, session)
@@ -454,7 +507,6 @@ async def rank_async[T: BaseModel](
         response_schema=response_schema,
         field_to_sort_by=field_name,
         ascending_order=ascending_order,
-        preview=preview,
     )
     request = DeepRankRequest(
         query=query,
@@ -477,34 +529,44 @@ async def rank_async[T: BaseModel](
 
 async def screen[T: BaseModel](
     task: str,
-    session: Session,
-    input: DataFrame | UUID | TableResult,
+    session: Session | None = None,
+    input: DataFrame | UUID | TableResult | None = None,
     response_model: type[T] | None = None,
-    batch_size: int | None = None,
-    preview: bool = False,
 ) -> TableResult:
     """Screen rows in a table using screen operation.
 
     Args:
         task: The task description for screening
-        session: The session to use
+        session: Optional session. If not provided, one will be created automatically.
         input: The input table (DataFrame, UUID, or TableResult)
-        response_model: Optional Pydantic model for the response schema
-        batch_size: Optional batch size for processing (default: 10)
-        preview: If True, process only the first few inputs
+        response_model: Optional Pydantic model for the response schema.
+            If not provided, defaults to a result with just a "passes" boolean.
 
     Returns:
         TableResult containing the screened table
     """
+    if input is None:
+        raise EveryrowError("input is required for screen")
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await screen_async(
+                task=task,
+                session=internal_session,
+                input=input,
+                response_model=response_model,
+            )
+            result = await cohort_task.await_result()
+            if isinstance(result, TableResult):
+                return result
+            else:
+                raise EveryrowError("Screen task did not return a table result")
     cohort_task = await screen_async(
         task=task,
         session=session,
         input=input,
         response_model=response_model,
-        batch_size=batch_size,
-        preview=preview,
     )
-    result = await cohort_task.await_result(session.client)
+    result = await cohort_task.await_result()
     if isinstance(result, TableResult):
         return result
     else:
@@ -516,25 +578,17 @@ async def screen_async[T: BaseModel](
     session: Session,
     input: DataFrame | UUID | TableResult,
     response_model: type[T] | None = None,
-    batch_size: int | None = None,
-    preview: bool = False,
 ) -> EveryrowTask[T]:
     """Submit a screen task asynchronously."""
     input_artifact_id = await _process_agent_map_input(input, session)
 
-    if response_model is not None:
-        response_schema = response_model.model_json_schema()
-        response_schema_type = ResponseSchemaType.JSON
-    else:
-        response_schema = UNSET
-        response_schema_type = UNSET
+    actual_response_model = response_model or DefaultScreenResult
+    response_schema = actual_response_model.model_json_schema()
 
     query = DeepScreenPublicParams(
         task=task,
-        batch_size=batch_size or UNSET,
         response_schema=response_schema,
-        response_schema_type=response_schema_type,
-        preview=preview,
+        response_schema_type=ResponseSchemaType.JSON,
     )
     request = DeepScreenRequest(
         query=query,
@@ -546,7 +600,7 @@ async def screen_async[T: BaseModel](
     )
 
     cohort_task: EveryrowTask[T] = EveryrowTask(
-        response_model=response_model or DefaultAgentResponse,  # type: ignore[arg-type]
+        response_model=actual_response_model,  # type: ignore[arg-type]
         is_map=True,
         is_expand=False,
     )
@@ -555,39 +609,44 @@ async def screen_async[T: BaseModel](
 
 
 async def dedupe(
-    session: Session,
-    input: DataFrame | UUID | TableResult,
     equivalence_relation: str,
-    llm: LLM | None = None,
-    chunk_size: int | None = None,
-    mode: DedupeMode | None = None,
-    embedding_model: EmbeddingModels | None = None,
+    session: Session | None = None,
+    input: DataFrame | UUID | TableResult | None = None,
+    select_representative: bool = True,
 ) -> TableResult:
     """Dedupe a table by removing duplicates using dedupe operation.
 
     Args:
-        session: The session to use
-        input: The input table (DataFrame, UUID, or TableResult)
         equivalence_relation: Description of what makes items equivalent
-        llm: Optional LLM model to use for deduplication
-        chunk_size: Optional maximum number of items to process in a single LLM call (default: 40)
-        mode: Optional dedupe mode (AGENTIC or DIRECT)
-        max_consecutive_empty: Optional stop processing a row after this many consecutive comparisons with no matches
-        embedding_model: Optional embedding model to use when reorder_by_embedding is True
+        session: Optional session. If not provided, one will be created automatically.
+        input: The input table (DataFrame, UUID, or TableResult)
+        select_representative: If True, select a representative for each group of duplicates
 
     Returns:
         TableResult containing the deduped table with duplicates removed
     """
+    if input is None or equivalence_relation is None:
+        raise EveryrowError("input and equivalence_relation are required for dedupe")
+    if session is None:
+        async with create_session() as internal_session:
+            cohort_task = await dedupe_async(
+                session=internal_session,
+                input=input,
+                equivalence_relation=equivalence_relation,
+                select_representative=select_representative,
+            )
+            result = await cohort_task.await_result()
+            if isinstance(result, TableResult):
+                return result
+            else:
+                raise EveryrowError("Dedupe task did not return a table result")
     cohort_task = await dedupe_async(
         session=session,
         input=input,
         equivalence_relation=equivalence_relation,
-        llm=llm,
-        chunk_size=chunk_size,
-        mode=mode,
-        embedding_model=embedding_model,
+        select_representative=select_representative,
     )
-    result = await cohort_task.await_result(session.client)
+    result = await cohort_task.await_result()
     if isinstance(result, TableResult):
         return result
     else:
@@ -598,20 +657,14 @@ async def dedupe_async(
     session: Session,
     input: DataFrame | UUID | TableResult,
     equivalence_relation: str,
-    llm: LLM | None = None,
-    chunk_size: int | None = None,
-    mode: DedupeMode | None = None,
-    embedding_model: EmbeddingModels | None = None,
+    select_representative: bool = True,
 ) -> EveryrowTask[BaseModel]:
     """Submit a dedupe task asynchronously."""
     input_artifact_id = await _process_agent_map_input(input, session)
 
-    query = DedupeQueryParams(
+    query = DedupePublicParams(
         equivalence_relation=equivalence_relation,
-        llm=llm or UNSET,
-        chunk_size=chunk_size or UNSET,
-        mode=mode or UNSET,
-        embedding_model=embedding_model or UNSET,
+        select_representative=select_representative,
     )
     request = DedupeRequestParams(
         query=query,
@@ -629,14 +682,14 @@ async def dedupe_async(
 
 
 async def derive(
-    session: Session,
-    input: DataFrame | UUID | TableResult,
-    expressions: dict[str, str],
+    session: Session | None = None,
+    input: DataFrame | UUID | TableResult | None = None,
+    expressions: dict[str, str] | None = None,
 ) -> TableResult:
     """Derive new columns using pandas eval expressions.
 
     Args:
-        session: The session to use
+        session: Optional session. If not provided, one will be created automatically.
         input: The input table (DataFrame, UUID, or TableResult)
         expressions: A dictionary mapping column names to pandas expressions.
             Example: {"approved": "True", "score": "price * quantity"}
@@ -644,6 +697,41 @@ async def derive(
     Returns:
         TableResult containing the table with new derived columns
     """
+    if input is None or expressions is None:
+        raise EveryrowError("input and expressions are required for derive")
+    if session is None:
+        async with create_session() as internal_session:
+            input_artifact_id = await _process_agent_map_input(input, internal_session)
+
+            derive_expressions = [
+                DeriveExpression(column_name=col_name, expression=expr)
+                for col_name, expr in expressions.items()
+            ]
+
+            query = DeriveQueryParams(expressions=derive_expressions)
+            request = DeriveRequest(
+                query=query,
+                input_artifacts=[input_artifact_id],
+            )
+            body = SubmitTaskBody(
+                payload=request,
+                session_id=internal_session.session_id,
+            )
+
+            task_id = await submit_task(body, internal_session.client)
+            finished_task = await await_task_completion(
+                task_id, internal_session.client
+            )
+
+            data = await read_table_result(
+                finished_task.artifact_id,  # type: ignore[arg-type]
+                internal_session.client,
+            )
+            return TableResult(
+                artifact_id=finished_task.artifact_id,  # type: ignore
+                data=data,
+                error=finished_task.error,
+            )
     input_artifact_id = await _process_agent_map_input(input, session)
 
     derive_expressions = [

everyrow/session.py

@@ -4,7 +4,7 @@ from contextlib import asynccontextmanager
 from datetime import datetime
 from uuid import UUID
 
-from everyrow.api_utils import handle_response
+from everyrow.api_utils import create_client, handle_response
 from everyrow.generated.api.default import (
     create_session_endpoint_sessions_create_post,
 )
@@ -33,21 +33,43 @@ class Session:
 
 @asynccontextmanager
 async def create_session(
-    client: AuthenticatedClient,
+    client: AuthenticatedClient | None = None,
     name: str | None = None,
 ) -> AsyncGenerator[Session, None]:
     """Create a new session and yield it as an async context manager.
 
     Args:
-        client: Authenticated client to use for session creation.
-                The client should already be in an async context manager.
+        client: Optional authenticated client. If not provided, one will be created
+                automatically using the EVERYROW_API_KEY environment variable and
+                managed within this context manager.
         name: Name for the session. If not provided, defaults to
               "everyrow-sdk-session-{timestamp}".
+
+    Example:
+        # With explicit client (client lifecycle managed externally)
+        async with create_client() as client:
+            async with create_session(client=client, name="My Session") as session:
+                ...
+
+        # Without client (client created and managed internally)
+        async with create_session(name="My Session") as session:
+            ...
     """
-    response = await create_session_endpoint_sessions_create_post.asyncio(
-        client=client,
-        body=CreateSessionRequest(name=name or f"everyrow-sdk-session-{datetime.now().isoformat()}"),
-    )
-    response = handle_response(response)
-    session = Session(client=client, session_id=response.session_id)
-    yield session
+    owns_client = client is None
+    if owns_client:
+        client = create_client()
+        await client.__aenter__()
+
+    try:
+        response = await create_session_endpoint_sessions_create_post.asyncio(
+            client=client,
+            body=CreateSessionRequest(
+                name=name or f"everyrow-sdk-session-{datetime.now().isoformat()}"
+            ),
+        )
+        response = handle_response(response)
+        session = Session(client=client, session_id=response.session_id)
+        yield session
+    finally:
+        if owns_client:
+            await client.__aexit__()