def import_own_files(
files: Mapping[str, TemporaryUploadedFile], *, qs: QuerySet, voice: str
) -> Generator[Mapping[Optional[str], Optional[str]], None, None]:
""" Import own file """
audio_list = [qs_object['name'] for qs_object in qs.values('name')]
converter = SoxTransformerMixin()
safe_extensions = ['.mp3', '.wav', '.raw']
for file_name, file_ in files.items():
file_name, extension = os.path.splitext(file_name)
if extension not in safe_extensions:
yield {'error': f'{file_name}{extension}', 'success': None}
if file_name not in audio_list:
yield {'error': file_name, 'success': None}
else:
if extension == '.mp3': # SoX do not nothing about mp3 o_O
file_ = convert_from_mp3(file_)
audio_record: AudioRecord = qs.get(name__exact=file_name)
wav_file = converter.convert_audio_type_format(
user_file=file_.file, extension_to='wav', normalise=True)
audio_record.source = Source.objects.get(name='Voice actor')
audio_record.voice = voice
audio_record.emote = 'Живые эмоции'
audio_record.playing_speed = Decimal(1.0)
with wav_file as converted_:
content = converted_.read()
audio_record.audio.save(f'{file_name}_{datetime.now()}.wav',
ContentFile(content))
audio_record.default_audio.save(
f'{file_name}_{datetime.now()}-default.wav',
ContentFile(content))
yield {'error': None, 'success': file_name}
def get_cursor(
queryset: QuerySet,
after_uuid: uuid.UUID = None,
before_uuid: uuid.UUID = None,
default_order: str = None,
) -> typing.Tuple[typing.Any, str]:
cursor_obj = None
if after_uuid is not None:
with contextlib.suppress(ObjectDoesNotExist):
cursor_obj = queryset.get(uuid=after_uuid)
order = 'after'
elif before_uuid is not None:
with contextlib.suppress(ObjectDoesNotExist):
cursor_obj = queryset.get(uuid=before_uuid)
order = 'before'
if cursor_obj is None:
order = default_order or ''
return cursor_obj, order
def retry_get(qs: QuerySet, **kwargs):
for delay in (0.5, 1, 2, 4, None):
try:
return qs.get(**kwargs)
except qs.model.DoesNotExist:
if delay:
time.sleep(delay)
else:
raise
def get_deleted(self, *args, **kwargs):
kwargs = self.model.resolve_subfield_filters(**kwargs)
assert kwargs["id"], "get_deleted() 호출 시에는 id 값을 넘겨야 합니다."
qs = DjangoQuerySet(self.model)
qs = qs.filter(status=Status.DELETED)
qs = self.process_queryset(qs)
instance = qs.get(*args, **kwargs)
if instance.status != Status.DELETED:
raise instance.__class__.DoesNotExist
instance._old_status = Status.DELETED
return instance
def get_excess_users_in_g_suite(
g_suite_users: List[Dict[str, str]], ow4_users: QuerySet
) -> List[Dict[str, str]]:
"""
Finds excess users from lists of G Suite users and OW4 users.
:param g_suite_users: The members of a G Suite group.
:param ow4_users: The members of an OW4 group.
:return: A list of excess users.
"""
excess_users = []
for user in g_suite_users:
try:
ow4_users.get(online_mail=user.get("email").split("@")[0])
except User.DoesNotExist:
excess_users.append(user)
logger.debug(f"Excess users in G Suite: {excess_users}")
return excess_users
def filter_transfers_by_transfer_set_index(self, transfers: QuerySet):
# If this context has no transfer, or its transfer has no id, do nothing as there's no index to filter with
if self.transfer is None:
return transfers
if self.transfer.id is None:
return transfers
# Find transfer in set, where index field is added
try:
transfer = transfers.get(id=self.transfer.id)
except Transfer.DoesNotExist:
return transfers
return transfers.filter(index__lte=transfer.index)
def export_applicants(self, request: HttpRequest, queryset: QuerySet):
if queryset.count() != 1:
self.message_user(request,
"Please select only one session for export",
messages.ERROR)
return
session: ApplicationSession = queryset.get()
csv_resp = HttpResponse(content_type='text/csv')
csv_resp[
'Content-Disposition'] = 'attachment; filename="Applicants %s.csv"' % (
session.move_in_str(), )
wr = csv.writer(csv_resp)
fields: List[Field] = Applicant._meta.get_fields(include_parents=False,
include_hidden=False)
header = []
fnames = []
for f in fields:
if f.is_relation:
continue
header.append(f.verbose_name)
fnames.append(f.name)
header.append("Abstain votes")
header.append("Not suitable votes") # -2
header.append("Suitable votes") # 1
header.append("Very suitable votes") # 2
qs = session.questions()
for q in qs:
header.append(q.question_text)
wr.writerow(header)
for ap in Applicant.objects.filter(session=session):
row = []
for f in fnames:
row.append(getattr(ap, f))
for vv in [0, -2, 1, 2]:
vc = ApplicationVote.objects.filter(applicant=ap,
points__exact=vv).count()
row.append(vc)
for q in qs:
ans = 'no answer'
try:
ans = ApplicationAnswer.objects.get(applicant=ap,
question=q).answer
except:
pass
row.append(ans)
wr.writerow(row)
return csv_resp
def check_responsible_reports(emails: QuerySet,
resps: List[models.ResponsibilityPerson],
num_responsibles: int):
assert len(resps) == num_responsibles
assert len(
emails
) == num_responsibles + 1 - 1 # +1 to participant. -1 because 1 does not want email notifications.
_full_report_hit = False
_no_full_report_hit = False
_no_email_hit = False
for r in resps:
if not r.send_email_notifications:
_no_email_hit = True
continue
email = emails.get(to_address=r.email)
url = urlparse(email.context_dict['url']).path
client1.session.clear()
res = client1.get(url)
assert res.status_code == Http.REDIR
assert res.url == Pages.REPORT_RESPONSIBLE
res = client1.get(res.url)
assert res.status_code == Http.OK
if r.show_full_report:
_full_report_hit = True
for p in REPORT_PAGES:
res = client1.get(p)
assert res.status_code == Http.OK
else:
_no_full_report_hit = True
for p in REPORT_PAGES:
res = client1.get(p)
assert res.status_code == Http.REDIR
assert res.url.startswith(Pages.ADMIN_LOGIN)
assert _no_full_report_hit and _full_report_hit and _no_email_hit # check that test data is comprehensive enough
def get_object_or_404(queryset: QuerySet, *args, **kwargs):
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise NotFoundError
def ref_rank_filter(ref_rank_set: QuerySet, yoe):
try:
ref_rank_name = ref_rank_set.get(yoe=yoe).rank.name
except ReferenceRank.DoesNotExist:
return None
return ref_rank_name
def safe_queryset_get(queryset: QuerySet, **get_kwarg) -> Model or None:
try:
return queryset.get(**get_kwarg)
except ObjectDoesNotExist or MultipleObjectsReturned:
return None
