uptimer-python-sdk 0.2.0__py3-none-any.whl

uptimer/__init__.py

@@ -0,0 +1,3 @@
+"""Uptimer Python SDK."""
+
+__version__ = "0.1.0"

uptimer/client.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import cast
+
+from uptimer.endpoints.v1 import V1Endpoint
+from uptimer.http import UptimerHttpLib
+
+
+class UptimerClient:
+    v1: V1Endpoint
+
+    def __init__(self, api_key: str, base_url: str | None = None):
+        self.set_uptimer_http_lib(UptimerHttpLib(api_key, base_url))
+        self.v1 = V1Endpoint(self._http_lib)
+
+    def version(self) -> str:
+        response = self._http_lib.client.get(self._http_lib.build_url("version"))
+        return cast("str", self._http_lib.parse_response(response=response))
+
+    def set_uptimer_http_lib(self, http_lib: UptimerHttpLib) -> None:
+        self._http_lib = http_lib

uptimer/endpoints/endpoint.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from uptimer.http import UptimerHttpLib
+
+
+class BaseEndpoint:
+    def __init__(
+        self,
+        http: UptimerHttpLib,
+        segment: str,
+        parent_segments: str | list[str] | None = None,
+    ):
+        self._http = http
+        self._segment = segment
+        if parent_segments is None:
+            parent_segments = []
+        if isinstance(parent_segments, str):
+            parent_segments = [parent_segments]
+        self._parent_segments = parent_segments
+
+    @property
+    def segment(self) -> str:
+        return self._segment
+
+    @property
+    def http(self) -> UptimerHttpLib:
+        return self._http
+
+    @property
+    def url(self) -> str:
+        return self._http.build_url(self.path)
+
+    @property
+    def path(self) -> str:
+        return "/".join([*self._parent_segments, self._segment])

uptimer/endpoints/regions.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from uptimer.endpoints.endpoint import BaseEndpoint
+from uptimer.models import from_api_region
+
+if TYPE_CHECKING:
+    from uptimer.http import UptimerHttpLib
+    from uptimer.models.region import Region
+
+
+class RegionsEndpoint(BaseEndpoint):
+    def __init__(
+        self,
+        http: UptimerHttpLib,
+        parent_segments: str | list[str] | None = None,
+    ):
+        super().__init__(http, "regions", parent_segments)
+
+    def all(self) -> list[Region]:
+        response = self.http.client.get(self.url)
+        result = self.http.parse_response(response=response)
+        return [from_api_region(region) for region in result]

uptimer/endpoints/rules.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import TYPE_CHECKING
+
+from uptimer.endpoints.endpoint import BaseEndpoint
+from uptimer.models import from_api_rule
+from uptimer.models.rule import DeleteRuleResponse
+
+if TYPE_CHECKING:
+    from uptimer.http import UptimerHttpLib
+    from uptimer.models.rule import (
+        BaseRule,
+        CreateRuleRequest,
+        Rule,
+    )
+
+
+class RulesEndpoint(BaseEndpoint):
+    def __init__(
+        self,
+        http: UptimerHttpLib,
+        parent_segments: str | list[str] | None = None,
+    ):
+        super().__init__(http, "rules", parent_segments)
+
+    def all(self, workspace_id: str) -> list[Rule]:
+        """Get all rules for a specific workspace."""
+        params = {"workspace_id": workspace_id}
+        response = self.http.client.get(self.url, params=params)
+        result = self.http.parse_response(response=response)
+
+        return [from_api_rule(rule_data) for rule_data in result]
+
+    def get(self, rule_id: str) -> Rule:
+        """Get a single rule by ID."""
+        response = self.http.client.get(f"{self.url}/{rule_id}")
+        result = self.http.parse_response(response=response)
+
+        return from_api_rule(result)
+
+    def create(self, rule_data: CreateRuleRequest) -> Rule:
+        """Create a new rule."""
+        # Use serialization to convert dataclass to dict
+        payload = asdict(rule_data)
+
+        response = self.http.client.post(self.url, json=payload)
+        result = self.http.parse_response(response=response)
+
+        return from_api_rule(result)
+
+    def update(self, rule_id: str, rule_data: BaseRule) -> Rule:
+        """Update an existing rule."""
+        # Use serialization to convert dataclass to dict
+        payload = asdict(rule_data)
+
+        # Remove id field if present (it's already in the URL)
+        payload.pop("id", None)
+
+        response = self.http.client.post(f"{self.url}/{rule_id}", json=payload)
+        result = self.http.parse_response(response=response)
+
+        return from_api_rule(result)
+
+    def delete(self, rule_id: str) -> DeleteRuleResponse:
+        """Delete a rule by ID."""
+        response = self.http.client.delete(f"{self.url}/{rule_id}")
+
+        # parse_response already returns the result field
+        result_data = self.http.parse_response(response=response)
+
+        return DeleteRuleResponse(
+            message=result_data["message"],
+            rule_id=result_data["rule_id"],
+        )

