datadog_api_client 1.8.0 → 1.9.0

data/.generator/src/generator/__main__.py

@@ -1,3 +1,3 @@
 from .cli import cli
 
-cli()
+cli()

data/.generator/src/generator/cli.py

@@ -1,20 +1,21 @@
-import json
 import pathlib
 
 import click
-from jinja2 import Environment, FileSystemLoader, Template
+from jinja2 import Environment, FileSystemLoader
 
 from . import openapi
 from . import formatter
 
+GEM_NAME = "datadog_api_client"
+
+MODULE_NAME = "DatadogAPIClient"
+
 
 @click.command()
 @click.option(
     "-i",
     "--input",
-    type=click.Path(
-        exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path
-    ),
+    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path),
 )
 @click.option(
     "-o",
@@ -28,12 +29,8 @@ def cli(input, output):
     spec = openapi.load(input)
 
     version = input.parent.name
-    with (input.parent.parent.parent / "config" / f"{version}.json").open() as fp:
-        config = json.load(fp)
 
-    env = Environment(
-        loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates"))
-    )
+    env = Environment(loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates")))
 
     env.filters["accept_headers"] = openapi.accept_headers
     env.filters["attribute_name"] = formatter.attribute_name
@@ -46,14 +43,20 @@ def cli(input, output):
     env.filters["parameters"] = openapi.parameters
     env.filters["return_type"] = openapi.return_type
     env.filters["snake_case"] = formatter.snake_case
+    env.filters["attribute_path"] = formatter.attribute_path
 
-    env.globals["config"] = config
+    env.globals["gem_name"] = GEM_NAME
+    env.globals["module_name"] = MODULE_NAME
     env.globals["enumerate"] = enumerate
     env.globals["version"] = version
     env.globals["openapi"] = spec
     env.globals["get_name"] = openapi.get_name
+    env.globals["type_to_ruby"] = openapi.type_to_ruby
     env.globals["get_type_for_attribute"] = openapi.get_type_for_attribute
     env.globals["get_type_for_parameter"] = openapi.get_type_for_parameter
+    env.globals["get_default"] = openapi.get_default
+    env.globals["get_container"] = openapi.get_container
+    env.globals["get_type_at_path"] = openapi.get_type_at_path
 
     api_j2 = env.get_template("api.j2")
     model_j2 = env.get_template("model.j2")
@@ -69,12 +72,12 @@ def cli(input, output):
     apis = openapi.apis(spec)
     models = openapi.models(spec)
 
-    package = output / config["gemNameInExamples"] / f"{version}.rb"
+    package = output / GEM_NAME / f"{version}.rb"
     package.parent.mkdir(parents=True, exist_ok=True)
     with package.open("w") as fp:
         fp.write(package_j2.render(apis=apis, models=models))
 
-    gem_path = output / config["gemName"]
+    gem_path = output / GEM_NAME / version
     gem_path.mkdir(parents=True, exist_ok=True)
 
     for name, template in extra_files.items():

data/.generator/src/generator/formatter.py

@@ -1,4 +1,6 @@
 """Data formatter."""
+import pathlib
+import json
 import re
 import warnings
 from functools import singledispatch
@@ -47,6 +49,9 @@ KEYWORDS = {
     "yield",
 }
 
+with (pathlib.Path(__file__).parent / "replacement.json").open() as f:
+    EDGE_CASES = json.load(f)
+
 PATTERN_DOUBLE_UNDERSCORE = re.compile(r"__+")
 PATTERN_LEADING_ALPHA = re.compile(r"(.)([A-Z][a-z]+)")
 PATTERN_FOLLOWING_ALPHA = re.compile(r"([a-z0-9])([A-Z])")
@@ -54,6 +59,8 @@ PATTERN_WHITESPACE = re.compile(r"\W")
 
 
 def snake_case(value):
+    for token, replacement in EDGE_CASES.items():
+        value = value.replace(token, replacement)
     s1 = PATTERN_LEADING_ALPHA.sub(r"\1_\2", value)
     s1 = PATTERN_FOLLOWING_ALPHA.sub(r"\1_\2", s1).lower()
     s1 = PATTERN_WHITESPACE.sub("_", s1)
@@ -85,6 +92,7 @@ def given_variables(context):
     """Return a list of variables using in given steps."""
     return {key for values in context.get("_given", {}).values() for key in values}
 
+
 def escape_reserved_keyword(word):
     """
     Escape reserved language keywords like openapi generator does it
@@ -102,17 +110,29 @@ def attribute_name(attribute):
 
 def format_value(value, quotes="'"):
     if isinstance(value, str):
-        return f'{quotes}{value}{quotes}'
+        return f"{quotes}{value}{quotes}"
     elif isinstance(value, bool):
         return "true" if value else "false"
     return value
 
 
 def format_parameters(kwargs, spec, replace_values=None, has_body=False):
+    parameters_spec = {p["name"]: p for p in spec.get("parameters", [])}
+    if "requestBody" in spec and "multipart/form-data" in spec["requestBody"]["content"]:
+        parent = spec["requestBody"]["content"]["multipart/form-data"]["schema"]
+        for name, schema in parent["properties"].items():
+            parameters_spec[name] = {
+                "in": "form",
+                "schema": schema,
+                "name": name,
+                "description": schema.get("description"),
+                "required": name in parent.get("required", []),
+            }
+
     parameters = ""
     optional_spec = {}
     opts = {}
-    for p in spec.get("parameters", []):
+    for p in parameters_spec.values():
         required = p.get("required", False)
         k = snake_case(p["name"])
         if required:
@@ -126,6 +146,14 @@ def format_parameters(kwargs, spec, replace_values=None, has_body=False):
         else:
             optional_spec[k] = p
 
+    if has_body:
+        body_is_required = spec.get("requestBody", {"required": None}).get("required", False)
+        if not body_is_required:
+            opts["body"] = "body"
+            parameters += "opts"
+        else:
+            parameters += "body, "
+
     if optional_spec:
         for k, v in kwargs.items():
             k = snake_case(k)
@@ -136,7 +164,7 @@ def format_parameters(kwargs, spec, replace_values=None, has_body=False):
             )
             opts[escape_reserved_keyword(k)] = value
 
-        if opts:
+        if opts and "opts" not in parameters:
             parameters += "opts"
 
     return parameters, opts
@@ -151,6 +179,33 @@ def get_name(schema):
     return name
 
 
+def _format_oneof(data, schema, name_prefix=None, replace_values=None):
+    parameters = ""
+    matched = 0
+    for sub_schema in schema["oneOf"]:
+        try:
+            formatted = format_data_with_schema(
+                data,
+                sub_schema,
+                name_prefix=name_prefix,
+                replace_values=replace_values,
+            )
+            if matched == 0:
+                # NOTE we do not support mixed schemas with oneOf
+                # parameters += formatted
+                parameters = formatted
+            matched += 1
+        except (KeyError, ValueError):
+            pass
+
+    if matched == 0:
+        raise ValueError(f"[{matched}] {data} is not valid for schema")
+    elif matched > 1:
+        warnings.warn(f"[{matched}] {data} is not valid for schema")
+
+    return parameters
+
+
 @singledispatch
 def format_data_with_schema(
     data,
@@ -165,7 +220,6 @@ def format_data_with_schema(
         raise ValueError(f"{data} is not valid enum value {schema['enum']}")
 
     if replace_values and data in replace_values:
-        warnings.warn(f"implement '{replace_values[data]}' with value {data}")
         parameters = replace_values[data]
         if schema.get("type") == "integer":
             parameters = f"{parameters}.to_i"
@@ -177,16 +231,24 @@ def format_data_with_schema(
         if schema.get("nullable") and data is None:
             return "nil"
         else:
-            formatter = {
-                "number": str,
-                "integer": str,
-                "boolean": lambda x: "true" if x else "false",
-                "string": repr,
-                None: repr,
-            }[schema.get("type")]
+            if "oneOf" in schema:
+                name = None
+                parameters = _format_oneof(data, schema, name_prefix=name_prefix, replace_values=replace_values)
+            else:
+
+                def open_file(x):
+                    return f"File.open({repr(x)}, 'r')"
 
-            # TODO format date and datetime
-            parameters = formatter(data)
+                formatter = {
+                    "number": str,
+                    "integer": str,
+                    "boolean": lambda x: "true" if x else "false",
+                    "string": open_file if schema.get("format") == "binary" else repr,
+                    None: repr,
+                }[schema.get("type")]
+
+                # TODO format date and datetime
+                parameters = formatter(data)
 
     if "enum" in schema and name:
         return f"{name_prefix}{name}::{parameters.upper()}"
@@ -246,7 +308,7 @@ def format_data_with_schema_dict(
             )
             parameters += f"{escape_reserved_keyword(snake_case(k))}: {value},\n"
 
-    if "additionalProperties" in schema:
+    if schema.get("additionalProperties"):
         for k, v in data.items():
             value = format_data_with_schema(
                 v,
@@ -257,37 +319,23 @@ def format_data_with_schema_dict(
             parameters += f"{k}: {value}, "
 
     if not name and "oneOf" not in schema:
-        if default_name:
+        if default_name and not schema.get("additionalProperties") and schema.get("properties"):
             name = default_name
         else:
             name = "dict"
             warnings.warn(f"Unnamed schema {schema} for {data}")
 
     if "oneOf" in schema:
-        matched = 0
-        for sub_schema in schema["oneOf"]:
-            try:
-                formatted = format_data_with_schema(
-                    data,
-                    sub_schema,
-                    name_prefix=name_prefix,
-                    replace_values=replace_values,
-                )
-                if matched == 0:
-                    # NOTE we do not support mixed schemas with oneOf
-                    # parameters += formatted
-                    parameters = formatted
-                    name = None
-                matched += 1
-            except (KeyError, ValueError) as e:
-                print(f"{e}")
-
-        if matched == 0:
-            raise ValueError(f"[{matched}] {data} is not valid for schema {name}")
-        elif matched > 1:
-            warnings.warn(f"[{matched}] {data} is not valid for schema {name}")
-
-    if name:
+        name = None
+        parameters = _format_oneof(data, schema, name_prefix=name_prefix, replace_values=replace_values)
+
+    if name == "dict":
+        return f"{{\n{parameters}}}"
+    elif name:
         return f"{name_prefix}{name}.new({{\n{parameters}}})"
 
     return parameters
+
+
+def attribute_path(attribute):
+    return ".".join(attribute_name(a) for a in attribute.split("."))

data/.generator/src/generator/openapi.py

@@ -1,4 +1,8 @@
+import hashlib
+import json
 import pathlib
+import random
+import uuid
 import yaml
 import warnings
 from jsonref import JsonRef
@@ -28,10 +32,7 @@ def type_to_ruby(schema, alternative_name=None):
     if name:
         if "enum" in schema:
             return name
-        if (
-            not schema.get("additionalProperties")
-            and schema.get("type", "object") == "object"
-        ):
+        if not schema.get("additionalProperties") and schema.get("type", "object") == "object":
             return name
 
     type_ = schema.get("type")
@@ -42,9 +43,7 @@ def type_to_ruby(schema, alternative_name=None):
             type_ = "object"
         else:
             type_ = "object"
-            warnings.warn(
-                f"Unknown type for schema: {schema} ({name or alternative_name})"
-            )
+            warnings.warn(f"Unknown type for schema: {schema} ({name or alternative_name})")
 
     if type_ == "integer":
         return "Integer"
@@ -63,18 +62,11 @@ def type_to_ruby(schema, alternative_name=None):
         return "Array<{}>".format(type_to_ruby(schema["items"]))
     elif type_ == "object":
         if "additionalProperties" in schema:
-            return "Hash<String, {}>".format(
-                type_to_ruby(schema["additionalProperties"])
-            )
+            return "Hash<String, {}>".format(type_to_ruby(schema["additionalProperties"]))
         return (
             alternative_name
             if alternative_name
-            and (
-                "properties" in schema
-                or "oneOf" in schema
-                or "anyOf" in schema
-                or "allOf" in schema
-            )
+            and ("properties" in schema or "oneOf" in schema or "anyOf" in schema or "allOf" in schema)
             else "Object"
         )
     elif type_ == "null":
@@ -86,9 +78,7 @@ def type_to_ruby(schema, alternative_name=None):
 def get_type_for_attribute(schema, attribute, current_name=None):
     """Return Ruby type name for the attribute."""
     child_schema = schema.get("properties", {}).get(attribute)
-    alternative_name = (
-        current_name + formatter.camel_case(attribute) if current_name else None
-    )
+    alternative_name = current_name + formatter.camel_case(attribute) if current_name else None
     return type_to_ruby(child_schema, alternative_name=alternative_name)
 
 
@@ -123,9 +113,7 @@ def child_models(schema, alternative_name=None, seen=None):
     if "items" in schema:
         yield from child_models(
             schema["items"],
-            alternative_name=alternative_name + "Item"
-            if alternative_name is not None
-            else None,
+            alternative_name=alternative_name + "Item" if alternative_name is not None else None,
             seen=seen,
         )
 
@@ -147,9 +135,7 @@ def child_models(schema, alternative_name=None, seen=None):
             yield name, schema
 
         for key, child in schema.get("properties", {}).items():
-            yield from child_models(
-                child, alternative_name=name + formatter.camel_case(key), seen=seen
-            )
+            yield from child_models(child, alternative_name=name + formatter.camel_case(key), seen=seen)
 
     if "enum" in schema:
         if name is None:
@@ -280,7 +266,7 @@ def collection_format(parameter):
         ("form", True): "multi",
         # TODO add more cases from https://swagger.io/specification/#parameter-style
     }
-    if (schema.get("type") == "array" or "items" in schema):
+    if schema.get("type") == "array" or "items" in schema:
         in_ = parameter.get("in", "query")
         style = parameter.get("style", in_to_style[in_])
         explode = parameter.get("explode", True if style == "form" else False)
@@ -296,9 +282,7 @@ def format_server(server, server_variables=None, path=""):
     for variable in server["variables"]:
         if server_variables and variable in server_variables:
             continue
-        url = url.replace(
-            "{" + variable + "}", server["variables"][variable]["default"]
-        )
+        url = url.replace("{" + variable + "}", server["variables"][variable]["default"])
     return urlparse(url)
 
 
@@ -312,9 +296,7 @@ def server_url_and_method(spec, operation_id, server_index=0, server_variables=N
                 else:
                     server = spec["servers"][server_index]
                 return (
-                    format_server(
-                        server, server_variables=server_variables, path=path
-                    ).geturl(),
+                    format_server(server, server_variables=server_variables, path=path).geturl(),
                     method,
                 )
 
@@ -324,13 +306,9 @@ def server_url_and_method(spec, operation_id, server_index=0, server_variables=N
 def response_code_and_accept_type(operation, status_code=None):
     for response in operation["responses"]:
         if status_code is None:
-            return int(response), next(
-                iter(operation["responses"][response].get("content", {None: None}))
-            )
+            return int(response), next(iter(operation["responses"][response].get("content", {None: None})))
         if response == str(status_code):
-            return status_code, next(
-                iter(operation["responses"][response].get("content", {None: None}))
-            )
+            return status_code, next(iter(operation["responses"][response].get("content", {None: None})))
     return status_code, None
 
 
@@ -341,7 +319,169 @@ def request_content_type(operation, status_code=None):
 def response(operation, status_code=None):
     for response in operation["responses"]:
         if status_code is None or response == str(status_code):
-            return list(operation["responses"][response]["content"].values())[0][
-                "schema"
-            ]
+            return list(operation["responses"][response]["content"].values())[0]["schema"]
     return None
+
+
+def generate_value(schema, use_random=False, prefix=None):
+    spec = schema.spec
+    if not use_random:
+        if "example" in spec:
+            return spec["example"]
+        if "default" in spec:
+            return spec["default"]
+
+    if spec["type"] == "string":
+        if use_random:
+            return str(
+                uuid.UUID(
+                    bytes=hashlib.sha256(
+                        str(prefix or schema.keys).encode("utf-8"),
+                    ).digest()[:16]
+                )
+            )
+        return "string"
+    elif spec["type"] == "integer":
+        return random.randint(0, 32000) if use_random else len(str(prefix or schema.keys))
+    elif spec["type"] == "number":
+        return random.random() if use_random else 1.0 / len(str(prefix or schema.keys))
+    elif spec["type"] == "boolean":
+        return True
+    elif spec["type"] == "array":
+        return [generate_value(schema[0], use_random=use_random)]
+    elif spec["type"] == "object":
+        return {key: generate_value(schema[key], use_random=use_random) for key in spec["properties"]}
+    else:
+        raise TypeError(f"Unknown type: {spec['type']}")
+
+
+class Schema:
+    def __init__(self, spec, value=None, keys=None):
+        self.spec = spec
+        self.value = value if value is not None else generate_value
+        self.keys = keys or tuple()
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        type_ = self.spec.get("type", "object")
+        if type_ == "object":
+            try:
+                return self.__class__(
+                    self.spec["properties"][key],
+                    value=self.value,
+                    keys=self.keys + (key,),
+                )
+            except KeyError:
+                if "oneOf" in self.spec:
+                    for schema in self.spec["oneOf"]:
+                        if schema.get("type", "object") == "object":
+                            try:
+                                return self.__class__(
+                                    schema["properties"][key],
+                                    value=self.value,
+                                    keys=self.keys + (key,),
+                                )
+                            except KeyError:
+                                pass
+            raise KeyError(f"{key} not found in {self.spec.get('properties', {}).keys()}: {self.spec}")
+        if type_ == "array":
+            return self.__class__(self.spec["items"], value=self.value, keys=self.keys + (key,))
+
+        raise KeyError(f"{key} not found in {self.spec}")
+
+    def __repr__(self):
+        value = self.value(self)
+        if isinstance(value, (dict, list)):
+            return json.dumps(value, indent=2)
+        return str(value)
+
+
+class Operation:
+    def __init__(self, name, spec, method, path):
+        self.name = name
+        self.spec = spec
+        self.method = method
+        self.path = path
+
+    def server_url_and_method(self, spec, server_index=0, server_variables=None):
+        def format_server(server, path):
+            url = server["url"] + path
+            # replace potential path variables
+            for variable, value in server_variables.items():
+                url = url.replace("{" + variable + "}", value)
+            # replace server variables if they were not replace before
+            for variable in server["variables"]:
+                if variable in server_variables:
+                    continue
+                url = url.replace("{" + variable + "}", server["variables"][variable]["default"])
+            return url
+
+        server_variables = server_variables or {}
+        if "servers" in self.spec:
+            server = self.spec["servers"][server_index]
+        else:
+            server = spec["servers"][server_index]
+        return format_server(server, self.path), self.method
+
+    def response_code_and_accept_type(self):
+        for response in self.spec["responses"]:
+            return int(response), next(iter(self.spec["responses"][response].get("content", {None: None})))
+        return None, None
+
+    def request_content_type(self):
+        return next(iter(self.spec.get("requestBody", {}).get("content", {None: None})))
+
+    def response(self):
+        for response in self.spec["responses"]:
+            return Schema(next(iter((self.spec["responses"][response]["content"].values())))["schema"])
+
+    def request(self):
+        return Schema(next(iter(self.spec["requestBody"]["content"].values()))["schema"])
+
+
+def get_default(operation, attribute_path):
+    attrs = attribute_path.split(".")
+    for name, parameter in parameters(operation):
+        if name == attrs[0]:
+            break
+    if name == attribute_path:
+        # We found a top level attribute matching the full path, let's use the default
+        return parameter["schema"]["default"]
+
+    if name == "body":
+        parameter = next(iter(parameter["content"].values()))["schema"]
+    for attr in attrs[1:]:
+        parameter = parameter["properties"][attr]
+    return parameter["default"]
+
+
+def get_container(operation, attribute_path, with_type=False):
+
+    def get_type(parameter):
+        if with_type:
+            return f", {get_type_for_parameter(parameter)}"
+        return ""
+
+    attribute_name = attribute_path.split(".")[0]
+    for name, parameter in parameters(operation):
+        if name == attribute_name:
+            if parameter["required"]:
+                return '{}, "{}"{}'.format(name, ".".join(formatter.attribute_name(a) for a in attribute_path.split(".")[1:]), get_type(parameter))
+    return f'opts, "{formatter.attribute_path(attribute_path)}"{get_type(parameter)}'
+
+
+def get_type_at_path(operation, attribute_path):
+    content = None
+    for code, response in operation.get("responses", {}).items():
+        if int(code) >= 300:
+            continue
+        for content in response.get("content", {}).values():
+            if "schema" in content:
+                break
+    if content is None:
+        raise RuntimeError("Default response not found")
+    for attr in attribute_path.split("."):
+        content = content["schema"]["properties"][attr]
+    return get_name(content.get("items"))

data/.generator/src/generator/replacement.json

@@ -0,0 +1 @@
+{"IdP": "Idp", "AuthNMapping": "AuthnMapping", "AuthN ": "Authn ", "IoT": "Iot", "SLOs": "Slos"}