hotglue-singer-sdk 1.0.2__py3-none-any.whl

hotglue_singer_sdk/helpers/_schema.py

@@ -0,0 +1,100 @@
+"""Provides an object model for JSON Schema."""
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Union
+
+from singer import Schema
+
+# These are keys defined in the JSON Schema spec that do not themselves contain
+# schemas (or lists of schemas)
+STANDARD_KEYS = [
+    "title",
+    "description",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "maxLength",
+    "minLength",
+    "format",
+    "type",
+    "required",
+    "enum",
+    # These are NOT simple keys (they can contain schemas themselves). We could
+    # consider adding extra handling to them.
+    "additionalProperties",
+    "anyOf",
+    "patternProperties",
+]
+
+
+@dataclass
+class SchemaPlus(Schema):
+    """Object model for JSON Schema.
+
+    Tap and Target authors may find this to be more convenient than
+    working directly with JSON Schema data structures.
+
+    This is based on, and overwrites
+    https://github.com/transferwise/pipelinewise-singer-python/blob/master/singer/schema.py.
+    This is because we wanted to expand it with extra STANDARD_KEYS.
+
+    """
+
+    type: Optional[Union[str, List[str]]] = None
+    properties: Optional[dict] = None
+    items: Optional[Any] = None
+    description: Optional[str] = None
+    minimum: Optional[float] = None
+    maximum: Optional[float] = None
+    exclusiveMinimum: Optional[float] = None
+    exclusiveMaximum: Optional[float] = None
+    multipleOf: Optional[float] = None
+    maxLength: Optional[int] = None
+    minLength: Optional[int] = None
+    anyOf: Optional[Any] = None
+    format: Optional[str] = None
+    additionalProperties: Optional[Any] = None
+    patternProperties: Optional[Any] = None
+    required: Optional[List[str]] = None
+    enum: Optional[List[Any]] = None
+    title: Optional[str] = None
+
+    def to_dict(self):
+        """Return the raw JSON Schema as a (possibly nested) dict."""
+        result = {}
+
+        if self.properties is not None:
+            result["properties"] = {k: v.to_dict() for k, v in self.properties.items()}
+
+        if self.items is not None:
+            result["items"] = self.items.to_dict()
+
+        for key in STANDARD_KEYS:
+            if self.__dict__.get(key) is not None:
+                result[key] = self.__dict__[key]
+
+        return result
+
+    @classmethod
+    def from_dict(cls, data, **schema_defaults):
+        """Initialize a Schema object based on the JSON Schema structure.
+
+        :param schema_defaults: The default values to the Schema constructor.
+        """
+        kwargs = schema_defaults.copy()
+        properties = data.get("properties")
+        items = data.get("items")
+
+        if properties is not None:
+            kwargs["properties"] = {
+                k: SchemaPlus.from_dict(v, **schema_defaults)
+                for k, v in properties.items()
+            }
+        if items is not None:
+            kwargs["items"] = SchemaPlus.from_dict(items, **schema_defaults)
+        for key in STANDARD_KEYS:
+            if key in data:
+                kwargs[key] = data[key]
+        return SchemaPlus(**kwargs)

hotglue_singer_sdk/helpers/_secrets.py

@@ -0,0 +1,41 @@
+"""Helpers function for secrets management."""
+
+COMMON_SECRET_KEYS = [
+    "db_password",
+    "password",
+    "access_key",
+    "private_key",
+    "client_id",
+    "client_secret",
+    "refresh_token",
+    "access_token",
+]
+COMMON_SECRET_KEY_SUFFIXES = ["access_key_id"]
+
+
+def is_common_secret_key(key_name: str) -> bool:
+    """Return true if the key_name value matches a known secret name or pattern."""
+    if key_name in COMMON_SECRET_KEYS:
+        return True
+    return any(
+        [
+            key_name.lower().endswith(key_suffix)
+            for key_suffix in COMMON_SECRET_KEY_SUFFIXES
+        ]
+    )
+
+
+class SecretString(str):
+    """For now, this class wraps a sensitive string to be identified as such later."""
+
+    def __init__(self, contents):
+        """Initialize secret string."""
+        self.contents = contents
+
+    def __repr__(self) -> str:
+        """Render secret contents."""
+        return str(self.contents.__repr__())
+
+    def __str__(self) -> str:
+        """Render secret contents."""
+        return str(self.contents.__str__())