codeset 0.4.4__py3-none-any.whl

codeset/resources/sessions/verify.py

@@ -0,0 +1,335 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import time
+
+import httpx
+
+from ..._types import Body, Query, Headers, NotGiven, not_given
+from ..._utils import check_timeout, get_remaining_timeout
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..._base_client import make_request_options
+from ...types.sessions.verify_start_response import VerifyStartResponse
+from ...types.sessions.verify_status_response import VerifyStatusResponse
+
+__all__ = ["VerifyResource", "AsyncVerifyResource"]
+
+
+class VerifyResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VerifyResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/codeset-ai/codeset-sdk#accessing-raw-response-data-eg-headers
+        """
+        return VerifyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VerifyResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/codeset-ai/codeset-sdk#with_streaming_response
+        """
+        return VerifyResourceWithStreamingResponse(self)
+
+    def start(
+        self,
+        session_id: str,
+        *,
+        poll_interval: float = 3.0,
+        wait_for_completion: bool = True,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerifyStatusResponse:
+        """
+        Start verification (oracle) in a session - async
+
+        Args:
+          poll_interval: Interval in seconds between polling attempts while waiting for verification to complete (default: 3.0).
+
+          wait_for_completion: Whether to poll until the verification is completed (default: True). If False, returns the current status immediately after creation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        start_time = time.time()
+
+        check_timeout(timeout, start_time)
+        response = self._post(
+            f"/sessions/{session_id}/verify",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=get_remaining_timeout(timeout, start_time),
+            ),
+            cast_to=VerifyStartResponse,
+        )
+
+        check_timeout(timeout, start_time)
+        status_response = self.status(
+            response.job_id,
+            session_id=session_id,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=get_remaining_timeout(timeout, start_time),
+        )
+
+        if not wait_for_completion:
+            return status_response
+
+        while status_response.status != "completed":
+            if status_response.status in ("error", "cancelled"):
+                return status_response
+            check_timeout(timeout, start_time)
+            self._sleep(poll_interval)
+            check_timeout(timeout, start_time)
+            status_response = self.status(
+                response.job_id,
+                session_id=session_id,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=get_remaining_timeout(timeout, start_time),
+            )
+
+        return status_response
+
+    def status(
+        self,
+        job_id: str,
+        *,
+        session_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerifyStatusResponse:
+        """
+        Get a verification job, including the result if it's completed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return self._get(
+            f"/sessions/{session_id}/verify/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VerifyStatusResponse,
+        )
+
+
+class AsyncVerifyResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVerifyResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/codeset-ai/codeset-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVerifyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVerifyResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/codeset-ai/codeset-sdk#with_streaming_response
+        """
+        return AsyncVerifyResourceWithStreamingResponse(self)
+
+    async def start(
+        self,
+        session_id: str,
+        *,
+        poll_interval: float = 3.0,
+        wait_for_completion: bool = True,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerifyStatusResponse:
+        """
+        Start verification (oracle) in a session - async
+
+        Args:
+          poll_interval: Interval in seconds between polling attempts while waiting for verification to complete (default: 3.0).
+
+          wait_for_completion: Whether to poll until the verification is completed (default: True). If False, returns the current status immediately after creation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        start_time = time.time()
+
+        check_timeout(timeout, start_time)
+        response = await self._post(
+            f"/sessions/{session_id}/verify",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=get_remaining_timeout(timeout, start_time),
+            ),
+            cast_to=VerifyStartResponse,
+        )
+
+        check_timeout(timeout, start_time)
+        status_response = await self.status(
+            response.job_id,
+            session_id=session_id,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=get_remaining_timeout(timeout, start_time),
+        )
+
+        if not wait_for_completion:
+            return status_response
+
+        while status_response.status != "completed":
+            if status_response.status in ("error", "cancelled"):
+                return status_response
+            check_timeout(timeout, start_time)
+            await self._sleep(poll_interval)
+            check_timeout(timeout, start_time)
+            status_response = await self.status(
+                response.job_id,
+                session_id=session_id,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=get_remaining_timeout(timeout, start_time),
+            )
+
+        return status_response
+
+    async def status(
+        self,
+        job_id: str,
+        *,
+        session_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerifyStatusResponse:
+        """
+        Get a verification job, including the result if it's completed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return await self._get(
+            f"/sessions/{session_id}/verify/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VerifyStatusResponse,
+        )
+
+
+class VerifyResourceWithRawResponse:
+    def __init__(self, verify: VerifyResource) -> None:
+        self._verify = verify
+
+        self.start = to_raw_response_wrapper(
+            verify.start,
+        )
+        self.status = to_raw_response_wrapper(
+            verify.status,
+        )
+
+
+class AsyncVerifyResourceWithRawResponse:
+    def __init__(self, verify: AsyncVerifyResource) -> None:
+        self._verify = verify
+
+        self.start = async_to_raw_response_wrapper(
+            verify.start,
+        )
+        self.status = async_to_raw_response_wrapper(
+            verify.status,
+        )
+
+
+class VerifyResourceWithStreamingResponse:
+    def __init__(self, verify: VerifyResource) -> None:
+        self._verify = verify
+
+        self.start = to_streamed_response_wrapper(
+            verify.start,
+        )
+        self.status = to_streamed_response_wrapper(
+            verify.status,
+        )
+
+
+class AsyncVerifyResourceWithStreamingResponse:
+    def __init__(self, verify: AsyncVerifyResource) -> None:
+        self._verify = verify
+
+        self.start = async_to_streamed_response_wrapper(
+            verify.start,
+        )
+        self.status = async_to_streamed_response_wrapper(
+            verify.status,
+        )

codeset/types/__init__.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .session import Session as Session
+from .error_info import ErrorInfo as ErrorInfo
+from .interaction import Interaction as Interaction
+from .container_info import ContainerInfo as ContainerInfo
+from .session_status import SessionStatus as SessionStatus
+from .sample_list_params import SampleListParams as SampleListParams
+from .sample_list_response import SampleListResponse as SampleListResponse
+from .dataset_list_response import DatasetListResponse as DatasetListResponse
+from .health_check_response import HealthCheckResponse as HealthCheckResponse
+from .session_create_params import SessionCreateParams as SessionCreateParams
+from .session_list_response import SessionListResponse as SessionListResponse
+from .sample_download_params import SampleDownloadParams as SampleDownloadParams
+from .session_close_response import SessionCloseResponse as SessionCloseResponse
+from .session_create_response import SessionCreateResponse as SessionCreateResponse
+from .session_str_replace_params import SessionStrReplaceParams as SessionStrReplaceParams
+from .session_str_replace_response import SessionStrReplaceResponse as SessionStrReplaceResponse
+from .session_execute_command_params import SessionExecuteCommandParams as SessionExecuteCommandParams
+from .session_execute_command_response import SessionExecuteCommandResponse as SessionExecuteCommandResponse

codeset/types/container_info.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["ContainerInfo"]
+
+
+class ContainerInfo(BaseModel):
+    """Information about a container."""
+
+    container_name: str
+    """Name of the Cloud Run service."""
+
+    created_at: datetime
+    """Timestamp when the container was created (UTC)."""
+
+    expires_at: datetime
+    """Timestamp when the container will expire (UTC)."""
+
+    location: str
+    """Cloud Run region where the container is deployed (e.g., 'europe-west1')."""
+
+    sample_id: str
+    """Sample ID of the container."""
+
+    service_url: str
+    """URL of the Cloud Run service."""
+
+    status: str
+    """Status of the container."""

codeset/types/dataset_list_response.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import TypeAlias
+
+from .._models import BaseModel
+
+__all__ = ["DatasetListResponse", "DatasetListResponseItem"]
+
+
+class DatasetListResponseItem(BaseModel):
+    """Information about a dataset."""
+
+    name: str
+    """Unique name of the dataset."""
+
+    sample_count: int
+    """Number of samples in the dataset."""
+
+    created_at: Optional[datetime] = None
+    """Timestamp when the dataset was first created (UTC)."""
+
+    description: Optional[str] = None
+    """A brief description of the dataset."""
+
+
+DatasetListResponse: TypeAlias = List[DatasetListResponseItem]

codeset/types/error_info.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["ErrorInfo"]
+
+
+class ErrorInfo(BaseModel):
+    """Details about an error that occurred during job processing."""
+
+    code: str
+    """A unique error code for programmatic handling."""
+
+    message: str
+    """A human-readable error message."""

codeset/types/health_check_response.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["HealthCheckResponse"]
+
+
+class HealthCheckResponse(BaseModel):
+    """Response model for health check endpoint."""
+
+    service: str
+    """Name of the service"""
+
+    status: str
+    """Health status of the service"""
+
+    timestamp: str
+    """Timestamp when the health check was performed (ISO format)"""
+
+    version: str
+    """Version of the service"""

codeset/types/interaction.py

@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["Interaction"]
+
+
+class Interaction(BaseModel):
+    interaction_id: str
+    """Unique identifier for the interaction."""
+
+    session_id: str
+    """Session identifier for this interaction."""
+
+    created_at: datetime
+    """Timestamp when the interaction was created (UTC)."""
+
+    exit_code: Optional[int] = None
+    """Exit code of the executed command (if completed)."""
+
+    stdout: Optional[str] = None
+    """Standard output from the command (if completed)."""
+
+    stderr: Optional[str] = None
+    """Standard error from the command (if completed)."""
+
+    execution_time_seconds: Optional[float] = None
+    """Execution time in seconds (if completed)."""
+
+    success: Optional[bool] = None
+    """Whether the command execution was successful (if completed)."""
+
+    message: Optional[str] = None
+    """Message describing the interaction status."""

codeset/types/interaction_status.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["InteractionStatus"]
+
+InteractionStatus: TypeAlias = Literal["pending", "completed", "error"]

codeset/types/sample_download_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["SampleDownloadParams"]
+
+
+class SampleDownloadParams(TypedDict, total=False):
+    dataset: Required[str]
+
+    version: Optional[int]

codeset/types/sample_list_params.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["SampleListParams"]
+
+
+class SampleListParams(TypedDict, total=False):
+    dataset: Optional[str]
+    """Filter samples by dataset name"""
+
+    page: Optional[int]
+    """Page number (1-based). If not provided, returns all samples"""
+
+    page_size: Optional[int]
+    """Number of samples per page (max 100). If not provided, returns all samples"""
+
+    search: Optional[str]
+    """Search for samples by instance_id"""

codeset/types/sample_list_response.py

@@ -0,0 +1,95 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["SampleListResponse", "Sample"]
+
+
+class Sample(BaseModel):
+    """Information about a software engineering task sample."""
+
+    base_commit: str
+    """Base commit hash for the sample."""
+
+    environment_setup_commit: str
+    """Environment setup commit hash for the sample."""
+
+    fail_to_fail: List[str]
+    """List of test names that remained FAIL to FAIL."""
+
+    fail_to_pass: List[str]
+    """List of test names that changed from FAIL to PASS."""
+
+    hints_text: str
+    """Hints text for the sample (concatenated issue comments)."""
+
+    instance_id: str
+    """Instance identifier for the sample (e.g., 'psf\\__\\__requests-1234')."""
+
+    language: str
+    """Primary programming language of the sample."""
+
+    non_code_patch: str
+    """Non-code patch for the sample."""
+
+    pass_to_pass: List[str]
+    """List of test names that remained PASS to PASS."""
+
+    patch: str
+    """Code patch (diff) that fixes the bug for the sample."""
+
+    problem_statement: str
+    """Problem statement for the sample (issue title + body)."""
+
+    repo: str
+    """Repository full name for the sample (e.g., 'psf/requests')."""
+
+    sample_id: str
+    """Unique identifier for the sample (e.g., 'traccar-1')."""
+
+    test_patch: str
+    """Test patch (diff) for the sample."""
+
+    verifier: Literal["test_suite", "static_analysis", "linter", "custom"]
+    """The type of verifier used for this sample."""
+
+    created_at: Optional[datetime] = None
+    """Timestamp when the sample was created (UTC)."""
+
+    dataset: Optional[str] = None
+    """Dataset name for the sample."""
+
+    description: Optional[str] = None
+    """A brief description of the sample."""
+
+    latest: Optional[bool] = None
+    """Whether this is the latest version."""
+
+    version: Optional[int] = None
+    """Version number of the sample."""
+
+    version_description: Optional[str] = None
+    """Description of this version."""
+
+
+class SampleListResponse(BaseModel):
+    """Response for listing samples with pagination."""
+
+    has_more: bool
+    """Indicates if more pages of results are available."""
+
+    page: int
+    """Current page number (1-based)."""
+
+    page_size: int
+    """Number of samples per page."""
+
+    samples: List[Sample]
+    """List of samples for the current page."""
+
+    total_count: int
+    """Total number of samples available."""

codeset/types/session.py

@@ -0,0 +1,48 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from .._models import BaseModel
+from .error_info import ErrorInfo
+from .container_info import ContainerInfo
+from .session_status import SessionStatus
+
+__all__ = ["Session"]
+
+
+class Session(BaseModel):
+    """Represents a session for multi-turn interactions."""
+
+    dataset: str
+    """Dataset name for the sample."""
+
+    expires_at: datetime
+    """Timestamp when the session will expire (UTC)."""
+
+    requested_at: datetime
+    """Timestamp when the session was requested (UTC)."""
+
+    sample_id: str
+    """Identifier of the sample being used for the session."""
+
+    session_id: str
+    """Unique identifier for the session."""
+
+    status: SessionStatus
+    """Current status of the session."""
+
+    user_id: str
+    """User ID who owns this session."""
+
+    container_info: Optional[ContainerInfo] = None
+    """Information about a container."""
+
+    created_at: Optional[datetime] = None
+    """Timestamp when the container became ready and billing started (UTC)."""
+
+    duration_seconds: Optional[float] = None
+    """Duration of the session in seconds."""
+
+    error: Optional[ErrorInfo] = None
+    """Details about an error that occurred during job processing."""