peak-sdk 1.4.0__tar.gz → 1.6.0__tar.gz

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: peak-sdk
-Version: 1.4.0
+Version: 1.6.0
 Summary: Python SDK for interacting with the Peak platform
 Home-page: https://docs.peak.ai/sdk
 License: Apache-2.0
@@ -16,18 +16,17 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
-Requires-Dist: certifi (>=2023.7.22)
+Requires-Dist: certifi (>=2024.2.2)
 Requires-Dist: jinja2 (>=3.1,<4.0)
-Requires-Dist: pathspec (>=0.11,<0.12)
+Requires-Dist: orjson (>=3.9.15,<4.0.0)
+Requires-Dist: pathspec
 Requires-Dist: pyyaml (>=6.0,<7.0)
-Requires-Dist: requests (>=2.30,<3.0)
+Requires-Dist: requests (>=2.31,<3.0)
 Requires-Dist: requests-toolbelt (>=1.0,<2.0)
-Requires-Dist: shellingham (<1.5.2)
+Requires-Dist: shellingham (<1.5.4)
 Requires-Dist: structlog (>=24.1.0,<25.0.0)
 Requires-Dist: typer[all] (>=0.9,<0.10)
 Requires-Dist: urllib3 (<2)
@@ -94,13 +93,13 @@ Follow these steps to create a virtual environment using Python's built-in `venv
     echo "compinit" >> ~/.zshrc # replace .zshrc with your shell's configuration file
     ```
 
-### Using the SDK/CLI
+### Using the SDK and CLI
 
--   To start using the SDK and CLI, you'll need either an API Key or an Access Token.
--   If you don't have one yet, sign up for an account on the Peak platform to obtain your API key or Access token.
--   To export it, run the following command in your terminal and replace <api_key> with your actual API key:
+-   To start using the SDK and CLI, you'll need either an API Key or a Personal Access Token (PAT).
+-   If you don't have one yet, sign up for an account on the Peak platform to obtain your API key or Personal Access token (PAT).
+-   To export it, run the following command in your terminal and replace <peak_auth_token> with your actual API key or PAT:
     ```
