python-anvil 2.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

python_anvil/api.py

@@ -1,4 +1,6 @@
-from logging import getLogger
+import logging
+from gql import gql
+from graphql import DocumentNode
 from typing import Any, AnyStr, Callable, Dict, List, Optional, Text, Tuple, Union
 
 from .api_resources.mutations import (
@@ -13,12 +15,11 @@ from .api_resources.payload import (
     ForgeSubmitPayload,
     GeneratePDFPayload,
 )
-from .api_resources.requests import GraphqlRequest, PlainRequest, RestRequest
-from .http import HTTPClient
-from .multipart_helpers import get_multipart_payload
+from .api_resources.requests import PlainRequest, RestRequest
+from .http import GQLClient, HTTPClient
 
 
-logger = getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 
 def _get_return(res: Dict, get_data: Callable[[Dict], Union[Dict, List]]):
@@ -47,39 +48,70 @@ class Anvil:
     # This is the default when a version is not provided.
     VERSION_LATEST_PUBLISHED = -2
 
-    def __init__(self, api_key=None, environment='dev'):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        environment="dev",
+        endpoint_url=None,
+    ):
+        if not api_key:
+            raise ValueError('`api_key` must be a valid string')
+
         self.client = HTTPClient(api_key=api_key, environment=environment)
+        self.gql_client = GQLClient.get_client(
+            api_key=api_key,
+            environment=environment,
+            endpoint_url=endpoint_url,
+        )
 
     def query(
         self,
-        query: str,
-        variables: Union[Optional[Text], Dict[Text, Any]] = None,
+        query: Union[str, DocumentNode],
+        variables: Optional[Dict[str, Any]] = None,
         **kwargs,
     ):
-        gql = GraphqlRequest(client=self.client)
-        return gql.post(query, variables=variables, **kwargs)
+        """Execute a GraphQL query.
+
+        :param query:
+        :type query: Union[str, DocumentNode]
+        :param variables:
+        :type variables: Optional[Dict[str, Any]]
+        :param kwargs:
+        :return:
+        """
+        # Remove `debug` for now.
+        kwargs.pop("debug", None)
+        if isinstance(query, str):
+            query = gql(query)
 
-    def mutate(self, query: BaseQuery, variables: dict, **kwargs):
-        gql = GraphqlRequest(client=self.client)
-        return gql.post(query.get_mutation(), variables, **kwargs)
+        return self.gql_client.execute(query, variable_values=variables, **kwargs)
 
-    def mutate_multipart(self, files: Dict, **kwargs):
+    def mutate(
+        self, query: Union[str, BaseQuery], variables: Dict[str, Any], **kwargs
+    ) -> Dict[str, Any]:
         """
-        Multipart version of `mutate`.
+        Execute a GraphQL mutation.
 
-        This will send a mutation based on the multipart spec defined here:
+        NOTE: Any files attached provided in `variables` will be sent via the
+        multipart spec:
         https://github.com/jaydenseric/graphql-multipart-request-spec
 
-        Note that `variables` and `query` have been removed and replaced with
-        `files`. The entire GraphQL payload should already be prepared as a
-        `dict` beforehand.
-
-        :param files:
+        :param query:
+        :type query: Union[str, BaseQuery]
+        :param variables:
+        :type variables: Dict[str, Any]
         :param kwargs:
         :return:
         """
-        gql = GraphqlRequest(client=self.client)
-        return gql.post_multipart(files=files, **kwargs)
+        # Remove `debug` for now.
+        kwargs.pop("debug", None)
+        if isinstance(query, str):
+            use_query = gql(query)
+        else:
+            mutation = query.get_mutation()
+            use_query = gql(mutation)
+
+        return self.gql_client.execute(use_query, variable_values=variables, **kwargs)
 
     def request_rest(self, options: Optional[dict] = None):
         api = RestRequest(self.client, options=options)
@@ -180,20 +212,34 @@ class Anvil:
             arg_str = f"({','.join(joined_args)})"
 
         res = self.query(
-            f"""{{
+            gql(
+                f"""{{
               cast {arg_str} {{
                 {" ".join(fields)}
               }}
-            }}""",
+            }}"""
+            ),
             **kwargs,
         )
 
-        def get_data(r) -> Dict[str, Any]:
-            return r["data"]["cast"]
+        def get_data(r: dict) -> Dict[str, Any]:
+            return r["cast"]
 
         return _get_return(res, get_data=get_data)
 
-    def get_casts(self, fields=None, show_all=False, **kwargs) -> List[Dict[str, Any]]:
+    def get_casts(
+        self, fields: Optional[List[str]] = None, show_all: bool = False, **kwargs
+    ) -> List[Dict[str, Any]]:
+        """Retrieve all Cast objects for the current user across all organizations.
+
+        :param fields: List of fields to retrieve for each cast object
+        :type fields: Optional[List[str]]
+        :param show_all: Boolean to show all Cast objects.
+            Defaults to showing only templates.
+        :type show_all: bool
+        :param kwargs:
+        :return:
+        """
         if not fields:
             # Use default fields
             fields = ["eid", "title", "fieldInfo"]
@@ -201,7 +247,8 @@ class Anvil:
         cast_args = "" if show_all else "(isTemplate: true)"
 
         res = self.query(
-            f"""{{
+            gql(
+                f"""{{
               currentUser {{
                 organizations {{
                   casts {cast_args} {{
@@ -209,19 +256,26 @@ class Anvil:
                   }}
                 }}
               }}
-            }}""",
+            }}"""
+            ),
             **kwargs,
         )
 
-        def get_data(r):
-            orgs = r["data"]["currentUser"]["organizations"]
+        def get_data(r: dict):
+            orgs = r["currentUser"]["organizations"]
             return [item for org in orgs for item in org["casts"]]
 
         return _get_return(res, get_data=get_data)
 
     def get_current_user(self, **kwargs):
