loki-reader-core 0.0.1__py3-none-any.whl

loki_reader_core/__init__.py

@@ -0,0 +1,21 @@
+"""
+Python library for querying Grafana Loki logs via REST API
+"""
+
+from .client import LokiClient
+from .exceptions import LokiAuthError, LokiConnectionError, LokiError, LokiQueryError
+from .models import LogEntry, LogStream, QueryResult, QueryStats
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "LokiClient",
+    "LogEntry",
+    "LogStream",
+    "QueryResult",
+    "QueryStats",
+    "LokiError",
+    "LokiConnectionError",
+    "LokiQueryError",
+    "LokiAuthError",
+]

loki_reader_core/client.py

@@ -0,0 +1,294 @@
+"""
+LokiClient for querying Grafana Loki logs via REST API.
+"""
+
+from typing import Optional
+
+import requests
+
+from .exceptions import LokiAuthError, LokiConnectionError, LokiQueryError
+from .models import QueryResult
+from .utils import now_ns
+
+
+class LokiClient:
+    """
+    Client for querying Grafana Loki logs.
+
+    Example:
+        client = LokiClient(
+            base_url="https://loki.example.com",
+            auth=("user", "pass"),
+            org_id="tenant-1"
+        )
+
+        result = client.query_range(
+            logql='{job="api"} |= "error"',
+            start=hours_ago_ns(1),
+            end=now_ns(),
+            limit=500
+        )
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        auth: Optional[tuple[str, str]] = None,
+        org_id: Optional[str] = None,
+        ca_cert: Optional[str] = None,
+        verify_ssl: bool = True,
+        timeout: int = 30
+    ):
+        """
+        Initialize the Loki client.
+
+        Args:
+            base_url: Base URL of the Loki server (e.g., "https://loki.example.com").
+            auth: Optional tuple of (username, password) for basic authentication.
+            org_id: Optional X-Scope-OrgID header for multi-tenant Loki setups.
+            ca_cert: Optional path to CA certificate PEM file for self-signed certs.
+            verify_ssl: Whether to verify SSL certificates. Set False to disable (insecure).
+            timeout: Request timeout in seconds.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.auth = auth
+        self.org_id = org_id
+        self.ca_cert = ca_cert
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+
+        self._session: Optional[requests.Session] = None
+
+    @property
+    def session(self) -> requests.Session:
+        """
+        Get or create HTTP session with configured authentication and SSL settings.
+
+        Returns:
+            Configured requests.Session instance.
+        """
+        if self._session is None:
+            self._session = requests.Session()
+
+            if self.auth:
+                self._session.auth = self.auth
+
+            if self.org_id:
+                self._session.headers["X-Scope-OrgID"] = self.org_id
+
+            if self.ca_cert:
+                self._session.verify = self.ca_cert
+            else:
+                self._session.verify = self.verify_ssl
+
+        return self._session
+
+    def _request(self, method: str, endpoint: str, params: Optional[dict] = None) -> dict:
+        """
+        Make HTTP request to Loki API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.).
+            endpoint: API endpoint path.
+            params: Optional query parameters.
+
+        Returns:
+            JSON response as dictionary.
+
+        Raises:
+            LokiConnectionError: If connection to Loki fails.
+            LokiAuthError: If authentication fails (401/403).
+            LokiQueryError: If the query fails or returns an error.
+        """
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                timeout=self.timeout
+            )
+        except requests.exceptions.SSLError as e:
+            raise LokiConnectionError(f"SSL error connecting to Loki: {e}") from e
+        except requests.exceptions.ConnectionError as e:
+            raise LokiConnectionError(f"Failed to connect to Loki at {url}: {e}") from e
+        except requests.exceptions.Timeout as e:
+            raise LokiConnectionError(f"Request to Loki timed out: {e}") from e
+        except requests.exceptions.RequestException as e:
+            raise LokiConnectionError(f"Request to Loki failed: {e}") from e
+
+        if response.status_code == 401:
+            raise LokiAuthError("Authentication failed: invalid credentials")
+        if response.status_code == 403:
+            raise LokiAuthError("Authorization failed: access denied")
+
+        if response.status_code != 200:
+            raise LokiQueryError(
+                f"Loki query failed with status {response.status_code}: {response.text}"
+            )
+
+        try:
+            data = response.json()
+        except ValueError as e:
+            raise LokiQueryError(f"Invalid JSON response from Loki: {e}") from e
+
+        if data.get("status") == "error":
+            error_msg = data.get("error", "Unknown error")
+            raise LokiQueryError(f"Loki query error: {error_msg}")
+
+        return data
+
+    def query(
+        self,
+        logql: str,
+        time: Optional[int] = None,
+        limit: int = 100
+    ) -> QueryResult:
+        """
+        Execute an instant query at a single point in time.
+
+        Args:
+            logql: LogQL query string (e.g., '{job="api"} |= "error"').
+            time: Optional timestamp in nanoseconds. Defaults to now.
+            limit: Maximum number of entries to return.
+
+        Returns:
+            QueryResult containing matching log streams.
+        """
+        params = {
+            "query": logql,
+            "limit": limit
+        }
+
+        if time is not None:
+            params["time"] = str(time)
+
+        response = self._request("GET", "/loki/api/v1/query", params)
+        return QueryResult.from_loki_response(response)
+
+    def query_range(
+        self,
+        logql: str,
+        start: int,
+        end: int,
+        limit: int = 1000,
+        direction: str = "backward"
+    ) -> QueryResult:
+        """
+        Execute a range query across a time period.
+
+        Args:
+            logql: LogQL query string (e.g., '{job="api"} |= "error"').
+            start: Start timestamp in nanoseconds.
+            end: End timestamp in nanoseconds.
+            limit: Maximum number of entries to return.
+            direction: Sort direction - "forward" (oldest first) or "backward" (newest first).
+
+        Returns:
+            QueryResult containing matching log streams.
+        """
+        params = {
+            "query": logql,
+            "start": str(start),
+            "end": str(end),
+            "limit": limit,
+            "direction": direction
+        }
+
+        response = self._request("GET", "/loki/api/v1/query_range", params)
+        return QueryResult.from_loki_response(response)
+
+    def get_labels(
+        self,
+        start: Optional[int] = None,
+        end: Optional[int] = None
+    ) -> list[str]:
+        """
+        Get list of available label names.
+
+        Args:
+            start: Optional start timestamp in nanoseconds.
+            end: Optional end timestamp in nanoseconds.
+
+        Returns:
+            List of label names.
+        """
+        params = {}
+
+        if start is not None:
+            params["start"] = str(start)
+        if end is not None:
+            params["end"] = str(end)
+
+        response = self._request("GET", "/loki/api/v1/labels", params or None)
+        return response.get("data", [])
+
+    def get_label_values(
+        self,
+        label: str,
+        start: Optional[int] = None,
+        end: Optional[int] = None
+    ) -> list[str]:
+        """
+        Get list of values for a specific label.
+
+        Args:
+            label: Label name to get values for.
+            start: Optional start timestamp in nanoseconds.
+            end: Optional end timestamp in nanoseconds.
+
+        Returns:
+            List of label values.
+        """
+        params = {}
+
+        if start is not None:
+            params["start"] = str(start)
+        if end is not None:
+            params["end"] = str(end)
+
+        endpoint = f"/loki/api/v1/label/{label}/values"
+        response = self._request("GET", endpoint, params or None)
+        return response.get("data", [])
+
+    def get_series(
+        self,
+        match: list[str],
+        start: Optional[int] = None,
+        end: Optional[int] = None
+    ) -> list[dict[str, str]]:
+        """
+        Get list of unique label sets matching the given selectors.
+
+        Args:
+            match: List of stream selectors (e.g., ['{job="api"}', '{container="web"}']).
+            start: Optional start timestamp in nanoseconds.
+            end: Optional end timestamp in nanoseconds.
+
+        Returns:
+            List of label dictionaries representing unique streams.
+        """
+        params = {"match[]": match}
+
+        if start is not None:
+            params["start"] = str(start)
+        if end is not None:
+            params["end"] = str(end)
+
+        response = self._request("GET", "/loki/api/v1/series", params)
+        return response.get("data", [])
+
+    def close(self) -> None:
+        """Close the HTTP session."""
+        if self._session is not None:
+            self._session.close()
+            self._session = None
+
+    def __enter__(self) -> "LokiClient":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit - closes session."""
+        self.close()

loki_reader_core/exceptions.py

@@ -0,0 +1,23 @@
+"""
+Custom exceptions for loki-reader-core.
+"""
+
+
+class LokiError(Exception):
+    """Base exception for all Loki-related errors."""
+    pass
+
+
+class LokiConnectionError(LokiError):
+    """Raised when connection to Loki server fails."""
+    pass
+
+
+class LokiQueryError(LokiError):
+    """Raised when a Loki query fails or returns an error."""
+    pass
+
+
+class LokiAuthError(LokiError):
+    """Raised when authentication to Loki fails."""
+    pass

loki_reader_core/models/__init__.py

@@ -0,0 +1,10 @@
+"""
+Data models for loki-reader-core.
+"""
+
+from .log_entry import LogEntry
+from .log_stream import LogStream
+from .query_stats import QueryStats
+from .query_result import QueryResult
+
+__all__ = ["LogEntry", "LogStream", "QueryStats", "QueryResult"]

loki_reader_core/models/log_entry.py

@@ -0,0 +1,63 @@
+"""
+LogEntry model representing a single log line from Loki.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class LogEntry:
+    """
+    A single log entry from a Loki stream.
+
+    Attributes:
+        timestamp: Unix timestamp in nanoseconds when the log was recorded.
+        message: The log message content.
+    """
+
+    timestamp: int
+    message: str
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary for serialization.
+
+        Returns:
+            Dictionary with timestamp and message.
+        """
+        return {
+            "timestamp": self.timestamp,
+            "message": self.message
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LogEntry":
+        """
+        Create LogEntry from dictionary.
+
+        Args:
+            data: Dictionary with timestamp and message keys.
+
+        Returns:
+            LogEntry instance.
+        """
+        return cls(
+            timestamp=int(data["timestamp"]),
+            message=data["message"]
+        )
+
+    @classmethod
+    def from_loki_value(cls, value: list) -> "LogEntry":
+        """
+        Create LogEntry from Loki's [timestamp, message] format.
+
+        Args:
+            value: List of [timestamp_string, message_string] from Loki API.
+
+        Returns:
+            LogEntry instance.
+        """
+        return cls(
+            timestamp=int(value[0]),
+            message=value[1]
+        )

loki_reader_core/models/log_stream.py

@@ -0,0 +1,66 @@
+"""
+LogStream model representing a stream of logs with common labels.
+"""
+
+from dataclasses import dataclass
+
+from .log_entry import LogEntry
+
+
+@dataclass
+class LogStream:
+    """
+    A stream of log entries sharing common labels.
+
+    Attributes:
+        labels: Dictionary of label key-value pairs (e.g., {"job": "api", "container": "web"}).
+        entries: List of LogEntry objects in this stream.
+    """
+
+    labels: dict[str, str]
+    entries: list[LogEntry]
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary for serialization.
+
+        Returns:
+            Dictionary with labels and entries.
+        """
+        return {
+            "labels": self.labels,
+            "entries": [entry.to_dict() for entry in self.entries]
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LogStream":
+        """
+        Create LogStream from dictionary.
+
+        Args:
+            data: Dictionary with labels and entries keys.
+
+        Returns:
+            LogStream instance.
+        """
+        entries = [LogEntry.from_dict(e) for e in data.get("entries", [])]
+        return cls(
+            labels=data["labels"],
+            entries=entries
+        )
+
+    @classmethod
+    def from_loki_stream(cls, stream_data: dict) -> "LogStream":
+        """
+        Create LogStream from Loki API response format.
+
+        Args:
+            stream_data: Dictionary with 'stream' (labels) and 'values' (log entries).
+
+        Returns:
+            LogStream instance.
+        """
+        labels = stream_data.get("stream", {})
+        values = stream_data.get("values", [])
+        entries = [LogEntry.from_loki_value(v) for v in values]
+        return cls(labels=labels, entries=entries)

loki_reader_core/models/query_result.py

@@ -0,0 +1,88 @@
+"""
+QueryResult model representing the result of a Loki query.
+"""
+
+from dataclasses import dataclass
+
+from .log_stream import LogStream
+from .query_stats import QueryStats
+
+
+@dataclass
+class QueryResult:
+    """
+    Result of a Loki query containing streams and statistics.
+
+    Attributes:
+        status: Response status from Loki (typically "success").
+        streams: List of LogStream objects containing the query results.
+        stats: Optional QueryStats with execution statistics.
+    """
+
+    status: str
+    streams: list[LogStream]
+    stats: QueryStats | None
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary for serialization.
+
+        Returns:
+            Dictionary with status, streams, and stats.
+        """
+        return {
+            "status": self.status,
+            "streams": [stream.to_dict() for stream in self.streams],
+            "stats": self.stats.to_dict() if self.stats else None
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "QueryResult":
+        """
+        Create QueryResult from dictionary.
+
+        Args:
+            data: Dictionary with status, streams, and stats keys.
+
+        Returns:
+            QueryResult instance.
+        """
+        streams = [LogStream.from_dict(s) for s in data.get("streams", [])]
+        stats = QueryStats.from_dict(data["stats"]) if data.get("stats") else None
+        return cls(
+            status=data["status"],
+            streams=streams,
+            stats=stats
+        )
+
+    @classmethod
+    def from_loki_response(cls, response_data: dict) -> "QueryResult":
+        """
+        Create QueryResult from Loki API response format.
+
+        Args:
+            response_data: Full response from Loki query API.
+
+        Returns:
+            QueryResult instance.
+        """
+        status = response_data.get("status", "unknown")
+        data = response_data.get("data", {})
+
+        result_list = data.get("result", [])
+        streams = [LogStream.from_loki_stream(s) for s in result_list]
+
+        stats_data = data.get("stats")
+        stats = QueryStats.from_loki_stats(stats_data) if stats_data else None
+
+        return cls(status=status, streams=streams, stats=stats)
+
+    @property
+    def total_entries(self) -> int:
+        """
+        Get total number of log entries across all streams.
+
+        Returns:
+            Total entry count.
+        """
+        return sum(len(stream.entries) for stream in self.streams)

loki_reader_core/models/query_stats.py

@@ -0,0 +1,69 @@
+"""
+QueryStats model representing statistics from a Loki query.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class QueryStats:
+    """
+    Statistics about a Loki query execution.
+
+    Attributes:
+        bytes_processed: Total bytes processed during the query.
+        lines_processed: Total log lines processed during the query.
+        exec_time_seconds: Query execution time in seconds.
+    """
+
+    bytes_processed: int
+    lines_processed: int
+    exec_time_seconds: float
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary for serialization.
+
+        Returns:
+            Dictionary with statistics.
+        """
+        return {
+            "bytes_processed": self.bytes_processed,
+            "lines_processed": self.lines_processed,
+            "exec_time_seconds": self.exec_time_seconds
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "QueryStats":
+        """
+        Create QueryStats from dictionary.
+
+        Args:
+            data: Dictionary with statistics keys.
+
+        Returns:
+            QueryStats instance.
+        """
+        return cls(
+            bytes_processed=data.get("bytes_processed", 0),
+            lines_processed=data.get("lines_processed", 0),
+            exec_time_seconds=data.get("exec_time_seconds", 0.0)
+        )
+
+    @classmethod
+    def from_loki_stats(cls, stats_data: dict) -> "QueryStats":
+        """
+        Create QueryStats from Loki API response format.
+
+        Args:
+            stats_data: Statistics object from Loki response.
+
+        Returns:
+            QueryStats instance.
+        """
+        summary = stats_data.get("summary", {})
+        return cls(
+            bytes_processed=summary.get("totalBytesProcessed", 0),
+            lines_processed=summary.get("totalLinesProcessed", 0),
+            exec_time_seconds=summary.get("execTime", 0.0)
+        )

loki_reader_core/utils.py

@@ -0,0 +1,85 @@
+"""
+Timestamp utility functions for working with Loki's nanosecond timestamps.
+"""
+
+import time
+
+
+NANOSECONDS_PER_SECOND = 1_000_000_000
+NANOSECONDS_PER_MINUTE = NANOSECONDS_PER_SECOND * 60
+NANOSECONDS_PER_HOUR = NANOSECONDS_PER_MINUTE * 60
+
+
+def now_ns() -> int:
+    """
+    Get current time as Unix nanoseconds.
+
+    Returns:
+        Current timestamp in nanoseconds.
+    """
+    return int(time.time() * NANOSECONDS_PER_SECOND)
+
+
+def seconds_to_ns(seconds: int) -> int:
+    """
+    Convert Unix seconds to nanoseconds.
+
+    Args:
+        seconds: Unix timestamp in seconds.
+
+    Returns:
+        Timestamp in nanoseconds.
+    """
+    return seconds * NANOSECONDS_PER_SECOND
+
+
+def ns_to_seconds(nanoseconds: int) -> int:
+    """
+    Convert Unix nanoseconds to seconds.
+
+    Args:
+        nanoseconds: Unix timestamp in nanoseconds.
+
+    Returns:
+        Timestamp in seconds.
+    """
+    return nanoseconds // NANOSECONDS_PER_SECOND
+
+
+def minutes_ago_ns(minutes: int) -> int:
+    """
+    Get timestamp N minutes ago as nanoseconds.
+
+    Args:
+        minutes: Number of minutes in the past.
+
+    Returns:
+        Timestamp in nanoseconds.
+    """
+    return now_ns() - (minutes * NANOSECONDS_PER_MINUTE)
+
+
+def hours_ago_ns(hours: int) -> int:
+    """
+    Get timestamp N hours ago as nanoseconds.
+
+    Args:
+        hours: Number of hours in the past.
+
+    Returns:
+        Timestamp in nanoseconds.
+    """
+    return now_ns() - (hours * NANOSECONDS_PER_HOUR)
+
+
+def days_ago_ns(days: int) -> int:
+    """
+    Get timestamp N days ago as nanoseconds.
+
+    Args:
+        days: Number of days in the past.
+
+    Returns:
+        Timestamp in nanoseconds.
+    """
+    return now_ns() - (days * NANOSECONDS_PER_HOUR * 24)

loki_reader_core-0.0.1.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: loki-reader-core
+Version: 0.0.1
+Summary: Python library for querying Grafana Loki logs via REST API
+Project-URL: Homepage, https://github.com/jmazzahacks/loki-reader-core
+Project-URL: Issues, https://github.com/jmazzahacks/loki-reader-core/issues
+Author-email: Jason Byteforge <jmazzahacks@gmail.com>
+License: MIT License
+Keywords: grafana,logging,logs,loki,observability
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# loki-reader-core
+
+A lightweight Python library for querying Grafana Loki logs via REST API.
+
+## Features
+
+- Simple, intuitive client for Loki's HTTP API
+- Supports `query`, `query_range`, label discovery, and series matching
+- SSL/TLS support including custom CA certificates for self-signed certs
+- Multi-tenant support via `X-Scope-OrgID` header
+- Basic authentication
+- Clean dataclass models with `to_dict()`/`from_dict()` serialization
+- All timestamps as Unix nanoseconds (Loki's native format)
+
+## Installation
+
+From PyPI (coming soon):
+
+```bash
+pip install loki-reader-core
+```
+
+From GitHub:
+
+```bash
+pip install loki-reader-core @ git+ssh://git@github.com/jmazzahacks/loki-reader-core.git@main
+```
+
+## Usage
+
+### Basic Query
+
+```python
+from loki_reader_core import LokiClient
+from loki_reader_core.utils import hours_ago_ns, now_ns
+
+client = LokiClient(base_url="https://loki.example.com")
+
+result = client.query_range(
+    logql='{job="api-server"} |= "error"',
+    start=hours_ago_ns(1),
+    end=now_ns(),
+    limit=500
+)
+
+for stream in result.streams:
+    print(f"Labels: {stream.labels}")
+    for entry in stream.entries:
+        print(f"  [{entry.timestamp}] {entry.message}")
+```
+
+### With Authentication and Self-Signed Certificates
+
+```python
+client = LokiClient(
+    base_url="https://loki.internal.company.com:8443",
+    auth=("username", "password"),
+    ca_cert="/path/to/ca.pem"
+)
+```
+
+### Multi-Tenant Setup
+
+```python
+client = LokiClient(
+    base_url="https://loki.example.com",
+    org_id="tenant-1"
+)
+```
+
+### Exploring Labels
+
+```python
+labels = client.get_labels()
+values = client.get_label_values("application")
+series = client.get_series(match=['{application="my-app"}'])
+```
+
+### Context Manager
+
+```python
+with LokiClient(base_url="https://loki.example.com") as client:
+    result = client.query(logql='{job="api"}')
+```
+
+## API Reference
+
+### LokiClient
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `base_url` | `str` | required | Loki server URL |
+| `auth` | `tuple[str, str]` | `None` | Basic auth `(username, password)` |
+| `org_id` | `str` | `None` | `X-Scope-OrgID` for multi-tenant |
+| `ca_cert` | `str` | `None` | Path to CA certificate PEM file |
+| `verify_ssl` | `bool` | `True` | Set `False` to disable SSL verification |
+| `timeout` | `int` | `30` | Request timeout in seconds |
+
+### Methods
+
+| Method | Description |
+|--------|-------------|
+| `query(logql, time, limit)` | Instant query at a single point in time |
+| `query_range(logql, start, end, limit, direction)` | Query across a time range |
+| `get_labels(start, end)` | List available label names |
+| `get_label_values(label, start, end)` | List values for a specific label |
+| `get_series(match, start, end)` | List streams matching selectors |
+
+### Timestamp Utilities
+
+```python
+from loki_reader_core.utils import (
+    now_ns,          # Current time as nanoseconds
+    seconds_to_ns,   # Convert Unix seconds to nanoseconds
+    ns_to_seconds,   # Convert nanoseconds to Unix seconds
+    minutes_ago_ns,  # Timestamp N minutes ago
+    hours_ago_ns,    # Timestamp N hours ago
+    days_ago_ns,     # Timestamp N days ago
+)
+```
+
+## Development
+
+### Setup
+
+```bash
+# Create virtual environment
+python -m venv .
+
+# Activate virtual environment
+source bin/activate
+
+# Install dependencies
+pip install -r dev-requirements.txt
+pip install -e .
+```
+
+### Running Tests
+
+```bash
+source bin/activate
+pytest tests/ -v
+```
+
+### Building and Publishing
+
+```bash
+./build-publish.sh
+```
+
+## License
+
+MIT
+
+## Author
+
+Jason Byteforge (@jmazzahacks)

loki_reader_core-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+loki_reader_core/__init__.py,sha256=n9Z3uOxrILiZjojQSX_egG1H2gal1aRcZ8nrsqE4b5w,463
+loki_reader_core/client.py,sha256=Sp7-b6mlR6RzcwqU99DmJT0gSpJTkQTvQrzf7g4PT-Y,8959
+loki_reader_core/exceptions.py,sha256=i10P8n46cwKzH-XMI8QBwOx3Hp6fVQDBMlXKR-U3cUU,446
+loki_reader_core/utils.py,sha256=UpveOw4GiHhjSs_he4lMq65yq13x5iBjljOXF7Kybds,1720
+loki_reader_core/models/__init__.py,sha256=THIMicK2P594P0evr5eWaobF1hmYYX1FBjq3SwF6Lcg,249
+loki_reader_core/models/log_entry.py,sha256=0lj2pAzMlMvV43fJv_lgwGIgSGwNew-3iEejyzwK-Y8,1410
+loki_reader_core/models/log_stream.py,sha256=Ynq0gdlKa5wfrmyLbKuPYY2fCYoOW2B43-s9KdHNdqM,1717
+loki_reader_core/models/query_result.py,sha256=SJVYGLpMw6MwORCIA5gQpzgkZFSFdgmptNW7angbTNU,2455
+loki_reader_core/models/query_stats.py,sha256=CYuc4Jev2NINby9hrTi4AqUtWt2D0Zzt_bdrcnN6t3k,1869
+loki_reader_core-0.0.1.dist-info/METADATA,sha256=jc3ByLUT3JdvXlxQJRwyz5oGIHt0BnkvxMOoFTEgRj8,4224
+loki_reader_core-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+loki_reader_core-0.0.1.dist-info/RECORD,,

loki_reader_core-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any