def serialize(cls, models):
if isinstance(models, ScientificModel):
data = cls._to_dict(models)
else:
data = [cls._to_dict(model) for model in models]
encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
return encoder.encode(data)
def encode_event_to_json(event):
"""
Encode Event to a JSON serialisable object.
"""
datetime_json_encoder = DjangoJSONEncoder()
return {'id': event.id,
'title': event.title,
'from_date': datetime_json_encoder.encode(event.from_date),
'from_time': datetime_json_encoder.encode(event.from_time),
'to_date': datetime_json_encoder.encode(event.to_date),
'to_time': datetime_json_encoder.encode(event.to_time),
'location': event.location,
'note': event.note,
'lecturer': '%s' % event.lecturer,
'module': '%s' % event.module,}
def serialize(cls, tests, version=None):
if isinstance(tests, ValidationTestDefinition):
data = cls._to_dict(tests, version=version)
else:
data = [cls._to_dict(test) for test in tests]
encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
return encoder.encode(data)
def serialize(cls, results):
if isinstance(results, ValidationTestResult):
data = cls._to_dict(results)
else:
data = [cls._to_dict(result) for result in results]
encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
return encoder.encode(data)
def send_notification_by_websocket(sender, instance, created, *args, **kwargs):
if not created:
return
if instance.action_type == NOTIFICATION_TYPE_AUCTION:
data = NotificationSerializer(instance).data
encoder = DjangoJSONEncoder()
AuctionChannel.send(encoder.encode(data))
def __init__(self, obj):
encoder = DjangoJSONEncoder(encoding='utf-8',
ensure_ascii=False,
sort_keys=False,
indent=1)
super(JsonResponse, self).__init__(encoder.encode(obj),
content_type='application/json')
class ProjectListSerializer(object):
template = "project_list.html"
def __init__(self, media_type):
self.media_type = media_type
self._encoder = DjangoJSONEncoder(ensure_ascii=False)
def encode(self, projects, request):
protocol = request.is_secure() and "https" or "http"
data = [
{
"id": project.id,
"name": project.get_name(),
"description": project.description,
"uri": "%s://%s%s"
% (protocol, request.get_host(), reverse("sumatra-project", args=[project.id])),
"last_updated": project.last_updated(),
}
for project in projects
]
if self.media_type in (
"application/vnd.sumatra.project-list-v3+json",
"application/vnd.sumatra.project-list-v4+json",
"application/json",
):
# later can add support for multiple versions
return self._encoder.encode(data)
elif self.media_type == "text/html":
context = {"data": data}
return render(request, self.template, context)
else:
raise ValueError("Unsupported media type")
def serialize(cls, projects):
encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
if isinstance(projects, Project):
data = cls._to_dict(projects)
else:
data = [cls._to_dict(project) for project in projects]
return encoder.encode(data)
def serialize(cls, quotas):
if isinstance(quotas, Quota):
data = cls._to_dict(quotas)
else:
data = [cls._to_dict(quota) for quota in quotas]
encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
return encoder.encode(data)
def instance_to_json(instance, fields=None, exclude=None, indent=1):
encoder = DjangoJSONEncoder(encoding='utf-8',
ensure_ascii=False,
sort_keys=False,
indent=indent)
return encoder.encode(
instance_to_dict(instance, fields=fields, exclude=exclude))
def encode_task_to_json(task):
"""
Encode Task to a JSON serialisable object.
"""
datetime_json_encoder = DjangoJSONEncoder()
return {'id': task.id,
'date': datetime_json_encoder.encode(task.date),
'notes': task.notes,}
def json_v1(req):
enc = DjangoJSONEncoder(
ensure_ascii=False, indent=2, separators=(',', ':'))
return HttpResponse(enc.encode(
[
info.toolinfo()
for info in ToolInfo.objects.all().order_by('name')
]),
content_type="application/json; charset=utf8"
)
def generate_access_token(user):
id_json = DjangoJSONEncoder()
user_id = id_json.encode(user.id)
payload = {
'username': user.username,
'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=60),
'iat': datetime.datetime.utcnow()
}
return jwt.encode(payload, settings.SECRET_KEY, algorithm='HS256').decode('utf-8')
def get_context_data(self, **kwargs):
data = super(MarketDetail, self).get_context_data(**kwargs)
serializer = DjangoJSONEncoder()
stations = (self.object.stations.filter(active=True)
.order_by('-latest_snapshot__timestamp')
.select_related('latest_snapshot')
)
data['stations'] = stations
json_data = {
'stations': map(self.station_to_json, stations),
'updated_at': stations[0].updated_at,
}
data['station_json'] = serializer.encode(json_data)
return data
class PermissionListSerializer(object):
template = "project_permissions.html"
def __init__(self, media_type):
self.media_type = media_type
self._encoder = DjangoJSONEncoder(ensure_ascii=False)
def encode(self, project, request=None):
data = {
"id": project.id,
"name": project.get_name(),
"access": [perm.user for perm in project.projectpermission_set.all()],
}
if self.media_type == "application/json":
return self._encoder.encode(data)
elif self.media_type == "text/html":
context = {"data": data}
return render(request, self.template, context)
else:
raise ValueError("Unsupported media type")
class ProjectSerializer(object):
template = "project_detail.html"
def __init__(self, media_type):
self.media_type = media_type
self._encoder = DjangoJSONEncoder(ensure_ascii=False, indent=4)
def encode(self, project, records, tags, request):
protocol = request.is_secure() and "https" or "http"
project_uri = "%s://%s%s" % (
protocol,
request.get_host(),
reverse("sumatra-project", args=[project.id]),
)
data = {
"id": project.id,
"name": project.get_name(),
"description": project.description,
"records": ["%s%s/" % (project_uri, rec.label) for rec in records],
"tags": tags,
"user": request.user.username,
}
if request.user.username != "anonymous":
# avoid non logged-in users harvesting usernames
data["access"] = [perm.user.username for perm in project.projectpermission_set.all()]
if self.media_type in (
"application/vnd.sumatra.project-v3+json",
"application/vnd.sumatra.project-v4+json",
"application/json",
):
# later can add support for multiple versions
return self._encoder.encode(data)
elif self.media_type == "text/html":
context = {"data": data}
return render(request, self.template, context)
else:
raise ValueError("Unsupported media type")
def get(self, request, **kwargs):
del_window = datetime.timedelta(hours=12)
serializer = DjangoJSONEncoder()
station = self.model.objects.get(market__slug=kwargs['slug'],
slug=kwargs['station_slug'])
# make querysets
recent_start = timezone.now() - datetime.timedelta(hours=11)
recent_qs = station.history.filter(
timestamp__gt=recent_start,
timestamp__lte=recent_start + del_window,
)
yesterday_start = recent_start - datetime.timedelta(days=1)
yesterday_qs = station.history.filter(
timestamp__gt=yesterday_start,
timestamp__lte=yesterday_start + del_window,
)
lastweek_start = recent_start - datetime.timedelta(days=7)
lastweek_qs = station.history.filter(
timestamp__gt=lastweek_start,
timestamp__lte=lastweek_start + del_window,
)
# convert querysets to json
recent = map(self.snapshot_to_json, recent_qs)
yesterday = map(self.snapshot_to_json, yesterday_qs)
lastweek = map(self.snapshot_to_json, lastweek_qs)
data = {
'capacity': station.capacity,
'recent': recent,
'yesterday': yesterday,
'lastweek': lastweek,
}
return HttpResponse(serializer.encode(data),
content_type='application/json')
def serialize_personal_quiz(microlearning_average):
json_encoder = DjangoJSONEncoder()
project = microlearning_average.get_project()
step_microlearnings = MicroLearning.objects.filter_by_step(
microlearning_average.step)
teams = project.teams.all()
# Old version socket data
serialized_data = microlearning_average.serialize()
# Append data for new socket version
serialized_data['personalRating'] = serialized_data.get('user')
serialized_data['teamRatings'] = []
for microlearning in step_microlearnings:
for team in teams.filter(stream=microlearning.step_stream.stream):
team_microlearning_avg = MicroLearningAverage(
step_stream=microlearning.step_stream,
user=None,
team=team
)
data = team_microlearning_avg.serialize()
serialized_data['teamRatings'].append(
json.loads(
json_encoder.encode({
'pkTeam': team.pk,
'nameTeam': team.name,
'ratings': data.get('ratings'),
'avg': data.get('allTeamAvg'),
})
)
)
serialized_data['teamRatings'] = sorted(
serialized_data['teamRatings'], key=lambda x: x['pkTeam'])
return serialized_data
def instance_to_json(instance, fields=None, exclude=None, indent=1):
encoder = DjangoJSONEncoder(
encoding='utf-8', ensure_ascii=False, sort_keys=False, indent=indent)
return encoder.encode(instance_to_dict(instance, fields=fields, exclude=exclude))
def json_encode(data):
encoder = DjangoJSONEncoder()
return encoder.encode(data)
def test_0_encode_default(self):
djangoencoder = DjangoJSONEncoder()
self.assertEquals(self.encoder.encode('str'),
djangoencoder.encode('str'))
def __init__(self, obj):
encoder = DjangoJSONEncoder(
encoding='utf-8', ensure_ascii=False, sort_keys=False, indent=1)
super(JsonResponse, self).__init__(
encoder.encode(obj),
content_type='application/json')
def as_json(d, indent=2):
encoder = DjangoJSONEncoder(indent=indent, sort_keys=True)
return encoder.encode(d)
def test_0_encode_default(self):
djangoencoder = DjangoJSONEncoder()
self.assertEquals(self.encoder.encode('str'), djangoencoder.encode('str'))
def json_pack(feed): encoder=DjangoJSONEncoder() return HttpResponse(encoder.encode(feed))
def json_response(response_obj):
Encoder = DjangoJSONEncoder()
return HttpResponse(Encoder.encode(response_obj))
class DnsAdGuardProvider(Provider):
def __init__(self, isSimulation=False):
super().__init__("DNS", isSimulation)
self.pattern_id = re.compile("\d+\.\d+\.\d+\.(\d+)")
resolver.default_resolver = resolver.Resolver(configure=False)
resolver.default_resolver.nameservers = [AppSettings.DNS_HOST]
self.encoder = DjangoJSONEncoder()
self.pattern6OrMoreDigits = re.compile(
"\.(\d{6})\d+") # .123456789 => .(123456)789
self.patterFloat = re.compile("(\d+\.\d+)") # 12.3456789
def GetProtected(self, data) -> []:
if AppSettings.DNS_ADGUARD.API_QUERY_LOG.startswith("http"):
url = f"{AppSettings.DNS_ADGUARD.API_QUERY_LOG}"
headers = {
'Authorization': AppSettings.DNS_ADGUARD.API_AUTH,
'User-Agent': "PostmanRuntime/7.20.1",
'Accept': "*/*",
'Cache-Control': "no-cache",
'Accept-Encoding': "gzip, deflate",
'Connection': "keep-alive",
'cache-control': "no-cache"
}
response = requests.request("GET", url, headers=headers)
re_json = response.json()
else:
self.log.debug(
f'Read data from file: 💾 {AppSettings.DNS_ADGUARD.API_QUERY_LOG}'
)
with open(AppSettings.DNS_ADGUARD.API_QUERY_LOG) as json_file:
re_json = json.load(json_file)
data = re_json['data']
oldestMinutes = self.OldestDateTimeMinutes(re_json['oldest'])
if oldestMinutes > 20:
self.log.debug(
f'Oldest (minutes): {oldestMinutes:.2f} (⏱️ {re_json["oldest"]})'
)
else:
self.log.error(
f'Oldest (minutes): {oldestMinutes:.2f} (⏱️ {re_json["oldest"]})'
)
self.log.debug(f"Data (items) : {len(data)}")
return data
def PostProcess(self, i, context: dict):
try:
match = self.pattern_id.search(i["client"])
if match:
i["client_id"] = int(match.group(1))
i["client_ip"] = i["client"]
# DNS reverse lookup
rev_name = reversename.from_address(i["client_ip"])
try:
if not self.isSimulation:
answer = resolver.query(rev_name,
"PTR",
lifetime=60,
raise_on_no_answer=False) #
i["client"] = answer[0].target.labels[0].decode("utf-8")
except resolver.NXDOMAIN as err:
self.log.warning(f"Cant resolve IP: 📶 {i['client_ip']}. {err}")
except IndexError as err:
self.log.warning(f"Cant resolve IP: 📶 {i['client_ip']}. {err}")
if 'answer' in i:
for item in i['answer']:
if not isinstance(item['value'],
str): # simplify complex answer SRV
item['value'] = str(item['value']['Target']).strip('.')
dt = self.ParseDateTime(i["time"])
del (i["time"])
dt = dt.astimezone(pytz.utc)
dtStr = self.encoder.encode(dt).strip('"')
i["@timestamp"] = dtStr
i["tags"] = ["camera_tools"]
i["elapsedMs"] = round(float(i["elapsedMs"]), 2)
i['_index'] = f"dns-{dt:%Y.%m}"
i['_id'] = f'{i["client"]}@{dtStr}_{i["question"]["host"]}'
except:
print("⚠ Unexpected error:", sys.exc_info()[0])
self.log.debug("Source: " + json.dumps(i, indent=4))
raise
def ParseDateTime(self, datetimeStr: str):
datetimeStr = datetimeStr.replace("Z", "+00:00")
# 12.354698787984 => 12.354698 # exact 6 digit after "." and 2 before
# 2.354698787984 => 02.354698
# 2.354 => 02.354000
datetimeStr = self.patterFloat.sub(
lambda x: '{:0>9.6f}'.format(float(x.group(1))), datetimeStr)
dt = datetime.datetime.fromisoformat(datetimeStr)
# dt = dt.replace(tzinfo=None)
return dt
def OldestDateTimeMinutes(self, oldestStr: str):
dt = self.ParseDateTime(oldestStr)
dt = dt.replace(tzinfo=None)
now = datetime.datetime.now()
return (now - dt).total_seconds() / 60
def json_encode(data):
encoder = DjangoJSONEncoder()
return encoder.encode(data)
class Command(BaseCommand):
"""
Export sample json for OCDEP.
"""
help = 'Export sample json for OCDEP.'
def handle(self, *args, **options):
"""
Do it.
"""
self.encoder = DjangoJSONEncoder(indent=4)
# Election
elec = Election.objects.latest('start_time')
full_elec = self.prep_dict(elec.__dict__).copy()
full_elec.update(self.prep_dict(elec.event_ptr.__dict__))
full_elec['identifiers'] = [
self.prep_dict(i.__dict__) for i in elec.identifiers.all()
]
full_elec['sources'] = [
self.prep_dict(i.__dict__) for i in elec.sources.all()
]
print('Sample Election')
print('+++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_elec))
print('--------------------------------------------------------')
# ContestBase
contest = ContestBase.objects.get(
election=elec,
name='STATE SENATE 01',
)
full_contest = self.prep_dict(contest.__dict__).copy()
full_contest['identifiers'] = [
self.prep_dict(i.__dict__) for i in contest.identifiers.all()
]
full_contest['sources'] = [
self.prep_dict(i.__dict__) for i in contest.sources.all()
]
print('Sample ContestBase')
print('+++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_contest))
print('--------------------------------------------------------')
# BallotMeasureContest
ballot_measure = BallotMeasureContest.objects.get(
election=elec,
name=
'PROPOSITION 060- ADULT FILMS. CONDOMS. HEALTH REQUIREMENTS. INITIATIVE STATUTE.',
)
full_ballot_measure = self.prep_dict(ballot_measure.__dict__).copy()
full_ballot_measure['identifiers'] = [
self.prep_dict(i.__dict__)
for i in ballot_measure.identifiers.all()
]
full_ballot_measure['sources'] = [
self.prep_dict(i.__dict__) for i in ballot_measure.sources.all()
]
print('Sample BallotMeasureContest')
print('+++++++++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_ballot_measure))
print('--------------------------------------------------------')
# CandidateContest
candidate_contest = CandidateContest.objects.get(
election=elec,
name='STATE SENATE 01',
)
full_candidate_contest = self.prep_dict(
candidate_contest.__dict__).copy()
full_candidate_contest['identifiers'] = [
self.prep_dict(i.__dict__)
for i in candidate_contest.identifiers.all()
]
full_candidate_contest['sources'] = [
self.prep_dict(i.__dict__)
for i in candidate_contest.sources.all()
]
print('Sample CandidateContest')
print('+++++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_candidate_contest))
print('--------------------------------------------------------')
# RetentionContest
retention_contest = RetentionContest.objects.get(
name='2003 RECALL QUESTION', )
full_retention_contest = self.prep_dict(
retention_contest.__dict__).copy()
full_retention_contest['identifiers'] = [
self.prep_dict(i.__dict__)
for i in retention_contest.identifiers.all()
]
full_retention_contest['sources'] = [
self.prep_dict(i.__dict__)
for i in retention_contest.sources.all()
]
print('Sample RetentionContest')
print('+++++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_retention_contest))
print('--------------------------------------------------------')
# Candidacy
candidacy = CandidateSelection.objects.filter(
contest__election=elec,
contest__name='STATE SENATE 01',
)[0].candidacies.all()[0]
full_candidacy = self.prep_dict(candidacy.__dict__).copy()
full_candidacy['sources'] = [
self.prep_dict(i.__dict__) for i in candidacy.sources.all()
]
print('Sample Candidacy')
print('++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_candidacy))
print('--------------------------------------------------------')
# Party
party = Party.objects.get(name='DEMOCRATIC')
full_party = self.prep_dict(party.__dict__).copy()
full_party['sources'] = [
self.prep_dict(i.__dict__) for i in party.sources.all()
]
print('Sample Party')
print('++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_party))
print('--------------------------------------------------------')
# BallotSelectionBase
ballot_selection = BallotSelectionBase.objects.filter(
candidateselection__contest__election=elec,
candidateselection__contest__name='STATE SENATE 01',
)[0]
full_ballot_selection = self.prep_dict(
ballot_selection.__dict__).copy()
print('Sample BallotSelectionBase')
print('++++++++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_ballot_selection))
print('--------------------------------------------------------')
# BallotMeasureSelection
ballot_measure_selection = BallotMeasureSelection.objects.get(
contest__name=
'PROPOSITION 060- ADULT FILMS. CONDOMS. HEALTH REQUIREMENTS. INITIATIVE STATUTE.',
selection='Yes',
)
full_ballot_measure_selection = self.prep_dict(
ballot_measure_selection.__dict__).copy()
print('Sample BallotMeasureSelection')
print('++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_ballot_measure_selection))
print('--------------------------------------------------------')
# CandidateSelection
candidate_selection = CandidateSelection.objects.filter(
contest__election=elec,
contest__name='STATE SENATE 01',
)[0]
full_candidate_selection = self.prep_dict(
candidate_selection.__dict__).copy()
full_candidate_selection['candidacy_ids'] = [
i.id for i in candidate_selection.candidacies.all()
]
print('Sample CandidateSelection')
print('++++++++++++++++++++++++++\n\n')
print('.. code:: javascript\n')
print(self.encoder.encode(full_candidate_selection))
print('--------------------------------------------------------')
def prep_dict(self, obj_dict):
"""
Remove unwanted items from given object.
"""
cp_dict = obj_dict.copy()
for k in obj_dict:
if re.match(r'^_.+$', k) or '_ptr_' in k:
del cp_dict[k]
if 'scheme' in cp_dict or 'url' in cp_dict:
_id = [k for k in cp_dict if k.endswith('_id')][0]
del cp_dict[_id]
del cp_dict['id']
return cp_dict
def handle(self, analysis_id, **options):
analysis = models.Analysis.objects.get(id=analysis_id)
serializer = DjangoJSONEncoder(indent=4)
output = serializer.encode(analysis.to_dict())
self.stdout.write('{}\n'.format(output))
from functools import partial
from datetime import datetime
make_datetime = partial(datetime, tzinfo=get_current_timezone())
encoder = DjangoJSONEncoder()
timeline_config = {
'start_real':
make_datetime(2017, 2, 25, 21),
'start_fake':
make_datetime(1948, 9, 20),
'periods': [ # (Seconds, speed)
[576000, 1],
[28800, 24],
[41400, 12],
[30600, 24],
]
}
timeline_config['periods'] = [{
'duration': period,
'speed': speed
} for period, speed in timeline_config['periods']]
timeline_data = encoder.encode(timeline_config)
def timeline_context_processor(request):
return {'timeline_data': timeline_data}
