cubicweb: comparison devtools/fill.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 """
 for cst in eschema.constraints(attrname):
 if isinstance(cst, StaticVocabularyConstraint):
 return cst.vocabulary()
 return None
 def get_max_length(eschema, attrname):
 """returns the maximum length allowed for 'attrname'"""
 for cst in eschema.constraints(attrname):
 if isinstance(cst, SizeConstraint) and cst.max:
 while value in _GENERATED_VALUES.get((self.e_schema.type, attrname), ()):
 index += 1
 value = self.__generate_value(attrname, index, **kwargs)
 _GENERATED_VALUES.setdefault((self.e_schema.type, attrname), set()).add(value)
 return value
 def __generate_value(self, attrname, index, **kwargs):
 """generates a consistent value for 'attrname'"""
 attrtype = str(self.e_schema.destination(attrname)).lower()
 # Before calling generate_%s functions, try to find values domain
 etype = self.e_schema.type
 """generates a consistent value for 'attrname' if it's a choice"""
 choices = get_choices(self.e_schema, attrname)
 if choices is None:
 return None
 return unicode(choice(choices)) # FIXME
 def generate_string(self, attrname, index, format=None):
 """generates a consistent value for 'attrname' if it's a string"""
 # First try to get choices
 choosed = self.generate_choice(attrname, index)
 if choosed is not None:
 return value[:attrlength]
 def generate_password(self, attrname, index):
 """generates a consistent value for 'attrname' if it's a password"""
 return u'toto'
 def generate_integer(self, attrname, index):
 """generates a consistent value for 'attrname' if it's an integer"""
 choosed = self.generate_choice(attrname, index)
 if choosed is not None:
 return choosed
 if maxvalue is not None and maxvalue <= 0 and minvalue is None:
 minvalue = maxvalue - index # i.e. randint(-index, 0)
 else:
 maxvalue = maxvalue or index
 return randint(minvalue or 0, maxvalue)
 generate_int = generate_integer
 def generate_float(self, attrname, index):
 """generates a consistent value for 'attrname' if it's a float"""
 return float(randint(-index, index))
 def generate_decimal(self, attrname, index):
 """generates a consistent value for 'attrname' if it's a float"""
 return Decimal(str(self.generate_float(attrname, index)))
 def generate_date(self, attrname, index):
 """generates a random date (format is 'yyyy-mm-dd')"""
 return date(randint(2000, 2004), randint(1, 12), randint(1, 28))
 def generate_time(self, attrname, index):
 """generates a random time (format is ' HH:MM')"""
 return timedelta(0, 11, index%60) #'11:%02d' % (index % 60)
 def generate_datetime(self, attrname, index):
 """generates a random date (format is 'yyyy-mm-dd HH:MM')"""
 return datetime(randint(2000, 2004), randint(1, 12), randint(1, 28), 11, index%60)
 def generate_bytes(self, attrname, index, format=None):
 # modpython way
 fakefile = Binary("%s%s" % (attrname, index))
 fakefile.filename = "file_%s" % attrname
 fakefile.value = fakefile.getvalue()
 return fakefile
 def generate_boolean(self, attrname, index):
 """generates a consistent value for 'attrname' if it's a boolean"""
 return index % 2 == 0
 def generate_Any_data_format(self, index, **kwargs):
 # data_format attribute of Image/File has no vocabulary constraint, we
 # need this method else stupid values will be set which make mtconverter
 # raise exception
 return u'application/octet-stream'
 def generate_Any_content_format(self, index, **kwargs):
 # content_format attribute of EmailPart has no vocabulary constraint, we
 # need this method else stupid values will be set which make mtconverter
 # raise exception
 return u'text/plain'
 if restrictions:
 queries.append(('INSERT %s X: %s' % (etype, ', '.join(restrictions)),
 args))
 assert not 'eid' in args, args
 else:
 queries.append(('INSERT %s X' % etype, {}))
 return queries
 def make_entity(etype, schema, vreg, index=0, choice_func=_default_choice_func,
 form=False):
 sym.add( (subj, obj) )
 if rschema.symetric and (obj, subj) in sym:
 continue
 subjcard, objcard = rschema.rproperty(subj, obj, 'cardinality')
 # process mandatory relations first
 if subjcard in '1+' or objcard in '1+':
 queries += self.make_relation_queries(sedict, oedict,
 rschema, subj, obj)
 else:
 delayed.append( (subj, obj) )
 for subj, obj in delayed:
 queries += self.make_relation_queries(sedict, oedict, rschema,
 subj, obj)
 return queries
 def qargs(self, subjeids, objeids, subjcard, objcard, subjeid, objeid):
 if subjcard in '?1':
 subjeids.remove(subjeid)
 if objcard in '?1':
 objeids.remove(objeid)
 objeids.remove(objeid)
 if subjeid in subjeids:
 subjeids.remove(subjeid)
 if not subjeids:
 check_card_satisfied(objcard, objeids, subj, rschema, obj)
 return
 if not objeids:
 check_card_satisfied(subjcard, subjeids, subj, rschema, obj)
 return
 if subjcard in '?1+':
 for subjeid in tuple(subjeids):
 for subjeid, objeid in zip(subjeidsiter, objeidsiter):
 if subjeid != objeid and not (subjeid, objeid) in used:
 used.add( (subjeid, objeid) )
 yield q, self.qargs(subjeids, objeids, subjcard, objcard,
 subjeid, objeid)
 def check_card_satisfied(card, remaining, subj, rschema, obj):
 if card in '1+' and remaining:
 raise Exception("can't satisfy cardinality %s for relation %s %s %s"
 % (card, subj, rschema, obj))
 return None
 objeid = choice(values)
 while objeid == avoid: # avoid infinite recursion like in X comment X
 objeid = choice(values)
 return objeid
 # UTILITIES FUNCS ##############################################################
 def make_tel(num_tel):
 """takes an integer, converts is as a string and inserts
 white spaces each 2 chars (french notation)

branch	tls-sprint
changeset 1802	d628defebc17
parent 1398	5fe84a5f7035
child 1977	606923dff11b