looker-sdk 24.18.0__py3-none-any.whl → 24.20.0__py3-none-any.whl

looker_sdk/rtl/model.py

@@ -0,0 +1,230 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Looker Data Sciences, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Base model for all generated models
+"""
+
+import collections
+import datetime
+import enum
+import functools
+import keyword
+from typing import Any, Iterable, Optional, Sequence, TypeVar, cast
+
+import cattr
+
+from looker_sdk.rtl import hooks
+
+try:
+    from typing import ForwardRef  # type: ignore
+except ImportError:
+    from typing import _ForwardRef as ForwardRef  # type: ignore
+
+
+EXPLICIT_NULL = cast(Any, "EXPLICIT_NULL")  # type:ignore
+
+
+class Model:
+    """Base model for all generated models."""
+
+    def _get_converter(self):
+        if not hasattr(self, "_converter"):
+            converter = cattr.Converter()
+            converter.register_unstructure_hook(
+                datetime.datetime, hooks.datetime_unstructure_hook
+            )
+            uh = functools.partial(hooks.unstructure_hook, converter)
+            converter.register_unstructure_hook(Model, uh)  # type: ignore
+            self._converter = converter
+        return self._converter
+
+    def _key_to_attr(self, key):
+        """Appends the trailing _ to python reserved words."""
+        if key[-1] == "_":
+            raise KeyError(key)
+        if key in keyword.kwlist:
+            key = f"{key}_"
+        return key
+
+    def __getitem__(self, key):
+        key = self._key_to_attr(key)
+        try:
+            ret = getattr(self, key)
+        except AttributeError:
+            raise KeyError(key)
+
+        if isinstance(ret, enum.Enum):
+            ret = ret.value
+        return ret
+
+    def __setitem__(self, key, value):
+        key = self._key_to_attr(key)
+        if not hasattr(self, key):
+            raise AttributeError(
+                f"'{self.__class__.__name__}' object has no attribute '{key}'"
+            )
+        annotation = self.__annotations__[key]
+        if isinstance(annotation, ForwardRef):
+            actual_type = eval(
+                annotation.__forward_arg__, self.__global_context, locals()
+            )
+            if isinstance(actual_type, enum.EnumMeta):
+
+                # untyped because mypy really doesn't like this enum internals stuff
+                def err(val):
+                    valid = []
+                    for v in actual_type.__members__.values():
+                        if v.value != "invalid_api_enum_value":
+                            valid.append(v.value)
+                    return (
+                        f"Invalid value '{val}' for "  # type: ignore
+                        f"'{self.__class__.__name__}.{key}'. Valid values are "
+                        f"{valid}"  # type: ignore
+                    )
+
+                if isinstance(value, actual_type):
+                    raise ValueError(err(value))
+                enum_member = actual_type(value)
+                if enum_member.value == "invalid_api_enum_value":
+                    raise ValueError(err(value))
+                value = enum_member
+            elif issubclass(actual_type, Model):
+                value = self._get_converter().structure(value, actual_type)
+
+        return setattr(self, key, value)
+
+    def __delitem__(self, key):
+        self[key]  # validates key
+        setattr(self, self._key_to_attr(key), None)
+
+    def __iter__(self):
+        return iter(self._get_converter().unstructure(self))
+
+    def __len__(self):
+        return len(self._get_converter().unstructure(self))
+
+    def __contains__(self, key):
+        return key in self._get_converter().unstructure(self)
+
+    def keys(self):
+        return self._get_converter().unstructure(self).keys()
+
+    def items(self):
+        return self._get_converter().unstructure(self).items()
+
+    def values(self):
+        return self._get_converter().unstructure(self).values()
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def pop(self, key, default=None):
+        ret = self.get(key, default)
+        if key in self:
+            del self[key]
+        return ret
+
+    def popitem(self):
+        raise NotImplementedError()
+
+    def clear(self):
+        raise NotImplementedError()
+
+    def update(self, iterable=None, **kwargs):
+        if iterable:
+            has_keys = getattr(iterable, "keys", None)
+            if callable(has_keys):
+                for k in iterable:
+                    self[k] = iterable[k]
+            else:
+                for k, v in iterable:
+                    self[k] = v
+        for k in kwargs:
+            self[k] = kwargs[k]
+
+    def setdefault(self, key, default=None):
+        if key not in self:
+            self[key] = default
+        return self[key]
+
+    def copy(self):
+        raise NotImplementedError()
+
+
+def safe_enum__new__(cls, value):
+    """Handle out-of-spec enum values returned by API.
+
+    This is achieved by overriding the __new__ method to return
+    `invalid_api_enum_value` (defined on each subclass) when an
+    unexpected value for the enum is returned by the API.
+    """
+    if not isinstance(value, (str, int, bool)):
+        return super().__new__(cls, value)
+    else:
+        vals = {v.value: v for v in cls.__members__.values()}
+        return vals.get(value, cls.invalid_api_enum_value)
+
+
+T = TypeVar("T")
+
+
+class DelimSequence(collections.UserList, Sequence[T]):
+    def __init__(
+        self,
+        data: Optional[Sequence[T]] = None,
+        prefix: str = "",
+        suffix: str = "",
+        separator: str = ",",
+    ):
+        self.prefix = prefix
+        self.suffix = suffix
+        self.separator = separator
+
+        super().__init__(data)
+
+    def append(self, elem: T):
+        super().append(elem)
+
+    def extend(self, iterable: Iterable[T]):
+        super().extend(iterable)
+
+    def insert(self, i: int, elem: T):
+        super().insert(i, elem)
+
+    def remove(self, elem: T):
+        super().remove(elem)
+
+    def index(self, x: T, *args):
+        super().index(x, *args)  # type: ignore
+
+    def count(self, elem: T):
+        super().count(elem)
+
+    def __str__(self):
+        return (
+            f"{self.prefix}"
+            f"{self.separator.join(str(d) for d in self.data)}"
+            f"{self.suffix}"
+        )

looker_sdk/rtl/requests_transport.py

@@ -0,0 +1,110 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Looker Data Sciences, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Transport implementation using requests package.
+"""
+
+import logging
+from typing import cast, Callable, Dict, MutableMapping, Optional
+
+import requests
+
+from looker_sdk.rtl import transport
+
+
+class RequestsTransport(transport.Transport):
+    """RequestsTransport implementation of Transport."""
+
+    def __init__(
+        self, settings: transport.PTransportSettings, session: requests.Session
+    ):
+        self.settings = settings
+        headers: Dict[str, str] = {transport.LOOKER_API_ID: settings.agent_tag}
+        if settings.headers:
+            headers.update(settings.headers)
+        session.headers.update(headers)
+        session.verify = settings.verify_ssl
+        self.session = session
+        self.logger = logging.getLogger(__name__)
+
+    @classmethod
+    def configure(cls, settings: transport.PTransportSettings) -> transport.Transport:
+        return cls(settings, requests.Session())
+
+    def request(
+        self,
+        method: transport.HttpMethod,
+        path: str,
+        query_params: Optional[MutableMapping[str, str]] = None,
+        body: Optional[bytes] = None,
+        authenticator: transport.TAuthenticator = None,
+        transport_options: Optional[transport.TransportOptions] = None,
+    ) -> transport.Response:
+
+        headers = {}
+        timeout = self.settings.timeout
+        if authenticator:
+            headers.update(authenticator(transport_options or {}))
+        if transport_options:
+            if transport_options.get("headers"):
+                headers.update(transport_options["headers"])
+            if transport_options.get("timeout"):
+                timeout = transport_options["timeout"]
+        self.logger.info("%s(%s)", method.name, path)
+        try:
+            resp = self.session.request(
+                method.name,
+                path,
+                auth=NullAuth(),
+                params=query_params,
+                data=body,
+                headers=headers,
+                timeout=timeout,
+            )
+        except IOError as exc:
+            ret = transport.Response(
+                False,
+                bytes(str(exc), encoding="utf-8"),
+                transport.ResponseMode.STRING,
+            )
+        else:
+            ret = transport.Response(
+                resp.ok,
+                resp.content,
+                transport.response_mode(resp.headers.get("content-type")),
+            )
+            encoding = cast(
+                Optional[str], requests.utils.get_encoding_from_headers(resp.headers)
+            )
+            if encoding:
+                ret.encoding = encoding
+
+        return ret
+
+
+class NullAuth(requests.auth.AuthBase):
+    """A custom auth class which ensures requests does not override authorization
+    headers with netrc file credentials if present.
+    """
+
+    def __call__(self, r):
+        return r