uptimer/endpoints/v1.py

@@ -0,0 +1,17 @@
+from uptimer.endpoints.endpoint import BaseEndpoint
+from uptimer.endpoints.regions import RegionsEndpoint
+from uptimer.endpoints.rules import RulesEndpoint
+from uptimer.endpoints.workspaces import WorkspacesEndpoint
+from uptimer.http import UptimerHttpLib
+
+
+class V1Endpoint(BaseEndpoint):
+    workspaces: WorkspacesEndpoint
+    regions: RegionsEndpoint
+    rules: RulesEndpoint
+
+    def __init__(self, http: UptimerHttpLib):
+        super().__init__(http, "v1")
+        self.workspaces = WorkspacesEndpoint(http, ["v1"])
+        self.regions = RegionsEndpoint(http, ["v1"])
+        self.rules = RulesEndpoint(http, ["v1"])

uptimer/endpoints/workspaces.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from uptimer.endpoints.endpoint import BaseEndpoint
+from uptimer.models import from_api_workspace
+
+if TYPE_CHECKING:
+    from uptimer.http import UptimerHttpLib
+    from uptimer.models.workspace import Workspace
+
+
+class WorkspacesEndpoint(BaseEndpoint):
+    def __init__(
+        self,
+        http: UptimerHttpLib,
+        parent_segments: str | list[str] | None = None,
+    ):
+        super().__init__(http, "workspaces", parent_segments)
+
+    def all(self) -> list[Workspace]:
+        response = self.http.client.get(self.url)
+        result = self.http.parse_response(response=response)
+        return [from_api_workspace(workspace) for workspace in result]

uptimer/errors.py

@@ -0,0 +1,25 @@
+import httpx
+
+
+class UptimerError(Exception):
+    pass
+
+
+class UptimerInvalidResponseError(UptimerError):
+    pass
+
+
+class UptimerInvalidHttpCodeError(UptimerError):
+    def __init__(self, url: httpx.URL, status_code: int):
+        self.url = url
+        self.status_code = status_code
+        super().__init__(f"Invalid HTTP code {status_code!s} for URL {url!s}")
+
+
+class DefaultUptimerApiError(UptimerError):
+    def __init__(self, error: dict):
+        self.code = error.get("code")
+        self.error_type = error.get("error_type")
+        self.message = error.get("message", "")
+        self.details = error.get("details", "")
+        super().__init__(f"API error: {self.code} {self.message}")

uptimer/http.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from uptimer.endpoints.endpoint import BaseEndpoint
+from uptimer.errors import DefaultUptimerApiError, UptimerInvalidHttpCodeError
+
+
+class WorkspacesEndpoint(BaseEndpoint):
+    pass
+
+
+class UptimerHttpLib:
+    def __init__(self, api_key: str, base_url: str | None = None):
+        if base_url is None:
+            base_url = "https://api.uptimer.com"
+
+        self._base_url = base_url.rstrip("/")
+        self._http_client = httpx.Client(
+            base_url=base_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+            },
+        )
+
+    @property
+    def client(self) -> httpx.Client:
+        return self._http_client
+
+    @property
+    def base_url(self) -> str:
+        return self._base_url
+
+    def build_url(self, path: str) -> str:
+        path = path.strip("/")
+        return self._base_url.rstrip("/") + "/" + path
+
+    @staticmethod
+    def parse_response(
+        response: httpx.Response,
+    ) -> Any:  # noqa: ANN401
+        if response.status_code != 200:
+            raise UptimerInvalidHttpCodeError(
+                response.request.url,
+                response.status_code,
+            )
+        data = response.json()
+        if data.get("error"):
+            raise DefaultUptimerApiError(data["error"])
+        return data["result"]

