Continued working on the Spect Insert feature for automatic conversion of API calls into Language SDK.

Refactored code base to seperate code logic and allow for more scalability in the future.

Example Below:
Since it might be asked,I will say we did try to make the rest and body tag one line, and we tried many solutions. but came to no avail for a working solution. Will continue to work on this to try to find a solution.

<!-- spec_insert_start
api: index
component: example_code
rest: PUT /my-index/_doc/1
body: {"title":"Spec Insert Test","timestamp":"2025-07-09T22:00:00Z"}
-->
{% capture step1_rest %}
PUT /my-index/_doc/1
{
  "title": "Spec Insert Test",
  "timestamp": "2025-07-09T22:00:00Z"
}
{% endcapture %}

{% capture step1_python %}

response = client.index(
  index = "my-index",
  id = "1",
  body =   {
    "title": "Spec Insert Test",
    "timestamp": "2025-07-09T22:00:00Z"
  }
)

{% endcapture %}

{% include code-block.html
rest=step1_rest
python=step1_python
%}
<!-- spec_insert_end -->

Signed-off-by: Daniel Jackson <[email protected]>

Author: Daniel Jackson

_api-reference/cat/cat-allocation.md

@@ -27,40 +27,6 @@ GET /_cat/allocation/{node_id}
 ```
 <!-- spec_insert_end -->
 
-<!-- spec_insert_start
-api: snapshot.restore
-component: example_code
-rest: GET _nodes/stats/indices
--->
-{% capture step1_rest %}
-POST _snapshot/<repository>/<snapshot>/_restore
-{% endcapture %}
-
-{% capture step1_python %}
-response = client.snapshot.restore(
-  repository = "<repository>",
-  snapshot = "<snapshot>",
-  body =   {
-    "indices": "opendistro-reports-definitions",
-    "ignore_unavailable": true,
-    "include_global_state": false,
-    "rename_pattern": "(.+)",
-    "rename_replacement": "$1_restored",
-    "include_aliases": false
-  }
-)
-
-{% endcapture %}
-
-{% capture step1_javascript %}
-JavaScript example code not yet implemented
-{% endcapture %}
-
-{% include code-block.html
-rest=step1_rest
-python=step1_python
-%}
-<!-- spec_insert_end -->
 
 <!-- spec_insert_start
 api: cat.allocation

spec-insert/lib/insert_arguments.rb

@@ -2,11 +2,13 @@
 
 require_relative 'utils'
 require_relative 'spec_insert_error'
-
+require 'json'
 # Doc Insert Arguments
 class InsertArguments
   attr_reader :raw
 
+  Rest = Struct.new(:verb, :path, :query, :body, :raw_lines, keyword_init:true)
+
   # @param [Hash] args raw arguments read from the doc insert marker
   def initialize(args)
     @raw = args.to_h.with_indifferent_access
@@ -61,6 +63,34 @@ def omit_header
     parse_boolean(@raw['omit_header'], default: false)
   end
 
+  # @return [Rest, nil]
+  def rest
+    lines = @raw['rest']&.split("\n")&.map(&:strip) || []
+    return nil if lines.empty?
+
+    verb, full_path = lines.first.to_s.split
+    path, query_string = full_path.to_s.split('?', 2)
+
+    query = (query_string || "").split('&').to_h do |pair|
+      k, v = pair.split('=', 2)
+      [k, v || "false"]
+    end
+
+    body = begin
+             JSON.parse(@raw['body']) if @raw['body']
+           rescue JSON::ParserError
+             @raw['body']
+           end
+
+    Rest.new(
+      verb: verb,
+      path: path,
+      query: query,
+      body: body,
+      raw_lines: lines
+    )
+  end
+
   private
 
   # @param [String] value comma-separated array

spec-insert/lib/renderers/example_code.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require_relative 'example_code_python'
 
 class ExampleCode < BaseMustacheRenderer
   self.template_file = "#{__dir__}/templates/example_code.mustache"
@@ -9,217 +10,21 @@ def initialize(action, args)
     super(action, args)
   end
 
-  # Resolves the correct OpenSearch client method call
-  def client_method_call
-    segments = @action.full_name.to_s.split('.')
-    return "client" if segments.empty?
- 
-    if segments.size == 1
-      "client.#{segments.first}"
-    else
-      "client.#{se  gments.first}.#{segments[1]}"
-    end
-  end
-
   def rest_lines
-    @args.raw['rest']&.split("\n")&.map(&:strip) || []
+    @args.rest.raw_lines
   end
 
   def rest_code
-    rest_lines.join("\n")
-  end
-
-  # Uses the declared HTTP method in the OpenAPI spec
-  def http_method
-    @action.http_verbs.first&.upcase || "GET"
-  end
-
-  # Converts OpenAPI-style path (/index/{id}) into Ruby-style interpolation (/index/#{id})
-  def path_only
-    url = @action.urls.first
-    return '' unless url
-    url.gsub(/\{(\w+)\}/, '#{\1}')
-  end
-  def javascript_code
-    "JavaScript example code not yet implemented"
-  end
-  # Assembles a query string from the declared query parameters
-  def query_string
-    return '' if @action.query_parameters.empty?
-    @action.query_parameters.map { |param| "#{param.name}=example" }.join('&')
-  end
-
-  # Combines path and query string for display
-  def path_with_query
-    qs = query_string
-    qs.empty? ? path_only : "#{path_only}?#{qs}"
-  end
-
-  # Hash version of query params
-  def query_params
-    @action.query_parameters.to_h { |param| [param.name, "example"] }
-  end
-
-  # Parses the body from the REST example (only for preserving raw formatting)
-  def body
-    body_lines = rest_lines[1..]
-    return nil if body_lines.empty?
-    begin
-      JSON.parse(body_lines.join("\n"))
-    rescue
-      nil
-    end
-  end
-
-  def action_expects_body?(verb)
-    verb = verb.downcase
-    @action.operations.any? do |op|
-      op.http_verb.to_s.downcase == verb &&
-        op.spec&.requestBody &&
-        op.spec.requestBody.respond_to?(:content)
-    end
-  end
-
-  def matching_spec_path
-    return @matching_spec_path if defined?(@matching_spec_path)
-
-    # Extract raw request path from rest line
-    raw_line = rest_lines.first.to_s
-    _, request_path = raw_line.split
-    request_segments = request_path.split('?').first.split('/').reject(&:empty?)
-
-    # Choose the best matching spec URL
-    best = nil
-    best_score = -1
-
-    @action.urls.each do |spec_path|
-      spec_segments = spec_path.split('/').reject(&:empty?)
-      next unless spec_segments.size == request_segments.size
-
-      score = 0
-      spec_segments.each_with_index do |seg, i|
-        if seg.start_with?('{')
-          score += 1 # parameter match
-        elsif seg == request_segments[i]
-          score += 2 # exact match
-        else
-          score = -1
-          break
-        end
-      end
-
-      if score > best_score
-        best = spec_path
-        best_score = score
-      end
+    base = rest_lines.join("\n")
+    body = @args.rest.body
+    if body
+      body.is_a?(String) ? base + "\n" + body : base + "\n" + JSON.pretty_generate(body)
+    else
+      base
     end
-
-    @matching_spec_path = best
   end
 
-  # Final Python code using action metadata
   def python_code
-    return "# Invalid action" unless @action&.full_name
-
-    client_setup = <<~PYTHON
-    from opensearchpy import OpenSearch
-    
-    host = 'localhost'
-    port = 9200
-    auth = ('admin', 'admin') # For testing only. Don't store credentials in code.
-    ca_certs_path = '/full/path/to/root-ca.pem' # Provide a CA bundle if you use intermediate CAs with your root CA.
-    
-    # Create the client with SSL/TLS enabled, but hostname verification disabled.
-    client = OpenSearch(
-        hosts = [{'host': host, 'port': port}],
-        http_compress = True, # enables gzip compression for request bodies
-        http_auth = auth,
-        use_ssl = True,
-        verify_certs = True,
-        ssl_assert_hostname = False,
-        ssl_show_warn = False,
-        ca_certs = ca_certs_path
-    )
-
-    PYTHON
-
-    if @args.raw['body'] == '{"hello"}'
-      puts "# This is a debug example"
-    end
-
-    namespace, method = @action.full_name.split('.')
-    client_call = "client"
-    client_call += ".#{namespace}" if namespace
-    client_call += ".#{method}"
-
-    args = []
-
-    # Extract actual path and query from the first line of the REST input
-    raw_line = rest_lines.first.to_s
-    http_verb, full_path = raw_line.split
-    path_part, query_string = full_path.to_s.split('?', 2)
-
-    # Extract used path values from the path part
-    path_values = path_part.split('/').reject(&:empty?)
-
-    # Match spec path (e.g. /_cat/aliases/{name}) to determine which param this value belongs to
-    spec_path = matching_spec_path.to_s
-    spec_parts = spec_path.split('/').reject(&:empty?)
-
-    param_mapping = {}
-    spec_parts.each_with_index do |part, i|
-      if part =~ /\{(.+?)\}/ && path_values[i]
-        param_mapping[$1] = path_values[i]
-      end
-    end
-
-    # Add path parameters if they were present in the example
-    @action.path_parameters.each do |param|
-      if param_mapping.key?(param.name)
-        args << "#{param.name} = \"#{param_mapping[param.name]}\""
-      end
-    end
-
-    # Add query parameters from query string
-    if query_string
-      query_pairs = query_string.split('&').map { |s| s.split('=', 2) }
-      query_hash = query_pairs.map do |k, v|
-        "#{k}: #{v ? "\"#{v}\"" : "True"}"
-      end.join(', ')
-      args << "params = { #{query_hash} }" unless query_hash.empty?
-    end
-
-    # Add body if spec allows it AND it's present in REST
-    if action_expects_body?(http_verb)
-      if @args.raw['body']
-        begin
-          parsed = JSON.parse(@args.raw['body'])
-          pretty = JSON.pretty_generate(parsed).gsub(/^/, '  ')
-          args << "body = #{pretty}"
-        rescue JSON::ParserError
-          args << "body = #{JSON.dump(@args.raw['body'])}"
-        end
-      else
-        args << 'body = { "Insert body here" }'
-      end
-    end
-
-    # Final result
-    call_code = if args.empty?
-                  "response = #{client_call}()"
-                else
-                  final_args = args.map { |line| "  #{line}" }.join(",\n")
-                  <<~PYTHON
-                  response = #{client_call}(
-                  #{final_args}
-                  )
-                  PYTHON
-                end
-    # Prepend client if requested
-    if @args.raw['include_client_setup']
-      client_setup + call_code
-    else
-      call_code
-    end
+    ExampleCodePython.new(@action, @args).render
   end
-end
+end