26

import sys, re, datetime

    30

LANGUAGES = ["en-US", "fr-FR", "en", "fr"]

    31

    32

"""

    33

Regular expression models for check all kind of string

    34

"""

    35

Name_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*)$')

    36

Names_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*(?: [a-zA-Z_\:][\w\.\-\:]*)*)$')

    37

NMToken_model = re.compile('([\w\.\-\:]*)$')

    38

NMTokens_model = re.compile('([\w\.\-\:]*(?: [\w\.\-\:]*)*)$')

    39

QName_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)$')

    40

QNames_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*(?: (?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)*)$')

    41

NCName_model = re.compile('([a-zA-Z_][\w]*)$')

    42

URI_model = re.compile('((?:http://|/)?(?:[\w.]*/?)*)$')

    43

    44

ONLY_ANNOTATION = re.compile("((?:annotation )?)")

    45

    49

time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)(?:Z)?$')

    50

date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')

    51

datetime_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')

    52

    53

class xml_timezone(datetime.tzinfo):

    74

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE, 

    75

 ATTRIBUTESGROUP, ELEMENTSGROUP, ATTRIBUTE, ELEMENT, CHOICE, ANY, TAG

    76

] = range(12)

    77

    78

def NotSupportedYet(type):

    79

    """

    80

    Function that generates a function that point out to user that datatype asked

    81

    are not yet supported by xmlclass

    82

    @param type: data type

    83

    @return: function generated

    84

    """

    85

    def GetUnknownValue(attr):

    86

        raise ValueError, "\"%s\" type isn't supported by \"xmlclass\" yet!"%type

    87

    return GetUnknownValue

    97

    98

def GetAttributeValue(attr, extract = True):

    99

    """

   100

    Function that extracts data from a tree node

   101

    @param attr: tree node containing data to extract

   102

    @param extract: attr is a tree node or not

   103

    @return: data extracted as string

   104

    """

   105

    if not extract:

   106

        return attr

   110

        # content is a CDATA

   117

   118

def GetNormalizedString(attr, extract = True):

   119

    """

   120

    Function that normalizes a string according to XML 1.0. Replace tabulations, 

   121

    line feed and carriage return by white space

   122

    @param attr: tree node containing data to extract or data to normalize

   123

    @param extract: attr is a tree node or not

   124

    @return: data normalized as string

   125

    """

   126

    if extract:

   127

        return GetAttributeValue(attr).replace("\n", " ").replace("\t", " ")

   129

        return attr.replace("\n", " ").replace("\t", " ")

   130

   131

   132

def GetToken(attr, extract = True):

   133

    """

   134

    Function that tokenizes a string according to XML 1.0. Remove any leading and 

   135

    trailing white space and replace internal sequence of two or more spaces by 

   136

    only one white space

   137

    @param attr: tree node containing data to extract or data to tokenize

   138

    @param extract: attr is a tree node or not

   139

    @return: data tokenized as string

   140

    """

   141

    return " ".join([part for part in GetNormalizedString(attr, extract).split(" ") if part])

   142

   143

   144

def GetHexInteger(attr, extract = True):

   145

    """

   146

    Function that extracts an hexadecimal integer from a tree node or a string

   147

    @param attr: tree node containing data to extract or data as a string

   148

    @param extract: attr is a tree node or not

   149

    @return: data as an integer

   150

    """

   151

    if extract:

   152

        value = GetAttributeValue(attr)

   153

    else:

   154

        value = attr

   155

    try:

   156

        return int(value, 16)

   157

    except:

   158

        raise ValueError, "\"%s\" isn't a valid hexadecimal integer!"%value

   159

   160

   161