uptimer/models/__init__.py

@@ -0,0 +1,47 @@
+from .deserialize import (
+    from_api,
+    from_api_region,
+    from_api_rule,
+    from_api_workspace,
+)
+from .errors import (
+    DeserializationError,
+    InvalidDataTypeError,
+    MissingKindError,
+    ModelError,
+    TypeMismatchError,
+    UnknownKindError,
+)
+from .region import Region
+from .rule import (
+    BaseRule,
+    CreateRuleRequest,
+    DeleteRuleResponse,
+    Rule,
+    RuleRequest,
+    RuleResponse,
+    RuleResponseBody,
+)
+from .workspace import Workspace
+
+__all__ = [
+    "BaseRule",
+    "CreateRuleRequest",
+    "DeleteRuleResponse",
+    "DeserializationError",
+    "InvalidDataTypeError",
+    "MissingKindError",
+    "ModelError",
+    "Region",
+    "Rule",
+    "RuleRequest",
+    "RuleResponse",
+    "RuleResponseBody",
+    "TypeMismatchError",
+    "UnknownKindError",
+    "Workspace",
+    "from_api",
+    "from_api_region",
+    "from_api_rule",
+    "from_api_workspace",
+]

uptimer/models/deserialize.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from typing import Any, TypeVar, Union
+
+from .errors import (
+    InvalidDataTypeError,
+    MissingKindError,
+    TypeMismatchError,
+    UnknownKindError,
+)
+from .region import Region
+from .rule import (
+    Rule,
+    RuleRequest,
+    RuleResponse,
+    RuleResponseBody,
+)
+from .workspace import Workspace
+
+# Type variable for the return type
+T = TypeVar("T")
+
+# Union type for all possible return types
+DeserializableType = Union[
+    Rule,
+    RuleRequest,
+    RuleResponse,
+    RuleResponseBody,
+    Region,
+    Workspace,
+]
+
+# Type for items that might be deserializable
+DeserializableItem = Union[dict[str, Any], list[Any], Any]
+
+# Registry of classes by their kind
+_KIND_REGISTRY = {
+    "rule": Rule,
+    "rule_request": RuleRequest,
+    "rule_response": RuleResponse,
+    "rule_response_body": RuleResponseBody,
+    "region": Region,
+    "workspace": Workspace,
+}
+
+
+def from_api(data: dict[str, Any]) -> DeserializableType:
+    """
+    Universal deserializer that creates objects based on their 'kind' property.
+
+    Recursively deserializes nested objects.
+
+    Args:
+        data: Dictionary containing the object data with a 'kind' property
+
+    Returns:
+        The appropriate object instance based on the 'kind' property
+
+    Raises:
+        InvalidDataTypeError: If data is not a dictionary
+        MissingKindError: If the 'kind' property is missing
+        UnknownKindError: If the 'kind' property is not recognized
+    """
+    if not isinstance(data, dict):
+        raise InvalidDataTypeError(type(data))
+
+    kind = data.get("kind")
+    if not kind:
+        raise MissingKindError(data)
+
+    if kind not in _KIND_REGISTRY:
+        raise UnknownKindError(kind)
+
+    cls = _KIND_REGISTRY[kind]
+
+    # Create a copy to avoid modifying the original
+    obj_data = data.copy()
+
+    # Recursively deserialize nested objects that have 'kind' properties
+    for key, value in obj_data.items():
+        if isinstance(value, dict) and value.get("kind"):
+            obj_data[key] = from_api(value)
+        elif isinstance(value, list):
+            # Handle lists of objects
+            obj_data[key] = [_deserialize_if_possible(item) for item in value]
+
+    return cls(**obj_data)
+
+
+def _deserialize_if_possible(item: DeserializableItem) -> DeserializableItem:
+    """Deserialize an item if it has a kind property."""
+    if isinstance(item, dict) and item.get("kind"):
+        return from_api(item)
+    return item
+
+
+def from_api_rule(data: dict[str, Any]) -> Rule:
+    """Type-safe deserializer for Rule objects."""
+    result = from_api(data)
+    if not isinstance(result, Rule):
+        msg = "Rule"
+        raise TypeMismatchError(msg, type(result).__name__)
+    return result
+
+
+def from_api_region(data: dict[str, Any]) -> Region:
+    """Type-safe deserializer for Region objects."""
+    result = from_api(data)
+    if not isinstance(result, Region):
+        msg = "Region"
+        raise TypeMismatchError(msg, type(result).__name__)
+    return result
+
+
+def from_api_workspace(data: dict[str, Any]) -> Workspace:
+    """Type-safe deserializer for Workspace objects."""
+    result = from_api(data)
+    if not isinstance(result, Workspace):
+        msg = "Workspace"
+        raise TypeMismatchError(msg, type(result).__name__)
+    return result

