datadog_api_client 1.9.0 → 2.0.0

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

@@ -12,9 +12,9 @@ MODULE_NAME = "DatadogAPIClient"
 
 
 @click.command()
-@click.option(
-    "-i",
-    "--input",
+@click.argument(
+    "specs",
+    nargs=-1,
     type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path),
 )
 @click.option(
@@ -22,14 +22,10 @@ MODULE_NAME = "DatadogAPIClient"
     "--output",
     type=click.Path(path_type=pathlib.Path),
 )
-def cli(input, output):
+def cli(specs, output):
     """
     Generate a Ruby code snippet from OpenAPI specification.
     """
-    spec = openapi.load(input)
-
-    version = input.parent.name
-
     env = Environment(loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates")))
 
     env.filters["accept_headers"] = openapi.accept_headers
@@ -48,8 +44,6 @@ def cli(input, output):
     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
@@ -63,38 +57,61 @@ def cli(input, output):
     package_j2 = env.get_template("package.j2")
 
     extra_files = {
-        "api_client.rb": env.get_template("api_client.j2"),
-        "api_error.rb": env.get_template("api_error.j2"),
-        "configuration.rb": env.get_template("configuration.j2"),
         "model_base.rb": env.get_template("model_base.j2"),
     }
 
-    apis = openapi.apis(spec)
-    models = openapi.models(spec)
-
-    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 / GEM_NAME / version
-    gem_path.mkdir(parents=True, exist_ok=True)
+    common_files = {
+        "api_client.rb": env.get_template("api_client.j2"),
+        "configuration.rb": env.get_template("configuration.j2"),
+        "inflector.rb": env.get_template("inflector.j2"),
+    }
 
-    for name, template in extra_files.items():
-        filename = gem_path / name
+    all_specs = {}
+    all_apis = {}
+    all_models = {}
+    for spec_path in specs:
+        version = spec_path.parent.name
+
+        spec = openapi.load(spec_path)
+        all_specs[version] = spec
+
+        apis = openapi.apis(spec)
+        all_apis[version] = apis
+
+        models = openapi.models(spec)
+        all_models[version] = models
+
+        env.globals["openapi"] = spec
+        env.globals["version"] = version
+
+        gem_path = output / GEM_NAME / version
+        gem_path.mkdir(parents=True, exist_ok=True)
+
+        for name, template in extra_files.items():
+            filename = gem_path / name
+            with filename.open("w") as fp:
+                fp.write(template.render(apis=apis, models=models))
+
+        for name, model in models.items():
+            filename = formatter.snake_case(name) + ".rb"
+            model_path = gem_path / "models" / filename
+            model_path.parent.mkdir(parents=True, exist_ok=True)
+            with model_path.open("w") as fp:
+                fp.write(model_j2.render(name=name, model=model))
+
+        for name, operations in apis.items():
+            filename = formatter.snake_case(name) + "_api.rb"
+            api_path = gem_path / "api" / filename
+            api_path.parent.mkdir(parents=True, exist_ok=True)
+            with api_path.open("w") as fp:
+                fp.write(api_j2.render(name=name, operations=operations))
+
+    models_output = output / GEM_NAME / "models.rb"
+    with models_output.open("w") as fp:
+        fp.write(package_j2.render(all_apis=all_apis, all_models=all_models))
+
+    common_output = output / GEM_NAME
+    for name, template in common_files.items():
+        filename = common_output / name
         with filename.open("w") as fp:
-            fp.write(template.render(apis=apis, models=models))
-
-    for name, model in models.items():
-        filename = formatter.snake_case(name) + ".rb"
-        model_path = gem_path / "models" / filename
-        model_path.parent.mkdir(parents=True, exist_ok=True)
-        with model_path.open("w") as fp:
-            fp.write(model_j2.render(name=name, model=model))
-
-    for name, operations in apis.items():
-        filename = formatter.snake_case(name) + "_api.rb"
-        api_path = gem_path / "api" / filename
-        api_path.parent.mkdir(parents=True, exist_ok=True)
-        with api_path.open("w") as fp:
-            fp.write(api_j2.render(name=name, operations=operations))
+            fp.write(template.render(all_apis=all_apis, all_specs=all_specs, all_models=all_models))

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

@@ -273,6 +273,20 @@ def format_data_with_schema_list(
 ):
     name = get_name(schema)
 
+    if "oneOf" in schema:
+        for sub_schema in schema["oneOf"]:
+            try:
+                value = format_data_with_schema(
+                    data,
+                    sub_schema,
+                    replace_values=replace_values,
+                    default_name=name,
+                )
+            except (KeyError, ValueError) as e:
+                continue
+            return value
+        raise ValueError(f"{data} is not valid oneOf {schema}")
+
     parameters = ""
     for d in data:
         value = format_data_with_schema(
@@ -297,8 +311,11 @@ def format_data_with_schema_dict(
     name = get_name(schema)
 
     parameters = ""
-    if "properties" in schema:
+    has_properties = schema.get("properties")
+    if has_properties:
         for k, v in data.items():
+            if k not in schema["properties"]:
+                continue
             value = format_data_with_schema(
                 v,
                 schema["properties"][k],
@@ -310,6 +327,8 @@ def format_data_with_schema_dict(
 
     if schema.get("additionalProperties"):
         for k, v in data.items():
+            if has_properties and k in schema["properties"]:
+                continue
             value = format_data_with_schema(
                 v,
                 schema["additionalProperties"],

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

@@ -32,7 +32,10 @@ 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 not schema.get("properties"))
+            and schema.get("type", "object") == "object"
+        ):
             return name
 
     type_ = schema.get("type")
@@ -59,9 +62,9 @@ def type_to_ruby(schema, alternative_name=None):
     elif type_ == "boolean":
         return "Boolean"
     elif type_ == "array":
-        return "Array<{}>".format(type_to_ruby(schema["items"]))
+        return "Array<{}>".format(type_to_ruby(schema["items"], name + "Item" if name else None))
     elif type_ == "object":
-        if "additionalProperties" in schema:
+        if "additionalProperties" in schema and not schema.get("properties"):
             return "Hash<String, {}>".format(type_to_ruby(schema["additionalProperties"]))
         return (
             alternative_name
@@ -113,13 +116,13 @@ 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=name + "Item" if name is not None else None,
             seen=seen,
         )
 
-    if (
-        schema.get("type") == "object" or "properties" in schema or has_sub_models
-    ) and "additionalProperties" not in schema:
+    if (schema.get("type") == "object" or "properties" in schema or has_sub_models) and not (
+        "additionalProperties" in schema and "properties" not in schema
+    ):
         if not has_sub_models and name is None:
             # this is a basic map object so we don't need a type
             return
@@ -458,7 +461,6 @@ def get_default(operation, attribute_path):
 
 
 def get_container(operation, attribute_path, with_type=False):
-
     def get_type(parameter):
         if with_type:
             return f", {get_type_for_parameter(parameter)}"
@@ -468,7 +470,11 @@ def get_container(operation, attribute_path, with_type=False):
     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 '{}, "{}"{}'.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)}'
 
 

data/.generator/src/generator/templates/api.j2

@@ -9,7 +9,7 @@ module {{ module_name }}::{{ version|upper }}
   class {{ classname }}
     attr_accessor :api_client
 
-    def initialize(api_client = APIClient.default)
+    def initialize(api_client = {{ module_name }}::APIClient.default)
       @api_client = api_client
     end
 
@@ -40,15 +40,14 @@ module {{ module_name }}::{{ version|upper }}
     {%- endfor %}
     # @return [Array<({% if returnType %}{{ returnType }}{% else %}nil{% endif %}, Integer, Hash)>] {% if returnType %}{{ returnType }} data{% else %}nil{% endif %}, response status code and response headers
     def {{ operation.operationId|snake_case }}_with_http_info({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
-
-      if @api_client.config.unstable_operations.has_key?(:{{ operation.operationId|snake_case }})
-        unstable_enabled = @api_client.config.unstable_operations[:{{ operation.operationId|snake_case }}]
-        if unstable_enabled
-          @api_client.config.logger.warn format("Using unstable operation '%s'", "{{ operation.operationId|snake_case }}")
-        else
-          raise APIError.new(message: format("Unstable operation '%s' is disabled", "{{ operation.operationId|snake_case }}"))
-        end
+      {%- if "x-unstable" in operation %}
+      unstable_enabled = @api_client.config.unstable_operations["{{ version }}.{{ operation.operationId|snake_case }}".to_sym]
+      if unstable_enabled
+        @api_client.config.logger.warn format("Using unstable operation '%s'", "{{ version }}.{{ operation.operationId|snake_case }}")
+      else
+        raise {{ module_name }}::APIError.new(message: format("Unstable operation '%s' is disabled", "{{ version }}.{{ operation.operationId|snake_case }}"))
       end
+      {%- endif %}
 
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: {{classname}}.{{ operation.operationId|snake_case }} ...'
@@ -198,7 +197,8 @@ module {{ module_name }}::{{ version|upper }}
         :form_params => form_params,
         :body => post_body,
         :auth_names => auth_names,
-        :return_type => return_type
+        :return_type => return_type,
+        :api_version => "{{ version|upper }}"
       )
 
       data, status_code, headers = @api_client.call_api(Net::HTTP::{{ httpMethod|camel_case }}, local_var_path, new_options)
@@ -218,8 +218,9 @@ module {{ module_name }}::{{ version|upper }}
     #
     # @yield [{{ get_type_at_path(operation, pagination.resultsPath) }}] Paginated items
     def {{ operation.operationId|snake_case }}_with_pagination({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
+        api_version = "{{ version|upper }}"
         page_size = @api_client.get_attribute_from_path({{ get_container(operation, pagination.limitParam) }}, {{ get_default(operation, pagination.limitParam) }})
-        @api_client.set_attribute_from_path({{ get_container(operation, pagination.limitParam, True) }}, page_size)
+        @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.limitParam, True) }}, page_size)
         while true do
             response = {{ operation.operationId|snake_case }}({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts)
             @api_client.get_attribute_from_path(response, "{{ pagination.resultsPath|attribute_path }}").each { |item| yield(item) }
@@ -227,10 +228,10 @@ module {{ module_name }}::{{ version|upper }}
               break
             end
             {%- if pagination.pageOffsetParam %}
-            @api_client.set_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam, True) }}, @api_client.get_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam) }}, 0) + page_size)
+            @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.pageOffsetParam, True) }}, @api_client.get_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam) }}, 0) + page_size)
             {%- endif %}
             {%- if pagination.cursorParam %}
