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-aliases.md

@@ -41,7 +41,7 @@ The following table lists the available query parameters. All query parameters a
 
 | Parameter | Data type | Description | Default |
 | :--- | :--- | :--- | :--- |
-| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with open, closed, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
+| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with `open`, `closed`, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
 | `format` | String | A short version of the `Accept` header, such as `json` or `yaml`. | N/A |
 | `h` | List | A comma-separated list of column names to display. | N/A |
 | `help` | Boolean | Returns help information. | `false` |

_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

_api-reference/cat/cat-indices.md

@@ -41,7 +41,7 @@ The following table lists the available query parameters. All query parameters a
 | :--- | :--- | :--- | :--- |
 | `bytes` | String | The units used to display byte values. <br> Valid values are: `b`, `kb`, `k`, `mb`, `m`, `gb`, `g`, `tb`, `t`, `pb`, and `p`. | N/A |
 | `cluster_manager_timeout` | String | The amount of time allowed to establish a connection to the cluster manager node. | N/A |
-| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with open, closed, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
+| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with `open`, `closed`, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
 | `format` | String | A short version of the `Accept` header, such as `json` or `yaml`. | N/A |
 | `h` | List | A comma-separated list of column names to display. | N/A |
 | `health` | String | Limits indexes based on their health status. Supported values are `green`, `yellow`, and `red`. <br> Valid values are: `green`, `GREEN`, `yellow`, `YELLOW`, `red`, and `RED`. | N/A |

_api-reference/cat/cat-segment-replication.md

@@ -60,7 +60,7 @@ The following table lists the available query parameters. All query parameters a
 | `bytes` | String | The units used to display byte values. <br> Valid values are: `b`, `kb`, `k`, `mb`, `m`, `gb`, `g`, `tb`, `t`, `pb`, and `p`. | N/A |
 | `completed_only` | Boolean | When `true`, the response only includes the last-completed segment replication events. | `false` |
 | `detailed` | Boolean | When `true`, the response includes additional metrics for each stage of a segment replication event. | `false` |
-| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with open, closed, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
+| `expand_wildcards` | List or String | Specifies the type of index that wildcard expressions can match. Supports comma-separated values. <br> Valid values are: <br> - `all`: Match any index, including hidden ones. <br> - `closed`: Match closed, non-hidden indexes. <br> - `hidden`: Match hidden indexes. Must be combined with `open`, `closed`, or both. <br> - `none`: Wildcard expressions are not accepted. <br> - `open`: Match open, non-hidden indexes. | N/A |
 | `format` | String | A short version of the `Accept` header, such as `json` or `yaml`. | N/A |
 | `h` | List | A comma-separated list of column names to display. | N/A |
 | `help` | Boolean | Returns help information. | `false` |

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