class ItemFactory(factory.DjangoModelFactory):
class Meta:
model = Item
name = factory.LazyFunction(lambda: ' '.join(generate()))
description = factory.LazyFunction(lambda: ' '.join(generate()))
cost = factory.LazyFunction(lambda: random.randint(10, 10000))
inventor = factory.Faker('name')
manufacturer = factory.SubFactory(ManufacturerFactory)
def generate_slug(n_words: int) -> str:
"""
Generates a random slug.
Args:
- n_words (int): the number of words in the slug
"""
words = coolname.generate(n_words)
# regenerate words if they include blacklisted words
while BLACKLIST.intersection(words):
words = coolname.generate(n_words)
return "-".join(words)
def genbook():
'''
Generates book information
Title randomly generated from coolname
Author randomly generated from names library
ISBN is randomly generated 12 digit number
CourseID is a randomly chosen id based off of known Ids
:return: Dictionary containing a title, author, and ISBN-13
'''
title = ' '.join(generate(3)).title()
author = names.get_full_name()
# Generate ISBN with proper checksum
isbn = ''.join([str(rm.randrange(10)) for i in range(12)])
check = sum(
[int(i) * 3 if isbn.index(i) % 2 != 0 else int(i) for i in isbn]) % 10
digit = check if check == 0 else 10 - check
isbn += str(digit)
courseID = rm.choice(constants.courseIds)
BNumber = rm.randint(0, 200)
# print(title,author, isbn)
return {
'id': BNumber,
'title': title,
'author': author,
'isbn': isbn,
'courseID': courseID,
'BPic': None
}
def handle(self, n, netid, slug, *args, **options):
if netid:
user = User.objects.get(netid=netid)
else:
user = None
tags = Tag.objects.all()
self.stdout.write(f"Generating {n} documents per course...")
courses = Course.objects.all()
if slug:
courses = courses.filter(slug=slug)
for course in courses:
for _ in range(n):
doc = Document.objects.create(
name=" ".join(generate()),
course=course,
user=user if user else User.objects.order_by("?").first(),
pages=max(1, int(random.gauss(5, 10))),
import_source="fake-doc",
)
k = random.randint(0, len(tags))
if choices := random.choices(tags, k=k):
doc.tags.set(choices)
for user in User.objects.order_by("?")[:random.randint(0, 4)]:
t = random.choices(Vote.VoteType.values, [1, 5], k=1)[0]
Vote.objects.create(user=user, document=doc, vote_type=t)
def read_disc_meta(disc_id, toc_filepath=tempfile.NamedTemporaryFile().name):
logger.info('Reading disc meta from the disc')
_read_toc_into_file(toc_filepath)
try:
toc = Toc(Path(toc_filepath).read_text())
disc_meta = toc.disc_meta
if 'title' not in disc_meta.keys():
disc_meta['title'] = 'Unknown Album %s' % ''.join(
x.capitalize() for x in generate())
tracks = [_convert_track_info(track) for track in disc_meta['tracks']]
duration = sum(track['duration'] for track in tracks)
return {
'disc_id': disc_id,
'title': disc_meta['title'],
'tracks': tracks,
'duration': duration,
'cd': 1,
'total_cds': 1
}
except TOCError:
logger.error('Could not parse disc TOC')
return None
async def channels_list_job():
channels = [
category.create_voice_channel(" ".join(generate(2)))
for _ in range(group_count)
]
shuffleState.channels = list(await asyncio.gather(*channels))
print(shuffleState.channels)
def test_slug(self):
# Basic test, to check that it doesn't crash.
# Output of default generator is always unicode.
items = coolname.generate()
self.assertIsInstance(items[0], six.text_type)
name = coolname.generate_slug()
self.assertIsInstance(name, six.text_type)
self.assertGreater(len(name), 10)
self.assertIn('-', name)
def test_slug(self):
# Basic test, to check that it doesn't crash.
# Output of default generator is always unicode.
items = coolname.generate()
self.assertIsInstance(items[0], six.text_type)
name = coolname.generate_slug()
self.assertIsInstance(name, six.text_type)
self.assertGreater(len(name), 10)
self.assertIn('-', name)
def init_logger(self, params):
project = "dqn_extended"
name = "qrdqn_dopamine_freeway"
logs_dir = "../logs"
uid = "_".join([generate()[0], name])
print("Exp name", uid)
wandb.init(name=name, project=project, dir=logs_dir, config=params)
self.writer = SummaryWriter(logs_dir + "/tensorboard/" + uid)
self.uid = uid
self.logs_dir = logs_dir
path = self.logs_dir + f"/models/{self.uid}/"
os.makedirs(path)
class RiverRaftingTeam(AbstractGroup):
max_team_members = 4
name = models.CharField(max_length=254,
verbose_name='Team name',
default=(" ".join(x.capitalize()
for x in generate(2)) + "s"))
number = models.IntegerField(verbose_name='Start Number',
null=True,
blank=True)
environment_raft = models.BooleanField(
verbose_name='I want an environmentally friendly raft', default=False)
presentation = models.CharField(max_length=250,
verbose_name='Presentation',
null=True,
blank=True)
payment_initialized = models.BooleanField(
verbose_name="Payment initialized", default=False)
def get_number_of_lifevests(self):
members_with_lifevests = \
super().get_group_members_where_nonempty("lifevest_size")
return len(members_with_lifevests)
def get_number_of_wetsuits(self):
members_with_wetsuits = \
super().get_group_members_where_nonempty("wetsuite_size")
return len(members_with_wetsuits)
def get_number_of_helmets(self):
members_with_helmets = \
super().get_group_members_where_nonempty("helmet_size")
return len(members_with_helmets)
def genbook():
'''
Generates book information
Title randomly generated from coolname
Author randomly generated from names library
ISBN is randomly generated 12 digit number
CourseID is a randomly chosen id based off of known Ids
:return: Dictionary containing a title, author, and ISBN-13
'''
title = ' '.join(generate(3)).title()
author = names.get_full_name()
# Generate ISBN with proper checksum
isbn = ''.join([str(rm.randrange(10)) for i in range(12)])
check = sum(
[int(i) * 3 if isbn.index(i) % 2 != 0 else int(i) for i in isbn]) % 10
digit = check if check == 0 else 10 - check
isbn += str(digit)
courseID = rm.choice(constants.courseIds)
BNumber = rm.randint(0, 200)
BPic = rm.choice(constants.sampleBoookPics)
BPrice = float(
str(rm.randrange(600)) + "." + str(rm.randrange(100)).zfill(2))
BDesc = f"{title} is a{rm.choice([' great', 'n awesome', ' bad', ' lovely', 'n ok'])} book but now I am " + \
f"{rm.choice(['choosing', 'being forced'])} to sell it. The book is in " + \
f"{rm.choice(['great', 'awesome', 'bad', 'lovely', 'ok'])} condition please contact me at the email " + \
"above if interested."
return {
'id': BNumber,
'title': title,
'author': author,
'isbn': isbn,
'courseID': courseID,
'BPic': BPic,
'BPrice': BPrice,
'BDesc': BDesc
}
def create_group(
cls: 't.Type[Group]',
group_set: 'GroupSet',
members: t.List['user_models.User'],
name: t.Optional[str] = None,
) -> 'Group':
"""Create a group with the given members.
.. warning::
This function **does** check if the given members are not yet in a
group. It however doesn't check if the current user has the
permission to add these users to the group, nor if the members are
enrolled in the course.
:param group_set: In which group set should this group be placed.
:param members: The initial members should this group have.
:param name: The name of the group. If not given a random name is
generated.
:returns: The newly created group.
"""
if members and db.session.query(
cls.contains_users(members).filter_by(
group_set=group_set).exists()).scalar():
raise APIException(
'Member already in a group',
'One of the members is already in a group for this group set',
APICodes.INVALID_PARAM, 400)
virt = user_models.User.create_virtual_user('GROUP_')
name = name or ' '.join(coolname.generate(3))
self = cls(group_set=group_set,
members=members,
virtual_user=virt,
name=name)
db.session.flush()
virt.name += str(self.id)
return self
def anonymous_name(self):
return ' '.join(map(lambda x: x.capitalize(), generate(2)))
def _generate():
return coolname.generate(2)
def gen_name():
return '{}-{}'.format(self.current_component,
coolname.generate()[0])
def get_random_nickname():
return "".join(word.capitalize() for word in coolname.generate(2))
def generate_friendly_name():
return (" ".join(coolname.generate(2)).capitalize() + " " +
str(random.randint(1000, 9999)))
class ManufacturerFactory(factory.DjangoModelFactory):
class Meta:
model = Manufacturer
name = factory.LazyFunction(lambda: ' '.join(generate(2)))
country = factory.Faker('country')
if isinstance(value, dict):
_merge(destination.setdefault(key, {}), value)
elif isinstance(value, list):
destination.setdefault(key, []).extend(value)
elif isinstance(value, set):
destination.setdefault(key, set()).update(value)
else:
destination[key] = value
@job_group.command(name="create")
@click.option(
"-n",
"--name",
type=str,
default=lambda: '_'.join(coolname.generate(2)),
help="A name for the job. If not given, a random name will be generated.")
@click.option("-f",
"--values-file",
type=click.File(),
multiple=True,
help="YAML file containing parameter values (multiple allowed).")
@click.option("--values",
"values_str",
type=str,
help="Parameter values as a YAML string.")
@click.option("--input/--no-input",
"interactive",
default=True,
help="Turn interactive configuration on/off (default on).")
@click.argument("template_name", required=False)
def get_funny_name():
return ''.join(x.capitalize() for x in generate())
software_names = [SoftwareName.CHROME.value]
operating_systems = [OperatingSystem.WINDOWS.value, OperatingSystem.LINUX.value]
user_agent_rotator = UserAgent(software_names=software_names, operating_systems=operating_systems, limit=100)
# Get list of user agents.
user_agents = user_agent_rotator.get_user_agents()
# Get Random User Agent String.
# user_agent = user_agent_rotator.get_random_user_agent()
p = KinesisProducer('EventStream', flush_callback=on_flush)
for i in range(10):
_generated = coolname.generate()
p.put_record(i,
metadata={
'request_id': uuid4(),
'request_timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S.000000"),
'cookie_id': uuid4(),
'topic': '.'.join(_generated[:3]),
"message": "{\"isAffiliate\":false,\"language\":\"es\",\"isRecommendedPalette\":true,\"color\":\"#6d8d79\",\"paletteIndex\":\"0\",\"workspaceId\":\"" + f"{uuid4()}" + "\"}",
'message': "{}.{}".format(names.get_first_name(),names.get_last_name()),
'environment': _generated[0],
"website_id": None,
'user_account_id': uuid4(),
"location": "https://cms.jimdo.com/wizard/color-palette/",
'user_agent': user_agent_rotator.get_random_user_agent(),
"referrer": "https://register.jimdo.com/es/product"
},
import paho.mqtt.client as mqtt
from coolname import generate
import time
broker_address = 'localhost'
client_name = 'Pub1'
topic = 'T1'
def on_connect(client, userdata, flags, rc):
print("Connected with result code " + str(rc))
if __name__ == '__main__':
client = mqtt.Client(client_name)
client.on_connect = on_connect
client.connect(broker_address, 1883, 60)
message = '-'.join(generate())
print(message)
client.publish(topic=topic, payload=message)
client.disconnect()