-            @api_client.set_attribute_from_path({{ get_container(operation, pagination.cursorParam, True) }}, @api_client.get_attribute_from_path(response, "{{ pagination.cursorPath }}"))
+            @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.cursorParam, True) }}, @api_client.get_attribute_from_path(response, "{{ pagination.cursorPath }}"))
             {%- endif %}
         end
     end

data/.generator/src/generator/templates/api_client.j2

@@ -8,8 +8,12 @@ require 'logger'
 require 'tempfile'
 require 'time'
 require 'httparty'
+begin
+  require 'zstandard'
+rescue LoadError
+end
 
-module {{ module_name }}::{{ version|upper }}
+module {{ module_name }}
   class APIClient
     # The Configuration object holding settings to be used in the API client.
     attr_accessor :config
@@ -25,7 +29,6 @@ module {{ module_name }}::{{ version|upper }}
       @config = config
       @user_agent = "#{{ '{' }}{{ module_name }}::USER_AGENT}"
       @default_headers = {
-        'Content-Type' => 'application/json',
         'User-Agent' => @user_agent
       }
       @default_headers['Accept-Encoding'] = 'gzip' if @config.compress
@@ -101,7 +104,7 @@ module {{ module_name }}::{{ version|upper }}
       end
 
       if opts[:return_type]
