fragment-python 0.1.1__py3-none-any.whl

fragment/client/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python3

fragment/client/async_client.py

@@ -0,0 +1,67 @@
+# Ignore untyped authlib
+# mypy: disable-error-code="import-untyped"
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+from ariadne_codegen.client_generators.dependencies.async_base_client import (
+    AsyncBaseClient,
+)
+from authlib.integrations.httpx_client import AsyncOAuth2Client
+
+from fragment.exceptions import MissingArgumentException, MissingTokenException
+
+
+class AsyncFragmentClient(AsyncBaseClient):
+    def __init__(
+        self,
+        api_url: str = "",
+        auth_url: str = "",
+        auth_scope: str = "",
+        client_id: str = "",
+        client_secret: str = "",
+        http_client: Optional[httpx.AsyncClient] = None,
+    ):
+        if api_url == "":
+            raise MissingArgumentException("api_url")
+        if auth_url == "":
+            raise MissingArgumentException("auth_url")
+        if auth_scope == "":
+            raise MissingArgumentException("auth_scope")
+        if client_id == "":
+            raise MissingArgumentException("client_id")
+        if client_secret == "":
+            raise MissingArgumentException("client_secret")
+        super().__init__(url=api_url, http_client=http_client)
+
+        self.auth_url = auth_url
+        self.expiration_time = None
+        self.token = None
+        self.oauth2_client = AsyncOAuth2Client(
+            client_id, client_secret, scope=auth_scope
+        )
+
+    async def refresh_token(self):
+        now = time.time()
+        if self.expiration_time is None or self.expiration_time <= now:
+            self.token = await self.oauth2_client.fetch_token(self.auth_url)
+            self.expiration_time = now + self.token["expires_in"]
+
+    async def execute(
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        await self.refresh_token()
+        if self.token is None:
+            raise MissingTokenException()
+        headers = kwargs.get("headers", {})
+        kwargs.update(
+            headers={
+                "Authorization": f'Bearer {self.token["access_token"]}',
+                **headers,
+            }
+        )
+        return await super().execute(query, operation_name, variables, **kwargs)

fragment/codegen/helpers.py

@@ -0,0 +1,51 @@
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+
+def get_project_path_relative_to_file(path: str) -> str:
+    """
+    Get the relative path of a file in the project.
+    It is important that this function is in the same directory
+    as the commandline entrypoint.
+    """
+    resolved_path = Path(__file__, path).resolve()
+    return os.path.relpath(resolved_path)
+
+
+def get_codegen_config(
+    *,
+    schema_path: str,
+    queries_path: str,
+    target_package_name: str,
+    target_package_path: Optional[str] = None
+) -> Dict:
+    """Get the configuration for the codegen tool."""
+    return dict(
+        tool={
+            "ariadne-codegen": dict(
+                schema_path=schema_path,
+                queries_path=queries_path,
+                target_package_name=target_package_name,
+                target_package_path=(
+                    target_package_path if target_package_path else Path.cwd()
+                ),
+                base_client_name="AsyncFragmentClient",
+                base_client_file_path=get_project_path_relative_to_file(
+                    "../../client/async_client.py"
+                ),
+                plugins=[
+                    "fragment.codegen.plugins.get_file_comment.GenerateFileComment",
+                    "fragment.codegen.plugins.generate_client_method.RewriteUnsetTypeMethodArguments",
+                ],
+            ),
+        },
+    )
+
+
+def get_standard_queries() -> str:
+    """Get the standard SDK queries for the codegen tool."""
+    standard_query_file_path = get_project_path_relative_to_file(
+        "../../std_queries/queries.graphql"
+    )
+    return Path(standard_query_file_path).read_text()

fragment/codegen/main.py

@@ -0,0 +1,64 @@
+import logging
+import sys
+import tempfile
+
+import click
+import httpx
+from ariadne_codegen.main import client as generate_graphql_client
+
+from fragment.codegen.helpers import get_codegen_config, get_standard_queries
+from fragment.logger import console_log
+
+logging.getLogger("httpx").setLevel(logging.WARNING)
+
+
+GRAPHQL_SCHEMA_API_URL = "https://api.us-west-2.fragment.dev/schema.graphql"
+
+
+@click.command()
+@click.option(
+    "-i",
+    "--input-dir",
+    default=None,
+    help="Path to your Schema queries",
+    required=True,
+)
+@click.option(
+    "-n",
+    "--target-package-name",
+    default="fragment_graphql_client",
+    help="The package name for the generated SDK",
+    required=False,
+)
+@click.option(
+    "-o",
+    "--output-dir",
+    default=None,
+    help="The output directory for the generated SDK. Defaults to CWD.",
+    required=False,
+)
+def run(input_dir, target_package_name, output_dir=None):
+    console_log.info(f"Downloading the GraphQL schema from {GRAPHQL_SCHEMA_API_URL}")
+    try:
+        r = httpx.get(GRAPHQL_SCHEMA_API_URL)
+        with tempfile.NamedTemporaryFile(
+            mode="w"
+        ) as schema_file, tempfile.NamedTemporaryFile(
+            dir=input_dir, mode="w", suffix=".graphql"
+        ) as standard_query_file:
+            # Write and flush the most recent schema
+            schema_file.write(r.text)
+            schema_file.flush()
+            # Write and flush the standard queries to the provided input
+            standard_query_file.write(get_standard_queries())
+            standard_query_file.flush()
+            config_dict = get_codegen_config(
+                schema_path=schema_file.name,
+                queries_path=input_dir,
+                target_package_name=target_package_name,
+                target_package_path=output_dir,
+            )
+            generate_graphql_client(config_dict)
+    except httpx.RequestError as e:
+        console_log.error(f"An error occurred while downloading the schema: {e}")
+        sys.exit(1)

fragment/codegen/plugins/generate_client_method.py

@@ -0,0 +1,62 @@
+import ast
+from typing import Union
+
+from ariadne_codegen.client_generators.constants import (
+    OPTIONAL,
+    UNION,
+    UNSET_NAME,
+    UNSET_TYPE_NAME,
+)
+from ariadne_codegen.plugins.base import Plugin
+from graphql import OperationDefinitionNode
+
+
+def is_ignorable_ast_node(node: Union[ast.expr, None]) -> bool:
+    return node is None or isinstance(node, ast.Name)
+
+
+class RewriteUnsetTypeMethodArguments(Plugin):
+    def generate_client_method(
+        self,
+        method_def: Union[ast.FunctionDef, ast.AsyncFunctionDef],
+        operation_definition: OperationDefinitionNode,
+    ) -> Union[ast.FunctionDef, ast.AsyncFunctionDef]:
+        for idx, arg in enumerate(method_def.args.args):
+            if isinstance(arg.annotation, ast.Subscript):
+                annotation = arg.annotation
+                if annotation.slice is None or not isinstance(
+                    annotation.slice, ast.Tuple
+                ):
+                    continue
+                if (
+                    not isinstance(annotation.value, ast.Name)
+                    or annotation.value.id != UNION
+                ):
+                    continue
+                subscript, name = annotation.slice.elts
+                if (
+                    isinstance(subscript, ast.Subscript)
+                    and isinstance(subscript.value, ast.Name)
+                    and subscript.value.id == OPTIONAL
+                    and isinstance(name, ast.Name)
+                    and name.id == UNSET_TYPE_NAME
+                ):
+                    arg.annotation = subscript
+                else:
+                    continue
+            elif not is_ignorable_ast_node(arg.annotation):
+                raise TypeError(
+                    f"Expected annotation to be of type Subscript. Got {arg.annotation}"
+                )
+        if method_def.args.defaults is not None:
+            method_def.args.defaults = list(
+                map(
+                    lambda arg: (
+                        ast.Name(id="None")
+                        if isinstance(arg, ast.Name) and arg.id == UNSET_NAME
+                        else arg
+                    ),
+                    method_def.args.defaults,
+                )
+            )
+        return method_def

fragment/codegen/plugins/get_file_comment.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from ariadne_codegen.plugins.base import Plugin
+
+
+class GenerateFileComment(Plugin):
+    def get_file_comment(
+        self, comment: str, code: str, source: Optional[str] = None
+    ) -> str:
+        comment_lines = ["# Generated by fragment (with the help of ariadne-codegen)"]
+        codegen_dict = self.config_dict.get("tool", {}).get("ariadne-codegen", {})
+        schema_path = codegen_dict.get("schema_path", "")
+        queries_path = codegen_dict.get("queries_path", "")
+        if source == queries_path:
+            comment_lines.append(f"# Source: {source}")
+        elif source == schema_path:
+            comment_lines.append(f"# Source: schema.graphql")
+        return "\n".join(comment_lines)

fragment/exceptions.py

@@ -0,0 +1,12 @@
+class MissingTokenException(ValueError):
+    """Token not found."""
+
+    def __init__(self):
+        super().__init__("Token is None")
+
+
+class MissingArgumentException(ValueError):
+    """Argument not present."""
+
+    def __init__(self, argument: str):
+        super().__init__(f"{argument} must be provided")

fragment/logger.py

@@ -0,0 +1,6 @@
+import logging
+import sys
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+console_log = logging.getLogger("console")