primitive 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

primitive/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@steins.studio>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.1.4"

primitive/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@steins.studio>
+#
+# SPDX-License-Identifier: MIT

primitive/auth/actions.py

@@ -0,0 +1,43 @@
+from gql import gql
+
+from ..utils.config import read_config_file, update_config_file
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Auth(BaseAction):
+    def whoami(self):
+        query = gql(
+            """
+            query whoami {
+                whoami {
+                    username
+                }
+            }
+        """
+        )
+
+        result = self.primitive.session.execute(query, get_execution_result=True)
+
+        return result
+
+    def setup_config(
+        self,
+        username: str,
+        token: str,
+        host: str = "api.primitive.tech",
+        transport: str = "https",
+    ):
+        full_config = read_config_file()
+        new_host_config = {
+            "username": username,
+            "token": token,
+            "transport": transport,
+        }
+
+        if existing_host_config := full_config.get(host, None):
+            full_config[host] = {**existing_host_config, **new_host_config}
+        else:
+            full_config[host] = new_host_config
+        update_config_file(new_config=full_config)

primitive/auth/commands.py

@@ -0,0 +1,77 @@
+import os
+import webbrowser
+import click
+from .actions import Auth
+from ..utils.config import PRIMITIVE_CREDENTIALS_FILEPATH
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Authentication"""
+    pass
+
+
+@cli.command("whoami")
+@click.pass_context
+def whoami_command(context):
+    """Whoami"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.auth.whoami()
+    if context.obj["DEBUG"] or context.obj["JSON"]:
+        message = result.data
+    else:
+        message = f"Logged in as {result.data['whoami']['username']}"
+    print_result(message=message, context=context)
+
+
+@cli.command("config")
+@click.pass_context
+@click.option(
+    "--username",
+    prompt=True,
+    default=lambda: os.environ.get("PRIMITIVE_USER", ""),
+    show_default="current user",
+    help="Username for Primitive API",
+)
+@click.option(
+    "--transport",
+    required=False,
+    default="https",
+    show_default="https",
+    help="Transport protocol for Primitive API",
+)
+def config_command(context, username: str, transport: str):
+    """Configure the CLI"""
+    token = os.environ.get("PRIMITIVE_TOKEN", "")
+    if not token and context.obj.get("YES"):
+        raise click.ClickException(
+            "PRIMITIVE_TOKEN environment variable is required for non-interactive mode"
+        )
+    host = context.obj.get("HOST", "api.primitive.tech")
+    while not token:
+        account_settings_url = (
+            f"{transport}://{host.replace('api', 'app')}/account/tokens"
+        )
+        if "localhost" in host:
+            account_settings_url = "http://localhost:3000/account/tokens"
+        click.secho(
+            f"You can find or create a Primitive API token at {account_settings_url}",
+            fg="yellow",
+        )
+
+        webbrowser.open_new_tab(account_settings_url)
+        token = click.prompt(
+            "Please enter your Primitive API token", hide_input=True, type=str
+        )
+
+    auth = Auth(primitive=None)
+    auth.setup_config(username=username, token=token, host=host, transport=transport)
+    message = f"Config created at '{PRIMITIVE_CREDENTIALS_FILEPATH}' for user '{username}' on host '{host}'"  # noqa
+    print_result(message=message, context=context, fg="green")

primitive/cli.py