def GenerateIntegerExtraction(minInclusive = None, maxInclusive = None, minExclusive = None, maxExclusive = None):

   162

    """

   163

    Function that generates an extraction function for integer defining min and max

   164

    of integer value

   165

    @param minInclusive: inclusive minimum

   166

    @param maxInclusive: inclusive maximum

   167

    @param minExclusive: exclusive minimum

   168

    @param maxExclusive: exclusive maximum

   169

    @return: function generated

   170

    """

   171

    def GetInteger(attr, extract = True):

   172

        """

   173

        Function that extracts an integer from a tree node or a string

   174

        @param attr: tree node containing data to extract or data as a string

   175

        @param extract: attr is a tree node or not

   176

        @return: data as an integer

   177

        """

   178

   179

        if extract:

   180

            value = GetAttributeValue(attr)

   181

        else:

   182

            value = attr

   183

        try:

   184

            # TODO: permit to write value like 1E2

   185

            value = int(value)

   186

        except:

   187

            raise ValueError, "\"%s\" isn't a valid integer!"%value

   188

        if minInclusive is not None and value < minInclusive:

   189

            raise ValueError, "%d isn't greater or equal to %d!"%(value, minInclusive)

   190

        if maxInclusive is not None and value > maxInclusive:

   191

            raise ValueError, "%d isn't lesser or equal to %d!"%(value, maxInclusive)

   192

        if minExclusive is not None and value <= minExclusive:

   193

            raise ValueError, "%d isn't greater than %d!"%(value, minExclusive)

   194

        if maxExclusive is not None and value >= maxExclusive:

   195

            raise ValueError, "%d isn't lesser than %d!"%(value, maxExclusive)

   197

    return GetInteger

   198

   199

   200

def GenerateFloatExtraction(type, extra_values = []):

   201

    """

   202

    Function that generates an extraction function for float

   203

    @param type: name of the type of float

   204

    @return: function generated

   205

    """

   206

    def GetFloat(attr, extract = True):

   207

        """

   208

        Function that extracts a float from a tree node or a string

   209

        @param attr: tree node containing data to extract or data as a string

   210

        @param extract: attr is a tree node or not

   211

        @return: data as a float

   212

        """

   213

        if extract:

   214

            value = GetAttributeValue(attr)

   215

        else:

   216

            value = attr

   217

        try:

   218

            if value in extra_values:

   219

                return value

   220

            return float(value)

   221

        except:

   222

            raise ValueError, "\"%s\" isn't a valid %s!"%(value, type)

   223

    return GetFloat

   224

   225

   226

def GetBoolean(attr, extract = True):

   227

    """

   228

    Function that extracts a boolean from a tree node or a string

   229

    @param attr: tree node containing data to extract or data as a string

   230

    @param extract: attr is a tree node or not

   231

    @return: data as a boolean

   232

    """

   233

    if extract:

   234

        value = GetAttributeValue(attr)

   236

        value = attr

   237

    if value == "true" or value == "1":

   238

        return True

   239

    elif value == "false" or value == "0":

   240

        return False

   241

    else:

   242

        raise ValueError, "\"%s\" isn't a valid boolean!"%value

   243

   244

   245

def GetTime(attr, extract = True):

   246

    """

   247

    Function that extracts a time from a tree node or a string

   248

    @param attr: tree node containing data to extract or data as a string

   249

    @param extract: attr is a tree node or not

   250

    @return: data as a time

   251

    """

   252

    if extract:

   253

        result = time_model.match(GetAttributeValue(attr))

   254

    else:

   255

        result = time_model.match(attr)

   256

    if result:

   257

        values = result.groups()

   258

        time_values = [int(v) for v in values[:2]]

   259

        seconds = float(values[2])

   260

        time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   261

        return datetime.time(*time_values)

   262

    else:

   263

        raise ValueError, "\"%s\" is not a valid time!"%value

   264

   265

   266

