def build_relation(inserted):
if related_model in inserted and inserted[related_model]:
pk = random.choice(inserted[related_model])
return related_model.objects.get(pk=pk)
else:
message = 'Field {} cannot be null'.format(field)
raise SeederException(message)
def func(inserted):
if related_model in inserted and inserted[related_model]:
pk = random.choice(inserted[related_model])
return related_model.objects.get(pk=pk)
elif not field.null:
message = "Field {} cannot be null".format(field)
raise SeederException(message)
def func(inserted):
if related_model in inserted and inserted[related_model]:
pk = random.choice(inserted[related_model])
if field.unique:
if pk in self.unique[field]:
while pk in self.unique[field]:
pk = random.choice(inserted[related_model])
self.unique[field].append(pk)
for i, unq_fields in enumerate(self.unique_together):
if field.name in unq_fields:
if len(self.unique_together[unq_fields]) == 0 or \
all(field.name in d and len(d.keys()) == 1 for d in self.unique_together[unq_fields]) \
or all(len(d.keys()) == len(unq_fields) for d in self.unique_together[unq_fields]):
self.unique_together[unq_fields].append({field.name: pk})
else:
for j, d in enumerate(self.unique_together[unq_fields]):
if field.name not in d:
tmp_dict = {**d, field.name: pk}
while tmp_dict in self.unique_together[unq_fields]:
pk = random.choice(inserted[related_model])
tmp_dict[field.name] = pk
self.unique_together[unq_fields][j][field.name] = pk
return related_model.objects.get(pk=pk)
else:
message = 'Field {} cannot be null'.format(field)
raise SeederException(message)
def func(inserted):
if related_model in inserted and inserted[related_model]:
pk = ModelSeeder.choice_unique(field, inserted[related_model])
return related_model.objects.get(pk=pk)
elif not field.null:
message = 'Field {} cannot be null'.format(field)
raise SeederException(message)
def func(inserted):
if related_model in inserted and inserted[related_model]:
max_relations = min(10, round(len(inserted[related_model]) / 5) + 1)
return [
related_model.objects.get(pk=random.choice(inserted[related_model]))
for _ in range(random.randint(0, max_relations))
]
elif not field.blank:
message = 'Field {} cannot be null'.format(field)
raise SeederException(message)
def func(inserted):
if related_model in inserted and inserted[related_model]:
unused = list(set(inserted[related_model]) - existing)
if unused:
pk = random.choice(unused)
existing.add(pk)
return related_model.objects.get(pk=pk)
if not field.null:
message = "Field {} cannot be null".format(field)
raise SeederException(message)
def get_connection(self):
"""
use the first connection available
:rtype: Connection
"""
klass = self.entities.keys()
if not klass:
message = 'No classed found. Did you add entities to the Seeder?'
raise SeederException(message)
klass = list(klass)[0]
return klass.objects._db
def get_connection(self):
"""
use the first connection available
:rtype: Connection
"""
klasses = [order["klass"] for order in self.orders]
if not klasses:
message = "No classes found. Did you add entities to the Seeder?"
raise SeederException(message)
klass = list(klasses)[0]
return klass.objects._db
def func(inserted):
if related_model in inserted and inserted[related_model]:
max_relations = min(10, round(len(inserted[related_model]) / 5) + 1)
return_list = []
for _ in range(random.randint(1, max_relations)):
choice = random.choice(inserted[related_model])
return_list.append(related_model.objects.get(pk=choice))
return return_list
elif not field.blank:
message = 'Field {} cannot be null'.format(field)
raise SeederException(message)
else:
logging.warn(
"Could not build many-to-many relationship for between {} and {}".format(
field, related_model,
)
)
return []
def format_many_to_many_field(obj, format, inserted_entities):
if callable(format):
format(obj, inserted_entities)
else:
message = "Many to many format must be callable"
raise SeederException(message)
