tower 0.3.4__py3-none-linux_armv6l.whl

tower/__init__.py

@@ -0,0 +1,4 @@
+from .client import (
+    run_app,
+    wait_for_run,
+)

tower/__main__.py

@@ -0,0 +1,38 @@
+import io
+import sys
+
+_CLEAN_GLOBALS = globals().copy()
+
+
+def run_program(filename):
+    ns = dict(
+        _CLEAN_GLOBALS,
+        # Make sure the __file__ variable is usable
+        # by the script we're profiling
+        __file__=filename,
+    )
+
+    with io.open(filename, encoding="utf-8") as f:
+        exec(compile(f.read(), filename, "exec"), ns, ns)
+
+
+def parse_args():
+    from argparse import REMAINDER, ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument(
+        "program",
+        nargs=REMAINDER,
+        help="python script or module followed by command line arguments to run",
+    )
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    if len(args.program) == 0:
+        print("A program to run must be provided. Use -h for help")
+        sys.exit(1)
+
+    run_program(args.program[0])

tower/client.py

@@ -0,0 +1,115 @@
+import os
+import time
+from typing import Dict, Optional
+
+from .tower_api_client import AuthenticatedClient
+from .tower_api_client.api.default import describe_run as describe_run_api
+from .tower_api_client.api.default import run_app as run_app_api
+from .tower_api_client.models import (
+    DescribeRunResponse,
+    Run,
+    RunAppParams,
+    RunAppParamsParameters,
+    RunAppResponse,
+)
+from .tower_api_client.models.error_model import ErrorModel
+
+# DEFAULT_TOWER_URL is the default tower URL to use when connecting back to
+# Tower.
+DEFAULT_TOWER_URL = "https://api.tower.dev"
+
+# DEFAULT_TOWER_ENVIRONMENT is the default environment to use when running an
+# app somewhere.
+DEFAULT_TOWER_ENVIRONMENT = "default"
+
+
+def _env_client() -> AuthenticatedClient:
+    api_key = os.getenv("TOWER_API_KEY")
+    tower_url = os.getenv("TOWER_URL", DEFAULT_TOWER_URL)
+
+    if not tower_url.endswith("/v1"):
+        if tower_url.endswith("/"):
+            tower_url += "v1"
+        else:
+            tower_url += "/v1"
+
+    return AuthenticatedClient(
+        verify_ssl=False,
+        base_url=tower_url,
+        token=api_key,
+        auth_header_name="X-API-Key",
+        prefix="",
+    )
+
+
+def run_app(
+    name: str,
+    environment: Optional[str] = None,
+    parameters: Optional[Dict[str, str]] = None,
+) -> Run:
+    """
+    `run_app` invokes an app based on the configured environment. You can
+    supply an optional `environment` override, and an optional dict
+    `parameters` to pass into the app.
+    """
+    client = _env_client()
+    run_params = RunAppParamsParameters()
+
+    if not environment:
+        environment = os.getenv("TOWER_ENVIRONMENT", DEFAULT_TOWER_ENVIRONMENT)
+
+    if parameters:
+        run_params = RunAppParamsParameters.from_dict(parameters)
+
+    input_body = RunAppParams(
+        environment=environment,
+        parameters=run_params,
+    )
+
+    output: Optional[Union[ErrorModel, RunAppResponse]] = run_app_api.sync(
+        name=name, client=client, json_body=input_body
+    )
+
+    if output is None:
+        raise RuntimeError("Error running app")
+    else:
+        if isinstance(output, ErrorModel):
+            raise RuntimeError(f"Error running app: {output.title}")
+        else:
+            return output.run
+
+
+def wait_for_run(run: Run) -> None:
+    """
+    `wait_for_run` waits for a run to reach a terminal state by polling the
+    Tower API every 2 seconds for the latest status. If the app returns a
+    terminal status (`exited`, `errored`, `cancelled`, or `crashed`) then this
+    function returns.
+    """
+    client = _env_client()
+
+    while True:
+        output: Optional[Union[DescribeRunResponse, ErrorModel]] = describe_run_api.sync(
+            name=run.app_name,
+            seq=run.number,
+            client=client
+        )
+
+        if output is None:
+            raise RuntimeError("Error fetching run")
+        else:
+            if isinstance(output, ErrorModel):
+                raise RuntimeError(f"Error fetching run: {output.title}")
+            else:
+                desc = output.run
+
+                if desc.status == "exited":
+                    return
+                elif desc.status == "failed":
+                    return
+                elif desc.status == "canceled":
+                    return
+                elif desc.status == "errored":
+                    return
+                else:
+                    time.sleep(2)

tower/tower_api_client/__init__.py

@@ -0,0 +1,7 @@
+""" A client library for accessing Tower API """
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

tower/tower_api_client/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

tower/tower_api_client/api/default/accept_invitation.py

