coolipy.client

Synchronous coolipy client.

 1"""Synchronous coolipy client."""
 2
 3from __future__ import annotations
 4
 5import httpx
 6
 7from coolipy._http import SyncTransport, build_base_url, parse_response
 8from coolipy._response import CoolipyAPIResponse
 9from coolipy.exceptions import CoolipyConfigError
10from coolipy.models.system import SystemMessage
11from coolipy.resources.applications import Applications
12from coolipy.resources.databases import Databases
13from coolipy.resources.deployments import Deployments
14from coolipy.resources.projects import Projects
15from coolipy.resources.s3_storages import S3Storages
16from coolipy.resources.security import Security
17from coolipy.resources.servers import Servers
18from coolipy.resources.services import Services
19from coolipy.resources.tags import Tags
20from coolipy.resources.teams import Teams
21
22
23class Coolipy:
24    """Synchronous client for the Coolify API.
25
26    Args:
27        coolify_api_key: Bearer token used to authenticate with the Coolify API.
28        coolify_endpoint: Hostname or IP of the Coolify instance.
29        coolify_port: Port of the Coolify instance (ignored when ``omit_port``).
30        omit_port: When ``True``, build the base URL without a port.
31        http_protocol: ``"http"`` or ``"https"``.
32        timeout: Request timeout in seconds.
33        transport: Optional httpx transport override (mainly for testing).
34    """
35
36    def __init__(
37        self,
38        coolify_api_key: str,
39        coolify_endpoint: str,
40        coolify_port: int = 8000,
41        omit_port: bool = False,
42        http_protocol: str = "http",
43        timeout: float = 30.0,
44        transport: httpx.BaseTransport | None = None,
45    ) -> None:
46        if not coolify_api_key:
47            raise CoolipyConfigError("coolify_api_key must be a non-empty string.")
48        base_url = build_base_url(http_protocol, coolify_endpoint, coolify_port, omit_port)
49        self._transport = SyncTransport(
50            base_url, coolify_api_key, timeout=timeout, transport=transport
51        )
52        self.applications = Applications(self._transport)
53        self.databases = Databases(self._transport)
54        self.services = Services(self._transport)
55        self.servers = Servers(self._transport)
56        self.projects = Projects(self._transport)
57        self.teams = Teams(self._transport)
58        self.deployments = Deployments(self._transport)
59        self.tags = Tags(self._transport)
60        self.s3_storages = S3Storages(self._transport)
61        self.security = Security(self._transport)
62
63    def version(self) -> CoolipyAPIResponse[str]:
64        """Get the Coolify version."""
65        return parse_response(self._transport.request("GET", "/version"), str)
66
67    def health(self) -> CoolipyAPIResponse[str]:
68        """Run the Coolify healthcheck."""
69        return parse_response(self._transport.request("GET", "/health"), str)
70
71    def enable_api(self) -> CoolipyAPIResponse[SystemMessage]:
72        """Enable the Coolify API (requires root permissions)."""
73        return parse_response(self._transport.request("POST", "/enable"), SystemMessage)
74
75    def disable_api(self) -> CoolipyAPIResponse[SystemMessage]:
76        """Disable the Coolify API (requires root permissions)."""
77        return parse_response(self._transport.request("POST", "/disable"), SystemMessage)
78
79    def enable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
80        """Enable the Coolify MCP server (requires root permissions)."""
81        return parse_response(self._transport.request("POST", "/mcp/enable"), SystemMessage)
82
83    def disable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
84        """Disable the Coolify MCP server (requires root permissions)."""
85        return parse_response(self._transport.request("POST", "/mcp/disable"), SystemMessage)
86
87    def close(self) -> None:
88        """Close the underlying HTTP client."""
89        self._transport.close()
90
91    def __enter__(self) -> Coolipy:
92        return self
93
94    def __exit__(self, *exc: object) -> None:
95        self.close()
class Coolipy: 
24class Coolipy:
25    """Synchronous client for the Coolify API.
26
27    Args:
28        coolify_api_key: Bearer token used to authenticate with the Coolify API.
29        coolify_endpoint: Hostname or IP of the Coolify instance.
30        coolify_port: Port of the Coolify instance (ignored when ``omit_port``).
31        omit_port: When ``True``, build the base URL without a port.
32        http_protocol: ``"http"`` or ``"https"``.
33        timeout: Request timeout in seconds.
34        transport: Optional httpx transport override (mainly for testing).
35    """
36
37    def __init__(
38        self,
39        coolify_api_key: str,
40        coolify_endpoint: str,
41        coolify_port: int = 8000,
42        omit_port: bool = False,
43        http_protocol: str = "http",
44        timeout: float = 30.0,
45        transport: httpx.BaseTransport | None = None,
46    ) -> None:
47        if not coolify_api_key:
48            raise CoolipyConfigError("coolify_api_key must be a non-empty string.")
49        base_url = build_base_url(http_protocol, coolify_endpoint, coolify_port, omit_port)
50        self._transport = SyncTransport(
51            base_url, coolify_api_key, timeout=timeout, transport=transport
52        )
53        self.applications = Applications(self._transport)
54        self.databases = Databases(self._transport)
55        self.services = Services(self._transport)
56        self.servers = Servers(self._transport)
57        self.projects = Projects(self._transport)
58        self.teams = Teams(self._transport)
59        self.deployments = Deployments(self._transport)
60        self.tags = Tags(self._transport)
61        self.s3_storages = S3Storages(self._transport)
62        self.security = Security(self._transport)
63
64    def version(self) -> CoolipyAPIResponse[str]:
65        """Get the Coolify version."""
66        return parse_response(self._transport.request("GET", "/version"), str)
67
68    def health(self) -> CoolipyAPIResponse[str]:
69        """Run the Coolify healthcheck."""
70        return parse_response(self._transport.request("GET", "/health"), str)
71
72    def enable_api(self) -> CoolipyAPIResponse[SystemMessage]:
73        """Enable the Coolify API (requires root permissions)."""
74        return parse_response(self._transport.request("POST", "/enable"), SystemMessage)
75
76    def disable_api(self) -> CoolipyAPIResponse[SystemMessage]:
77        """Disable the Coolify API (requires root permissions)."""
78        return parse_response(self._transport.request("POST", "/disable"), SystemMessage)
79
80    def enable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
81        """Enable the Coolify MCP server (requires root permissions)."""
82        return parse_response(self._transport.request("POST", "/mcp/enable"), SystemMessage)
83
84    def disable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
85        """Disable the Coolify MCP server (requires root permissions)."""
86        return parse_response(self._transport.request("POST", "/mcp/disable"), SystemMessage)
87
88    def close(self) -> None:
89        """Close the underlying HTTP client."""
90        self._transport.close()
91
92    def __enter__(self) -> Coolipy:
93        return self
94
95    def __exit__(self, *exc: object) -> None:
96        self.close()