@@ -0,0 +1,60 @@
+import os
+import sys
+import click
+from .__about__ import __version__
+from .client import Primitive
+from .auth.commands import config_command, whoami_command
+from .files.commands import cli as file_commands
+from .hardware.commands import cli as hardware_commands
+from .lint.commands import cli as lint_commands
+
+
+@click.group()
+@click.option(
+    "--host",
+    required=False,
+    default=lambda: os.environ.get("PRIMITIVE_HOST", "api.primitive.tech"),
+    show_default="api.primitive.tech",
+    help="Environment of Primitive API",
+)
+@click.option(
+    "--yes", is_flag=True, show_default=True, default=False, help="Skip interactions."
+)
+@click.option(
+    "--debug", is_flag=True, show_default=True, default=False, help="Enable debug mode."
+)
+@click.option(
+    "--json",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Turn all outputs into JSON.",
+)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Verbosity of output levels.",
+)
+@click.version_option(__version__)
+@click.pass_context
+def cli(context, host, yes, debug, json, verbose):
+    """primitive - a CLI tool for https://primitive.design"""
+    context.ensure_object(dict)
+    context.obj["YES"] = yes
+    context.obj["DEBUG"] = debug
+    context.obj["JSON"] = json
+    context.obj["VERBOSE"] = verbose
+    context.obj["HOST"] = host
+    if "config" not in sys.argv:
+        context.obj["PRIMITIVE"] = Primitive(host=host, DEBUG=debug, JSON=json)
+
+
+cli.add_command(config_command, "config")
+cli.add_command(whoami_command, "whoami")
+cli.add_command(file_commands, "files")
+cli.add_command(hardware_commands, "hardware")
+cli.add_command(lint_commands, "lint")
+
+if __name__ == "__main__":
+    cli(obj={})

primitive/client.py

@@ -0,0 +1,66 @@
+import sys
+from .auth.actions import Auth
+from .projects.actions import Projects
+from .graphql.sdk import create_session
+from .utils.config import read_config_file
+from .files.actions import Files
+from .simulations.actions import Simulations
+from .hardware.actions import Hardware
+from .lint.actions import Lint
+
+from loguru import logger
+
+logger.disable("primitive")
+
+
+class Primitive:
+    def __init__(
+        self,
+        host: str = "api.primitive.tech",
+        DEBUG: bool = False,
+        JSON: bool = False,
+        token: str = None,
+        transport: str = None,
+    ) -> None:
+        self.host = host
+        self.DEBUG = DEBUG
+        self.JSON = JSON
+
+        if self.DEBUG:
+            logger.enable("primitive")
+            logger.remove()
+            logger.add(
+                sink=sys.stderr,
+                serialize=self.JSON,
+                catch=True,
+                backtrace=True,
+                diagnose=True,
+            )
+
+        host = self.host
+        fingerprint = None
+        if not token and not transport:
+            self.get_host_config()
+            token = self.host_config.get("token")
+            transport = self.host_config.get("transport")
+            fingerprint = self.host_config.get("fingerprint")
+        else:
+            self.host_config = {"username": "", "token": token, "transport": transport}
+
+        self.session = create_session(
+            host=self.host, token=token, transport=transport, fingerprint=fingerprint
+        )
+
+        self.auth: Auth = Auth(self)
+        self.projects: Projects = Projects(self)
+        self.files: Files = Files(self)
+        self.simulations: Simulations = Simulations(self)
+        self.hardware: Hardware = Hardware(self)
+        self.lint: Lint = Lint(self)
+
+    def get_host_config(self):
+        self.full_config = read_config_file()
+        self.host_config = self.full_config.get(self.host)
+
+        if not self.host_config:
+            raise KeyError(f"Host {self.host} not found in config file.")

