Just disable xml file validation.<br>
Speed up boostrap
182841
@Override
  protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {
    try {
      ErrorLogger errorLogger = new ErrorLogger(resourceName);
      SAXReader reader = xmlHelper.createSAXReader(errorLogger, getEntityResolver());
      reader.setValidation(false);
      Document document = reader.read(new InputSource(stream));
      if (errorLogger.hasErrors()) { throw new MappingException("invalid configuration",
          errorLogger.getErrors().get(0)); }
      doConfigure(document);
    } catch (DocumentException e) {
      throw new HibernateException("Could not parse configuration: " + resourceName, e);
    } finally {
      try {
        stream.close();
      } catch (IOException ioe) {
        logger.error("Could not close input stream for {}", resourceName);
      }
    }
    return this;
  }
698524
function isSCXMLValid(model){
        return new Promise(function(resolve, reject) {
            if(model === "") {
                reject("Model is empty");
                return;
            }

            validator.validateXML(model, __dirname + '/xmlSchemas/scxml.xsd', function(err, result) {
                if (err) {
                    reject(err);
                    return;
                }
                resolve(result.valid);
            })
        });
    }
244045
def visit_unload_from_select(element, compiler, **kw):
    """"""

    template = """
       UNLOAD (:select) TO :unload_location
       CREDENTIALS :credentials
       {manifest}
       {header}
       {delimiter}
       {encrypted}
       {fixed_width}
       {gzip}
       {add_quotes}
       {null}
       {escape}
       {allow_overwrite}
       {parallel}
       {region}
       {max_file_size}
    """
    el = element

    qs = template.format(
        manifest='MANIFEST' if el.manifest else '',
        header='HEADER' if el.header else '',
        delimiter=(
            'DELIMITER AS :delimiter' if el.delimiter is not None else ''
        ),
        encrypted='ENCRYPTED' if el.encrypted else '',
        fixed_width='FIXEDWIDTH AS :fixed_width' if el.fixed_width else '',
        gzip='GZIP' if el.gzip else '',
        add_quotes='ADDQUOTES' if el.add_quotes else '',
        escape='ESCAPE' if el.escape else '',
        null='NULL AS :null_as' if el.null is not None else '',
        allow_overwrite='ALLOWOVERWRITE' if el.allow_overwrite else '',
        parallel='PARALLEL OFF' if not el.parallel else '',
        region='REGION :region' if el.region is not None else '',
        max_file_size=(
            'MAXFILESIZE :max_file_size MB'
            if el.max_file_size is not None else ''
        ),
    )

    query = sa.text(qs)

    if el.delimiter is not None:
        query = query.bindparams(sa.bindparam(
            'delimiter', value=element.delimiter, type_=sa.String,
        ))

    if el.fixed_width:
        query = query.bindparams(sa.bindparam(
            'fixed_width',
            value=_process_fixed_width(el.fixed_width),
            type_=sa.String,
        ))

    if el.null is not None:
        query = query.bindparams(sa.bindparam(
            'null_as', value=el.null, type_=sa.String
        ))

    if el.region is not None:
        query = query.bindparams(sa.bindparam(
            'region', value=el.region, type_=sa.String
        ))

    if el.max_file_size is not None:
        max_file_size_mib = float(el.max_file_size) / 1024 / 1024
        query = query.bindparams(sa.bindparam(
            'max_file_size', value=max_file_size_mib, type_=sa.Float
        ))

    return compiler.process(
        query.bindparams(
            sa.bindparam('credentials', value=el.credentials, type_=sa.String),
            sa.bindparam(
                'unload_location', value=el.unload_location, type_=sa.String,
            ),
            sa.bindparam(
                'select',
                value=compiler.process(
                    el.select,
                    literal_binds=True,
                ),
                type_=sa.String,
            ),
        ),
        **kw
    )
1143491
function(){
			var indicator = lib.node(this._prefix+this._id);
			if (indicator) {
				indicator.parentNode.removeChild(indicator);
			}
		}
1240366
def _remove_legacy_bootstrap():
        """"""
        home = os.environ['HOME']
        old_base_dir = os.path.join(home, '.config', 'classpath_project_ensime')
        if os.path.isdir(old_base_dir):
            shutil.rmtree(old_base_dir, ignore_errors=True)