-        data = deserialize(response, opts[:return_type])
+        data = deserialize(opts[:api_version], response, opts[:return_type])
       else
         data = nil
       end
@@ -188,6 +191,8 @@ module {{ module_name }}::{{ version|upper }}
         gzip.close
       elsif header_params['Content-Encoding'] == 'deflate'
         data = Zlib::deflate(data)
+      elsif header_params['Content-Encoding'] == 'zstd1'
+        data = Zstandard.deflate(data)
       end
       data
     end
@@ -206,9 +211,10 @@ module {{ module_name }}::{{ version|upper }}
 
     # Deserialize the response to the given return type.
     #
+    # @param [String] the api version
     # @param [Response] response HTTP response
     # @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
-    def deserialize(response, return_type)
+    def deserialize(api_version, response, return_type)
       body = response.body
 
       # handle file downloading - return the File instance processed in request callbacks
@@ -241,14 +247,14 @@ module {{ module_name }}::{{ version|upper }}
         end
       end
 
-      convert_to_type data, return_type
+      convert_to_type data, return_type, api_version
     end
 
     # Convert data to the given return type.
     # @param [Object] data Data to be converted
     # @param [String] return_type Return type
     # @return [Mixed] Data in a particular type
-    def convert_to_type(data, return_type)
+    def convert_to_type(data, return_type, api_version)
       return nil if data.nil?
       case return_type
       when 'String'