primitive/files/actions.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+from gql import gql
+from primitive.graphql.sdk import create_requests_session
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Files(BaseAction):
+    def trace_create(
+        self,
+        file_id: str,
+        signal_id: str,
+        signal_name: str,
+        module_name: str,
+        is_vector: bool,
+        size: int,
+    ):
+        mutation = gql(
+            """
+            mutation createTrace($input: TraceCreateInput!) {
+                traceCreate(input: $input) {
+                    ... on Trace {
+                        id
+                        signalId
+                        signalName
+                    }
+                }
+            }
+        """
+        )
+        input = {
+            "fileId": file_id,
+            "signalId": signal_id,
+            "signalName": signal_name,
+            "moduleName": module_name,
+            "isVector": is_vector,
+            "size": size,
+        }
+        variables = {"input": input}
+        result = self.primitive.session.execute(mutation, variable_values=variables)
+        return result
+
+    def file_upload(self, path: Path, is_public: bool = False, key_prefix: str = ""):
+        file_path = str(path.resolve())
+        if path.exists() is False:
+            raise FileNotFoundError(f"File not found at {file_path}")
+
+        if is_public:
+            operations = (
+                """{ "query": "mutation fileUpload($input: FileUploadInput!) { fileUpload(input: $input) { ... on File { id } } }", "variables": { "input": { "fileObject": null, "isPublic": true, "filePath": \""""
+                + file_path
+                + """\", "keyPrefix": \""""
+                + key_prefix
+                + """\" } } }"""
+            )  # noqa
+
+        else:
+            operations = (
+                """{ "query": "mutation fileUpload($input: FileUploadInput!) { fileUpload(input: $input) { ... on File { id } } }", "variables": { "input": { "fileObject": null, "isPublic": false, "filePath": \""""
+                + file_path
+                + """\", "keyPrefix": \""""
+                + key_prefix
+                + """\" } } }"""
+            )  # noqa
+        body = {
+            "operations": ("", operations),
+            "map": ("", '{"fileObject": ["variables.input.fileObject"]}'),
+            "fileObject": (path.name, open(path, "rb")),
+        }
+
+        session = create_requests_session(self.primitive.host_config)
+        transport = self.primitive.host_config.get("transport")
+        url = f"{transport}://{self.primitive.host}/"
+        response = session.post(url, files=body)
+        return response

primitive/files/commands.py

@@ -0,0 +1,28 @@
+import click
+from ..utils.printer import print_result
+from pathlib import Path
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group("files")
+@click.pass_context
+def cli(context):
+    """Files"""
+    pass
+
+
+@cli.command("upload")
+@click.pass_context
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--public", "-p", help="Is this a Public file", is_flag=True)
+@click.option("--key-prefix", "-k", help="Key Prefix", default="")
+def file_upload_command(context, path, public, key_prefix):
+    """File Upload"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    path = Path(path)
+    result = primitive.files.file_upload(path, is_public=public, key_prefix=key_prefix)
+    message = result.json()
+    print_result(message=message, context=context)

primitive/graphql/sdk.py

@@ -0,0 +1,53 @@
+from typing import Dict
+from gql import Client
+from gql.transport.aiohttp import AIOHTTPTransport
+import requests
+from primitive.__about__ import __version__
+
+
+def create_session(
+    token: str,
+    host: str = "api.primitive.tech",
+    transport: str = "https",
+    fingerprint: str = None,
+    fetch_schema_from_transport: bool = False,
+):
+    url = f"{transport}://{host}/"
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "x-primitive-agent": f"primitive@{__version__}",
+    }
+    if token:
+        headers["Authorization"] = f"Token {token}"
+
+    if fingerprint:
+        headers["x-primitive-fingerprint"] = fingerprint
+
+    transport = AIOHTTPTransport(url=url, headers=headers)
+    session = Client(
+        transport=transport,
+        fetch_schema_from_transport=fetch_schema_from_transport,
+    )
+    return session
+
+
+def create_requests_session(
+    host_config: Dict,
+):
+    token = host_config.get("token")
+
+    headers = {
+        # "Content-Type": "multipart/form-data", # DO NOT ADD THIS MIME TYPE IT BREAKS
+        "Accept": "application/json",
+        "x-primitive-agent": f"primitive@{__version__}",
+    }
+    if token:
+        headers["Authorization"] = f"Token {token}"
+
+    if fingerprint := host_config.get("fingerprint", None):
+        headers["x-primitive-fingerprint"] = fingerprint
+
+    session = requests.Session()
+    session.headers.update(headers)
+    return session