/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision f78e128d

     from random import random, choice, randint
     from math import log
     from inspect import isclass
     from .utils.argmap import argmap_decode
     from .utils.argmap import argmap_decode, argmap_check, argmap_dict_to_list
     try:
         from collections import OrderedDict
-...
     class Args(Canonical):
         def _parse(self, arglist):
             formalslen = len(self.kw)
             arglen = len(arglist)
             if arglen != formalslen:
                 raise Exception('param inconsistent')
         def _check(self, item):
             if argmap_check(item):
                 if hasattr(item, 'keys') and callable(item.keys):
                     arglist = argmap_dict_to_list(item)[:-1]
                 else:
                     arglist = [(None, item[i]) for i in xrange(0, len(item)-1)]
             else:
                 try:
                     arglist = OrderedDict(item).items()
                 except (TypeError, ValueError), e:
                     m = "%s: %s is not dict-able" % (self, shorts(item))
                     raise CanonifyException(m)
             parsed = OrderedDict()
             keys = self.kw.keys()
             kw = self.kw
             arglen = len(arglist)
             if arglen != len(keys):
                 m = "inconsistent number of parameters: %s != %s" % (
                     arglen, len(keys))
                 raise CanonifyException(m)
             canonified = OrderedDict()
             position = 0
             for k, v in arglist:
                 if k:
                     parsed[k] = self.kw[k].parse(v)
                     canonified[k] = kw[k].check(v)
                 else:
                     # find the right position
                     for i in range(position, arglen):
                         key = keys[i]
                         if not key in parsed.keys():
                         if not key in canonified.keys():
                             position = i + 1
                             break
                     else: # exhausted
                         raise Exception("shouldn't happen")
                     parsed[key] = self.kw[key].parse(v)
             return parsed
         def _check(self, item):
             try:
                 item = OrderedDict(item)
             except TypeError, e:
                 m = "%s: %s is not dict-able" % (self, shorts(item))
                 raise CanonifyException(m)
             canonified = OrderedDict()
             try:
                 for n, c in self.kw.items():
                     t = item[n] if n in item else None
                     canonified[n] = c(t)
             except KeyError:
                 m = ("%s: Argument '%s' not found in '%s'"
                             % (self, shorts(n), shorts(item)))
                 raise CanonifyException(m)
                     canonified[key] = kw[key].check(v)
             return canonified

     def argmap_decode_args(inputf):
         args = [ARGMAP_MAGIC]
         append = args.append
         s = inputf(1)
         key = None
-...
             if s == ']':
                 if key is not None:
                     append((None, key))
     	    args.append(ARGMAP_MAGIC)
                 return args, None
             if s == '=':
-...
         if hasattr(obj, 'keys'):
             # this could cover both cases
             return ARGMAP_MAGIC in obj
         return hasattr(obj, '__len__') and len(obj) and obj[0] == ARGMAP_MAGIC
         return hasattr(obj, '__len__') and len(obj) and obj[-1] == ARGMAP_MAGIC
     def argmap_unzip_dict(argmap):
         if not hasattr(argmap, 'keys'):
-...
         return args, kw
     def argmap_unzip_list(argmap):
         if not argmap or argmap[0] != ARGMAP_MAGIC:
         if not argmap or argmap[-1] != ARGMAP_MAGIC:
             m = "argmap unzip list: magic not found"
             raise ValueError(m)
-...
             raise ValueError(m)
     def argmap_zip_list(args, kw):
         return [ARGMAP_MAGIC] + [(None, a) for a in args] + kw.items()
         return [(None, a) for a in args] + kw.items() + [ARGMAP_MAGIC]
     def argmap_zip_dict(args, kw):
         argmap = OrderedDict()
-...
     argmap_zip = argmap_zip_list
     def argmap_list_to_dict(argmap):
         args, kw = argmap_unzip_list(argmap)
         kw[ARGMAP_MAGIC] = ARGMAP_MAGIC
         kw[None] = args
         return kw
     def argmap_dict_to_list(argmap):
         args, kw = argmap_unzip_dict(argmap)
         return args + kw.items() + [ARGMAP_MAGIC]

Also available in: Unified diff