@@ -271,16 +277,16 @@ module {{ module_name }}::{{ version|upper }}
       when /\AArray<(.+)>\z/
         # e.g. Array<Pet>
         sub_type = $1
-        data.map { |item| convert_to_type(item, sub_type) }
+        data.map { |item| convert_to_type(item, sub_type, api_version) }
       when /\AHash\<String, (.+)\>\z/
         # e.g. Hash<String, Integer>
         sub_type = $1
         {}.tap do |hash|
-          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type, api_version) }
         end
       else
         # models (e.g. Pet) or oneOf
-        klass = {{ module_name }}::{{ version|upper }}.const_get(return_type)
+        klass = {{ module_name }}.const_get(api_version).const_get(return_type)
         klass.respond_to?(:openapi_one_of) ? klass.build(data) : klass.build_from_hash(data)
       end
     end
@@ -297,7 +303,7 @@ module {{ module_name }}::{{ version|upper }}
     def build_request_url(path, opts = {})
       # Add leading and trailing slashes to path
       path = "/#{path}".gsub(/\/+/, '/')
-      @config.base_url(opts[:operation]) + path
+      @config.base_url("#{opts[:api_version].respond_to?(:downcase) ? opts[:api_version].downcase : opts[:api_version]}.#{opts[:operation]}") + path
     end
 
     # Update header and query params based on authentication settings.
@@ -330,9 +336,7 @@ module {{ module_name }}::{{ version|upper }}
     # @return [String] the Accept header (e.g. application/json)
     def select_header_accept(accepts)
       return nil if accepts.nil? || accepts.empty?
-      # use JSON when present, otherwise use all of the provided
-      json_accept = accepts.find { |s| json_mime?(s) }
-      json_accept || accepts.join(',')
+      accepts.join(', ')
     end
 
     # Return Content-Type header based on an array of content types provided.
@@ -414,12 +418,13 @@ module {{ module_name }}::{{ version|upper }}
 
     # Set an attribute at the given path
     #
+    # @param [String] api_version The api version
     # @param [Object] obj The source object
     # @param [String] attribute_path The path spefication, separated by "."
     # @param [Object] builder The class matching the top level attribute
     # @param [Object] value The value to set
     # @!visibility private
-    def set_attribute_from_path(obj, attribute_path, builder, value)
+    def set_attribute_from_path(api_version, obj, attribute_path, builder, value)
       attrs = attribute_path.split(".")
       last = attrs.pop
       i = 0
@@ -430,7 +435,7 @@ module {{ module_name }}::{{ version|upper }}
         else
           obj = obj.send(attr)
         end
-        builder = DatadogAPIClient::V2.const_get(builder.openapi_types[attr.to_sym]) if i > 0
+        builder = DatadogAPIClient.const_get(api_version).const_get(builder.openapi_types[attr.to_sym]) if i > 0
         obj = builder.new if obj.nil?
         i += 1
       end
@@ -442,4 +447,48 @@ module {{ module_name }}::{{ version|upper }}
       end
     end
   end
+
+  class APIError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   APIError.new
+    #   APIError.new("message")
+    #   APIError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   APIError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a? Hash
+        if arg.key?(:message) || arg.key?('message')
+          super(arg[:message] || arg['message'])
+        else
+          super arg
+        end
+
+        arg.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      else
+        super arg
+      end
+    end
+
+    # Override to_s to display a friendly error message
+    def to_s
+      message
+    end
+
+    def message
+      if @message.nil?
+        msg = "Error message: the server returns an error"
+      else
+        msg = @message
+      end
+
+      msg += "\nHTTP status code: #{code}" if code
+      msg += "\nResponse headers: #{response_headers}" if response_headers
+      msg += "\nResponse body: #{response_body}" if response_body
+
+      msg
+    end
+  end
 end

data/.generator/src/generator/templates/configuration.j2

@@ -2,7 +2,7 @@
 {% include "api_info.j2" %}
 =end
 
-module {{ module_name }}::{{ version|upper }}
+module {{ module_name }}
   class Configuration
     # Defines url scheme
     attr_accessor :scheme