@@ -0,0 +1,150 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import AuthenticatedClient
+from ...models.accept_invitation_params import AcceptInvitationParams
+from ...models.accept_invitation_response import AcceptInvitationResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: AuthenticatedClient,
+    json_body: AcceptInvitationParams,
+) -> Dict[str, Any]:
+    url = "{}/accounts/invite".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[AcceptInvitationResponse]:
+    if response.status_code == 200:
+        response_200 = AcceptInvitationResponse.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[AcceptInvitationResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: AcceptInvitationParams,
+) -> Response[AcceptInvitationResponse]:
+    """Accept an invitation code
+
+     Accept an invitation code to join an account
+
+    Args:
+        json_body (AcceptInvitationParams):
+
+    Returns:
+        Response[AcceptInvitationResponse]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    json_body: AcceptInvitationParams,
+) -> Optional[AcceptInvitationResponse]:
+    """Accept an invitation code
+
+     Accept an invitation code to join an account
+
+    Args:
+        json_body (AcceptInvitationParams):
+
+    Returns:
+        Response[AcceptInvitationResponse]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: AcceptInvitationParams,
+) -> Response[AcceptInvitationResponse]:
+    """Accept an invitation code
+
+     Accept an invitation code to join an account
+
+    Args:
+        json_body (AcceptInvitationParams):
+
+    Returns:
+        Response[AcceptInvitationResponse]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    json_body: AcceptInvitationParams,
+) -> Optional[AcceptInvitationResponse]:
+    """Accept an invitation code
+
+     Accept an invitation code to join an account
+
+    Args:
+        json_body (AcceptInvitationParams):
+
+    Returns:
+        Response[AcceptInvitationResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

tower/tower_api_client/api/default/cancel_run.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import AuthenticatedClient
+from ...models.cancel_run_response import CancelRunResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    name: str,
+    seq: int,
+    *,
+    client: AuthenticatedClient,
+) -> Dict[str, Any]:
+    url = "{}/apps/{name}/runs/{seq}".format(client.base_url, name=name, seq=seq)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[CancelRunResponse]:
+    if response.status_code == 200:
+        response_200 = CancelRunResponse.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[CancelRunResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    name: str,
+    seq: int,
+    *,
+    client: AuthenticatedClient,
+) -> Response[CancelRunResponse]:
+    """Cancel run
+
+     Cancel a run
+
+    Args:
+        name (str): The name of the app to fetch runs for.
+        seq (int): The number of the run to fetch.
+
+    Returns:
+        Response[CancelRunResponse]
+    """
+
+    kwargs = _get_kwargs(
+        name=name,
+        seq=seq,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    name: str,
+    seq: int,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[CancelRunResponse]:
+    """Cancel run
+
+     Cancel a run
+
+    Args:
+        name (str): The name of the app to fetch runs for.
+        seq (int): The number of the run to fetch.
+
+    Returns:
+        Response[CancelRunResponse]
+    """
+
+    return sync_detailed(
+        name=name,
+        seq=seq,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    name: str,
+    seq: int,
+    *,
+    client: AuthenticatedClient,
+) -> Response[CancelRunResponse]:
+    """Cancel run
+
+     Cancel a run
+
+    Args:
+        name (str): The name of the app to fetch runs for.
+        seq (int): The number of the run to fetch.
+
+    Returns:
+        Response[CancelRunResponse]
+    """
+
+    kwargs = _get_kwargs(
+        name=name,
+        seq=seq,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)
+
+
+async def asyncio(
+    name: str,
+    seq: int,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[CancelRunResponse]:
+    """Cancel run
+
+     Cancel a run
+
+    Args:
+        name (str): The name of the app to fetch runs for.
+        seq (int): The number of the run to fetch.
+
+    Returns:
+        Response[CancelRunResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            name=name,
+            seq=seq,
+            client=client,
+        )
+    ).parsed

tower/tower_api_client/api/default/claim_device_login_ticket.py

@@ -0,0 +1,154 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import AuthenticatedClient
+from ...models.claim_device_login_ticket_params import ClaimDeviceLoginTicketParams
+from ...models.claim_device_login_ticket_response import ClaimDeviceLoginTicketResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: AuthenticatedClient,
+    json_body: ClaimDeviceLoginTicketParams,
+) -> Dict[str, Any]:
+    url = "{}/login/device/claim".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(
+    *, response: httpx.Response
+) -> Optional[ClaimDeviceLoginTicketResponse]:
+    if response.status_code == 200:
+        response_200 = ClaimDeviceLoginTicketResponse.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(
+    *, response: httpx.Response
+) -> Response[ClaimDeviceLoginTicketResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: ClaimDeviceLoginTicketParams,
+) -> Response[ClaimDeviceLoginTicketResponse]:
+    """Claim a device login ticket
+
+     Claims a device login ticket code for the authenticated user.
+
+    Args:
+        json_body (ClaimDeviceLoginTicketParams):
+
+    Returns:
+        Response[ClaimDeviceLoginTicketResponse]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    json_body: ClaimDeviceLoginTicketParams,
+) -> Optional[ClaimDeviceLoginTicketResponse]:
+    """Claim a device login ticket
+
+     Claims a device login ticket code for the authenticated user.
+
+    Args:
+        json_body (ClaimDeviceLoginTicketParams):
+
+    Returns:
+        Response[ClaimDeviceLoginTicketResponse]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: ClaimDeviceLoginTicketParams,
+) -> Response[ClaimDeviceLoginTicketResponse]:
+    """Claim a device login ticket
+
+     Claims a device login ticket code for the authenticated user.
+
+    Args:
+        json_body (ClaimDeviceLoginTicketParams):
+
+    Returns:
+        Response[ClaimDeviceLoginTicketResponse]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    json_body: ClaimDeviceLoginTicketParams,
+) -> Optional[ClaimDeviceLoginTicketResponse]:
+    """Claim a device login ticket
+
+     Claims a device login ticket code for the authenticated user.
+
+    Args:
+        json_body (ClaimDeviceLoginTicketParams):
+
+    Returns:
+        Response[ClaimDeviceLoginTicketResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed