def validate(self, attrs):
username_or_email = attrs['username_or_email']
password = attrs['password']
user_username = User.objects.filter(
username__iexact=username_or_email).first()
user_email = User.objects.filter(
email__iexact=username_or_email).first()
if user_email and user_username is None:
msg = self.default_error_messages['email or username not verified']
raise exceptions.AuthenticationFailed(msg)
if user_username:
if not user_username.check_password(password):
msg = self.default_error_messages['wrong_password']
raise exceptions.AuthenticationFailed(msg)
access_token = generate(size=48)
person, created = UserAuthInfo.objects.update_or_create(
user=user_username, defaults={"access_token": access_token})
data = {'access_token': str(access_token)}
else:
if not user_email.check_password(password):
msg = self.default_error_messages['wrong_password']
raise exceptions.AuthenticationFailed(msg)
access_token = generate(size=48)
person, created = UserAuthInfo.objects.update_or_create(
user=user_email, defaults={"access_token": access_token})
data = {'access_token': str(access_token)}
attrs['data'] = data
return attrs
def create_new_user(socket_id):
user = {
"id": generate(),
"username": "******" + generate(size=6),
"socket_ids": [socket_id],
"color": generate_random_hex_color()
}
return user
def add_new_thread(board_id):
try:
db = get_db()
now_timestamp = datetime.now(timezone.utc).timestamp()
db.cursor().execute(
"""
INSERT INTO thread(
_id, board_id, text, created_on, bumped_on, reported, delete_password
)
VALUES (?, ?, ?, ?, ?, ?, ?)
""",
(
nanoid.generate(),
board_id,
request.form["text"],
now_timestamp,
now_timestamp,
False,
request.form["delete_password"],
),
)
db.commit()
return redirect(f"/b/{board_id}")
except:
return {"error": "Database error"}
def signupUser(APP_ROOT, email, name, password):
json_file = open(f"{APP_ROOT}/db/login.json", "r")
users = json.load(json_file)
backup = copy.deepcopy(users)
json_file.close()
resp = {}
for user in users:
if user["email"] == email:
resp = {"status": "not-ok", "message": "Email already in use!"}
return resp
try:
data = {
"id": str(nanoid.generate()),
"email": email,
"name": name,
"password": password,
}
users.append(data)
json_file = open(f"{APP_ROOT}/db/login.json", "w")
json_file.seek(0)
json.dump(users, json_file, indent=2)
json_file.close()
resp = {"status": "ok", "message": "Signup successful!"}
return resp
except Exception:
json_file = open(f"{APP_ROOT}/db/login.json", "w")
json_file.seek(0)
json.dump(backup, json_file, indent=2)
json_file.close()
resp = {"status": "not-ok", "message": "Signup failed!"}
return resp
def reset_password(cls, data):
new_password = nanoid.generate(size=20)
display_name = normalize_display_name(data.get('username'))
username = to_username(display_name)
email = data.get('email', '')
uuid = data.get('uuid')
try:
user, is_created = User.objects.reset_password(
username, display_name, email, uuid, new_password)
except ValidationError:
logger.info({
'event': 'password_reset_failed',
'username': username,
'uuid': uuid
})
raise
logger.info({
'event': 'password_reset_success',
'username': user.username,
'uuid': user.uuid,
'is_created': is_created
})
return Response({'password': new_password})
def post(self, request):
data = request.data
opening = Opening.objects.get(slug=data['slug'])
chapter_number = int(
data.get('chapter_number') or opening.chapters.count() + 1)
jsoned_games = pgn_to_json(data['pgn'], False, True)
with atomic():
opening.chapters.filter(
Q(chapter_number__gte=chapter_number)).update(
chapter_number=F('chapter_number') + len(jsoned_games))
for i, game in enumerate(jsoned_games, start=chapter_number):
title = f"{game['headers'].get('White')}. " \
f"{(game['headers'].get('Black')) if game['headers'].get('Black') else ''}"
description = f"{game['headers'].get('Event')}"
OpeningChapter(
title=title,
description=description,
chapter_number=i,
opening=opening,
url=generate(
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
8),
data=game).save()
opening.save()
return Response(OpeningDetailSerializer(opening).data)
def handle_chat_message(room_id, message_input):
trimmed_body = message_input["body"]
if trimmed_body:
trimmed_body = utils.trim_spaces(trimmed_body)
file = message_input["file"]
if not trimmed_body and not file:
return
if file:
is_image = utils.is_image_file(file)
if not is_image:
return
current_user = session["current_user"]
message = {
"id": generate(),
"author": current_user,
"body": trimmed_body,
"file": file,
"timestamp": time() * 1000
}
emit("chat message", message, room=room_id, include_self=False)
return message
def index(request):
"""
Index view for handling form data and generating shortened URLs
"""
if request.method == "POST":
form = URLMappingForm(request.POST)
if form.is_valid():
original_url = form.cleaned_data["original_url"]
generated_hash = form.cleaned_data["generated_hash"] \
if form.cleaned_data["generated_hash"] \
else generate(size=5)
mapping = URLMapping(original_url=original_url,
generated_hash=generated_hash)
mapping.save()
base_url = request.META["HTTP_ORIGIN"] + "/"
generated_url = base_url + mapping.generated_hash
return JsonResponse({
"original_url": original_url,
"generated_url": generated_url
})
return JsonResponse({"errors": form.errors})
form = URLMappingForm()
return render(request, "home.html", {"form": form})
def match_make(request: Dict[str, Any]):
if request[GAME_ID] is None:
publish(request[CONNECTION_CHANNEL], request[CONNECTION_KEY], {
'type': 'response',
'error': 'game-id was not specified'
})
existing_room = redis.spop('rooms:waiting:' + request[GAME_ID])
player_id = generate()
player_password = generate()
register_player(request[CONNECTION_CHANNEL], request[CONNECTION_KEY],
player_id, player_password)
if existing_room is not None:
join_room(request, existing_room, player_id, player_password)
else:
create_room(request, player_id, player_password)
def __init__(self):
self.state: Type[Fitting_State] = Fitting_State(self.broadcast)
self.fso: Type[FSO] = FSO
self.__guid: str = generate()
self._subscribers: List[Callable] = []
# self.client:Type[AsyncClient] = client
self.client = None
def put_item(self, item: dict) -> dict:
if '_id' not in item or bool(item['_id']) == False:
item['_id'] = nanoid.generate()
self.table.put_item(Item=item)
return item
def create(self, request, *args, **kwargs):
'''
@param {string} message
@param {string} user_id
@param {string} post_id
'''
data = request.data
try:
user = User.objects.get(id=data['user_id'])
except User.DoesNotExist:
return Response(data={
"success": False,
"message": "User not found"
},
status=406)
try:
post = Post.objects.get(id=data['post_id'])
except Post.DoesNotExist:
return Response(data={
"success": False,
"message": "Post not found"
},
status=406)
comment = Comment(id=generate(),
user=user,
message=data['message'],
post=post)
comment.save()
serialized = CommentSerializer(comment)
return Response(data=serialized.data, status=201)
def create_quiz():
body = request.get_json()
quiz_ott = body["ott"]
# Create quiz record
quiz_uuid = generate(size=8)
quiz = Quiz(uuid=quiz_uuid, ott=quiz_ott, num_questions=5)
db.session.add(quiz)
db.session.flush()
# Get node data for the passed in OTT
top_node = (db.session.query(Node.id, Node.name,
Vernacular.vernacular).join(
Vernacular,
and_(
Vernacular.ott == Node.ott,
Vernacular.lang_primary == "en",
Vernacular.preferred,
),
isouter=True,
).where(Node.ott == quiz_ott).first())
if not top_node:
raise BadRequest("No node found with that ott.")
db.session.commit()
return {
"uuid": quiz.uuid,
"title": top_node.vernacular or top_node.name,
"num_questions": quiz.num_questions,
}
def save_bracket_to_database(shared_bracket_data) -> str:
"""saves user's bracket & all its info/data to the database
Args:
shared_bracket_data (dict): a validated (via pydantic) bracket dict-like structure
Returns:
(str) bracket unique id for further sharing
"""
# generate unique id for saving & sharing
bracket_id = generate(size=13)
# prepare bracket data
bracket_type = shared_bracket_data["bracket_type"]
title = shared_bracket_data["title"]
value1 = shared_bracket_data["value1"]
value2 = shared_bracket_data["value2"]
extra = shared_bracket_data["extra"]
bracket_info = shared_bracket_data["bracket_info"]
bracket_info = json.dumps(bracket_info)
bracket_entry = BracketData(bracket_id=bracket_id,
bracket_type=bracket_type,
title=title,
bracket_info=bracket_info,
value1=value1,
value2=value2,
extra=extra)
# check if bracket has a winner, save if true
if shared_bracket_data["winner"]:
winner = shared_bracket_data["winner"]
bracket_entry.winner = winner
db.session.add(bracket_entry)
db.session.commit()
return bracket_id
async def test(url: UrlSchema):
url = dict(url)
if url["customCode"]:
shortCode = url["customCode"]
shortCode = shortCode.replace(' ', '')
else:
shortCode = nanoid.generate(size=8)
shortUrl = os.path.join(config("BASE_URL"), shortCode)
urlExists = Url.objects(shortCode=shortCode)
if len(urlExists) != 0:
raise HTTPException(status_code=400,
detail="Short code is invalid, It has been used.")
try:
url = Url(longUrl=url["longUrl"],
shortCode=shortCode,
shortUrl=shortUrl)
url.save()
return {
"message": "Successfully shortened URL.",
"shortUrl": shortUrl,
"longUrl": url["longUrl"]
}
except Exception as e:
print(e)
raise HTTPException(status_code=500,
detail="An unknown error occurred.")
def create(event, context):
data = json.loads(event['body'])
if 'url' not in data:
logging.error('URL parameter not provided')
return {
'statusCode': 422,
'body': json.dumps({'error_message': 'Insufficient data'})
}
url = data['url']
if not url:
logging.error('URL value missing')
return {
'statusCode': 422,
'body': json.dumps({'error_message': 'URL missing'})
}
if not checkers.is_url(url):
logging.error('URL is invalid')
return {
'statusCode': 422,
'body': json.dumps({'error_message': 'URL invalid'})
}
if 'id' in data:
id = data['id']
else:
id = generate(size=6)
url_added = UrlModel(id=id, url=url, created=datetime.now())
url_added.save()
return {'statusCode': 200, 'body': json.dumps({'id': id, 'url': url})}
def test_flat_distribution(self):
count = 100 * 1000
length = 5
alphabet = 'abcdefghijklmnopqrstuvwxyz'
chars = {}
for _ in range(count):
id = generate(alphabet, length)
for j in range(len(id)):
char = id[j]
if not chars.get(char):
chars[char] = 0
chars[char] += 1
self.assertEqual(len(chars.keys()), len(alphabet))
max = 0
min = maxsize
for k in chars:
distribution = (chars[k] * len(alphabet)) / float((count * length))
if distribution > max:
max = distribution
if distribution < min:
min = distribution
self.assertLessEqual(max - min, 0.05)
def test_has_no_collisions(self):
count = 100 * 1000
used = {}
for _ in range(count):
id = generate()
self.assertIsNotNone(id in used)
used[id] = True
def post(self):
if not re.match(regex, request.form['url']): # check if input is URL
abort(400)
id = generate(size=max_id_size
) # Generate new id and add it to the URL dictionary
urls[id] = request.form['url']
return {'id': id}, 201
def save(self):
if self.reset_slug or not self.slug:
hash = generate('1234567890abcdefefghijklmneoprstyuvwxyz')
self.slug = slugify(hash)
self.reset_slug = False
return super(CV, self).save()
def get_new_cavas():
incoming = request.get_json()
canvas_id = nanoid.generate(size=20)
canvas_type = incoming["canvas_type"]
canvas = Canvas({
'canvas_id':
canvas_id,
'canvas_name':
"New Canvas",
'canvas_description':
choice(awesome_text),
'canvas_type':
canvas_type,
'canvas_team': [{
"user": g.current_user["email"],
"role": "creator"
}],
'canvas_preview':
None,
'canvas_notes':
None,
'canvas_lastUpdate':
int(1000 * time.time())
})
try:
canvas.save()
except:
return "Couldn't save that!", 501
last_canvas = Canvas.find_one({"canvas_id": canvas_id}, {"_id": 0})
return jsonify(canvas=last_canvas)
def get_poses_from_video(video_download_path):
poses = []
images = []
video_cap = cv2.VideoCapture(video_download_path)
ret, frame = video_cap.read()
height, width, ch = frame.shape
output_path = "tmp/videos/output-videos/" + generate() + ".MOV"
ffmpeg = "ffmpeg"
dimension = f"{width}x{height}"
f_format = "bgr24"
fps = str(video_cap.get(cv2.CAP_PROP_FPS))
command = [ffmpeg, "-y", "-f", "rawvideo", "-vcodec", "rawvideo", "-s", dimension, "-pix_fmt", f_format, "-r", fps, "-i", "-", "-an", "-vcodec", "mpeg4", "-b:v", "5000k", output_path]
proc = sp.Popen(command, stdin=sp.PIPE, stderr=sp.PIPE)
with mp_pose.Pose(min_detection_confidence=0.99, min_tracking_confidence=0.99) as pose:
while video_cap.isOpened():
success, image = video_cap.read()
if not success:
print("Can't receive frame")
break
image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB)
image.flags.writeable = False
results = pose.process(image)
image.flags.writeable = True
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
images.append(image)
proc.stdin.write(image.tostring())
frame_pose = {}
if results.pose_landmarks is not None:
for lm_id, lm in enumerate(results.pose_landmarks.landmark):
h, w, _ = image.shape
frame_pose[str(2 * lm_id)] = lm.x * w
frame_pose[str(2 * lm_id + 1)] = lm.y * h
poses.append(frame_pose)
if cv2.waitKey(5) & 0xFF == ord("q"):
break
video_cap.release()
proc.stdin.close()
proc.stderr.close()
proc.wait()
os.remove(video_download_path)
return poses, images, output_path
def __init__(self, path: str, fittings: list, props: dict):
self.state: Type[FSO_State] = FSO_State(fittings, self)
self.props: dict = Box(props)
self._subscribers: list = []
self.__guid: str = generate()
self.__path: str = path
self.__locked: bool = False
self.__inbound_name: str = self.extract_inbound_name(path)
def new_or_get(self, name:str):
new_client, _ = self.get_or_create(
name = name,
defaults = {
'guid': generate()
}
)
return new_client
def _generate_slug_and_save(url):
_slug = generate('1234567890abcdef', 5)
_errors = ''
global mappings
if not mappings.save_mapping(_slug, url):
_errors = 'Failed to save'
logging.warning('failed to save document {}'.format(_errors))
return (_slug, _errors)
def new_or_get(self, client: Type[Client], prod_num: int, **kwargs):
new_project, _ = self.get_or_create(client=client,
production_number=prod_num,
defaults={
'guid': generate(),
**kwargs
})
return new_project
def generate_object_key(self, prefix=None):
salt = nanoid.generate(size=10)
base = datetime.now().strftime("%Y%m%d%H%M%S")
path = f"{base}.{salt}.json"
if prefix:
path = f"{prefix}/{base}.{salt}.json"
return path
class BlogPost(models.Model):
id = models.CharField(max_length=21, primary_key=True, default=generate(), editable=False)
title = models.CharField(max_length=50, unique=True)
content = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
def new_or_get(self, shot: Type[Shot], name: str, location: str, **kwargs):
new_motion_shot, _ = self.get_or_create(shot=shot,
name=name,
defaults={
'guid': generate(),
'location': location,
**kwargs,
})
return new_motion_shot
def __init__(
self,
params: ObjMap,
pop: Optional["population.Population"] = None,
):
"""
This is the core class used to simulate the spread of exposures through a relationship based network.
args:
params: the parameter object for this model
pop: an initialized population to run the model on
"""
self.params = params
# pre-fetch commonly used param sub-sets for performance
self.calibration = params.calibration
print("=== Begin Initialization Protocol ===\n")
if pop is None:
print("\tGenerating new population")
self.pop = population.Population(params)
else:
print("\tUsing provided population")
self.pop = pop
self.time = -1 * self.params.model.time.burn_steps # burn is negative time
self.id = nanoid.generate(size=8)
self.features = [
feature for feature in features.BaseFeature.__subclasses__()
if self.params.features[feature.name]
]
# set up the in-scope exposures
self.exposures = [
exposure for exposure in exposures.BaseExposure.__subclasses__()
if self.params.exposures[exposure.name]
]
self.interactions = {
interaction.name: interaction
for interaction in interactions.BaseInteraction.__subclasses__()
}
# Set seed format. 0: pure random, else: fixed value
self.run_seed = utils.get_check_rand_int(params.model.seed.run)
print(f"\tRun seed was set to: {self.run_seed}")
self.run_random = random.Random(self.run_seed)
self.np_random = np.random.default_rng(self.run_seed)
random.seed(self.run_seed)
print(("\tFIRST RANDOM CALL {}".format(random.randint(0, 100))))
print("\tResetting death count")
self.deaths: List["ag.Agent"] = [] # Number of death
print("\n === Initialization Protocol Finished ===")
