worqhat 0.0.1__py3-none-any.whl → 0.1.0a3__py3-none-any.whl

worqhat/resources/flows.py

@@ -0,0 +1,223 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import date
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import flow_retrieve_metrics_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
+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.flow_retrieve_metrics_response import FlowRetrieveMetricsResponse
+
+__all__ = ["FlowsResource", "AsyncFlowsResource"]
+
+
+class FlowsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FlowsResourceWithRawResponse:
+        """
+        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/WorqHat/worqhat-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return FlowsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FlowsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/WorqHat/worqhat-python-sdk#with_streaming_response
+        """
+        return FlowsResourceWithStreamingResponse(self)
+
+    def retrieve_metrics(
+        self,
+        *,
+        end_date: Union[str, date] | NotGiven = NOT_GIVEN,
+        start_date: Union[str, date] | NotGiven = NOT_GIVEN,
+        status: Literal["completed", "failed", "in_progress"] | NotGiven = NOT_GIVEN,
+        user_id: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FlowRetrieveMetricsResponse:
+        """Get metrics for workflows within a specified date range.
+
+        This endpoint provides
+        aggregated statistics about workflow execution and detailed information about
+        individual workflows.
+
+        The response includes metrics aggregated by user and a list of all workflows
+        matching the specified criteria.
+
+        Args:
+          end_date: End date for filtering (YYYY-MM-DD format)
+
+          start_date: Start date for filtering (YYYY-MM-DD format)
+
+          status: Filter by workflow status
+
+          user_id: Filter by specific user ID
+
+          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
+        """
+        return self._get(
+            "/flows/metrics",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "end_date": end_date,
+                        "start_date": start_date,
+                        "status": status,
+                        "user_id": user_id,
+                    },
+                    flow_retrieve_metrics_params.FlowRetrieveMetricsParams,
+                ),
+            ),
+            cast_to=FlowRetrieveMetricsResponse,
+        )
+
+
+class AsyncFlowsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFlowsResourceWithRawResponse:
+        """
+        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/WorqHat/worqhat-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFlowsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFlowsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/WorqHat/worqhat-python-sdk#with_streaming_response
+        """
+        return AsyncFlowsResourceWithStreamingResponse(self)
+
+    async def retrieve_metrics(
+        self,
+        *,
+        end_date: Union[str, date] | NotGiven = NOT_GIVEN,
+        start_date: Union[str, date] | NotGiven = NOT_GIVEN,
+        status: Literal["completed", "failed", "in_progress"] | NotGiven = NOT_GIVEN,
+        user_id: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FlowRetrieveMetricsResponse:
+        """Get metrics for workflows within a specified date range.
+
+        This endpoint provides
+        aggregated statistics about workflow execution and detailed information about
+        individual workflows.
+
+        The response includes metrics aggregated by user and a list of all workflows
+        matching the specified criteria.
+
+        Args:
+          end_date: End date for filtering (YYYY-MM-DD format)
+
+          start_date: Start date for filtering (YYYY-MM-DD format)
+
+          status: Filter by workflow status
+
+          user_id: Filter by specific user ID
+
+          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
+        """
+        return await self._get(
+            "/flows/metrics",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "end_date": end_date,
+                        "start_date": start_date,
+                        "status": status,
+                        "user_id": user_id,
+                    },
+                    flow_retrieve_metrics_params.FlowRetrieveMetricsParams,
+                ),
+            ),
+            cast_to=FlowRetrieveMetricsResponse,
+        )
+
+
+class FlowsResourceWithRawResponse:
+    def __init__(self, flows: FlowsResource) -> None:
+        self._flows = flows
+
+        self.retrieve_metrics = to_raw_response_wrapper(
+            flows.retrieve_metrics,
+        )
+
+
+class AsyncFlowsResourceWithRawResponse:
+    def __init__(self, flows: AsyncFlowsResource) -> None:
+        self._flows = flows
+
+        self.retrieve_metrics = async_to_raw_response_wrapper(
+            flows.retrieve_metrics,
+        )
+
+
+class FlowsResourceWithStreamingResponse:
+    def __init__(self, flows: FlowsResource) -> None:
+        self._flows = flows
+
+        self.retrieve_metrics = to_streamed_response_wrapper(
+            flows.retrieve_metrics,
+        )
+
+
+class AsyncFlowsResourceWithStreamingResponse:
+    def __init__(self, flows: AsyncFlowsResource) -> None:
+        self._flows = flows
+
+        self.retrieve_metrics = async_to_streamed_response_wrapper(
+            flows.retrieve_metrics,
+        )

worqhat/resources/health.py

