logfire-api 4.34.0__tar.gz → 4.35.0__tar.gz

{logfire_api-4.34.0 → logfire_api-4.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logfire-api
-Version: 4.34.0
+Version: 4.35.0
 Summary: Shim for the Logfire SDK which does nothing unless Logfire is installed
 Author-email: Pydantic Team <engineering@pydantic.dev>, Samuel Colvin <samuel@pydantic.dev>, Hasan Ramezani <hasan@pydantic.dev>, Adrian Garcia Badaracco <adrian@pydantic.dev>, David Montague <david@pydantic.dev>, Marcelo Trylesinski <marcelo@pydantic.dev>, David Hewitt <david.hewitt@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT

{logfire_api-4.34.0 → logfire_api-4.35.0}/logfire_api/_internal/integrations/system_metrics.pyi

@@ -4,7 +4,7 @@ from logfire import Logfire as Logfire
 from typing import Literal
 from typing_extensions import LiteralString
 
-MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
+MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.disk.io', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
 Config = dict[MetricName, Iterable[str] | None]
 CPU_FIELDS: list[LiteralString]
 MEMORY_FIELDS: list[LiteralString]

{logfire_api-4.34.0 → logfire_api-4.35.0}/logfire_api/db_api.pyi

@@ -2,7 +2,7 @@ from _typeshed import Incomplete
 from collections.abc import Sequence
 from datetime import datetime, timedelta
 from logfire.experimental.query_client import ColumnDetails as ColumnDetails, LogfireQueryClient as LogfireQueryClient
-from typing import Any
+from typing import Any, overload
 
 apilevel: str
 threadsafety: int
@@ -49,11 +49,15 @@ class Cursor:
     """PEP 249 Cursor that executes queries via `LogfireQueryClient.query_json_rows()`."""
     rowcount: int
     arraysize: int
-    min_timestamp: datetime | None
     max_timestamp: datetime | None
     limit: int
     def __init__(self, connection: Connection) -> None: ...
     @property
+    def min_timestamp(self) -> datetime | None:
+        """Per-cursor override for the lower `start_timestamp` bound."""
+    @min_timestamp.setter
+    def min_timestamp(self, value: datetime | None) -> None: ...
+    @property
     def description(self) -> list[tuple[Any, ...]] | None:
         """Column description as a list of 7-tuples per PEP 249.
 
@@ -88,23 +92,7 @@ class Cursor:
     def __enter__(self) -> Cursor: ...
     def __exit__(self, *args: Any) -> None: ...
 
-def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta | None = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection:
-    """Create a PEP 249 connection to the Logfire query API.
-
-    Args:
-        read_token: A Logfire read token for authentication.
-        base_url: Override the default API base URL (inferred from token region).
-        timeout: HTTP request timeout in seconds.
-        min_timestamp: Default lower bound for `start_timestamp` filtering.
-            Accepts a `datetime` for an exact bound, a `timedelta` for a
-            relative window (computed as `now - timedelta`), or `None` to
-            disable the filter.  Defaults to 1 day ago.
-        max_timestamp: Default upper bound for `start_timestamp` filtering.
-        limit: Default row limit per query (max 10,000). When the number of
-            returned rows equals the limit a warning is emitted.
-        **kwargs: Additional keyword arguments forwarded to the underlying
-            `httpx.Client`.
-
-    Returns:
-        A PEP 249 `Connection` object.
-    """
+@overload
+def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: None, max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...
+@overload
+def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...

logfire_api-4.35.0/logfire_api/experimental/query_client.pyi

@@ -0,0 +1,123 @@
+from _typeshed import Incomplete
+from datetime import datetime
+from httpx import AsyncClient, Client, Response, Timeout
+from httpx._client import BaseClient
+from logfire import VERSION as VERSION
+from logfire._internal.config import get_base_url_from_token as get_base_url_from_token
+from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
+from pyarrow import Table
+from types import TracebackType
+from typing import Any, Generic, TypeVar, TypedDict, overload
+from typing_extensions import Self
+
+DEFAULT_TIMEOUT: Incomplete
+
+class QueryExecutionError(RuntimeError):
+    """Raised when the query execution fails on the server."""
+class QueryRequestError(RuntimeError):
+    """Raised when the query request is invalid."""
+class InfoRequestError(RuntimeError):
+    """Raised when the request for read token info fails because of unavailable information."""
+
+class ReadTokenInfo(TypedDict, total=False):
+    """Information about the read token."""
+    organization_name: str
+    project_name: str
+
+class ColumnDetails(TypedDict):
+    """The details of a column in the row-oriented JSON-format query results."""
+    name: str
+    datatype: Any
+    nullable: bool
+
+class ColumnData(ColumnDetails):
+    """The data of a column in the column-oriented JSON-format query results."""
+    values: list[Any]
+
+class QueryResults(TypedDict):
+    """The (column-oriented) results of a JSON-format query."""
+    columns: list[ColumnData]
+
+class RowQueryResults(TypedDict):
+    """The row-oriented results of a JSON-format query."""
+    columns: list[ColumnDetails]
+    rows: list[dict[str, Any]]
+T = TypeVar('T', bound=BaseClient)
+
+class _BaseLogfireQueryClient(Generic[T]):
+    base_url: Incomplete
+    read_token: Incomplete
+    timeout: Incomplete
+    client: T
+    def __init__(self, base_url: str, read_token: str, timeout: Timeout, client: type[T], **client_kwargs: Any) -> None: ...
+    def handle_response_errors(self, response: Response) -> None: ...
+
+class LogfireQueryClient(_BaseLogfireQueryClient[Client]):
+    """A synchronous client for querying Logfire data."""
+    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **client_kwargs: Any) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
+    def info(self) -> ReadTokenInfo:
+        """Get information about the read token."""
+    def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
+        """Query Logfire data and return the results as a column-oriented dictionary."""
+    @overload
+    def query_json_rows(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    def query_json_rows(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    def query_arrow(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    def query_arrow(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    def query_csv(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+    @overload
+    def query_csv(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+
+class AsyncLogfireQueryClient(_BaseLogfireQueryClient[AsyncClient]):
+    """An asynchronous client for querying Logfire data."""
+    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **async_client_kwargs: Any) -> None: ...
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
+    async def info(self) -> ReadTokenInfo:
+        """Get information about the read token."""
+    @overload
+    async def query_json_rows(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    async def query_json_rows(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    async def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
+        """Query Logfire data and return the results as a column-oriented dictionary."""
+    async def query_json_rows(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults:
+        """Query Logfire data and return the results as a row-oriented dictionary.
+
+        Args:
+            sql: The SQL `SELECT` query to execute.
+            min_timestamp: The minimum timestamp to use when querying data. If the provided
+                [`datetime`][datetime.datetime] doesn't have a timezone set, it is assumed to
+                be UTC.
+
+                /// version-deprecated | v4.35.0
+                Not providing a `min_timestamp` is deprecated.
+                ///
+            max_timestamp: The maximum timestamp to use when querying data. If the provided
+                [`datetime`][datetime.datetime] doesn't have a timezone set, it is assumed to
+                be UTC.
+            limit: The maximum number of rows to query. This value takes priority over the
+                `LIMIT` clause in the `sql` query.
+            timezone: The timezone to use for the query execution context.
+            environment: Restrict rows to the provided environment(s). To only query rows where no environment is set,
+                use the empty string (`''`).
+
+        Returns:
+            A dictionary with two entries:
+              * `columns`: A list of column details including the name, datatype and whether the column is nullable.
+              * `rows`: The list of rows matching the query.
+        """
+    @overload
+    async def query_arrow(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    async def query_arrow(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    async def query_csv(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+    @overload
+    async def query_csv(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...

logfire_api-4.35.0/logfire_api/query_client.pyi

@@ -0,0 +1,3 @@
+from .experimental.query_client import AsyncLogfireQueryClient as AsyncLogfireQueryClient, ColumnData as ColumnData, ColumnDetails as ColumnDetails, InfoRequestError as InfoRequestError, LogfireQueryClient as LogfireQueryClient, QueryExecutionError as QueryExecutionError, QueryRequestError as QueryRequestError, QueryResults as QueryResults, ReadTokenInfo as ReadTokenInfo, RowQueryResults as RowQueryResults
+
+__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'ReadTokenInfo', 'ColumnDetails', 'ColumnData', 'QueryResults', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']

{logfire_api-4.34.0 → logfire_api-4.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "logfire-api"
-version = "4.34.0"
+version = "4.35.0"
 description = "Shim for the Logfire SDK which does nothing unless Logfire is installed"
 authors = [
     { name = "Pydantic Team", email = "engineering@pydantic.dev" },

logfire_api-4.34.0/logfire_api/experimental/query_client.pyi

@@ -1,100 +0,0 @@
-from _typeshed import Incomplete
-from datetime import datetime
-from httpx import AsyncClient, Client, Response, Timeout
-from httpx._client import BaseClient
-from logfire import VERSION as VERSION
-from logfire._internal.config import get_base_url_from_token as get_base_url_from_token
-from pyarrow import Table
-from types import TracebackType
-from typing import Any, Generic, TypeVar, TypedDict
-from typing_extensions import Self
-
-DEFAULT_TIMEOUT: Incomplete
-
-class QueryExecutionError(RuntimeError):
-    """Raised when the query execution fails on the server."""
-class QueryRequestError(RuntimeError):
-    """Raised when the query request is invalid."""
-class InfoRequestError(RuntimeError):
-    """Raised when the request for read token info fails because of unavailable information."""
-
-class ReadTokenInfo(TypedDict, total=False):
-    """Information about the read token."""
-    organization_name: str
-    project_name: str
-
-class ColumnDetails(TypedDict):
-    """The details of a column in the row-oriented JSON-format query results."""
-    name: str
-    datatype: Any
-    nullable: bool
-
-class ColumnData(ColumnDetails):
-    """The data of a column in the column-oriented JSON-format query results."""
-    values: list[Any]
-
-class QueryResults(TypedDict):
-    """The (column-oriented) results of a JSON-format query."""
-    columns: list[ColumnData]
-
-class RowQueryResults(TypedDict):
-    """The row-oriented results of a JSON-format query."""
-    columns: list[ColumnDetails]
-    rows: list[dict[str, Any]]
-T = TypeVar('T', bound=BaseClient)
-
-class _BaseLogfireQueryClient(Generic[T]):
-    base_url: Incomplete
-    read_token: Incomplete
-    timeout: Incomplete
-    client: T
-    def __init__(self, base_url: str, read_token: str, timeout: Timeout, client: type[T], **client_kwargs: Any) -> None: ...
-    def handle_response_errors(self, response: Response) -> None: ...
-
-class LogfireQueryClient(_BaseLogfireQueryClient[Client]):
-    """A synchronous client for querying Logfire data."""
-    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **client_kwargs: Any) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
-    def info(self) -> ReadTokenInfo:
-        """Get information about the read token."""
-    def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
-        """Query Logfire data and return the results as a column-oriented dictionary."""
-    def query_json_rows(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> RowQueryResults:
-        """Query Logfire data and return the results as a row-oriented dictionary."""
-    def query_arrow(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> Table:
-        """Query Logfire data and return the results as a pyarrow Table.
-
-        Note that pyarrow must be installed for this method to succeed.
-
-        You can use `polars.from_arrow(result)` to convert the returned table to a polars DataFrame.
-        """
-    def query_csv(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> str:
-        """Query Logfire data and return the results as a CSV-format string.
-
-        Use `polars.read_csv(StringIO(result))` to convert the returned CSV to a polars DataFrame.
-        """
-
-class AsyncLogfireQueryClient(_BaseLogfireQueryClient[AsyncClient]):
-    """An asynchronous client for querying Logfire data."""
-    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **async_client_kwargs: Any) -> None: ...
-    async def __aenter__(self) -> Self: ...
-    async def __aexit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
-    async def info(self) -> ReadTokenInfo:
-        """Get information about the read token."""
-    async def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
-        """Query Logfire data and return the results as a column-oriented dictionary."""
-    async def query_json_rows(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> RowQueryResults:
-        """Query Logfire data and return the results as a row-oriented dictionary."""
-    async def query_arrow(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> Table:
-        """Query Logfire data and return the results as a pyarrow Table.
-
-        Note that pyarrow must be installed for this method to succeed.
-
-        You can use `polars.from_arrow(result)` to convert the returned table to a polars DataFrame.
-        """
-    async def query_csv(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> str:
-        """Query Logfire data and return the results as a CSV-format string.
-
-        Use `polars.read_csv(StringIO(result))` to convert the returned CSV to a polars DataFrame.
-        """

logfire_api-4.34.0/logfire_api/query_client.pyi

@@ -1 +0,0 @@
-from .experimental.query_client import *