def _do_execv(self):
"""Re-execute the current process.
This must be called from the main thread, because certain platforms
(OS X) don't allow execv to be called in a child thread very well.
"""
args = sys.argv[:]
self._extend_pythonpath(os.environ)
logger.info('Re-spawning %s' % ' '.join(args))
logger.info("")
logger.info("%s Bye! %s", YEL("-" * 35), YEL("-" * 35))
logger.info("")
if sys.platform[:4] == 'java':
from _systemrestart import SystemRestart
raise SystemRestart
args.insert(0, sys.executable)
if sys.platform == 'win32':
args = ['"%s"' % arg for arg in args]
os.chdir(_module__file__base)
logger.debug("Change working directory to: %s", _module__file__base)
if self.max_cloexec_files:
self._set_cloexec()
os.execv(sys.executable, args)
def process_pending(self):
# process pending
self.debug0("6 %s processing pending complex_types", B(self.tns))
for (c_name, e_name), _v in list(self.pending_types.items()):
self.process_complex_type(_v)
self.debug0("7 %s processing pending elements", YEL(self.tns))
for _k, _v in self.pending_elements.items():
self.process_schema_element(_v)
def parse_schema(self, elt):
self.nsmap = dict(elt.nsmap.items())
self.prefmap = dict([(v, k) for k, v in self.nsmap.items()])
self.schema = schema = _prot.from_element(self, XmlSchema10, elt)
self.pending_types = {}
self.pending_elements = {}
self.tns = tns = schema.target_namespace
if self.tns is None:
self.tns = tns = '__no_ns__'
if tns in self.retval:
return
self.retval[tns] = _Schema()
self.debug0("1 %s processing includes", MAG(tns))
if schema.includes:
for include in schema.includes:
self.process_includes(include)
if schema.elements:
schema.elements = odict([(e.name, e) for e in schema.elements])
if schema.complex_types:
schema.complex_types = odict([(c.name, c)
for c in schema.complex_types])
if schema.simple_types:
schema.simple_types = odict([(s.name, s)
for s in schema.simple_types])
if schema.attributes:
schema.attributes = odict([(a.name, a) for a in schema.attributes])
self.debug0("2 %s processing imports", R(tns))
if schema.imports:
for imp in schema.imports:
if not imp.namespace in self.retval:
self.debug1("%s importing %s", tns, imp.namespace)
fname = self.files[imp.namespace]
self.clone(2, dirname(fname)).parse_schema_file(fname)
self.retval[tns].imports.add(imp.namespace)
self.debug0("3 %s processing simple_types", G(tns))
if schema.simple_types:
for s in schema.simple_types.values():
self.process_simple_type(s)
# no simple types should have been left behind.
assert sum((len(v) for v in self.pending_simple_types.values())) == 0, \
self.pending_simple_types.values()
self.debug0("4 %s processing attributes", G(tns))
if schema.attributes:
for s in schema.attributes.values():
n, t = self.process_attribute(s)
self.retval[self.tns].types[n] = t
self.debug0("5 %s processing complex_types", B(tns))
if schema.complex_types:
for c in schema.complex_types.values():
self.process_complex_type(c)
self.debug0("6 %s processing elements", YEL(tns))
if schema.elements:
for e in schema.elements.values():
self.process_schema_element(e)
self.process_pending()
if self.parent is None: # for the top-most schema
if self.children is not None: # if it uses <include> or <import>
# This is needed for schemas with circular imports
for c in chain([self], self.children):
c.print_pending()
self.debug0('')
# FIXME: should put this in a while loop that loops until no
# changes occur
for c in chain([self], self.children):
c.process_pending()
for c in chain([self], self.children):
c.process_pending()
self.debug0('')
for c in chain([self], self.children):
c.print_pending(fail=(not self.skip_errors))
return self.retval