def GetDate(attr, extract = True):

   267

    """

   268

    Function that extracts a date from a tree node or a string

   269

    @param attr: tree node containing data to extract or data as a string

   270

    @param extract: attr is a tree node or not

   271

    @return: data as a date

   272

    """

   273

    if extract:

   274

        result = date_model.match(GetAttributeValue(attr))

   275

    else:

   276

        result = date_model.match(attr)

   277

    if result:

   278

        values = result.groups()

   279

        date_values = [int(v) for v in values[:3]]

   280

        if values[3] is not None:

   281

            tz = xml_timezone()

   282

            tz.SetOffset(values[3])

   283

            date_values.append(tz)

   284

        return datetime.date(*date_values)

   285

    else:

   286

        raise ValueError, "\"%s\" is not a valid date!"%value

   287

   288

   289

def GetDateTime(attr, extract = True):

   290

    """

   291

    Function that extracts date and time from a tree node or a string

   292

    @param attr: tree node containing data to extract or data as a string

   293

    @param extract: attr is a tree node or not

   294

    @return: data as date and time

   295

    """

   296

    if extract:

   297

        result = datetime_model.match(GetAttributeValue(attr))

   298

    else:

   299

        result = datetime_model.match(attr)

   300

    if result:

   301

        values = result.groups()

   302

        datetime_values = [int(v) for v in values[:5]]

   303

        seconds = float(values[5])

   304

        datetime_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   305

        if values[6] is not None:

   306

            tz = xml_timezone()

   307

            tz.SetOffset(values[6])

   308

            datetime_values.append(tz)

   309

        return datetime.datetime(*datetime_values)

   310

    else:

   311

        raise ValueError, "\"%s\" is not a valid datetime!"%value

   312

   313

   314

def GenerateModelNameExtraction(type, model):

   315

    """

   316

    Function that generates an extraction function for string matching a model

   317

    @param type: name of the data type

   318

    @param model: model that data must match

   319

    @return: function generated

   320

    """

   321

    def GetModelName(attr, extract = True):

   322

        """

   323

        Function that extracts a string from a tree node or not and check that

   324

        string extracted or given match the model

   325

        @param attr: tree node containing data to extract or data as a string

   326

        @param extract: attr is a tree node or not

   327

        @return: data as a string if matching

   328

        """

   329

        if extract:

   330

            value = GetAttributeValue(attr)

   331

        else:

   332

            value = attr

   333

        result = model.match(value)

   334

        if not result:

   335

            raise ValueError, "\"%s\" is not a valid %s!"%(value, type)

   336

        return value

   337

    return GetModelName

   338

   339

   340

def GenerateLimitExtraction(min = None, max = None, unbounded = True):

   341

    """

   342

    Function that generates an extraction function for integer defining min and max

   343

    of integer value

   344

    @param min: minimum limit value

   345

    @param max: maximum limit value

   346

    @param unbounded: value can be "unbounded" or not

   347

    @return: function generated

   348

    """

   349

    def GetLimit(attr, extract = True):

   350

        """

   351

        Function that extracts a string from a tree node or not and check that

   352

        string extracted or given is in a list of values

   353

        @param attr: tree node containing data to extract or data as a string

   354

        @param extract: attr is a tree node or not

   355

        @return: data as a string

   356

        """

   357

        if extract:

   358

            value = GetAttributeValue(attr)

   359

        else:

   360

            value = attr

   361

        if value == "unbounded":

   362

            if unbounded:

   363

                return value

   364

            else:

   365

                raise "\"%s\" isn't a valid value for this member limit!"%value

   366

        try:

   367

            limit = int(value)

   368

        except:

   369

            raise "\"%s\" isn't a valid value for this member limit!"%value

   370

        if limit < 0:

   371

            raise "\"%s\" isn't a valid value for this member limit!"%value

   372

        elif min is not None and limit < min:

   373

            raise "\"%s\" isn't a valid value for this member limit!"%value

   374

        elif max is not None and limit > max:

   375

            raise "\"%s\" isn't a valid value for this member limit!"%value

   376

        return limit

   377

    return GetLimit

   378

   379

   380