+        """Retrieve current user data.
+
+        :param kwargs:
+        :return:
+        """
         res = self.query(
-            """{
+            gql(
+                """{
               currentUser {
                 name
                 email
@@ -237,22 +291,23 @@ class Anvil:
                   }
                 }
               }
-            }
-            """,
+            }"""
+            ),
             **kwargs,
         )
 
-        return _get_return(res, get_data=lambda r: r["data"]["currentUser"])
+        return _get_return(res, get_data=lambda r: r["currentUser"])
 
     def get_welds(self, **kwargs) -> Union[List, Tuple[List, Dict]]:
         res = self.query(
-            """{
+            gql(
+                """{
               currentUser {
                 organizations {
                   welds {
                     eid
                     slug
-                    title
+                    name
                     forges {
                       eid
                       name
@@ -260,19 +315,21 @@ class Anvil:
                   }
                 }
               }
-            }""",
+            }"""
+            ),
             **kwargs,
         )
 
-        def get_data(r):
-            orgs = r["data"]["currentUser"]["organizations"]
+        def get_data(r: dict):
+            orgs = r["currentUser"]["organizations"]
             return [item for org in orgs for item in org["welds"]]
 
         return _get_return(res, get_data=get_data)
 
     def get_weld(self, eid: Text, **kwargs):
         res = self.query(
-            """
+            gql(
+                """
             query WeldQuery(
                 #$organizationSlug: String!,
                 #$slug: String!
@@ -292,13 +349,14 @@ class Anvil:
                         slug
                     }
                 }
-            }""",
+            }"""
+            ),
             variables=dict(eid=eid),
             **kwargs,
         )
 
-        def get_data(r):
-            return r["data"]["weld"]
+        def get_data(r: dict):
+            return r["weld"]
 
         return _get_return(res, get_data=get_data)
 
@@ -337,10 +395,10 @@ class Anvil:
                 "`payload` must be a valid CreateEtchPacket instance or dict"
             )
 
-        files = get_multipart_payload(mutation)
+        payload = mutation.create_payload()
+        variables = payload.dict(by_alias=True, exclude_none=True)
 
-        res = self.mutate_multipart(files, **kwargs)
-        return res
+        return self.mutate(mutation, variables=variables, upload_files=True, **kwargs)
 
     def generate_etch_signing_url(self, signer_eid: str, client_user_id: str, **kwargs):
         """Generate a signing URL for a given user."""
@@ -361,7 +419,7 @@ class Anvil:
         payload: Optional[Union[Dict[Text, Any], ForgeSubmitPayload]] = None,
         json=None,
         **kwargs,
-    ):
+    ) -> Dict[str, Any]:
         """Create a Webform (forge) submission via a graphql mutation."""
         if not any([json, payload]):
             raise TypeError('One of arguments `json` or `payload` are required')

python_anvil/api_resources/mutations/create_etch_packet.py

