Formatting documents

from sid import DocumentCache

cache = DocumentCache(range_mode="lenient")

import { DocumentCache } from "@sid-ai/sid-sdk";

const cache = new DocumentCache({ rangeMode: "lenient" });

import sid "github.com/sidhq/sid-go"

cache, err := sid.NewDocumentCache(sid.DocumentCacheOptions{RangeMode: sid.RangeModeLenient})
if err != nil {
	log.Fatal(err)
}

document = {
    "id": "support-2fa-001",
    "title": "Two-factor authentication",
    "content": (
        "Account settings are available from the menu beside your profile. "
        "You can change your name, email address and notification preferences there. "
        "To enable two-factor authentication, open Settings, choose Security, and add an authenticator app. "
        "Save the recovery codes somewhere safe. "
        "If you lose your device, use a recovery code to sign in. "
        "Contact support if you cannot access either."
    ),
}
results = [document]

const document = {
  id: "support-2fa-001",
  title: "Two-factor authentication",
  content:
    "Account settings are available from the menu beside your profile. " +
    "You can change your name, email address and notification preferences there. " +
    "To enable two-factor authentication, open Settings, choose Security, and add an authenticator app. " +
    "Save the recovery codes somewhere safe. " +
    "If you lose your device, use a recovery code to sign in. " +
    "Contact support if you cannot access either.",
};
const results = [document];

document := map[string]any{
	"id":    "support-2fa-001",
	"title": "Two-factor authentication",
	"content": "Account settings are available from the menu beside your profile. " +
		"You can change your name, email address and notification preferences there. " +
		"To enable two-factor authentication, open Settings, choose Security, and add an authenticator app. " +
		"Save the recovery codes somewhere safe. " +
		"If you lose your device, use a recovery code to sign in. " +
		"Contact support if you cannot access either.",
}
results := []map[string]any{document}

rendered = []
for result in results:
    fields = dict(result)
    data_id = fields.pop("id")
    model_id = cache.add_document(data_id, fields)
    view = cache.apply_snippet(
        data_id,
        snippet_field="content",
        query="enable two-factor authentication",
        snippet_size=20,
    )
    rendered.append(view.render_xml())
    cache.update_seen(view)

observation = "\n".join(rendered) if rendered else "No results found. Try a different query."
print(observation)

const rendered: string[] = [];
for (const result of results) {
  const { id: dataId, ...fields } = result;
  cache.addDocument(dataId, fields);
  const view = cache.applySnippet(dataId, {
    snippetField: "content",
    query: "enable two-factor authentication",
    snippetSize: 20,
  });
  rendered.push(view.renderXml());
  cache.updateSeen(view);
}

const observation = rendered.join("\n") || "No results found. Try a different query.";
console.log(observation);

var rendered []string
for _, result := range results {
	fields := maps.Clone(result)
	dataID := fields["id"].(string)
	delete(fields, "id")
	if _, err := cache.AddDocument(dataID, fields); err != nil {
		log.Fatal(err)
	}
	view, err := cache.ApplySnippet(dataID, sid.ApplySnippetOptions{
		SnippetField: "content",
		Query:        "enable two-factor authentication",
		SnippetSize:  20,
	})
	if err != nil {
		log.Fatal(err)
	}
	xml, err := view.RenderXML()
	if err != nil {
		log.Fatal(err)
	}
	rendered = append(rendered, xml)
	if err := cache.UpdateSeen(view); err != nil {
		log.Fatal(err)
	}
}

observation := strings.Join(rendered, "\n")
if observation == "" {
	observation = "No results found. Try a different query."
}
fmt.Println(observation)

print(cache.to_model_facing_id(data_id))  # the id returned by add_document
print(cache.to_data_id(model_id))        # support-2fa-001

# Adding the same database id again keeps its original id and content.
assert cache.add_document(data_id, fields) == model_id

const { id: dataId, ...fields } = document;
const modelId = cache.toModelFacingId(dataId);
console.log(modelId);
console.log(cache.toDataId(modelId)); // support-2fa-001

// Adding the same database ID again keeps its original ID and content.
console.assert(cache.addDocument(dataId, fields) === modelId);

dataID := document["id"].(string)
fields := maps.Clone(document)
delete(fields, "id")
modelID, err := cache.ToModelFacingID(dataID)
if err != nil {
	log.Fatal(err)
}
fmt.Println(modelID)
fmt.Println(cache.ToDataID(modelID)) // support-2fa-001 <nil>

// Adding the same database ID again keeps its original ID and content.
if again, _ := cache.AddDocument(dataID, fields); again != modelID {
	log.Fatal("model-facing ID changed")
}

from sid import parse_rendered_model_facing_id

reference = f"{model_id}#98:245"
model_facing_id, char_range = parse_rendered_model_facing_id(reference)
print(cache.to_data_id(model_facing_id))  # support-2fa-001
print(char_range)                        # (98, 245)

import { parseRenderedModelFacingId } from "@sid-ai/sid-sdk";

const reference = `${modelId}#98:245`;
const [modelFacingId, charRange] = parseRenderedModelFacingId(reference);
console.log(cache.toDataId(modelFacingId)); // support-2fa-001
console.log(charRange);                    // [98, 245]

reference := modelID + "#98:245"
modelFacingID, charRange, err := sid.ParseRenderedModelFacingID(reference)
if err != nil {
	log.Fatal(err)
}
fmt.Println(cache.ToDataID(modelFacingID)) // support-2fa-001 <nil>
fmt.Println(*charRange)                    // [98 245]