def GenerateEnumeratedExtraction(type, list):

   381

    """

   382

    Function that generates an extraction function for enumerated values

   383

    @param type: name of the data type

   384

    @param list: list of possible values

   385

    @return: function generated

   386

    """

   387

    def GetEnumerated(attr, extract = True):

   388

        """

   389

        Function that extracts a string from a tree node or not and check that

   390

        string extracted or given is in a list of values

   391

        @param attr: tree node containing data to extract or data as a string

   392

        @param extract: attr is a tree node or not

   393

        @return: data as a string

   394

        """

   395

        if extract:

   396

            value = GetAttributeValue(attr)

   397

        else:

   398

            value = attr

   399

        if value in list:

   400

            return value

   401

        else:

   402

            raise ValueError, "\"%s\" isn't a valid value for %s!"%(value, type)

   403

    return GetEnumerated

   404

   405

   406

def GetNamespaces(attr, extract = True):

   407

    """

   408

    Function that extracts a list of namespaces from a tree node or a string

   409

    @param attr: tree node containing data to extract or data as a string

   410

    @param extract: attr is a tree node or not

   411

    @return: list of namespaces

   412

    """

   413

    if extract:

   414

        value = GetAttributeValue(attr)

   415

    else:

   416

        value = attr

   417

    if value == "":

   418

        return []

   419

    elif value == "##any" or value == "##other":

   420

        namespaces = [value]

   421

    else:

   422

        namespaces = []

   423

        for item in value.split(" "):

   424

            if item == "##targetNamespace" or item == "##local":

   425

                namespaces.append(item)

   426

            else:

   427

                result = URI_model.match(item)

   428

                if result is not None:

   429

                    namespaces.append(item)

   430

                else:

   431

                    raise ValueError, "\"%s\" isn't a valid value for namespace!"%value

   432

    return namespaces

   433

   434

   435

def GenerateGetList(type, list):

   436

    """

   437

    Function that generates an extraction function for a list of values

   438

    @param type: name of the data type

   439

    @param list: list of possible values

   440

    @return: function generated

   441

    """

   442

    def GetLists(attr, extract = True):

   443

        """

   444

        Function that extracts a list of values from a tree node or a string

   445

        @param attr: tree node containing data to extract or data as a string

   446

        @param extract: attr is a tree node or not

   447

        @return: list of values

   448

        """

   449

        if extract:

   450

            value = GetAttributeValue(attr)

   451

        else:

   452

            value = attr

   453

        if value == "":

   454

            return []

   455

        elif value == "#all":

   456

            return [value]

   457

        else:

   458

            values = []

   459

            for item in value.split(" "):

   460

                if item in list:

   461

                    values.append(item)

   462

                else:

   463

                    raise ValueError, "\"%s\" isn't a valid value for %s!"%(value, type)

   464

            return values

   465

    return GetLists

   466

   467

   468

def GenerateModelNameListExtraction(type, model):

   469

    """

   470

    Function that generates an extraction function for list of string matching a model

   471

    @param type: name of the data type

   472

    @param model: model that list elements must match

   473

    @return: function generated

   474

    """

   475

    def GetModelNameList(attr, extract = True):

   476

        """

   477

        Function that extracts a list of string from a tree node or not and check 

   478

        that all the items extracted match the model

   479

        @param attr: tree node containing data to extract or data as a string

   480

        @param extract: attr is a tree node or not

   481

        @return: data as a list of string if matching 

   482

        """

   483

        if extract:

   484

            value = GetAttributeValue(attr)

   485

        else:

   486

            value = attr

   487

        values = []

   488

        for item in value.split(" "):

   489

            result = model.match(item)

   490

            if result is not None:

   491

                values.append(item)

   492

            else:

   493

                raise ValueError, "\"%s\" isn't a valid value for %s!"%(value, type)

   494

        return values

   495

    return GetModelNameList

   496

   497

def GenerateAnyInfos():