@@ -1,11 +1,13 @@
 # pylint: disable=too-many-instance-attributes
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+import logging
+from io import BufferedIOBase
+from logging import Logger
+from mimetypes import guess_type
+from typing import Any, Dict, List, Optional, Union
 
 from python_anvil.api_resources.mutations.base import BaseQuery
 from python_anvil.api_resources.payload import (
     AttachableEtchFile,
-    Base64Upload,
     CreateEtchFilePayload,
     CreateEtchPacketPayload,
     DocumentUpload,
@@ -14,6 +16,8 @@ from python_anvil.api_resources.payload import (
 from python_anvil.utils import create_unique_id
 
 
+logger: Logger = logging.getLogger(__name__)
+
 DEFAULT_RESPONSE_QUERY = """{
   id
   eid
@@ -193,6 +197,18 @@ class CreateEtchPacket(BaseQuery):
         Files will not be uploaded when running this method. They will be
         uploaded when the mutation actually runs.
         """
+        if (
+            isinstance(file, DocumentUpload)
+            and isinstance(file.file, BufferedIOBase)
+            and getattr(file.file, "content_type", None) is None
+        ):
+            # Don't clobber existing `content_type`s provided.
+            content_type, _ = guess_type(file.file.name)  # type: ignore
+            logger.debug(
+                "File did not have a `content_type`, guessing as '%s'", content_type
+            )
+            file.file.content_type = content_type  # type: ignore
+
         self.files.append(file)
 
     def add_file_payloads(self, file_id: str, fill_payload):
@@ -215,43 +231,7 @@ class CreateEtchPacket(BaseQuery):
                 )
         return self.file_payloads
 
-    def get_files_for_payload(self) -> Tuple[List[AttachableEtchFile], List[Any]]:
-        """Scan through and gather files for use in multipart requests.
-
-        During the process, files will be replaced with a dummy `Path`
-        instance as `Callable` instances and likely their returns of some
-        sort of IO reader is not serializable and not easily dealt with in
-        pydantic (the underlying model system for the types used in this
-        library). Closer to the actual request, when the multipart payload is
-        being constructed, the dummy instances will be replaced by their actual
-        file instances.
-
-        :return: Tuple containing a list of uploadable file types, and a list
-            of actual file references
-        :rtype: Tuple[List, List]
-        """
-        contains_uploads = any(  # pylint: disable=use-a-generator
-            [isinstance(f, DocumentUpload) for f in self.files]
-        )
-        if not contains_uploads:
-            return self.files, []
-
-        files = []
-        for f in self.files:
-            if not isinstance(f, DocumentUpload):
-                continue
-
-            if getattr(f.Config, "contains_uploads", False):
-                attr_name = getattr(f.Config, "contains_uploads")
-                upload = getattr(f, attr_name)
-
-                if not isinstance(upload, Base64Upload):
-                    files.append(upload)
-                    setattr(f, attr_name, Path())
-
-        return self.files, files
-
-    def create_payload(self) -> Tuple[CreateEtchPacketPayload, List]:
+    def create_payload(self) -> CreateEtchPacketPayload:
         """Create a payload based on data set on the class instance.
 
         Check `api_resources.payload.CreateEtchPacketPayload` for full payload
@@ -260,19 +240,17 @@ class CreateEtchPacket(BaseQuery):
         """
         # If there's an existing payload instance attribute, just return that.
         if self.payload:
-            return self.payload, []
+            return self.payload
 
         if not self.name:
             raise TypeError("`name` and `signature_email_subject` cannot be None")
 
-        payload_files, file_refs = self.get_files_for_payload()
-
         payload = CreateEtchPacketPayload(
             is_test=self.is_test,
             is_draft=self.is_draft,
             name=self.name,
             signers=self.signers,
-            files=payload_files,
+            files=self.files,
             data=CreateEtchFilePayload(payloads=self.get_file_payloads()),
             signature_email_subject=self.signature_email_subject,
             signature_email_body=self.signature_email_body,
@@ -286,4 +264,4 @@ class CreateEtchPacket(BaseQuery):
             duplicate_casts=self.duplicate_casts,
         )
 
-        return payload, file_refs
+        return payload

python_anvil/api_resources/mutations/forge_submit.py

@@ -47,7 +47,6 @@ mutation ForgeSubmit(
     $timezone: String,
     $groupArrayId: String,
     $groupArrayIndex: Int,
-    $errorType: String,
     $webhookURL: String,
 ) {{
     forgeSubmit (
@@ -61,7 +60,6 @@ mutation ForgeSubmit(
         timezone: $timezone,
         groupArrayId: $groupArrayId,
         groupArrayIndex: $groupArrayIndex,
-        errorType: $errorType,
         webhookURL: $webhookURL
     ) {query}
 }}

python_anvil/api_resources/payload.py

@@ -7,12 +7,11 @@ from io import BufferedIOBase
 # import `BaseModel` and it's not broken, so let's keep it.
 from pydantic import (  # pylint: disable=no-name-in-module
     Field,
-    FilePath,
     HttpUrl,
     root_validator,
     validator,
 )
-from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union
+from typing import Any, Dict, List, Optional, Text, Union
 
 from .base import BaseModel
 
@@ -184,7 +183,13 @@ class DocumentUpload(BaseModel):
 
     id: str
     title: str
-    file: "UploadableFile"
+    # Previously "UploadableFile", however, that seems to cause weird upload
+    # issues where a PDF file would have its first few bytes removed.
+    # We're now relying on the backend to validate this property instead of on
+    # the client library side.
+    # This might be a bug on the `pydantic` side(?) when this object gets
+    # converted into a dict.
+    file: Any
     fields: List[SignatureField]
     font_size: int = 14
     text_color: str = "#000000"
@@ -192,10 +197,8 @@ class DocumentUpload(BaseModel):
     class Config:
         """Special rules for this model class."""
 
+        # Needed to allow `BufferedIOBase` as an allowed `file` type.
         arbitrary_types_allowed = True
-        # String to help point out the file upload attr.
-        # Used in multipart uploads and should not affect base64-encoded files.
-        contains_uploads = "file"
 
 
 class EtchCastRef(BaseModel):
@@ -271,16 +274,7 @@ class ForgeSubmitPayload(BaseModel):
         return values
 
 
-# Types usable for uploads:
-# Base64Upload: An entire PDF file base64 encoded
-# FilePath: The absolute path of the file. When the pydantic model is used,
-#   it will convert a path string (i.e. "/home/me/my_file.pdf") into a
-#   `pathlib.Path` instance.
-# UploadMethod: A function that returns a tuple of:
-#   * BufferedIOBase instance for use in `requests`
-#   * String containing the name for the file for use in Anvil
-UploadMethod = Callable[[Any], Tuple[BufferedIOBase, str]]
-UploadableFile = Union[Base64Upload, FilePath, UploadMethod]
+UploadableFile = Union[Base64Upload, BufferedIOBase]
 AttachableEtchFile = Union[
     DocumentUpload, EtchCastRef, DocumentMarkup, DocumentMarkdown
 ]

python_anvil/api_resources/requests.py

@@ -34,6 +34,7 @@ class AnvilRequest:
         else:
             message = f"Error: {status_code}: {response} {extra}"
 
+        # pylint: disable=broad-exception-raised
         raise Exception(message)
 
     def process_response(self, response, status_code, headers, **kwargs):
@@ -78,6 +79,12 @@ class BaseAnvilHttpRequest(AnvilRequest):
 
 
 class GraphqlRequest(AnvilRequest):
+    """Create a GraphQL request.
+
+    .. deprecated :: 2.0.0
+       Use `python_anvil.http.GQLClient` to make GraphQL queries and mutations.
+    """
+
     API_HOST = "https://graphql.useanvil.com"
 
     def __init__(self, client: HTTPClient):

python_anvil/cli.py

@@ -102,11 +102,12 @@ def weld(ctx, eid, list_all):
             if debug:
                 click.echo(headers)
 
-        data = [(w["eid"], w.get("slug"), w.get("title"), w.get("forges")) for w in res]
+        data = [(w["eid"], w.get("slug"), w.get("name"), w.get("forges")) for w in res]
         click.echo(tabulate(data, tablefmt="pretty", headers=["eid", "slug", "title"]))
         return
 
     if not eid:
+        # pylint: disable=broad-exception-raised
         raise Exception("You need to pass in a weld eid")
 
     res = anvil.get_weld(eid)

python_anvil/constants.py

@@ -0,0 +1,18 @@
+"""Basic constants used in the library."""
+
+GRAPHQL_ENDPOINT: str = "https://graphql.useanvil.com"
+REST_ENDPOINT = "https://app.useanvil.com/api/v1/"
+
+RETRIES_LIMIT = 5
+REQUESTS_LIMIT = {
+    "dev": {
+        "calls": 2,
+        "seconds": 1,
+    },
+    "prod": {
+        "calls": 40,
+        "seconds": 1,
+    },
+}
+
+RATELIMIT_ENV = "dev"

python_anvil/http.py

@@ -1,33 +1,89 @@
+import os
 import requests
 from base64 import b64encode
+from gql import Client
+from gql.dsl import DSLSchema
+from gql.transport.requests import RequestsHTTPTransport
 from logging import getLogger
 from ratelimit import limits, sleep_and_retry
 from ratelimit.exception import RateLimitException
 from requests.auth import HTTPBasicAuth
+from typing import Optional
 
 from python_anvil.exceptions import AnvilRequestException
 
+from .constants import GRAPHQL_ENDPOINT, RATELIMIT_ENV, REQUESTS_LIMIT, RETRIES_LIMIT
 
-logger = getLogger(__name__)
-
-REQUESTS_LIMIT = {
-    "dev": {
-        "calls": 2,
-        "seconds": 1,
-    },
-    "prod": {
-        "calls": 40,
-        "seconds": 1,
-    },
-}
 
-RATELIMIT_ENV = "dev"
+logger = getLogger(__name__)
 
 
 def _handle_request_error(e: Exception):
     raise e
 
 
+def get_local_schema(raise_on_error=False) -> Optional[str]:
+    """
+    Retrieve local GraphQL schema.
+
+    :param raise_on_error:
+    :return:
+    """
+    try:
+        file_dir = os.path.dirname(os.path.realpath(__file__))
+        file_path = os.path.join(file_dir, "..", "schema", "anvil_schema.graphql")
+        with open(file_path, encoding="utf-8") as file:
+            schema = file.read()
+    except Exception:  # pylint: disable
+        logger.warning(
+            "Unable to find local schema. Will not use schema for local "
+            "validation. Use `fetch_schema_from_transport=True` to allow "
+            "fetching the remote schema."
+        )
+        if raise_on_error:
+            raise
+        schema = None
+
+    return schema
+
+
+def get_gql_ds(client: Client) -> DSLSchema:
+    if not client.schema:
+        raise ValueError("Client does not have a valid GraphQL schema.")
+    return DSLSchema(client.schema)
+
+
+class GQLClient:
+    """GraphQL client factory class."""
+
+    @staticmethod
+    def get_client(
+        api_key: str,
+        environment: str = "dev",  # pylint: disable=unused-argument
+        endpoint_url: Optional[str] = None,
+        fetch_schema_from_transport: bool = False,
+        force_local_schema: bool = False,
+    ) -> Client:
+        auth = HTTPBasicAuth(username=api_key, password="")
+        endpoint_url = endpoint_url or GRAPHQL_ENDPOINT
+        transport = RequestsHTTPTransport(
+            retries=RETRIES_LIMIT,
+            auth=auth,
+            url=endpoint_url,
+            verify=True,
+        )
+
+        schema = None
+        if force_local_schema or not fetch_schema_from_transport:
+            schema = get_local_schema(raise_on_error=False)
+
+        return Client(
+            schema=schema,
+            transport=transport,
+            fetch_schema_from_transport=fetch_schema_from_transport,
+        )
+
+
 class HTTPClient:
     def __init__(self, api_key=None, environment="dev"):
         self._session = requests.Session()

python_anvil/tests/test_api.py

@@ -17,22 +17,58 @@ from . import payloads
 
 DEV_KEY = "MY-SECRET-KEY"
 
+TEST_SCHEMA = """
+type GenerateEmbedURLResponse {
+  eid: String!
+  url: String!
+}
+"""
+
 
 def describe_api():
     @pytest.fixture
-    def anvil():
+    @mock.patch("builtins.open", new_callable=mock.mock_open, read_data=TEST_SCHEMA)
+    def anvil(m_open):
         return Anvil(api_key=DEV_KEY)
 
     def describe_init():
+        @mock.patch('python_anvil.api.GQLClient')
         @mock.patch('python_anvil.api.HTTPClient')
-        def test_init_key_default(mock_client):
+        def test_init_key_default(mock_client, mock_gql):
             Anvil(api_key="what")
             mock_client.assert_called_once_with(api_key="what", environment="dev")
+            mock_gql.get_client.assert_called_once_with(
+                api_key="what", environment="dev", endpoint_url=None
+            )
+
+        @mock.patch('python_anvil.api.GQLClient')
+        @mock.patch('python_anvil.api.HTTPClient')
+        def test_init_with_endpoint(mock_client, mock_gql):
+            Anvil(api_key="what", endpoint_url="http://somewhere.example")
+            mock_client.assert_called_once_with(api_key="what", environment="dev")
+            mock_gql.get_client.assert_called_once_with(
+                api_key="what",
+                environment="dev",
+                endpoint_url="http://somewhere.example",
+            )
 
+        @mock.patch('python_anvil.api.GQLClient')
         @mock.patch('python_anvil.api.HTTPClient')
-        def test_init_key_prod(mock_client):
+        def test_init_key_prod(mock_client, mock_gql):
             Anvil(api_key="what", environment="prod")
             mock_client.assert_called_once_with(api_key="what", environment="prod")
+            mock_gql.get_client.assert_called_once_with(
+                api_key="what", environment="prod", endpoint_url=None
+            )
+
+        @mock.patch('python_anvil.api.GQLClient')
+        @mock.patch('python_anvil.api.HTTPClient')
+        def test_init_no_key(mock_client, mock_gql):
+            with pytest.raises(ValueError):
+                Anvil(environment="prod")
+
+            assert mock_client.call_count == 0
+            assert mock_gql.get_client.call_count == 0
 
     def describe_query():
         def test_query():
@@ -175,19 +211,19 @@ def describe_api():
             assert m_request_post.call_count == 0
 
     def describe_current_user_query():
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_get_current_user(m_request_post, anvil):
             anvil.get_current_user()
             assert m_request_post.call_count == 1
 
     def describe_get_welds():
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_get_weld(m_request_post, anvil):
             anvil.get_welds()
             assert m_request_post.call_count == 1
 
     def describe_generate_etch_signing_url():
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_get_url(m_request_post, anvil):
             anvil.generate_etch_signing_url(
                 signer_eid='someId', client_user_id='anotherId'
@@ -201,13 +237,13 @@ def describe_api():
             assert m_request_post.call_count == 1
 
     def describe_get_cast():
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_get_cast(m_request_post, anvil):
             anvil.get_cast('castEid')
             assert m_request_post.call_count == 1
 
     def describe_get_casts():
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_get_casts(m_request_post, anvil):
             anvil.get_casts()
             assert m_request_post.call_count == 1
@@ -224,19 +260,19 @@ def describe_api():
             'signaturePageOptions': {},
         }
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_empty_payload(m_request_post, anvil):
             with pytest.raises(TypeError):
                 anvil.create_etch_packet(payload={})
                 assert m_request_post.call_count == 0
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_invalid_payload(m_request_post, anvil):
             with pytest.raises(TypeError):
                 anvil.create_etch_packet({})
                 assert m_request_post.call_count == 0
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_valid_payload_type(m_request_post, anvil):
             payload = CreateEtchPacket(
                 name="Packet name",
@@ -245,12 +281,10 @@ def describe_api():
             anvil.create_etch_packet(payload=payload)
             assert m_request_post.call_count == 1
 
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+            variables = m_request_post.call_args[1]["variable_values"]
             assert expected_data == variables
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_passes_options(m_request_post, anvil):
             payload = CreateEtchPacket(
                 is_test=False,
@@ -262,43 +296,39 @@ def describe_api():
             new_expected["isTest"] = False
             new_expected["isDraft"] = True
             anvil.create_etch_packet(payload)
-
             assert m_request_post.call_count == 1
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+
+            variables = m_request_post.call_args[1]["variable_values"]
             assert new_expected == variables
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_valid_dict_type(m_request_post, anvil):
             anvil.create_etch_packet(
                 dict(name="Packet name", signature_email_subject="The subject")
             )
             assert m_request_post.call_count == 1
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+
+            variables = m_request_post.call_args[1]["variable_values"]
             assert expected_data == variables
 
         @mock.patch(
             'python_anvil.api_resources.mutations.create_etch_packet.create_unique_id'
         )
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_dict_with_signer(
             m_request_post, m_create_unique, anvil
         ):
             m_create_unique.return_value = "signer-mock-generated"
             anvil.create_etch_packet(payload=payloads.ETCH_TEST_PAYLOAD)
             assert m_request_post.call_count == 1
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+
+            variables = m_request_post.call_args[1]["variable_values"]
             assert payloads.EXPECTED_ETCH_TEST_PAYLOAD == variables
 
         @mock.patch(
             'python_anvil.api_resources.mutations.create_etch_packet.create_unique_id'
         )
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_create_etch_packet_json(m_request_post, m_create_unique, anvil):
             m_create_unique.return_value = "signer-mock-generated"
             # We are currently removing `None`s from the payload, so do that here too.
@@ -310,15 +340,13 @@ def describe_api():
             anvil.create_etch_packet(json=json.dumps(payload))
             assert m_request_post.call_count == 1
 
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+            variables = m_request_post.call_args[1]["variable_values"]
             assert payload == variables
 
         @mock.patch(
             'python_anvil.api_resources.mutations.create_etch_packet.create_unique_id'
         )
-        @mock.patch('python_anvil.api.GraphqlRequest.post_multipart')
+        @mock.patch('gql.Client.execute')
         def test_adding_unsupported_fields(m_request_post, m_create_unique, anvil):
             m_create_unique.return_value = "signer-mock-generated"
             # We are currently removing `None`s from the payload, so do that here too.
@@ -332,9 +360,7 @@ def describe_api():
             anvil.create_etch_packet(payload=cep)
             assert m_request_post.call_count == 1
 
-            files = m_request_post.call_args[1]["files"]
-            files_payload = json.loads(files["operations"][1])
-            variables = files_payload["variables"]
+            variables = m_request_post.call_args[1]["variable_values"]
             assert cep.dict(by_alias=True, exclude_none=True) == variables
             assert "newFeature" in variables
 
@@ -345,22 +371,22 @@ def describe_api():
             "isTest": True,
         }
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_invalid_payload(m_request_post, anvil):
             with pytest.raises(TypeError):
                 anvil.forge_submit({})
                 assert m_request_post.call_count == 0
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_minimum_valid_data_forge_eid(m_request_post, anvil):
             payload = ForgeSubmitPayload(
                 forge_eid="forge1234", payload=dict(field1="Some data")
             )
             anvil.forge_submit(payload=payload)
             assert m_request_post.call_count == 1
-            assert expected_data == m_request_post.call_args[0][1]
+            assert {"variable_values": expected_data} in m_request_post.call_args
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_invalid_wd_submission(m_request_post, anvil):
             with pytest.raises(ValidationError):
                 payload = dict(
@@ -384,7 +410,7 @@ def describe_api():
                 anvil.forge_submit(payload=payload)
                 assert m_request_post.call_count == 0
 
-        @mock.patch('python_anvil.api.GraphqlRequest.post')
+        @mock.patch('gql.Client.execute')
         def test_minimum_valid_data_submission(m_request_post, anvil):
             payload = ForgeSubmitPayload(
                 forge_eid="forge1234",
@@ -396,12 +422,14 @@ def describe_api():
             # We copy `expected_data` here as it can cause a race condition
             # in other tests that use it.
             _expected_data: MutableMapping[str, Any] = {
-                **expected_data,
-                "submissionEid": "sub1234",
-                "weldDataEid": "wd1234",
-                "payload": {"field1": "Updated data"},
+                "variable_values": {
+                    **expected_data,
+                    "submissionEid": "sub1234",
+                    "weldDataEid": "wd1234",
+                    "payload": {"field1": "Updated data"},
+                }
             }
 
             anvil.forge_submit(payload=payload)
             assert m_request_post.call_count == 1
-            assert _expected_data in m_request_post.call_args[0]
+            assert _expected_data in m_request_post.call_args

python_anvil/tests/test_cli.py

@@ -35,7 +35,7 @@ def describe_cli():
         @mock.patch("python_anvil.api.Anvil.query")
         def it_queries(query, runner, monkeypatch):
             set_key(monkeypatch)
-            query.return_value = {"data": {"currentUser": {"name": "Cameron"}}}
+            query.return_value = {"currentUser": {"name": "Cameron"}}
 
             res = runner.invoke(cli, ['current-user'])
             assert "{'name': 'Cameron'}" in res.output
@@ -46,7 +46,7 @@ def describe_cli():
         def it_handles_headers(query, runner, monkeypatch):
             set_key(monkeypatch)
             query.return_value = {
-                "response": {"data": {"currentUser": {"name": "Cameron"}}},
+                "response": {"currentUser": {"name": "Cameron"}},
                 "headers": {"Header-1": "val1", "Header-2": "val2"},
             }
 
@@ -71,3 +71,42 @@ def describe_cli():
                 )
                 generate_pdf.assert_called_once_with(in_data, debug=False)
                 m().write.assert_called_once_with("Some bytes")
+
+    def describe_gql_query():
+        @mock.patch("python_anvil.api.Anvil.query")
+        def it_works_query_only(query, runner, monkeypatch):
+            set_key(monkeypatch)
+
+            query.return_value = dict(
+                eid="abc123",
+                name="Some User",
+            )
+
+            query_str = """
+            query SomeQuery {
+                someQuery { eid name }
+            }
+            """
+
+            runner.invoke(cli, ['gql-query', '-q', query_str])
+            query.assert_called_once_with(query_str, variables=None, debug=False)
+
+        @mock.patch("python_anvil.api.Anvil.query")
+        def it_works_query_and_variables(query, runner, monkeypatch):
+            set_key(monkeypatch)
+
+            query.return_value = dict(
+                eid="abc123",
+                name="Some User",
+            )
+
+            query_str = """
+            query SomeQuery ($eid: String) {
+                someQuery(eid: $eid) { eid name }
+            }
+            """
+
+            variables = json.dumps(dict(eid="abc123"))
+
+            runner.invoke(cli, ['gql-query', '-q', query_str, '-v', variables])
+            query.assert_called_once_with(query_str, variables=variables, debug=False)

{python_anvil-2.0.0.dist-info → python_anvil-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-anvil
-Version: 2.0.0
+Version: 3.0.1
 Summary: Anvil API
 Home-page: https://www.useanvil.com/
 License: MIT
@@ -18,17 +18,15 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: click (>=8.0,<9.0)
+Requires-Dist: gql[requests] (==3.5.0b1)
 Requires-Dist: pydantic (>=1.8.2,<2.0.0)
 Requires-Dist: ratelimit (>=2.2.1,<3.0.0)
 Requires-Dist: requests (>=2.25.0,<3.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: urllib3 (<2)
 Project-URL: Documentation, https://github.com/anvilco/python-anvil
 Project-URL: Repository, https://github.com/anvilco/python-anvil
 Description-Content-Type: text/markdown
@@ -61,7 +59,7 @@ General API documentation: [Anvil API docs](https://www.useanvil.com/docs)
 
 ## Requirements
 
-* Python 3.6.2+
+* Python 3.7.2+
 
 ## Installation
 

{python_anvil-2.0.0.dist-info → python_anvil-3.0.1.dist-info}/RECORD

@@ -1,31 +1,30 @@
 python_anvil/__init__.py,sha256=hY54dJl0FjAPEVKv_dNJ9wrWy-YHocDHD7WPG-x3Pg4,223
-python_anvil/api.py,sha256=axTBN2STiGMDzedWLZEsWW5Lh7PV_autUkB8VJYpxTI,12234
+python_anvil/api.py,sha256=lyqBapTFLVQOX4L4ryCvpH84riQOfAcQ8Afw2XcyDdc,13709
 python_anvil/api_resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_anvil/api_resources/base.py,sha256=Y8Q1mM9RJ27SedmtNA0bzzQoXODpQuFeatY8d6DzWC4,941
 python_anvil/api_resources/mutations/__init__.py,sha256=9JOe1MiowInNzCJmuRLBTkVZcT-mOzETMoL5S_E_Y84,177
 python_anvil/api_resources/mutations/base.py,sha256=qYo_vwhNrFY-azvze_llQiz7P5KcuREjNjGPrleBbT4,588
-python_anvil/api_resources/mutations/create_etch_packet.py,sha256=uGEAiyEJ_htV6GQZzgehJYtuGIY6UeFu7VjxHu5N9RE,10235
-python_anvil/api_resources/mutations/forge_submit.py,sha256=Ir2w4-FtbLPhWJOwSx8ORzS7qedVMs32ErsSfhVY6XI,3639
+python_anvil/api_resources/mutations/create_etch_packet.py,sha256=3FHjzc0EPXJQBwMxLglkEkvbQCi_FWjl8DbMcbWJdOw,9271
+python_anvil/api_resources/mutations/forge_submit.py,sha256=i4EYPXVdZpYP3gmsiM3ltrmvsAF1Q11vlgn1Sn28PNM,3584
 python_anvil/api_resources/mutations/generate_etch_signing_url.py,sha256=O3uBgHmd5WStuHtn6I54ujFjSbQFbP_E7zE9BlGV-yg,737
 python_anvil/api_resources/mutations/helpers.py,sha256=-Us_rfqnXRR6aVwc6wBBwoXluppNkIchccAdvQINTnI,211
-python_anvil/api_resources/payload.py,sha256=n9I9X_01-IOqsISCYFFh0WYRnVP0MgtHaZuPnWJEaUY,9279
-python_anvil/api_resources/requests.py,sha256=x7kNIYo8lCvS0oVDeAJIsUTKgi4B0JYtQwUTVmVk7yA,4947
-python_anvil/cli.py,sha256=cfVjLC1GeFzzVLa8yNwZWAYHeTMjVQnjlcGDGHSe0DQ,10289
+python_anvil/api_resources/payload.py,sha256=F5WUlFZdgPrwEKbcDPoiEbGCuWGJ-DCZeRizKq6WFCY,9006
+python_anvil/api_resources/requests.py,sha256=X5YUV_DBBryWqhEkxXzJFphMx2HVqcUd1ZzJ7b9iHk0,5146
+python_anvil/cli.py,sha256=X6g5L41z5nszLIvOOQYTVdBrkQxweluqAzY2WKq3R0c,10337
+python_anvil/constants.py,sha256=MxuTbJf6PPa7_2P_SqyaXrqO0Nwo-8EwP6bA0FTvG7A,339
 python_anvil/exceptions.py,sha256=XhgeG6oGQ78_DZDrmsLGX7789ygQ78aIlpJZbhCfRhg,102
-python_anvil/http.py,sha256=ouaYAp0fXhl2McMZiZtUD3LOcH-GSBV1BqT8otw5sdw,4620
-python_anvil/multipart_helpers.py,sha256=vUcA-ul5TvzieVhIcrqU5H16-8OJtlEWbyZa2sf6pLo,4064
+python_anvil/http.py,sha256=eVmGji6x86r3M7NkHeeWkQ0aWTM-juUF4cUzdPQEcXY,6554
 python_anvil/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 python_anvil/tests/__init__.py,sha256=LURUPwwDqcFmVe1XvEzadPdXxro8RdEF-rTaMw-AfiI,34
 python_anvil/tests/conftest.py,sha256=Noz5CUwT-xh2CJNKsYyu_bUFaoMMKavOiAuhHzZeOp8,267
 python_anvil/tests/payloads.py,sha256=bn__agyTyRl6Lw0nZPRLvpjErt1mElDZQ5T2WteqcOU,2367
-python_anvil/tests/test_api.py,sha256=3IokYxw6kB_32OvrS3XCui-XKwYp-7AXNnem7W_tlgw,16904
-python_anvil/tests/test_cli.py,sha256=IBnlS8OEpDfznRUlLh4u92cyHbc7R3M3DrUA1wLfcIg,2644
+python_anvil/tests/test_api.py,sha256=aIoAVs3DGVRLDbmW27ZCzUtJr-HHaAyFpBaM3d3VrQw,17441
+python_anvil/tests/test_cli.py,sha256=Ghnqx2q0V0w-Y9aWGaMpi6_OTo8x7E7NaSkfjVLZixY,3845
 python_anvil/tests/test_http.py,sha256=4BLJ0A7HKWq-9_NKoUmHKiBwbNLasig6ppGMhYJIisQ,4908
-python_anvil/tests/test_multipart_helpers.py,sha256=nwq35mGaQhNef6uOFOkgIVYsMB6Lk9Rr9XrZ0l59oIU,1237
 python_anvil/tests/test_utils.py,sha256=VQ3u0WQd7Oa_aMRF-GibRKqAlo3Bf62tHH6auCBF5o4,1352
 python_anvil/utils.py,sha256=xKbrMV6RnPMz_5eEnD-N1uvUn9895yiUhjSIUUnh13w,1103
-python_anvil-2.0.0.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-python_anvil-2.0.0.dist-info/LICENSE.md,sha256=0Z9mdiVAIMBp50iEbXt4bDHqlnAwAfKbj9Yi2b6O8fo,1091
-python_anvil-2.0.0.dist-info/METADATA,sha256=bys085a_OZZpDN64hEdtyDFtYZyE8nnnWMCiowpgdu0,3476
-python_anvil-2.0.0.dist-info/entry_points.txt,sha256=nf_xgj2f9K2Zascpk2MtOP-CT2fmKc1xUDWnTdq4P_Y,46
-python_anvil-2.0.0.dist-info/RECORD,,
+python_anvil-3.0.1.dist-info/LICENSE.md,sha256=0Z9mdiVAIMBp50iEbXt4bDHqlnAwAfKbj9Yi2b6O8fo,1091
+python_anvil-3.0.1.dist-info/METADATA,sha256=cVLWTK41GBsU033ejHlDi2rartdu7Nv3eJ1Z5aBDSNA,3346
+python_anvil-3.0.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+python_anvil-3.0.1.dist-info/entry_points.txt,sha256=nf_xgj2f9K2Zascpk2MtOP-CT2fmKc1xUDWnTdq4P_Y,46
+python_anvil-3.0.1.dist-info/RECORD,,

{python_anvil-2.0.0.dist-info → python_anvil-3.0.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.4.0
+Generator: poetry-core 1.6.1
 Root-Is-Purelib: true
 Tag: py3-none-any

python_anvil/multipart_helpers.py

@@ -1,124 +0,0 @@
-import copy
-import json
-import mimetypes
-from io import BufferedIOBase
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
-from python_anvil.api_resources.mutations import BaseQuery
-
-
-FileLikeObject = Union[Path, BufferedIOBase]
-
-
-def get_extractable_files_from_payload(
-    variables: Any,
-    is_match: Callable,
-    cur_path: Optional[str] = None,
-    cur_files: Optional[List] = None,
-) -> Tuple[List[Tuple[str, FileLikeObject]], bool]:
-    """Process variables bound for a Graphql multipart request.
-
-    IMPORTANT: This will __overwrite__ the file-like objects to `None` due to
-    the expected request format in the spec.
-
-    Spec: https://github.com/jaydenseric/graphql-multipart-request-spec
-
-    :param variables:
-    :param is_match:
-    :param cur_path:
-    :param cur_files:
-    :return: List containing a tuple of (file path string, file path/buffer object)
-    :rtype: Tuple[List[Tuple[str, Union[Path, BufferedIOBase]], bool, List]
-    """
-
-    if cur_path is None:
-        cur_path = "variables"
-    if cur_files is None:
-        cur_files = []
-    if not variables:
-        return [], False
-
-    if is_match(variables):
-        cur_files.append((cur_path, copy.deepcopy(variables)))
-        return cur_files, True
-
-    if isinstance(variables, dict):
-        to_remove = []
-        for key in variables:
-            _, remove = get_extractable_files_from_payload(
-                variables[key],
-                is_match=is_match,
-                cur_path=f"{cur_path}.{key}",
-                cur_files=cur_files,
-            )
-            if remove:
-                to_remove.append(key)
-
-        for key in to_remove:
-            variables[key] = None
-
-    elif isinstance(variables, list):
-        to_remove = []
-        for idx, item in enumerate(variables):
-            _, remove = get_extractable_files_from_payload(
-                item,
-                is_match=is_match,
-                cur_path=f"{cur_path}.{idx}",
-                cur_files=cur_files,
-            )
-            if remove:
-                to_remove.append(idx)
-
-        for idx in to_remove:
-            variables[idx] = None
-
-    return cur_files, False
-
-
-def get_multipart_payload(mutation: BaseQuery):  # pylint: disable=too-many-locals
-    def is_match(item):
-        return isinstance(item, (BufferedIOBase, Path))
-
-    payload, to_upload = mutation.create_payload()
-    variables = payload.dict(by_alias=True, exclude_none=True)
-    multipart_map, _ = get_extractable_files_from_payload(variables, is_match=is_match)
-
-    operations = json.dumps(
-        {
-            "query": mutation.get_mutation(),
-            "variables": variables,
-        }
-    )
-
-    filemap = {}
-    for idx, filepath in enumerate(multipart_map):
-        filemap[idx] = [filepath[0]]
-
-    files = {
-        "operations": (None, operations),
-        "map": (None, json.dumps(filemap)),
-    }  # type: Dict[str, Union[Tuple[None, str], Tuple[Any, Any, Optional[str]]]]
-
-    for idx, file_or_path in enumerate(to_upload):
-        # `key` here is most likely going to be a list index (int), but
-        # `requests` will expect an actual string when it constructs the
-        # multipart request. We make sure this is a string here.
-        actual_key = str(idx)
-
-        # This is already a file-like object, pass it directly to `requests`.
-        if isinstance(file_or_path, Callable):  # type: ignore
-            # If you have a `ValueError` here, make sure your callable returns
-            # a tuple of the file and filename:
-            # Example: (open(file, "rb"), "file.pdf"))
-            file_part, name_part = file_or_path()
-        elif isinstance(file_or_path, Path):
-            file_part = open(file_or_path, "rb")  # pylint: disable=consider-using-with
-            name_part = file_or_path.parts[-1]
-        else:
-            raise AssertionError("File path or file-like object not given")
-
-        mimetype, _ = mimetypes.guess_type(file_part.name)
-        files[actual_key] = (name_part, file_part, mimetype)
-
-    return files

python_anvil/tests/test_multipart_helpers.py

@@ -1,38 +0,0 @@
-# pylint: disable=redefined-outer-name,unused-variable,expression-not-assigned,singleton-comparison
-
-from python_anvil.multipart_helpers import get_extractable_files_from_payload
-
-
-def describe_get_extractable_files_from_payload():
-    def test_it_works():
-        def is_match(x):
-            return isinstance(x, int)
-
-        variables = {
-            "one": [{"f1": "data", "f2": 1}],
-            "two": {"s2-1": "more data", "s2-2": "more more data", "s2-3": 2},
-            "three": "nothing here",
-            "four": 4,
-        }
-
-        paths, _ = get_extractable_files_from_payload(
-            variables, is_match, cur_path="variables"
-        )
-        assert len(paths) == 3
-        assert ("variables.one.0.f2", 1) in paths
-        assert ("variables.two.s2-3", 2) in paths
-        assert ("variables.four", 4) in paths
-
-    def test_handles_empty_things():
-        payload_expected_pairs = [
-            ({}, 0),
-            ([], 0),
-            ('', 0),
-            (' ', 1),
-        ]
-
-        for var_input, exp_len in payload_expected_pairs:
-            paths, _ = get_extractable_files_from_payload(
-                var_input, lambda x: x, cur_path="variables"
-            )
-            assert len(paths) == exp_len