Mercurial Mercurial > beremiz / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
xmlclass/xsdschema.py
branchpython3
changeset 3752 9f6f46dbe3ae
parent 3750 f62625418bff
equal deleted inserted replaced
3751:a80a66ba52d6 3752:9f6f46dbe3ae 
    21 # You should have received a copy of the GNU General Public License
 
    21 # You should have received a copy of the GNU General Public License
 
    22 # along with this program; if not, write to the Free Software
 
    22 # along with this program; if not, write to the Free Software
 
    23 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
    23 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
    24 
    24 
    25 
    25 
    26 
       
    27 
       
    28 import os
 
    26 import os
 
    29 import re
 
    27 import re
 
    30 import datetime
 
    28 import datetime
 
    31 from types import FunctionType
 
    29 from types import FunctionType
 
    32 from xml.dom import minidom
 
    30 from xml.dom import minidom
 
    33 from future.builtins import round
 
       
    34 from six import string_types
 
       
    35 from past.builtins import int
 
       
    36 
    31 
    37 from xmlclass.xmlclass import *
 
    32 from xmlclass.xmlclass import *
 
    38 
    33 
    39 
    34 
    40 def GenerateDictFacets(facets):
 
    35 def GenerateDictFacets(facets):
 
   168     if "name" in attributes:
 
   163     if "name" in attributes:
 
   169         simpleType["name"] = attributes["name"]
 
   164         simpleType["name"] = attributes["name"]
 
   170 
   165 
   171     if typeinfos["type"] in ["restriction", "extension"]:
 
   166     if typeinfos["type"] in ["restriction", "extension"]:
 
   172         # Search for base type definition
 
   167         # Search for base type definition
 
   173         if isinstance(typeinfos["base"], string_types):
 
   168         if isinstance(typeinfos["base"], str):
 
   174             basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)
 
   169             basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)
 
   175             if basetypeinfos is None:
 
   170             if basetypeinfos is None:
 
   176                 raise "\"%s\" isn't defined!" % typeinfos["base"]
 
   171                 raise "\"%s\" isn't defined!" % typeinfos["base"]
 
   177         else:
 
   172         else:
 
   178             basetypeinfos = typeinfos["base"]
 
   173             basetypeinfos = typeinfos["base"]
 
   392 
   387 
   393         GenerateSimpleType = basetypeinfos["generate"]
 
   388         GenerateSimpleType = basetypeinfos["generate"]
 
   394 
   389 
   395     elif typeinfos["type"] == "list":
 
   390     elif typeinfos["type"] == "list":
 
   396         # Search for item type definition
 
   391         # Search for item type definition
 
   397         if isinstance(typeinfos["itemType"], string_types):
 
   392         if isinstance(typeinfos["itemType"], str):
 
   398             itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)
 
   393             itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)
 
   399             if itemtypeinfos is None:
 
   394             if itemtypeinfos is None:
 
   400                 raise "\"%s\" isn't defined!" % typeinfos["itemType"]
 
   395                 raise "\"%s\" isn't defined!" % typeinfos["itemType"]
 
   401         else:
 
   396         else:
 
   402             itemtypeinfos = typeinfos["itemType"]
 
   397             itemtypeinfos = typeinfos["itemType"]
 
   438 
   433 
   439     elif typeinfos["type"] == "union":
 
   434     elif typeinfos["type"] == "union":
 
   440         # Search for member types definition
 
   435         # Search for member types definition
 
   441         membertypesinfos = []
 
   436         membertypesinfos = []
 
   442         for membertype in typeinfos["memberTypes"]:
 
   437         for membertype in typeinfos["memberTypes"]:
 
   443             if isinstance(membertype, string_types):
 
   438             if isinstance(membertype, str):
 
   444                 infos = factory.FindSchemaElement(membertype, SIMPLETYPE)
 
   439                 infos = factory.FindSchemaElement(membertype, SIMPLETYPE)
 
   445                 if infos is None:
 
   440                 if infos is None:
 
   446                     raise ValueError("\"%s\" isn't defined!" % membertype)
 
   441                     raise ValueError("\"%s\" isn't defined!" % membertype)
 
   447             else:
 
   442             else:
 
   448                 infos = membertype
 
   443                 infos = membertype
 
   512 def ExtractAttributes(factory, elements, base=None):
 
   507 def ExtractAttributes(factory, elements, base=None):
 
   513     attrs = []
 
   508     attrs = []
 
   514     attrnames = {}
 
   509     attrnames = {}
 
   515     if base is not None:
 
   510     if base is not None:
 
   516         basetypeinfos = factory.FindSchemaElement(base)
 
   511         basetypeinfos = factory.FindSchemaElement(base)
 
   517         if not isinstance(basetypeinfos, string_types) and basetypeinfos["type"] == COMPLEXTYPE:
 
   512         if not isinstance(basetypeinfos, str) and basetypeinfos["type"] == COMPLEXTYPE:
 
   518             attrnames = dict([(x["name"], True) for x in basetypeinfos["attributes"]])
 
   513             attrnames = dict([(x["name"], True) for x in basetypeinfos["attributes"]])
 
   519 
   514 
   520     for element in elements:
 
   515     for element in elements:
 
   521         if element["type"] == ATTRIBUTE:
 
   516         if element["type"] == ATTRIBUTE:
 
   522             if attrnames.get(element["name"], False):
 
   517             if attrnames.get(element["name"], False):
 
   813             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 
   808             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 
   814             if "choices" not in elmtgroup:
 
   809             if "choices" not in elmtgroup:
 
   815                 raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")
 
   810                 raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")
 
   816             choices_tmp = []
 
   811             choices_tmp = []
 
   817             for choice in elmtgroup["choices"]:
 
   812             for choice in elmtgroup["choices"]:
 
   818                 if not isinstance(choice["elmt_type"], string_types) and choice["elmt_type"]["type"] == COMPLEXTYPE:
 
   813                 if not isinstance(choice["elmt_type"], str) and choice["elmt_type"]["type"] == COMPLEXTYPE:
 
   819                     elmt_type = "%s_%s" % (elmtgroup["name"], choice["name"])
 
   814                     elmt_type = "%s_%s" % (elmtgroup["name"], choice["name"])
 
   820                     if factory.TargetNamespace is not None:
 
   815                     if factory.TargetNamespace is not None:
 
   821                         elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 
   816                         elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 
   822                     new_choice = choice.copy()
 
   817                     new_choice = choice.copy()
 
   823                     new_choice["elmt_type"] = elmt_type
 
   818                     new_choice["elmt_type"] = elmt_type
 
   847             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 
   842             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 
   848             if "elements" not in elmtgroup or not elmtgroup["order"]:
 
   843             if "elements" not in elmtgroup or not elmtgroup["order"]:
 
   849                 raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")
 
   844                 raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")
 
   850             elements_tmp = []
 
   845             elements_tmp = []
 
   851             for element in elmtgroup["elements"]:
 
   846             for element in elmtgroup["elements"]:
 
   852                 if not isinstance(element["elmt_type"], string_types) and element["elmt_type"]["type"] == COMPLEXTYPE:
 
   847                 if not isinstance(element["elmt_type"], str) and element["elmt_type"]["type"] == COMPLEXTYPE:
 
   853                     elmt_type = "%s_%s" % (elmtgroup["name"], element["name"])
 
   848                     elmt_type = "%s_%s" % (elmtgroup["name"], element["name"])
 
   854                     if factory.TargetNamespace is not None:
 
   849                     if factory.TargetNamespace is not None:
 
   855                         elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 
   850                         elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 
   856                     new_element = element.copy()
 
   851                     new_element = element.copy()
 
   857                     new_element["elmt_type"] = elmt_type
 
   852                     new_element["elmt_type"] = elmt_type
 
  2213         "basename": "string",
 
  2208         "basename": "string",
 
  2214         "extract": GetAttributeValue,
 
  2209         "extract": GetAttributeValue,
 
  2215         "facets": STRING_FACETS,
 
  2210         "facets": STRING_FACETS,
 
  2216         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2211         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2217         "initial": lambda: "",
 
  2212         "initial": lambda: "",
 
  2218         "check": lambda x: isinstance(x, string_types)},
 
  2213         "check": lambda x: isinstance(x, str)},
 
  2219 
  2214 
  2220     "normalizedString": {
 
  2215     "normalizedString": {
 
  2221         "type": SIMPLETYPE,
 
  2216         "type": SIMPLETYPE,
 
  2222         "basename": "normalizedString",
 
  2217         "basename": "normalizedString",
 
  2223         "extract": GetNormalizedString,
 
  2218         "extract": GetNormalizedString,
 
  2224         "facets": STRING_FACETS,
 
  2219         "facets": STRING_FACETS,
 
  2225         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2220         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2226         "initial": lambda: "",
 
  2221         "initial": lambda: "",
 
  2227         "check": lambda x: isinstance(x, string_types)
 
  2222         "check": lambda x: isinstance(x, str)
 
  2228     },
 
  2223     },
 
  2229 
  2224 
  2230     "token": {
 
  2225     "token": {
 
  2231         "type": SIMPLETYPE,
 
  2226         "type": SIMPLETYPE,
 
  2232         "basename": "token",
 
  2227         "basename": "token",
 
  2233         "extract": GetToken,
 
  2228         "extract": GetToken,
 
  2234         "facets": STRING_FACETS,
 
  2229         "facets": STRING_FACETS,
 
  2235         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2230         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2236         "initial": lambda: "",
 
  2231         "initial": lambda: "",
 
  2237         "check": lambda x: isinstance(x, string_types)
 
  2232         "check": lambda x: isinstance(x, str)
 
  2238     },
 
  2233     },
 
  2239 
  2234 
  2240     "base64Binary": {
 
  2235     "base64Binary": {
 
  2241         "type": SIMPLETYPE,
 
  2236         "type": SIMPLETYPE,
 
  2242         "basename": "base64Binary",
 
  2237         "basename": "base64Binary",
 
  2432         "basename": "duration",
 
  2427         "basename": "duration",
 
  2433         "extract": NotSupportedYet("duration"),
 
  2428         "extract": NotSupportedYet("duration"),
 
  2434         "facets": NUMBER_FACETS,
 
  2429         "facets": NUMBER_FACETS,
 
  2435         "generate": GenerateSimpleTypeXMLText(str),
 
  2430         "generate": GenerateSimpleTypeXMLText(str),
 
  2436         "initial": lambda: "",
 
  2431         "initial": lambda: "",
 
  2437         "check": lambda x: isinstance(x, string_types)
 
  2432         "check": lambda x: isinstance(x, str)
 
  2438     },
 
  2433     },
 
  2439 
  2434 
  2440     "dateTime": {
 
  2435     "dateTime": {
 
  2441         "type": SIMPLETYPE,
 
  2436         "type": SIMPLETYPE,
 
  2442         "basename": "dateTime",
 
  2437         "basename": "dateTime",
 
  2472         "basename": "gYear",
 
  2467         "basename": "gYear",
 
  2473         "extract": NotSupportedYet("gYear"),
 
  2468         "extract": NotSupportedYet("gYear"),
 
  2474         "facets": NUMBER_FACETS,
 
  2469         "facets": NUMBER_FACETS,
 
  2475         "generate": GenerateSimpleTypeXMLText(str),
 
  2470         "generate": GenerateSimpleTypeXMLText(str),
 
  2476         "initial": lambda: "",
 
  2471         "initial": lambda: "",
 
  2477         "check": lambda x: isinstance(x, string_types)
 
  2472         "check": lambda x: isinstance(x, str)
 
  2478     },
 
  2473     },
 
  2479 
  2474 
  2480     "gYearMonth": {
 
  2475     "gYearMonth": {
 
  2481         "type": SIMPLETYPE,
 
  2476         "type": SIMPLETYPE,
 
  2482         "basename": "gYearMonth",
 
  2477         "basename": "gYearMonth",
 
  2483         "extract": NotSupportedYet("gYearMonth"),
 
  2478         "extract": NotSupportedYet("gYearMonth"),
 
  2484         "facets": NUMBER_FACETS,
 
  2479         "facets": NUMBER_FACETS,
 
  2485         "generate": GenerateSimpleTypeXMLText(str),
 
  2480         "generate": GenerateSimpleTypeXMLText(str),
 
  2486         "initial": lambda: "",
 
  2481         "initial": lambda: "",
 
  2487         "check": lambda x: isinstance(x, string_types)
 
  2482         "check": lambda x: isinstance(x, str)
 
  2488     },
 
  2483     },
 
  2489 
  2484 
  2490     "gMonth": {
 
  2485     "gMonth": {
 
  2491         "type": SIMPLETYPE,
 
  2486         "type": SIMPLETYPE,
 
  2492         "basename": "gMonth",
 
  2487         "basename": "gMonth",
 
  2493         "extract": NotSupportedYet("gMonth"),
 
  2488         "extract": NotSupportedYet("gMonth"),
 
  2494         "facets": NUMBER_FACETS,
 
  2489         "facets": NUMBER_FACETS,
 
  2495         "generate": GenerateSimpleTypeXMLText(str),
 
  2490         "generate": GenerateSimpleTypeXMLText(str),
 
  2496         "initial": lambda: "",
 
  2491         "initial": lambda: "",
 
  2497         "check": lambda x: isinstance(x, string_types)
 
  2492         "check": lambda x: isinstance(x, str)
 
  2498     },
 
  2493     },
 
  2499 
  2494 
  2500     "gMonthDay": {
 
  2495     "gMonthDay": {
 
  2501         "type": SIMPLETYPE,
 
  2496         "type": SIMPLETYPE,
 
  2502         "basename": "gMonthDay",
 
  2497         "basename": "gMonthDay",
 
  2503         "extract": NotSupportedYet("gMonthDay"),
 
  2498         "extract": NotSupportedYet("gMonthDay"),
 
  2504         "facets": NUMBER_FACETS,
 
  2499         "facets": NUMBER_FACETS,
 
  2505         "generate": GenerateSimpleTypeXMLText(str),
 
  2500         "generate": GenerateSimpleTypeXMLText(str),
 
  2506         "initial": lambda: "",
 
  2501         "initial": lambda: "",
 
  2507         "check": lambda x: isinstance(x, string_types)
 
  2502         "check": lambda x: isinstance(x, str)
 
  2508     },
 
  2503     },
 
  2509 
  2504 
  2510     "gDay": {
 
  2505     "gDay": {
 
  2511         "type": SIMPLETYPE,
 
  2506         "type": SIMPLETYPE,
 
  2512         "basename": "gDay",
 
  2507         "basename": "gDay",
 
  2513         "extract": NotSupportedYet("gDay"),
 
  2508         "extract": NotSupportedYet("gDay"),
 
  2514         "facets": NUMBER_FACETS,
 
  2509         "facets": NUMBER_FACETS,
 
  2515         "generate": GenerateSimpleTypeXMLText(str),
 
  2510         "generate": GenerateSimpleTypeXMLText(str),
 
  2516         "initial": lambda: "",
 
  2511         "initial": lambda: "",
 
  2517         "check": lambda x: isinstance(x, string_types)
 
  2512         "check": lambda x: isinstance(x, str)
 
  2518     },
 
  2513     },
 
  2519 
  2514 
  2520     "Name": {
 
  2515     "Name": {
 
  2521         "type": SIMPLETYPE,
 
  2516         "type": SIMPLETYPE,
 
  2522         "basename": "Name",
 
  2517         "basename": "Name",
 
  2523         "extract": GenerateModelNameExtraction("Name", Name_model),
 
  2518         "extract": GenerateModelNameExtraction("Name", Name_model),
 
  2524         "facets": STRING_FACETS,
 
  2519         "facets": STRING_FACETS,
 
  2525         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2520         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2526         "initial": lambda: "",
 
  2521         "initial": lambda: "",
 
  2527         "check": lambda x: isinstance(x, string_types)
 
  2522         "check": lambda x: isinstance(x, str)
 
  2528     },
 
  2523     },
 
  2529 
  2524 
  2530     "QName": {
 
  2525     "QName": {
 
  2531         "type": SIMPLETYPE,
 
  2526         "type": SIMPLETYPE,
 
  2532         "basename": "QName",
 
  2527         "basename": "QName",
 
  2533         "extract": GenerateModelNameExtraction("QName", QName_model),
 
  2528         "extract": GenerateModelNameExtraction("QName", QName_model),
 
  2534         "facets": STRING_FACETS,
 
  2529         "facets": STRING_FACETS,
 
  2535         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2530         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2536         "initial": lambda: "",
 
  2531         "initial": lambda: "",
 
  2537         "check": lambda x: isinstance(x, string_types)
 
  2532         "check": lambda x: isinstance(x, str)
 
  2538     },
 
  2533     },
 
  2539 
  2534 
  2540     "NCName": {
 
  2535     "NCName": {
 
  2541         "type": SIMPLETYPE,
 
  2536         "type": SIMPLETYPE,
 
  2542         "basename": "NCName",
 
  2537         "basename": "NCName",
 
  2543         "extract": GenerateModelNameExtraction("NCName", NCName_model),
 
  2538         "extract": GenerateModelNameExtraction("NCName", NCName_model),
 
  2544         "facets": STRING_FACETS,
 
  2539         "facets": STRING_FACETS,
 
  2545         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2540         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2546         "initial": lambda: "",
 
  2541         "initial": lambda: "",
 
  2547         "check": lambda x: isinstance(x, string_types)
 
  2542         "check": lambda x: isinstance(x, str)
 
  2548     },
 
  2543     },
 
  2549 
  2544 
  2550     "anyURI": {
 
  2545     "anyURI": {
 
  2551         "type": SIMPLETYPE,
 
  2546         "type": SIMPLETYPE,
 
  2552         "basename": "anyURI",
 
  2547         "basename": "anyURI",
 
  2553         "extract": GenerateModelNameExtraction("anyURI", URI_model),
 
  2548         "extract": GenerateModelNameExtraction("anyURI", URI_model),
 
  2554         "facets": STRING_FACETS,
 
  2549         "facets": STRING_FACETS,
 
  2555         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2550         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2556         "initial": lambda: "",
 
  2551         "initial": lambda: "",
 
  2557         "check": lambda x: isinstance(x, string_types)
 
  2552         "check": lambda x: isinstance(x, str)
 
  2558     },
 
  2553     },
 
  2559 
  2554 
  2560     "language": {
 
  2555     "language": {
 
  2561         "type": SIMPLETYPE,
 
  2556         "type": SIMPLETYPE,
 
  2562         "basename": "language",
 
  2557         "basename": "language",
 
  2563         "extract": GenerateModelNameExtraction("language", LANGUAGE_model),
 
  2558         "extract": GenerateModelNameExtraction("language", LANGUAGE_model),
 
  2564         "facets": STRING_FACETS,
 
  2559         "facets": STRING_FACETS,
 
  2565         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2560         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2566         "initial": lambda: "en",
 
  2561         "initial": lambda: "en",
 
  2567         "check": lambda x: isinstance(x, string_types)
 
  2562         "check": lambda x: isinstance(x, str)
 
  2568     },
 
  2563     },
 
  2569 
  2564 
  2570     "ID": {
 
  2565     "ID": {
 
  2571         "type": SIMPLETYPE,
 
  2566         "type": SIMPLETYPE,
 
  2572         "basename": "ID",
 
  2567         "basename": "ID",
 
  2573         "extract": GenerateModelNameExtraction("ID", Name_model),
 
  2568         "extract": GenerateModelNameExtraction("ID", Name_model),
 
  2574         "facets": STRING_FACETS,
 
  2569         "facets": STRING_FACETS,
 
  2575         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2570         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2576         "initial": lambda: "",
 
  2571         "initial": lambda: "",
 
  2577         "check": lambda x: isinstance(x, string_types)
 
  2572         "check": lambda x: isinstance(x, str)
 
  2578     },
 
  2573     },
 
  2579 
  2574 
  2580     "IDREF": {
 
  2575     "IDREF": {
 
  2581         "type": SIMPLETYPE,
 
  2576         "type": SIMPLETYPE,
 
  2582         "basename": "IDREF",
 
  2577         "basename": "IDREF",
 
  2583         "extract": GenerateModelNameExtraction("IDREF", Name_model),
 
  2578         "extract": GenerateModelNameExtraction("IDREF", Name_model),
 
  2584         "facets": STRING_FACETS,
 
  2579         "facets": STRING_FACETS,
 
  2585         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2580         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2586         "initial": lambda: "",
 
  2581         "initial": lambda: "",
 
  2587         "check": lambda x: isinstance(x, string_types)
 
  2582         "check": lambda x: isinstance(x, str)
 
  2588     },
 
  2583     },
 
  2589 
  2584 
  2590     "IDREFS": {
 
  2585     "IDREFS": {
 
  2591         "type": SIMPLETYPE,
 
  2586         "type": SIMPLETYPE,
 
  2592         "basename": "IDREFS",
 
  2587         "basename": "IDREFS",
 
  2593         "extract": GenerateModelNameExtraction("IDREFS", Names_model),
 
  2588         "extract": GenerateModelNameExtraction("IDREFS", Names_model),
 
  2594         "facets": STRING_FACETS,
 
  2589         "facets": STRING_FACETS,
 
  2595         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2590         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2596         "initial": lambda: "",
 
  2591         "initial": lambda: "",
 
  2597         "check": lambda x: isinstance(x, string_types)
 
  2592         "check": lambda x: isinstance(x, str)
 
  2598     },
 
  2593     },
 
  2599 
  2594 
  2600     "ENTITY": {
 
  2595     "ENTITY": {
 
  2601         "type": SIMPLETYPE,
 
  2596         "type": SIMPLETYPE,
 
  2602         "basename": "ENTITY",
 
  2597         "basename": "ENTITY",
 
  2603         "extract": GenerateModelNameExtraction("ENTITY", Name_model),
 
  2598         "extract": GenerateModelNameExtraction("ENTITY", Name_model),
 
  2604         "facets": STRING_FACETS,
 
  2599         "facets": STRING_FACETS,
 
  2605         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2600         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2606         "initial": lambda: "",
 
  2601         "initial": lambda: "",
 
  2607         "check": lambda x: isinstance(x, string_types)
 
  2602         "check": lambda x: isinstance(x, str)
 
  2608     },
 
  2603     },
 
  2609 
  2604 
  2610     "ENTITIES": {
 
  2605     "ENTITIES": {
 
  2611         "type": SIMPLETYPE,
 
  2606         "type": SIMPLETYPE,
 
  2612         "basename": "ENTITIES",
 
  2607         "basename": "ENTITIES",
 
  2613         "extract": GenerateModelNameExtraction("ENTITIES", Names_model),
 
  2608         "extract": GenerateModelNameExtraction("ENTITIES", Names_model),
 
  2614         "facets": STRING_FACETS,
 
  2609         "facets": STRING_FACETS,
 
  2615         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2610         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2616         "initial": lambda: "",
 
  2611         "initial": lambda: "",
 
  2617         "check": lambda x: isinstance(x, string_types)
 
  2612         "check": lambda x: isinstance(x, str)
 
  2618     },
 
  2613     },
 
  2619 
  2614 
  2620     "NOTATION": {
 
  2615     "NOTATION": {
 
  2621         "type": SIMPLETYPE,
 
  2616         "type": SIMPLETYPE,
 
  2622         "basename": "NOTATION",
 
  2617         "basename": "NOTATION",
 
  2623         "extract": GenerateModelNameExtraction("NOTATION", Name_model),
 
  2618         "extract": GenerateModelNameExtraction("NOTATION", Name_model),
 
  2624         "facets": STRING_FACETS,
 
  2619         "facets": STRING_FACETS,
 
  2625         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2620         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2626         "initial": lambda: "",
 
  2621         "initial": lambda: "",
 
  2627         "check": lambda x: isinstance(x, string_types)
 
  2622         "check": lambda x: isinstance(x, str)
 
  2628     },
 
  2623     },
 
  2629 
  2624 
  2630     "NMTOKEN": {
 
  2625     "NMTOKEN": {
 
  2631         "type": SIMPLETYPE,
 
  2626         "type": SIMPLETYPE,
 
  2632         "basename": "NMTOKEN",
 
  2627         "basename": "NMTOKEN",
 
  2633         "extract": GenerateModelNameExtraction("NMTOKEN", NMToken_model),
 
  2628         "extract": GenerateModelNameExtraction("NMTOKEN", NMToken_model),
 
  2634         "facets": STRING_FACETS,
 
  2629         "facets": STRING_FACETS,
 
  2635         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2630         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2636         "initial": lambda: "",
 
  2631         "initial": lambda: "",
 
  2637         "check": lambda x: isinstance(x, string_types)
 
  2632         "check": lambda x: isinstance(x, str)
 
  2638     },
 
  2633     },
 
  2639 
  2634 
  2640     "NMTOKENS": {
 
  2635     "NMTOKENS": {
 
  2641         "type": SIMPLETYPE,
 
  2636         "type": SIMPLETYPE,
 
  2642         "basename": "NMTOKENS",
 
  2637         "basename": "NMTOKENS",
 
  2643         "extract": GenerateModelNameExtraction("NMTOKENS", NMTokens_model),
 
  2638         "extract": GenerateModelNameExtraction("NMTOKENS", NMTokens_model),
 
  2644         "facets": STRING_FACETS,
 
  2639         "facets": STRING_FACETS,
 
  2645         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2640         "generate": GenerateSimpleTypeXMLText(lambda x: x),
 
  2646         "initial": lambda: "",
 
  2641         "initial": lambda: "",
 
  2647         "check": lambda x: isinstance(x, string_types)
 
  2642         "check": lambda x: isinstance(x, str)
 
  2648     },
 
  2643     },
 
  2649 
  2644 
  2650     # Complex Types
 
  2645     # Complex Types
 
  2651     "anyType": {"type": COMPLEXTYPE, "extract": lambda x: None},
 
  2646     "anyType": {"type": COMPLEXTYPE, "extract": lambda x: None},
 
  2652 }
 
  2647 }
beremiz