uptimer/models/errors.py

@@ -0,0 +1,44 @@
+"""Error classes for model operations."""
+
+
+class ModelError(Exception):
+    """Base class for all model-related errors."""
+
+
+class DeserializationError(ModelError):
+    """Base class for deserialization errors."""
+
+
+class MissingKindError(DeserializationError):
+    """Raised when an object is missing the 'kind' property."""
+
+    def __init__(self, data: dict):
+        self.data = data
+        super().__init__("Data must contain a 'kind' property")
+
+
+class UnknownKindError(DeserializationError):
+    """Raised when an object has an unknown 'kind' property."""
+
+    def __init__(self, kind: str):
+        self.kind = kind
+        super().__init__(f"Unknown kind: {kind}")
+
+
+class InvalidDataTypeError(DeserializationError):
+    """Raised when data is not a dictionary."""
+
+    def __init__(self, data_type: type):
+        self.data_type = data_type
+        super().__init__(
+            f"Data must be a dictionary, got {data_type.__name__}",
+        )
+
+
+class TypeMismatchError(DeserializationError):
+    """Raised when the deserialized object is not of the expected type."""
+
+    def __init__(self, expected_type: str, actual_type: str):
+        self.expected_type = expected_type
+        self.actual_type = actual_type
+        super().__init__(f"Expected {expected_type}, got {actual_type}")

uptimer/models/region.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Region:
+    id: str  # region id, uuids used for api ids
+    name: str  # region name
+    active_workers_count: int  # number of active workers in the region
+    kind: str  # any object has kind property, defines class of object

uptimer/models/rule.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RuleRequest:
+    url: str  # request URL
+    method: str  # HTTP method (GET, POST, etc.)
+    content_type: str  # content type for the request
+    data: str  # request data/payload
+    kind: str = "rule_request"
+
+
+@dataclass
+class RuleResponseBody:
+    content: str  # expected response body content
+    kind: str = "rule_response_body"
+
+
+@dataclass
+class RuleResponse:
+    statuses: list[int]  # list of acceptable HTTP status codes
+    body: RuleResponseBody  # expected response body
+    kind: str = "rule_response"
+
+
+@dataclass
+class BaseRule:
+    """Base class containing common rule fields."""
+
+    name: str  # rule name
+    interval: int  # check interval in seconds
+    workspace_id: str  # workspace id
+    request: RuleRequest  # request configuration
+    response: RuleResponse  # response validation
+    kind: str = "rule"
+
+
+@dataclass
+class Rule(BaseRule):
+    """Complete rule with ID for API responses."""
+
+    id: str = ""  # rule id, uuids used for api ids
+
+
+@dataclass
+class CreateRuleRequest(BaseRule):
+    """Rule data for creation requests (no ID needed)."""
+
+
+@dataclass
+class DeleteRuleResponse:
+    """Response object for successful rule deletion."""
+
+    message: str  # success message
+    rule_id: str  # ID of the deleted rule

uptimer/models/workspace.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Workspace:
+    id: str  # workspace id, uuids used for api ids
+    name: str  # workspace name
+    role: str  # user role in workspace
+    kind: str  # any object has kind property, defines class of object

