Generar un XSD a partir de XML

// No dependency: DOMParser is enough to collect the shape of a document.
// This prints the inventory a schema is built from, which is the part worth
// reading before you trust any generator's output.
function inventory(xmlText) {
  const doc = new DOMParser().parseFromString(xmlText, 'application/xml');
  if (doc.querySelector('parsererror')) throw new Error('not well-formed');

  const shapes = new Map();

  const visit = (el) => {
    let shape = shapes.get(el.tagName);
    if (!shape) {
      shape = { count: 0, attrs: new Map(), children: new Map(), values: new Set() };
      shapes.set(el.tagName, shape);
    }
    shape.count++;

    for (const a of el.attributes) {
      if (a.name === 'xmlns' || a.name.startsWith('xmlns:')) continue;
      shape.attrs.set(a.name, (shape.attrs.get(a.name) ?? 0) + 1);
    }

    const kids = [...el.children];
    const seen = new Map();
    for (const c of kids) seen.set(c.tagName, (seen.get(c.tagName) ?? 0) + 1);
    for (const [name, n] of seen) {
      const m = shape.children.get(name) ?? { min: Infinity, max: 0 };
      shape.children.set(name, { min: Math.min(m.min, n), max: Math.max(m.max, n) });
    }
    if (!kids.length && el.textContent.trim()) shape.values.add(el.textContent.trim());

    kids.forEach(visit);
  };
  visit(doc.documentElement);

  for (const [name, s] of shapes) {
    // An attribute seen fewer times than its element is optional. Present on
    // every occurrence proves nothing: it may still be optional in the format.
    const optional = [...s.attrs].filter(([, n]) => n < s.count).map(([a]) => a);
    console.log(name, 'x' + s.count, 'optional attrs:', optional.join(', ') || 'none');
  }
}

# pip install defusedxml
# The standard library parser is not safe on input you did not write.
from collections import defaultdict
from defusedxml.ElementTree import parse

def inventory(path):
    root = parse(path).getroot()
    shapes = defaultdict(lambda: {'count': 0, 'attrs': defaultdict(int),
                                  'children': {}, 'values': set()})

    def visit(el):
        s = shapes[el.tag]
        s['count'] += 1
        for name in el.attrib:
            s['attrs'][name] += 1

        counts = defaultdict(int)
        for c in el:
            counts[c.tag] += 1
        for name, n in counts.items():
            lo, hi = s['children'].get(name, (n, n))
            s['children'][name] = (min(lo, n), max(hi, n))
        if len(el) == 0 and (el.text or '').strip():
            s['values'].add(el.text.strip())

        for c in el:
            visit(c)

    visit(root)

    for tag, s in shapes.items():
        optional = [a for a, n in s['attrs'].items() if n < s['count']]
        print(f"{tag} x{s['count']}  optional attributes: {optional or 'none'}")
        for name, (lo, hi) in s['children'].items():
            # lo == 0 is never inferable from a single occurrence of the parent.
            print(f"  {name}: seen {lo}..{hi} per parent")

inventory('sample.xml')

// Apache XMLBeans: org.apache.xmlbeans:xmlbeans:5.2.1
// Inst2Xsd is the closest thing Java has to a standard inference tool, and it
// takes several instance documents, which is the main thing this page cannot.
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.impl.inst2xsd.Inst2Xsd;
import org.apache.xmlbeans.impl.inst2xsd.Inst2XsdOptions;
import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument;
import java.io.File;

XmlObject[] instances = new XmlObject[] {
    XmlObject.Factory.parse(new File("sample-1.xml")),
    XmlObject.Factory.parse(new File("sample-2.xml")),   // more samples, better guesses
};

Inst2XsdOptions options = new Inst2XsdOptions();
// RUSSIAN_DOLL nests everything; SALAMI_SLICE makes every element global,
// which is easier to hand-edit afterwards.
options.setDesign(Inst2XsdOptions.DESIGN_SALAMI_SLICE);
options.setSimpleContentTypes(Inst2XsdOptions.SIMPLE_CONTENT_TYPES_SMART);
options.setUseEnumerations(Inst2XsdOptions.ENUMERATION_NEVER);

SchemaDocument[] schemas = Inst2Xsd.inst2xsd(instances, options);
for (int i = 0; i < schemas.length; i++) {
    schemas[i].save(new File("inferred-" + i + ".xsd"));
}

using System.Xml;
using System.Xml.Schema;

// XmlSchemaInference is in the framework: no package needed. It is also the
// only one of these that will refine an existing schema with a new sample.
var settings = new XmlReaderSettings
{
    DtdProcessing = DtdProcessing.Prohibit,
    XmlResolver = null,
};

var inference = new XmlSchemaInference
{
    // Relaxed: string everywhere. Restricted: guess int, date, boolean and so
    // on, with all the risk that implies for codes and identifiers.
    TypeInference = XmlSchemaInference.InferenceOption.Restricted,
    Occurrence = XmlSchemaInference.InferenceOption.Relaxed,
};

XmlSchemaSet schemas;
using (var reader = XmlReader.Create("sample-1.xml", settings))
{
    schemas = inference.InferSchema(reader);
}
using (var reader = XmlReader.Create("sample-2.xml", settings))
{
    schemas = inference.InferSchema(reader, schemas);   // widen with a second sample
}

using var output = new XmlTextWriter("inferred.xsd", null) { Formatting = Formatting.Indented };
foreach (XmlSchema schema in schemas.Schemas())
{
    schema.Write(output);
}

# Trang, from the RELAX NG authors, is the best command-line option and takes
# as many samples as you can give it.
java -jar trang.jar -I xml -O xsd sample-1.xml sample-2.xml sample-3.xml inferred.xsd

# It will emit a DTD or a RELAX NG schema from the same input:
java -jar trang.jar -I xml -O dtd sample-1.xml inferred.dtd

# Then do the step most people skip: check the schema against the documents it
# was inferred from before trusting it.
xmllint --noout --nonet --schema inferred.xsd sample-1.xml