-    export API_KEY=<api_key | access_token>
+    export PEAK_AUTH_TOKEN=<peak_auth_token>
     ```
 
 ### Documentation

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/_metadata.py

@@ -24,13 +24,14 @@ The metadata represents the following:
     - table_params: Parameters required for the table output formatting.
     - request_body_yaml_path: File containing the yaml file examples for the command.
 """
+
+from __future__ import annotations
+
 from typing import Any, Dict, List
 
 
 def tag_parser(data: Any) -> str:
-    tag_array = []
-    for tag in data:
-        tag_array.append(tag["name"])
+    tag_array = [tag["name"] for tag in data]
     return ", ".join(tag_array)
 
 
@@ -623,6 +624,57 @@ command_metadata: Dict[str, Any] = {
             "data_key": "data",
         },
     },
+    "list_emails": {
+        "table_params": {
+            "output_keys": {
+                "id": {
+                    "label": "ID",
+                },
+                "subject": {
+                    "label": "Subject",
+                },
+                "status": {
+                    "label": "Status",
+                },
+                "templateName": {
+                    "label": "Template Name",
+                },
+                "createdAt": {
+                    "label": "Created At",
+                },
+                "createdBy": {
+                    "label": "Created By",
+                },
+            },
+            "title": "Emails",
+            "data_key": "emails",
+            "subheader_key": "emailCount",
+        },
+    },
+    "list_templates": {
+        "table_params": {
+            "output_keys": {
+                "id": {
+                    "label": "ID",
+                },
+                "name": {
+                    "label": "Name",
+                },
+                "scope": {
+                    "label": "Status",
+                },
+                "createdAt": {
+                    "label": "Created At",
+                },
+                "createdBy": {
+                    "label": "Created By",
+                },
+            },
+            "title": "Templates",
+            "data_key": "templates",
+            "subheader_key": "templateCount",
+        },
+    },
     "create_artifact": {
         "request_body_yaml_path": "sample_yaml/resources/artifacts/create_artifact.yaml",
     },
@@ -680,6 +732,9 @@ command_metadata: Dict[str, Any] = {
     "test_service": {
         "request_body_yaml_path": "sample_yaml/resources/services/test_service.yaml",
     },
+    "send_email": {
+        "request_body_yaml_path": "sample_yaml/resources/emails/send_email.yaml",
+    },
     "create_app_spec": {
         "request_body_yaml_path": "sample_yaml/press/apps/specs/create_app_spec.yaml",
     },

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/_version.py

@@ -18,4 +18,4 @@
 # # You should have received a copy of the APACHE LICENSE, VERSION 2.0
 # # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
 #
-__version__: str = "1.4.0"
+__version__: str = "1.6.0"

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/cli/cli.py

@@ -25,15 +25,16 @@ import peak.config
 import typer
 from peak.cli import args, helpers
 from peak.cli.press import apps, blocks, deployments, specs
-from peak.cli.resources import artifacts, images, services, tenants, webapps, workflows
+from peak.cli.resources import alerts, artifacts, images, services, tenants, users, webapps, workflows
 from peak.constants import Sources
 from peak.output import Writer
 
-# Hack to not gray out texts after first paragraph
+# Workaround to not gray out texts after first paragraph
 typer.rich_utils.STYLE_HELPTEXT = ""
 
 typer_app = typer.Typer(rich_markup_mode="markdown", help="Create and Manage Peak Resources")
 typer_app.add_typer(images.app, name="images")
+typer_app.add_typer(alerts.app, name="alerts")
 typer_app.add_typer(artifacts.app, name="artifacts")
 typer_app.add_typer(workflows.app, name="workflows")
 typer_app.add_typer(webapps.app, name="webapps")
@@ -43,6 +44,7 @@ typer_app.add_typer(apps.app, name="apps")
 typer_app.add_typer(blocks.app, name="blocks")
 typer_app.add_typer(specs.app, name="specs")
 typer_app.add_typer(deployments.app, name="deployments")
+typer_app.add_typer(users.app, name="users")
 
 
 @typer_app.callback()

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/cli/helpers.py

@@ -251,5 +251,7 @@ def get_client(command: str) -> base_client.BaseClient:
         "services": resources.services,
         "webapps": resources.webapps,
         "tenants": resources.tenants,
+        "users": resources.users,
+        "alerts": resources.alerts,
     }
     return command_client_map[command].get_client()  # type: ignore[no-any-return]

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/cli/press/blocks/specs.py

@@ -169,7 +169,7 @@ def create(
                 - events (map):
                     success (boolean | required: false): Whether to call event on success.
                     fail (boolean | required: false): Whether to call event on failure.
-                    runtimeExceeded (int | required: false): The runtime after which event is called.
+                    runtimeExceeded (int | required: false): The runtime in minutes after which event is called.
                   user (string | required: false): User to be notified. To be added in case of user watcher.
                   webhook (map | required: false): To be added in case of webhook watcher.
                     name (string): Name of the webhook.
@@ -433,7 +433,7 @@ def create_release(
                 - events (map):
                     success (boolean | required: false): Whether to call event on success.
                     fail (boolean | required: false): Whether to call event on failure.
-                    runtimeExceeded (int | required: false): The runtime after which event is called.
+                    runtimeExceeded (int | required: false): The runtime in minutes after which event is called.
                   user (string | required: false): User to be notified. To be added in case of user watcher.
                   webhook (map | required: false): To be added in case of webhook watcher.
                     name (string): Name of the webhook.

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/cli/press/specs.py

@@ -35,6 +35,8 @@ app = typer.Typer(
 )
 console = Console()
 
+RELEASE_VERSION = typer.Option(None, help="The release version of the spec in valid semantic versioning format.")
+
 
 @app.command("list", short_help="List App and Block specs.", options_metavar="list_specs")
 def list_specs(
@@ -94,7 +96,7 @@ def list_specs(
 def list_release_deployments(
     ctx: typer.Context,
     spec_id: str = args.SPEC_ID,
-    version: str = args.RELEASE_VERSION,
+    version: Optional[str] = RELEASE_VERSION,
     page_size: Optional[int] = args.PAGE_SIZE,
     page_number: Optional[int] = args.PAGE_NUMBER,
     status: Optional[List[str]] = args.STATUS_FILTER_SPEC_RELEASES,
@@ -104,7 +106,7 @@ def list_release_deployments(
     paging: Optional[bool] = PAGING,  # noqa: ARG001
     output_type: Optional[OutputTypes] = OUTPUT_TYPES,  # noqa: ARG001
 ) -> None:
-    """***List*** all the deployments for a given spec release.
+    """***List*** all the deployments for a given spec. Version is optional and if not provided, all deployments for the spec will be returned.
 
     \b
     📝 ***Example usage:***<br/>

peak_sdk-1.6.0/peak/cli/resources/alerts/__init__.py

@@ -0,0 +1,35 @@
+#
+# # Copyright © 2024 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+"""Alerts Module."""
+
+import typer
+from peak.cli.resources.alerts import emails
+
+app = typer.Typer(
+    help="Create and manage peak alerts.",
+    short_help="Create and manage peak alerts.",
+)
+app.add_typer(
+    emails.app,
+    name="emails",
+    help="Create and manage peak emails.",
+    short_help="Create and manage peak emails.",
+)

peak_sdk-1.6.0/peak/cli/resources/alerts/emails.py

@@ -0,0 +1,360 @@
+#
+# # Copyright © 2024 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+
+"""Peak Alerts commands."""
+
+from typing import Any, Dict, List, Optional
+
+import typer
+from peak.cli import helpers
+from peak.cli.args import OUTPUT_TYPES, PAGING, TEMPLATE_PARAMS, TEMPLATE_PARAMS_FILE
+from peak.constants import OutputTypes, OutputTypesNoTable
+from peak.helpers import combine_dictionaries, map_user_options, parse_list_of_strings, variables_to_dict
+from peak.output import Writer
+from peak.resources.alerts import Alert
+from typing_extensions import Annotated
+
+app = typer.Typer(
+    help="Alerts management commands.",
+    short_help="Manage alerts.",
+)
+
+_EMAIL_ID = typer.Argument(..., help="The ID of the email.")
+_RECIPIENTS = typer.Option(None, help="The email addresses of the recipients.")
+_SUBJECT = typer.Option(None, help="The subject of the email.")
+_TEMPLATE_NAME = typer.Option(None, help="The name of the email template.")
+_TEMPLATE_PARAMETERS = typer.Option(
+    None,
+    help="The parameters for the email template. To be passed in stringified JSON format.",
+)
+_COUNT = typer.Option(None, help="The number of emails to retrieve.")
+_DATE_FROM = typer.Option(None, help="The date from which to retrieve emails (in ISO format).")
+_DATE_TO = typer.Option(None, help="The date till which to retrieve emails (in ISO format).")
+_PAGE_SIZE = typer.Option(None, help="The number of emails per page.")
+_PAGE_NUMBER = typer.Option(None, help="The page number to retrieve.")
+_CC = typer.Option(None, help="The email addresses of the recipients to be CC'd.")
+_BCC = typer.Option(None, help="The email addresses of the recipients to be BCC'd.")
+_LIST_TEMPLATE_NAME = typer.Option(None, help="Email Template Name to search for.")
+_LIST_TEMPLATE_SCOPE = typer.Option(None, help="List of type of template to filter the templates by.")
+_DESCRIBE_TEMPLATE_NAME = typer.Argument(None, help="The name of the email template.")
+
+
+@app.command("list", short_help="List all emails.", options_metavar="list_emails")
+def list_emails(
+    ctx: typer.Context,
+    page_size: Optional[int] = _PAGE_SIZE,
+    page_number: Optional[int] = _PAGE_NUMBER,
+    count: Optional[int] = _COUNT,
+    date_from: Optional[str] = _DATE_FROM,
+    date_to: Optional[str] = _DATE_TO,
+    paging: Optional[bool] = PAGING,  # noqa: ARG001
+    output_type: Optional[OutputTypes] = OUTPUT_TYPES,  # noqa: ARG001
+) -> None:
+    """Retrieve the history of emails sent.
+
+    \b
+    📝 ***Example usage:***
+    ```bash
+    peak alerts emails list --page-size 10 --page-number 1
+    ```
+
+    \b
+    🆗 ***Response:***
+    ```
+    {
+        "emailCount": 1,
+        "emails": [
+            {
+                "createdAt": "2024-01-01T00:00:00.200Z",
+                "createdBy": "platform@peak.ai",
+                "id": 1,
+                "status": "Delivered",
+                "subject": "email_subject",
+                "templateName": "template_name",
+            }
+        ],
+        "pageCount": 1,
+        "pageNumber": 1,
+        "pageSize": 25
+    }
+    ```
+
+    🔗 [**API Documentation**](https://service.peak.ai/notifications/api-docs/index.htm#/Emails/get_api_v1_emails)
+    """
+    alert_client: Alert = ctx.obj["client"]
+    writer: Writer = ctx.obj["writer"]
+
+    with writer.pager():
+        response = alert_client.list_emails(
+            page_size=page_size,
+            page_number=page_number,
+            count=count,
+            date_from=date_from,
+            date_to=date_to,
+            return_iterator=False,
+        )
+        writer.write(response)
+
+
+@app.command("send", short_help="Send an email.", options_metavar="send_email")
+def send_email(
+    ctx: typer.Context,
+    file: Annotated[
+        Optional[str],
+        typer.Argument(
+            ...,
+            help="Path to the file that defines the body for this operation, supports both `yaml` file or a `jinja` template.",
+        ),
+    ] = None,
+    params_file: str = TEMPLATE_PARAMS_FILE,
+    params: List[str] = TEMPLATE_PARAMS,
+    recipients: Optional[List[str]] = _RECIPIENTS,
+    cc: Optional[List[str]] = _CC,
+    bcc: Optional[List[str]] = _BCC,
+    subject: Optional[str] = _SUBJECT,
+    template_name: Optional[str] = _TEMPLATE_NAME,
+    template_parameters: Optional[str] = _TEMPLATE_PARAMETERS,
+    paging: Optional[bool] = PAGING,  # noqa: ARG001
+    output_type: Optional[OutputTypesNoTable] = OUTPUT_TYPES,  # noqa: ARG001
+) -> None:
+    """Send an email to the specified recipients using the specified template.
+
+    \b
+    🧩 ***Input file schema(yaml):***<br/>
+    ```yaml
+      body (map):
+        recipients (list(str) | required: true): List of email addresses of the recipients.
+        cc (list(str) | required: false): List of email addresses of the recipients to be CC'd.
+        bcc (list(str) | required: false): List of email addresses of the recipients to be BCC'd.
+        subject (str | required: true): The subject of the email.
+        templateName (str | required: true): The name of the email template.
+        templateParameters (map | required: false): The parameters for the email template.
+    ```
+
+     \b
+    📝 ***Example usage:***
+    ```bash
+    peak alerts emails send '/path/to/email.yaml' --params-file '/path/to/values.yaml'
+    ```
+
+    We can also provide the required parameters from the command line or combine the YAML template and command line arguments in which case the command line arguments will take precedence.
+
+    \b
+    📝 ***Example usage without yaml:***
+    ```bash
+    peak alerts emails send --recipients <recipient_email_1> --recipients <recipient_email_2> --subject <email_subject> --template-name <template_name> --template-parameters '{"key": "value"}'
+    ```
+
+    \b
+    🆗 ***Response:***
+    ```json
+    {
+        "id": 1
+    }
+    ```
+
+    🔗 [**API Documentation**](https://service.peak.ai/notifications/api-docs/index.htm#/Emails/post_api_v1_emails)
+    """
+    alert_client: Alert = ctx.obj["client"]
+    writer: Writer = ctx.obj["writer"]
+
+    user_options: Dict[str, Any] = variables_to_dict(
+        recipients,
+        cc,
+        bcc,
+        subject,
+        template_name,
+        template_parameters,
+    )
+
+    body: Dict[str, Any] = {}
+    if file:
+        body = helpers.template_handler(file=file, params_file=params_file, params=params)
+        body = helpers.remove_unknown_args(body, alert_client.send_email)
+
+    updated_body = combine_dictionaries(body.get("body") or {}, user_options)
+
+    if recipients:
+        updated_body["recipients"] = parse_list_of_strings(recipients)
+
+    if cc:
+        updated_body["cc"] = parse_list_of_strings(cc)
+
+    if bcc:
+        updated_body["bcc"] = parse_list_of_strings(bcc)
+
+    if template_parameters:
+        updated_body["templateParameters"] = map_user_options(
+            user_options=user_options,
+            mapping={},
+            dict_type_keys=["templateParameters"],
+        )
+
+    with writer.pager():
+        response: Dict[str, Any] = alert_client.send_email(body=updated_body)
+        writer.write(response)
+
+
+@app.command(short_help="Describe details of a specific email.", options_metavar="describe_email")
+def describe(
+    ctx: typer.Context,
+    email_id: int = _EMAIL_ID,
+    paging: Optional[bool] = PAGING,  # noqa: ARG001
+    output_type: Optional[OutputTypesNoTable] = OUTPUT_TYPES,  # noqa: ARG001
+) -> None:
+    """***Describe*** details of a specific email.
+
+    \b
+    📝 ***Example usage:***
+    ```bash
+    peak alerts emails describe <email-id>
+    ```
+
+    \b
+    🆗 ***Response:***
+    ```
+    {
+        "createdAt": "2024-01-01T00:00:00.000Z",
+        "createdBy": "platform@peak.ai",
+        "deliveredAt": "2024-01-01T00:00:00.000Z",
+        "id": 1,
+        "recipients": {
+            "cc": [],
+            "to": ["someone@peak.ai"],
+            "bcc": []
+        },
+        "status": "Delivered",
+        "statusDetails": [
+            {
+                "email": "someone@peak.ai",
+                "status": "Delivered",
+                "description": "The email was successfully delivered."
+            }
+        ],
+        "subject": "Hello, world!",
+        "templateName": "template_name",
+    }
+    ```
+
+    🔗 [**API Documentation**](https://service.peak.ai/notifications/api-docs/index.htm#/Emails/get_api_v1_emails__id_)
+    """
+    alert_client: Alert = ctx.obj["client"]
+    writer: Writer = ctx.obj["writer"]
+
+    with writer.pager():
+        response = alert_client.describe_email(email_id=email_id)
+        writer.write(response)
+
+
+@app.command(short_help="List all the templates.", options_metavar="list_templates")
+def list_templates(
+    ctx: typer.Context,
+    page_size: Optional[int] = _PAGE_SIZE,
+    page_number: Optional[int] = _PAGE_NUMBER,
+    scope: Optional[List[str]] = _LIST_TEMPLATE_SCOPE,
+    name: Optional[str] = _LIST_TEMPLATE_NAME,
+    paging: Optional[bool] = PAGING,  # noqa: ARG001
+    output_type: Optional[OutputTypes] = OUTPUT_TYPES,  # noqa: ARG001
+) -> None:
+    """Retrieve the email templates list.
+
+    \b
+    📝 ***Example usage:***
+    ```bash
+    peak alerts emails list-templates --page-size 10 --page-number 1
+    ```
+
+    \b
+    🆗 ***Response:***
+    ```
+    {
+        "templateCount": 1,
+        "templates": [
+            {
+                "id": 1,
+                "createdAt": "2021-09-01T12:00:00Z",
+                "createdBy": "platform@peak.ai",
+                "name": "test_template",
+                "scope": "custom"
+            }
+        ],
+        "pageCount": 1,
+        "pageNumber": 1,
+        "pageSize": 25
+    }
+    ```
+
+    🔗 [**API Documentation**](https://service.peak.ai/notifications/api-docs/index.htm#/Templates/get_api_v1_emails_templates)
+    """
+    alert_client: Alert = ctx.obj["client"]
+    writer: Writer = ctx.obj["writer"]
+
+    with writer.pager():
+        response = alert_client.list_templates(
+            page_size=page_size,
+            page_number=page_number,
+            scope=scope,
+            name=name,
+            return_iterator=False,
+        )
+        writer.write(response)
+
+
+@app.command(
+    short_help="Describe details of a specific template.",
+    options_metavar="describe_template",
+)
+def describe_template(
+    ctx: typer.Context,
+    template_name: str = _DESCRIBE_TEMPLATE_NAME,
+    paging: Optional[bool] = PAGING,  # noqa: ARG001
+    output_type: Optional[OutputTypesNoTable] = OUTPUT_TYPES,  # noqa: ARG001
+) -> None:
+    """***Describe*** details of a specific template.
+
+    \b
+    📝 ***Example usage:***
+    ```bash
+    peak alerts emails describe-template <template-name>
+    ```
+
+    \b
+    🆗 ***Response:***
+    ```
+    {
+        "id": 1,
+        "createdAt": "2021-09-01T12:00:00Z",
+        "createdBy": "platform@peak.ai",
+        "name": "test_template",
+        "subject": "Important Account Update Information",
+        "body": "<h1>Hello</h1><p>Your account has been updated.</p>",
+        "scope": "custom"
+    }
+    ```
+
+    🔗 [**API Documentation**](https://service.peak.ai/notifications/api-docs/index.htm#/Templates/get_api_v1_emails_templates__name_)
+    """
+    alert_client: Alert = ctx.obj["client"]
+    writer: Writer = ctx.obj["writer"]
+
+    with writer.pager():
+        response = alert_client.describe_template(template_name=template_name)
+        writer.write(response)

{peak_sdk-1.4.0 → peak_sdk-1.6.0}/peak/cli/resources/images.py

@@ -1086,4 +1086,4 @@ def get_build_logs(
                 writer.write(response)
                 break
 
-            next_token = response["nextToken"] if "nextToken" in response else None
+            next_token = response.get("nextToken", None)