670064
private void cleanBvalCache() {
        if (isBeanValidationVersion11() && !FrameworkState.isStopping()) {
            ClassLoader classLoader = null;
            SetContextClassLoaderPrivileged setClassLoader = null;
            ClassLoader oldClassLoader = null;
            boolean wasTcclCreated = false;
            try {
                // Get a classloader that has the bean validation 1.1 API.
                classLoader = validationConfigFactorySR.getServiceWithException().getClass().getClassLoader();

                if (classLoader != null && !classLoadingServiceSR.getServiceWithException().isThreadContextClassLoader(classLoader)) {
                    classLoader = createTCCL(classLoader);
                    wasTcclCreated = true;
                }

                ThreadContextAccessor tca = System.getSecurityManager() == null ? ThreadContextAccessor.getThreadContextAccessor() : AccessController.doPrivileged(getThreadContextAccessorAction);

                // set the thread context class loader to be used, must be reset in finally block
                setClassLoader = new SetContextClassLoaderPrivileged(tca);
                oldClassLoader = setClassLoader.execute(classLoader);

                if (classLoader == null) {
                    classLoader = oldClassLoader;
                }

                Class<?> clazz = classLoader.loadClass("org.apache.bval.jsr.ConstraintAnnotationAttributes");
                final Field methodByNameAndClass = clazz.getDeclaredField("METHOD_BY_NAME_AND_CLASS");

                priv.setAccessible(methodByNameAndClass, true);

                Map<?, ?> methodMap = (Map<?, ?>) methodByNameAndClass.get(null);
                methodMap.clear();
            } catch (Exception e) {
                //ffdc
            } finally {
                if (setClassLoader != null) {
                    setClassLoader.execute(oldClassLoader);
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Set Class loader back to " + oldClassLoader);
                    }
                }
                if (classLoader != null && wasTcclCreated) {
                    releaseLoader(classLoader);
                }
            }
        }
    }
399314
def _strip_dirty(xmltree):
    '''
    
    '''
    dirty = xmltree.attrib.pop('dirtyId', None)
    if dirty:
        xmltree.attrib.pop('admin', None)
        xmltree.attrib.pop('time', None)

    for child in xmltree:
        child = _strip_dirty(child)

    return xmltree
1056864
private function SkipWhitespace()
	{
		do
		{
			// if ( XmlCharType.Instance.IsWhiteSpace( $this->Peek( 0 ) ) )
			if ( preg_match( "/\s/", $this->Peek( 0 ) ) )
			{
				$c;
				while ( ( $c = $this->Peek( 0 ) ) && ord( $c ) != 0 && preg_match( "/\s/", $c ) )
				{
					$this->Read();
				}
				continue;
			}
			if ( $this->Peek( 0 ) == '(' && $this->Peek( 1 ) == ':' )
			{
				$this->Read();
				$this->Read();
				$n = 1;
				while ( true )
				{
					$c = $this->Peek( 0 );
					if ( ord( $c ) == 0 )
					{
						break;
					}
					else if ( $c == '(' && $this->Peek( 1 ) == ':' )
					{
						$this->Read();
						$this->Read();
						$n++;
					}
					else if ( $c == ':' && $this->Peek( 1 ) == ')' )
					{
						$this->Read();
						$this->Read();
						if ( --$n == 0 )
						{
							break;
						}
					}
					else
					{
						$this->Read();
					}
				}
				if ( $n )
				{
					throw XPath2Exception::withErrorCodeAndParam( "XPST0003", Resources::XPST0003, "Comment not closed" );
				}
				continue;
			}
			break;
		}
		while ( true );
	}
1258562
public static void validateInputs(EditXmlInputs inputs) throws Exception {
        validateXmlAndFilePathInputs(inputs.getXml(), inputs.getFilePath());

        if (Constants.Inputs.MOVE_ACTION.equals(inputs.getAction())) {
            validateIsNotEmpty(inputs.getXpath2(), "xpath2 input is required for action 'move' ");
        }
        if (!Constants.Inputs.SUBNODE_ACTION.equals(inputs.getAction()) && !Constants.Inputs.MOVE_ACTION.equals(inputs.getAction())) {
            validateIsNotEmpty(inputs.getType(), "type input is required for action '" + inputs.getAction() + "'");
            if (!Constants.Inputs.TYPE_ELEM.equals(inputs.getType()) && !Constants.Inputs.TYPE_ATTR.equals(inputs.getType()) && !Constants.Inputs.TYPE_TEXT.equals(inputs.getType())) {
                throw new Exception("Invalid type. Only supported : " + Constants.Inputs.TYPE_ELEM + ", " + Constants.Inputs.TYPE_ATTR + ", " + Constants.Inputs.TYPE_TEXT);
            }
            if (Constants.Inputs.TYPE_ATTR.equals(inputs.getType())) {
                validateIsNotEmpty(inputs.getName(), "name input is required for type 'attr' ");
            }
        }
    }