uptimer_python_sdk-0.2.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: uptimer-python-sdk
+Version: 0.2.0
+Summary: A Python SDK for uptimer
+Project-URL: Repository, https://github.com/myuptime-info/uptimer-python-sdk
+Author-email: Roman Zadoev <zadoev@gmail.com>
+License: MIT
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.28.1
+Description-Content-Type: text/markdown
+
+# Uptimer Python SDK
+
+A Python SDK for [uptimer](https://uptimer.myuptime.info/) - a monitoring and uptime checking service.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+For third-party license information, see the [NOTICE](NOTICE) file.
+
+## Usage
+
+```python
+from uptimer.client import UptimerClient
+from uptimer.models.rule import CreateRuleRequest, RuleRequest, RuleResponse, RuleResponseBody
+from uptimer.errors import DefaultUptimerApiError, UptimerInvalidHttpCodeError, UptimerError
+# Initialize the client
+client = UptimerClient(
+    api_key="your-api-key-here",
+    base_url="http://127.0.0.1:2517/api",  # or your custom base URL
+)
+regions = client.v1.regions.all()
+workspaces = client.v1.workspaces.all()
+workspace_id = workspaces[0].id
+rules =client.v1.rules.all(workspace_id)
+
+new_rule = client.v1.rules.create(
+    CreateRuleRequest(
+        name="My Test Rule",
+        interval=60,  # Check every 60 seconds
+        workspace_id=workspace_id,
+        request=RuleRequest(
+            url="https://example.com",
+            method="GET",  # PATCH, POST, HEAD
+            content_type="application/json",  # expected content type
+            data="",  # data (substring) that should be contained in resonse
+        ),
+        response=RuleResponse(
+            statuses=[200, 201, 202],  # any of this status means site is up
+            body=RuleResponseBody(content="expected response"),
+        ),
+    ),
+)
+
+new_rule_updated = client.v1.rules.update(
+    new_rule.id,
+    CreateRuleRequest(
+        name="Updated Rule Name",
+        interval=120,  # Change to 2 minutes
+        workspace_id=workspace_id,
+        request=RuleRequest(
+            url="https://updated-example.com",
+            method="POST",
+            content_type="application/json",
+            data='{"key": "value"}',
+        ),
+        response=RuleResponse(
+            statuses=[200, 201],
+            body=RuleResponseBody(content="updated expected response"),
+        ),
+    ),
+)
+
+# caching errors on delete example
+try:
+  client.v1.rules.delete(new_rule_updated.id)
+except DefaultUptimerApiError as e:
+  # error responses from uptimer server
+  print(
+    e.message,  # user message
+    e.code,  # error id
+    e.error_type,  # class of error,
+    e.details,  # detailed message for a developer
+  )
+except UptimerInvalidHttpCodeError as e:
+  # uptimer api always return 200, if not -> http transport error
+  # for an example 404 status is really page (url) not found, it doesn't mean that an object with id not found.
+  print(
+    e.url,
+    e.status_code,
+  )
+except UptimerError as e: # base error, if you need one
+  raise
+```
+
+Also, check out [examples directory](https://github.com/myuptime-info/uptimer-python-sdk/examples)
+
+### Development Setup
+
+1. Clone the repository:
+
+```bash
+git clone <repository-url>
+cd uptimer-python-sdk
+```
+
+2. Install dependencies:
+
+```bash
+uv sync --dev
+# for integration tests
+uv run playwright install chromium
+```
+
+3. Run tests:
+
+```bash
+uv run pytest
+# integration
+docker pull myuptime/uptimer
+docker run -p 2517:2517 myuptime/uptimer
+UPTIMER_URL=http://localhost:2517  uv run --integration
+```
+
+4. Run linting:
+
+```bash
+uv run ruff check .
+uv run mypy src
+```
+
+5. Format code:
+
+```bash
+uv run ruff format .
+```
+
+6. Run pre-commit hooks:
+
+```bash
+uv run pre-commit run --all-files
+```
+
+## Third-Party Licenses
+
+This project uses the following third-party libraries:
+
+### Production Dependencies
+
+- **httpx** (BSD 3-Clause License) - HTTP client for Python
+
+### Development Dependencies
+
+- **mypy** (Apache 2.0 License) - Static type checker
+- **playwright** (Apache 2.0 License) - Browser automation
+- **pre-commit** (MIT License) - Git hooks framework
+- **pytest** (MIT License) - Testing framework
+- **pytest-cov** (MIT License) - Coverage plugin for pytest
+- **pytest-httpx** (MIT License) - HTTPX plugin for pytest
+- **pytest-playwright** (MIT License) - Playwright plugin for pytest
+- **responses** (Apache 2.0 License) - Mock library for requests
+- **ruff** (MIT License) - Fast Python linter and formatter
+
+All third-party licenses are compatible with the MIT License used by this project. Note that the BSD 3-Clause License (used by httpx) includes an additional restriction prohibiting the use of the copyright holder's name for endorsement without permission.

uptimer_python_sdk-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+uptimer/__init__.py,sha256=xPKvxeYbWVTJxqdgCWKJV6_t24PlvBGs0qn6SiuAGAk,49
+uptimer/client.py,sha256=VCjXlg4xvbhBVD3iA_rOU1jr_qTcKYSdd_ZmA9yorUQ,664
+uptimer/errors.py,sha256=ttei31pQhKnozY4xbDh3oMQEh3s8tNj4z6ed0_Htwkk,699
+uptimer/http.py,sha256=fKFZzsol6SuD1RvgRKds7VqKksbK-KEJN7Yqt5i_02E,1369
+uptimer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uptimer/endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uptimer/endpoints/endpoint.py,sha256=TLITtDy4C-Mqs7dWnL3TYwyaoR2HnjqnCT_rTqI7T-s,917
+uptimer/endpoints/regions.py,sha256=pJOT2VuUTCDnSpsuQNLvVGcjTWbKeKc0AMRkXGZxv5s,705
+uptimer/endpoints/rules.py,sha256=7iwpbR-XPFtlWLRX1QYy4xVKDeNbAzG5PCf2boFOoEY,2470
+uptimer/endpoints/v1.py,sha256=Hbl8AUrR4Pn_4a685V1-f_mv9ZI_BWU7fp-qBhp6W_w,624
+uptimer/endpoints/workspaces.py,sha256=FNMn7kGQ8uy6ecMjVrzOOMDuAS6UmMz3wUkL3IpIl34,732
+uptimer/models/__init__.py,sha256=3BIJH0JzLbGJumJTgdEAQYN09JW9UXRMK0XSsEp78Bk,897
+uptimer/models/deserialize.py,sha256=fprfBiF9BK6ccGS8p4TZMBmUTezRZG-tfdv1SAe4SwE,3294
+uptimer/models/errors.py,sha256=xuKwRpX-MQjWggJYsqaM4p0bcvRLDKuWbCmH0JdpOQs,1299
+uptimer/models/region.py,sha256=PEZpXXDaoF884dfiIYfHBh1Akmr0fhjODtqVcXDzQYM,282
+uptimer/models/rule.py,sha256=ZzLpPBeOH0Qtl-bw9Jk_z_VvKnsUu6EEDKgvLZ-mCR4,1346
+uptimer/models/workspace.py,sha256=zxD05PuNcnGBBqB42X_qRGG_oqxDuW-iTafereiw5Q4,259
+uptimer_python_sdk-0.2.0.dist-info/METADATA,sha256=S1_QtLhnEW3yR4K3dhT_2fqghliicPM_SXS-qN0Grtg,4732
+uptimer_python_sdk-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uptimer_python_sdk-0.2.0.dist-info/licenses/LICENSE,sha256=f5hNPk9nMiFFcs8hvC1uy5erybWlFm-7iHCOJd4HATc,1069
+uptimer_python_sdk-0.2.0.dist-info/licenses/NOTICE,sha256=gimzxqrDPQ8cq3bH6aXBkuoPek6DbQwKS6Ix56F1CR4,1628
+uptimer_python_sdk-0.2.0.dist-info/RECORD,,

uptimer_python_sdk-0.2.0.dist-info/WHEEL

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

uptimer_python_sdk-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Roman Zadoev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uptimer_python_sdk-0.2.0.dist-info/licenses/NOTICE

@@ -0,0 +1,18 @@
+Uptimer Python SDK
+Copyright (c) 2025 myuptime.info
+
+This software includes the following third-party components:
+
+httpx
+Copyright © 2019, Encode OSS Ltd (https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+- Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.