looker_sdk/rtl/serialize.py

@@ -0,0 +1,120 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Looker Data Sciences, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Deserialize API response into models
+"""
+import datetime
+import enum
+import functools
+import json
+import keyword
+import sys
+from typing import (
+    Callable,
+    MutableMapping,
+    Sequence,
+    Type,
+    Union,
+)
+
+import cattr
+
+from looker_sdk.rtl import model, hooks
+
+
+class DeserializeError(Exception):
+    """Improperly formatted data to deserialize."""
+
+
+TModelOrSequence = Union[
+    MutableMapping[str, str],
+    Sequence[int],
+    Sequence[str],
+    model.Model,
+    Sequence[model.Model],
+]
+TDeserializeReturn = TModelOrSequence
+TStructure = Union[Type[Sequence[int]], Type[Sequence[str]], Type[TDeserializeReturn]]
+TDeserialize = Callable[[str, TStructure], TDeserializeReturn]
+TSerialize = Callable[[TModelOrSequence], bytes]
+
+
+def deserialize(
+    *, data: str, structure: TStructure, converter: cattr.Converter
+) -> TDeserializeReturn:
+    """Translate API data into models."""
+    try:
+        data = json.loads(data)
+    except json.JSONDecodeError as ex:
+        raise DeserializeError(f"Bad json {ex}")
+    try:
+        response: TDeserializeReturn = converter.structure(  # type: ignore
+            data, structure
+        )
+    except (TypeError, AttributeError) as ex:
+        raise DeserializeError(f"Bad data {ex}")
+    return response
+
+
+def serialize(*, api_model: TModelOrSequence, converter: cattr.Converter) -> bytes:
+    """Translate api_model into formdata encoded json bytes"""
+    data = converter.unstructure(api_model)  # type: ignore
+    return json.dumps(data).encode("utf-8")  # type: ignore
+
+
+def forward_ref_structure_hook(context, converter, data, forward_ref):
+    """Applied to ForwardRef model and enum annotations
+
+    - Map reserved words in json keys to approriate (safe) names in model.
+    - handle ForwardRef types until github.com/Tinche/cattrs/pull/42/ is fixed
+       Note: this is the reason we need a "context" param and have to use a
+       partial func to register the hook. Once the issue is resolved we can
+       remove "context" and the partial.
+    """
+    data = hooks.tr_data_keys(data)
+    actual_type = eval(forward_ref.__forward_arg__, context, locals())
+    if issubclass(actual_type, enum.Enum):
+        instance = converter.structure(data, actual_type)
+    elif issubclass(actual_type, model.Model):
+        # cannot use converter.structure - recursion error
+        instance = converter.structure_attrs_fromdict(data, actual_type)
+    else:
+        raise DeserializeError(f"Unknown type to deserialize: {actual_type}")
+    return instance
+
+
+def translate_keys_structure_hook(converter, data, model_type):
+    """Applied only to models.Model"""
+    new_data = hooks.tr_data_keys(data)
+    ret = converter.structure_attrs_fromdict(new_data, model_type)
+    return ret
+
+converter40 = cattr.Converter()
+deserialize40 = functools.partial(deserialize, converter=converter40)
+serialize40 = functools.partial(serialize, converter=converter40)
+
+converter40.register_structure_hook(datetime.datetime, hooks.datetime_structure_hook)
+unstructure_hook40 = functools.partial(hooks.unstructure_hook, converter40)  # type: ignore
+converter40.register_unstructure_hook(model.Model, unstructure_hook40)  # type: ignore
+converter40.register_unstructure_hook(
+    datetime.datetime, hooks.datetime_unstructure_hook  # type: ignore
+)

looker_sdk/rtl/transport.py

@@ -0,0 +1,137 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Looker Data Sciences, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Types and abstract base class for transport implementations.
+"""
+import abc
+import enum
+import re
+import sys
+from typing import Callable, Dict, MutableMapping, Optional
+
+import attr
+
+from looker_sdk import error
+from looker_sdk.rtl import constants
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol, TypedDict
+else:
+    from typing_extensions import Protocol, TypedDict
+
+
+AGENT_PREFIX = "PY SDK"
+LOOKER_API_ID = "x-looker-appid"
+
+
+class HttpMethod(enum.Enum):
+    """Supported HTTP verbs."""
+
+    GET = 1
+    POST = 2
+    PUT = 3
+    DELETE = 4
+    PATCH = 5
+    TRACE = 6
+    HEAD = 7
+
+
+class PTransportSettings(Protocol):
+    base_url: str
+    verify_ssl: bool
+    timeout: int
+    agent_tag: str
+    headers: Optional[MutableMapping[str, str]]
+
+    def is_configured(self):
+        if not self.base_url:
+            raise error.SDKError("Missing required configuration value: base_url")
+
+
+class TransportOptions(TypedDict, total=False):
+    """Dictionary of available per-request transport options
+
+    # make me() call with 5 minute timeout and send a special header
+    e.g. sdk.me(transport_options={"timeout": 60 * 5, headers: {"foo": "bar"}})
+    """
+
+    timeout: int
+    headers: MutableMapping[str, str]
+
+
+TAuthenticator = Optional[Callable[[TransportOptions], Dict[str, str]]]
+
+
+class ResponseMode(enum.Enum):
+    """ResponseMode for an HTTP request - either binary or "string" """
+
+    BINARY = 1
+    STRING = 2
+    UNKNOWN = 3
+
+
+@attr.s(auto_attribs=True)
+class Response:
+    """Success Response object."""
+
+    ok: bool
+    value: bytes
+    response_mode: ResponseMode
+    encoding: str = "utf-8"
+
+
+_STRING_MODE = re.compile(constants.RESPONSE_STRING_MODE, re.IGNORECASE)
+_BINARY_MODE = re.compile(constants.RESPONSE_BINARY_MODE, re.IGNORECASE)
+
+
+def response_mode(content_type: Optional[str] = None) -> ResponseMode:
+    """Determine ResponseMode from http Content-Type header"""
+    response = ResponseMode.UNKNOWN
+    if not content_type:
+        return response
+
+    if _STRING_MODE.search(content_type):
+        response = ResponseMode.STRING
+    elif _BINARY_MODE.search(content_type):
+        response = ResponseMode.BINARY
+    return response
+
+
+class Transport(abc.ABC):
+    """Transport base class."""
+
+    @classmethod
+    @abc.abstractmethod
+    def configure(cls, settings: PTransportSettings) -> "Transport":
+        """Configure and return an instance of Transport"""
+
+    @abc.abstractmethod
+    def request(
+        self,
+        method: HttpMethod,
+        path: str,
+        query_params: Optional[MutableMapping[str, str]] = None,
+        body: Optional[bytes] = None,
+        authenticator: TAuthenticator = None,
+        transport_options: Optional[TransportOptions] = None,
+    ) -> Response:
+        """Send API request."""

looker_sdk/sdk/api40/__init__.py

@@ -0,0 +1 @@
+# Generated file.