1014742
def remove_response_property(xml_root):
    """"""
    if xml_root.tag == "testsuites":
        properties = xml_root.find("properties")
        resp_properties = []
        for prop in properties:
            prop_name = prop.get("name", "")
            if "polarion-response-" in prop_name:
                resp_properties.append(prop)
        for resp_property in resp_properties:
            properties.remove(resp_property)
    elif xml_root.tag in ("testcases", "requirements"):
        resp_properties = xml_root.find("response-properties")
        if resp_properties is not None:
            xml_root.remove(resp_properties)
    else:
        raise Dump2PolarionException(_NOT_EXPECTED_FORMAT_MSG)
690947
private Source sanitizeXml(@Nullable String xml) {
    if (xml != null && !sensitiveXPathStrings.isEmpty()) {
      try {
        DocumentBuilder documentBuilder = documentBuilderSupplier.get();
        XPath xpath = xpathSupplier.get();
        if (documentBuilder != null && xpath != null) {
          Document doc = documentBuilder.parse(new InputSource(new StringReader(xml)));
          for (String xpathString : sensitiveXPathStrings) {
            XPathExpression expr = xpath.compile(xpathString);
            Node node = (Node) expr.evaluate(doc, XPathConstants.NODE);
            if (node != null && node.getTextContent() != null) {
              node.setTextContent("REDACTED");
            }
          }
          return new DOMSource(doc);
        }
      } catch (SAXException e) {
        libLogger.warn("Unable to parse XML: {}", e);
      } catch (IOException e) {
        libLogger.warn("Unable to parse XML: {}", e);
      } catch (XPathExpressionException e) {
        libLogger.warn("Unable to parse XML: {}", e);
      }
    }
    return null;
  }
485515
def clean_bootstrap_builds(self, _args):
        """"""
        if exists(join(self.ctx.build_dir, 'bootstrap_builds')):
            shutil.rmtree(join(self.ctx.build_dir, 'bootstrap_builds'))
601351
def clean():
    """"""
    shutil.rmtree('{PROJECT_NAME}.egg-info'.format(PROJECT_NAME=PROJECT_NAME), ignore_errors=True)
    shutil.rmtree('build', ignore_errors=True)
    shutil.rmtree('dist', ignore_errors=True)
    shutil.rmtree('htmlcov', ignore_errors=True)
    shutil.rmtree('__pycache__', ignore_errors=True)
1182147
def remove_property(xml_root, partial_name):
    """"""
    if xml_root.tag in ("testsuites", "testcases", "requirements"):
        properties = xml_root.find("properties")
        remove_properties = []
        for prop in properties:
            prop_name = prop.get("name", "")
            if partial_name in prop_name:
                remove_properties.append(prop)
        for rem_prop in remove_properties:
            properties.remove(rem_prop)
    else:
        raise Dump2PolarionException(_NOT_EXPECTED_FORMAT_MSG)
1132169
private String removeAbsoluteRootPathElement(String xPath) {
        String trimmedXpath = xPath;
        if (xPath.startsWith("/") && xPath.charAt(1) != '/') {
            trimmedXpath = xPath.substring(1);
        }
        return trimmedXpath;
    }
1330737
function disallowNodeType(type) {

  return function() {

    function check(node, reporter) {

      if (is(node, type)) {
        reporter.report(node.id, 'Element has disallowed type <' + type + '>');
      }
    }

    return {
      check
    };

  };

}
694915
private function cleanupDOMDocument()
    {
        $expressions = array(
            '//comment()',
            '//processing-instruction()',
        );

        foreach ($expressions as $expression) {
            foreach ($this->xpath->query($expression) as $node) {
                $node->parentNode->removeChild($node);
            }
        }

        $this->dom->normalizeDocument();
    }