@@ -0,0 +1,143 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.health_check_response import HealthCheckResponse
+
+__all__ = ["HealthResource", "AsyncHealthResource"]
+
+
+class HealthResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> HealthResourceWithRawResponse:
+        """
+        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/WorqHat/worqhat-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return HealthResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> HealthResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/WorqHat/worqhat-python-sdk#with_streaming_response
+        """
+        return HealthResourceWithStreamingResponse(self)
+
+    def check(
+        self,
+        *,
+        # 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,
+    ) -> HealthCheckResponse:
+        """Check if the server is running and get uptime information.
+
+        This endpoint can be
+        used for monitoring and alerting systems.
+        """
+        return self._get(
+            "/health",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=HealthCheckResponse,
+        )
+
+
+class AsyncHealthResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncHealthResourceWithRawResponse:
+        """
+        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/WorqHat/worqhat-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncHealthResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncHealthResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/WorqHat/worqhat-python-sdk#with_streaming_response
+        """
+        return AsyncHealthResourceWithStreamingResponse(self)
+
+    async def check(
+        self,
+        *,
+        # 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,
+    ) -> HealthCheckResponse:
+        """Check if the server is running and get uptime information.
+
+        This endpoint can be
+        used for monitoring and alerting systems.
+        """
+        return await self._get(
+            "/health",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=HealthCheckResponse,
+        )
+
+
+class HealthResourceWithRawResponse:
+    def __init__(self, health: HealthResource) -> None:
+        self._health = health
+
+        self.check = to_raw_response_wrapper(
+            health.check,
+        )
+
+
+class AsyncHealthResourceWithRawResponse:
+    def __init__(self, health: AsyncHealthResource) -> None:
+        self._health = health
+
+        self.check = async_to_raw_response_wrapper(
+            health.check,
+        )
+
+
+class HealthResourceWithStreamingResponse:
+    def __init__(self, health: HealthResource) -> None:
+        self._health = health
+
+        self.check = to_streamed_response_wrapper(
+            health.check,
+        )
+
+
+class AsyncHealthResourceWithStreamingResponse:
+    def __init__(self, health: AsyncHealthResource) -> None:
+        self._health = health
+
+        self.check = async_to_streamed_response_wrapper(
+            health.check,
+        )

worqhat/types/__init__.py

@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .health_check_response import HealthCheckResponse as HealthCheckResponse
+from .flow_retrieve_metrics_params import FlowRetrieveMetricsParams as FlowRetrieveMetricsParams
+from .retrieve_server_info_response import RetrieveServerInfoResponse as RetrieveServerInfoResponse
+from .flow_retrieve_metrics_response import FlowRetrieveMetricsResponse as FlowRetrieveMetricsResponse

worqhat/types/flow_retrieve_metrics_params.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import date
+from typing_extensions import Literal, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["FlowRetrieveMetricsParams"]
+
+
+class FlowRetrieveMetricsParams(TypedDict, total=False):
+    end_date: Annotated[Union[str, date], PropertyInfo(format="iso8601")]
+    """End date for filtering (YYYY-MM-DD format)"""
+
+    start_date: Annotated[Union[str, date], PropertyInfo(format="iso8601")]
+    """Start date for filtering (YYYY-MM-DD format)"""
+
+    status: Literal["completed", "failed", "in_progress"]
+    """Filter by workflow status"""
+
+    user_id: str
+    """Filter by specific user ID"""

worqhat/types/flow_retrieve_metrics_response.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["FlowRetrieveMetricsResponse", "Metrics", "MetricsMetricsByUser", "Workflow"]
+
+
+class MetricsMetricsByUser(BaseModel):
+    completed: Optional[int] = None
+
+    failed: Optional[int] = None
+
+    in_progress: Optional[int] = None
+
+    total: Optional[int] = None
+
+
+class Metrics(BaseModel):
+    avg_duration_ms: Optional[float] = None
+
+    completed_workflows: Optional[int] = None
+
+    failed_workflows: Optional[int] = None
+
+    in_progress_workflows: Optional[int] = None
+
+    metrics_by_user: Optional[Dict[str, MetricsMetricsByUser]] = None
+
+    total_workflows: Optional[int] = None
+
+
+class Workflow(BaseModel):
+    id: Optional[str] = None
+
+    end_timestamp: Optional[datetime] = None
+
+    org_id: Optional[str] = None
+
+    start_timestamp: Optional[datetime] = None
+
+    status: Optional[Literal["completed", "failed", "in_progress"]] = None
+
+    user_id: Optional[str] = None
+
+    workflow_id: Optional[str] = None
+
+
+class FlowRetrieveMetricsResponse(BaseModel):
+    metrics: Optional[Metrics] = None
+
+    workflows: Optional[List[Workflow]] = None

worqhat/types/health_check_response.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["HealthCheckResponse", "Services"]
+
+
+class Services(BaseModel):
+    database: Optional[Literal["ok", "degraded", "down"]] = None
+
+
+class HealthCheckResponse(BaseModel):
+    status: Literal["ok", "degraded", "maintenance", "down"]
+    """Current health status of the API"""
+
+    uptime: float
+    """Server uptime in seconds"""
+
+    environment: Optional[Literal["development", "staging", "production"]] = None
+    """Current environment"""
+
+    services: Optional[Services] = None
+    """Status of dependent services"""
+
+    timestamp: Optional[datetime] = None
+    """Current server time"""
+
+    version: Optional[str] = None
+    """Current API version"""

worqhat/types/retrieve_server_info_response.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["RetrieveServerInfoResponse"]
+
+
+class RetrieveServerInfoResponse(BaseModel):
+    environment: Optional[str] = None
+
+    name: Optional[str] = None
+
+    version: Optional[str] = None