snippet = cache.apply_snippet(
    data_id,
    snippet_field="content",
    query="recovery code",
    snippet_size=20,
    display_fields=["title", "content"],
    language="english",
)
print(snippet.render_xml())

const snippet = cache.applySnippet(dataId, {
  snippetField: "content",
  query: "recovery code",
  snippetSize: 20,
  displayFields: ["title", "content"],
  language: "english",
});
console.log(snippet.renderXml());

snippet, err := cache.ApplySnippet(dataID, sid.ApplySnippetOptions{
	SnippetField:  "content",
	Query:         "recovery code",
	SnippetSize:   20,
	DisplayFields: []string{"title", "content"},
	Language:      sid.LanguageEnglish,
})
if err != nil {
	log.Fatal(err)
}
xml, err := snippet.RenderXML()
if err != nil {
	log.Fatal(err)
}
fmt.Println(xml)

repeated = cache.apply_snippet(
    data_id,
    snippet_field="content",
    query="enable two-factor authentication",
    snippet_size=20,
)
print(repeated.render_xml())

const repeated = cache.applySnippet(dataId, {
  snippetField: "content",
  query: "enable two-factor authentication",
  snippetSize: 20,
});
console.log(repeated.renderXml());

repeated, err := cache.ApplySnippet(dataID, sid.ApplySnippetOptions{
	SnippetField: "content",
	Query:        "enable two-factor authentication",
	SnippetSize:  20,
})
if err != nil {
	log.Fatal(err)
}
xml, err = repeated.RenderXML()
if err != nil {
	log.Fatal(err)
}
fmt.Println(xml)

from sid import InvalidCharacterRange, parse_rendered_model_facing_id


def render_read(reference: str) -> str:
    try:
        model_facing_id, char_range = parse_rendered_model_facing_id(reference)
        if not cache.contains_model_facing_id(model_facing_id):
            return "Unknown document id. Use search or text_search first."

        data_id = cache.to_data_id(model_facing_id)
        if char_range is not None:
            char_range = cache.resolve_char_range(data_id, "content", char_range)
    except (ValueError, InvalidCharacterRange) as error:
        return f"Error executing read: {error}"

    if char_range is not None:
        start, end = char_range
        char_range = (start, min(end, start + 10_000))
    elif len(cache.get_document(data_id)["content"]) > 10_000:
        char_range = (0, 10_000)

    read_view = cache.get_single_span_document_view(
        data_id,
        snippet_field="content",
        snippet_display_span=char_range,
    )
    output = read_view.render_xml()
    cache.update_seen(read_view)
    return output


print(render_read(f"{model_id}#98:99999"))

import { InvalidCharacterRange } from "@sid-ai/sid-sdk";

function renderRead(reference: string): string {
  try {
    const [modelId, range] = parseRenderedModelFacingId(reference);
    if (!cache.containsModelFacingId(modelId)) {
      return "Unknown document ID. Use search or text_search first.";
    }
    const dataId = cache.toDataId(modelId);
    let span = range === null ? undefined : cache.resolveCharRange(dataId, "content", range);
    if (span) {
      span = [span[0], Math.min(span[1], span[0] + 10_000)];
    } else if (Array.from(cache.getDocument(dataId).content as string).length > 10_000) {
      span = [0, 10_000];
    }
    const readView = cache.getSingleSpanDocumentView(dataId, {
      snippetField: "content",
      snippetDisplaySpan: span,
    });
    const output = readView.renderXml();
    cache.updateSeen(readView);
    return output;
  } catch (error) {
    if (error instanceof InvalidCharacterRange || error instanceof TypeError || error instanceof RangeError) {
      return `Error executing read: ${error.message}`;
    }
    throw error;
  }
}

console.log(renderRead(`${modelId}#98:99999`));

func renderRead(cache *sid.DocumentCache, reference string) (string, error) {
	modelID, charRange, err := sid.ParseRenderedModelFacingID(reference)
	if err != nil {
		return "Error executing read: " + err.Error(), nil
	}
	if !cache.ContainsModelFacingID(modelID) {
		return "Unknown document ID. Use search or text_search first.", nil
	}
	dataID, err := cache.ToDataID(modelID)
	if err != nil {
		return "", err
	}
	if charRange != nil {
		resolved, err := cache.ResolveCharRange(dataID, "content", *charRange)
		var invalid *sid.InvalidCharacterRange
		if errors.As(err, &invalid) {
			return "Error executing read: " + err.Error(), nil
		} else if err != nil {
			return "", err
		}
		charRange = &resolved
	}

	// Cap document text per read at 10,000 code points.
	if charRange != nil {
		charRange = sid.RangeValue(charRange.Start(), min(charRange.End(), charRange.Start()+10_000))
	} else {
		document, err := cache.GetDocument(dataID)
		if err != nil {
			return "", err
		}
		if utf8.RuneCountInString(document["content"].(string)) > 10_000 {
			charRange = sid.RangeValue(0, 10_000)
		}
	}

	readView, err := cache.GetSingleSpanDocumentView(dataID, sid.SingleSpanOptions{
		SnippetField:       "content",
		SnippetDisplaySpan: charRange,
	})
	if err != nil {
		return "", err
	}
	output, err := readView.RenderXML()
	if err != nil {
		return "", err
	}
	return output, cache.UpdateSeen(readView)
}

output, err := renderRead(cache, modelID+"#98:99999")
if err != nil {
	log.Fatal(err)
}
fmt.Println(output)