@@ -148,13 +148,15 @@ module {{ module_name }}::{{ version|upper }}
       @compress = true
       @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
       @unstable_operations = {
-      {%- for path in openapi.paths.values() %}
-      {%- for operation in path.values() %}
+      {%- for version, apis in all_apis.items() %}
+      {%- for operations in apis.values() %}
+      {%- for _, _, operation in operations|sort(attribute="2.operationId") %}
       {%- if "x-unstable" in operation %}
-            {{ operation.operationId|snake_case }}: false,
+            "{{ version }}.{{ operation.operationId|snake_case }}": false,
       {%- endif %}
       {%- endfor %}
       {%- endfor %}
+      {%- endfor %}
       }
       @server_variables[:site] = ENV['DD_SITE'] if ENV.key? 'DD_SITE'
       {%- for name, schema in openapi.components.securitySchemes.items() if "x-env-name" in schema and schema.in == "header" and schema.type == "apiKey" %}
@@ -191,10 +193,10 @@ module {{ module_name }}::{{ version|upper }}
 
     # Returns base URL for specified operation based on server settings
     def base_url(operation = nil)
-      index = server_operation_index.fetch(operation, server_index)
+      index = server_operation_index.fetch(operation.to_sym, server_index)
       return "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '') if index == nil
 
-      server_url(index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])
+      server_url(index, server_operation_variables.fetch(operation.to_sym, server_variables), operation_server_settings[operation.to_sym])
     end
 
     # Gets API key (with prefix if set).
@@ -294,11 +296,12 @@ module {{ module_name }}::{{ version|upper }}
 
     def operation_server_settings
       {
-        {%- for path in openapi.paths.values() %}
+        {%- for version, spec in all_specs.items() %}
+        {%- for path in spec.paths.values() %}
         {%- for operation in path.values() %}
         {%- for server in operation.servers %}
         {%- if loop.first %}
-        {{ operation.operationId|snake_case }}: [
+        "{{ version }}.{{ operation.operationId|snake_case }}": [
         {%- endif %}
           {{ server_configuration(server)|indent(10) }}{% if not loop.last %},{% endif %}
         {%- if loop.last %}  
@@ -307,6 +310,7 @@ module {{ module_name }}::{{ version|upper }}
         {%- endfor %}
         {%- endfor %}
         {%- endfor %}
+        {%- endfor %}
       }
     end
 

data/.generator/src/generator/templates/example.j2

@@ -8,7 +8,7 @@ require 'datadog_api_client'
 {%- if context._enable_operations %}
 DatadogAPIClient::V2.configure do |config|
 {%- for operation in context._enable_operations %}
-  config.unstable_operations[:{{ operation|snake_case }}] = true
+  config.unstable_operations["{{ version }}.{{ operation|snake_case }}".to_sym] = true
 {%- endfor %}
 end
 {%- endif %}

data/.generator/src/generator/templates/inflector.j2

@@ -0,0 +1,28 @@
+require 'zeitwerk'
+
+module {{ module_name }}
+  class {{ module_name }}Inflector < Zeitwerk::Inflector
+    def camelize(basename, abspath)
+      model_name = "#{abspath.match('v[0-9]')}.#{basename}"
+      overrides[model_name] || basename.split('_').each(&:capitalize!).join
+    end
+
+    def overrides
+      @overrides ||= {
+        # Models
+        {%- for version, models in all_models.items() %}
+        {%- for model in models|sort %}
+          "{{ version }}.{{ model|snake_case }}" => "{{ model }}",
+        {%- endfor %}
+        {%- endfor %}
+        # APIs
+        {%- for version, apis in all_apis.items() %}
+        {%- for api in apis|sort %}
+        {%- set name = api.replace(" ", "") + "API" %}
+        "{{ version }}.{{ api|snake_case }}_api" => "{{ name }}"{%-if not loop.last %},{% endif %}
+        {%- endfor %}{%-if not loop.last %},{% endif %}
+        {%- endfor %}
+        }
+    end
+  end
+end

data/.generator/src/generator/templates/model_base.j2

@@ -10,7 +10,7 @@ module {{ module_name }}::{{ version|upper }}
     # @!visibility private
     def build_from_hash(value)
       constantValues = self.class.constants.select { |c| self.class::const_get(c) == value }
-      constantValues.empty? ? {{ module_name }}::{{ version|upper }}::UnparsedObject.new(value) : value
+      constantValues.empty? ? {{ module_name }}::UnparsedObject.new(value) : value
     end
 
     module ClassMethods
@@ -107,7 +107,7 @@ module {{ module_name }}::{{ version|upper }}
         # models (e.g. Pet) or oneOf
         klass = {{ module_name }}::{{ version|upper }}.const_get(type)
         res = klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-        if res.instance_of? {{ module_name }}::{{ version|upper }}::UnparsedObject
+        if res.instance_of? {{ module_name }}::UnparsedObject
           self._unparsed = true
         end
         res