Synchronous client for the Coolify API.

Args: coolify_api_key: Bearer token used to authenticate with the Coolify API. coolify_endpoint: Hostname or IP of the Coolify instance. coolify_port: Port of the Coolify instance (ignored when omit_port). omit_port: When True, build the base URL without a port. http_protocol: "http" or "https". timeout: Request timeout in seconds. transport: Optional httpx transport override (mainly for testing).

Coolipy( coolify_api_key: str, coolify_endpoint: str, coolify_port: int = 8000, omit_port: bool = False, http_protocol: str = 'http', timeout: float = 30.0, transport: httpx.BaseTransport | None = None) 
37    def __init__(
38        self,
39        coolify_api_key: str,
40        coolify_endpoint: str,
41        coolify_port: int = 8000,
42        omit_port: bool = False,
43        http_protocol: str = "http",
44        timeout: float = 30.0,
45        transport: httpx.BaseTransport | None = None,
46    ) -> None:
47        if not coolify_api_key:
48            raise CoolipyConfigError("coolify_api_key must be a non-empty string.")
49        base_url = build_base_url(http_protocol, coolify_endpoint, coolify_port, omit_port)
50        self._transport = SyncTransport(
51            base_url, coolify_api_key, timeout=timeout, transport=transport
52        )
53        self.applications = Applications(self._transport)
54        self.databases = Databases(self._transport)
55        self.services = Services(self._transport)
56        self.servers = Servers(self._transport)
57        self.projects = Projects(self._transport)
58        self.teams = Teams(self._transport)
59        self.deployments = Deployments(self._transport)
60        self.tags = Tags(self._transport)
61        self.s3_storages = S3Storages(self._transport)
62        self.security = Security(self._transport)
applications
databases
services
servers
projects
teams
deployments
tags
s3_storages
security
def version(self) -> coolipy.CoolipyAPIResponse[str]: 
64    def version(self) -> CoolipyAPIResponse[str]:
65        """Get the Coolify version."""
66        return parse_response(self._transport.request("GET", "/version"), str)

Get the Coolify version.

def health(self) -> coolipy.CoolipyAPIResponse[str]: 
68    def health(self) -> CoolipyAPIResponse[str]:
69        """Run the Coolify healthcheck."""
70        return parse_response(self._transport.request("GET", "/health"), str)

Run the Coolify healthcheck.

def enable_api( self) -> coolipy.CoolipyAPIResponse[coolipy.models.system.SystemMessage]: 
72    def enable_api(self) -> CoolipyAPIResponse[SystemMessage]:
73        """Enable the Coolify API (requires root permissions)."""
74        return parse_response(self._transport.request("POST", "/enable"), SystemMessage)

Enable the Coolify API (requires root permissions).

def disable_api( self) -> coolipy.CoolipyAPIResponse[coolipy.models.system.SystemMessage]: 
76    def disable_api(self) -> CoolipyAPIResponse[SystemMessage]:
77        """Disable the Coolify API (requires root permissions)."""
78        return parse_response(self._transport.request("POST", "/disable"), SystemMessage)

Disable the Coolify API (requires root permissions).

def enable_mcp( self) -> coolipy.CoolipyAPIResponse[coolipy.models.system.SystemMessage]: 
80    def enable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
81        """Enable the Coolify MCP server (requires root permissions)."""
82        return parse_response(self._transport.request("POST", "/mcp/enable"), SystemMessage)

Enable the Coolify MCP server (requires root permissions).

def disable_mcp( self) -> coolipy.CoolipyAPIResponse[coolipy.models.system.SystemMessage]: 
84    def disable_mcp(self) -> CoolipyAPIResponse[SystemMessage]:
85        """Disable the Coolify MCP server (requires root permissions)."""
86        return parse_response(self._transport.request("POST", "/mcp/disable"), SystemMessage)

Disable the Coolify MCP server (requires root permissions).

def close(self) -> None: 
88    def close(self) -> None:
89        """Close the underlying HTTP client."""
90        self._transport.close()

Close the underlying HTTP client.