def _draw_track(self, dr: svgwrite.Drawing, tr: Track, size: XY,
offset: XY):
color = self.color(self.poster.length_range, tr.length, tr.special)
str_length = utils.format_float(self.poster.m2u(tr.length))
date_title = f"{str(tr.start_time)[:10]} {str_length}km"
for line in utils.project(tr.bbox(), size, offset, tr.polylines):
distance1 = self.poster.special_distance["special_distance"]
distance2 = self.poster.special_distance["special_distance2"]
has_special = distance1 < tr.length / 1000 < distance2
color = self.color(self.poster.length_range_by_date, tr.length,
has_special)
if tr.length / 1000 >= distance2:
color = self.poster.colors.get(
"special2") or self.poster.colors.get("special")
polyline = dr.polyline(
points=line,
stroke=color,
fill="none",
stroke_width=0.5,
stroke_linejoin="round",
stroke_linecap="round",
)
polyline.set_desc(title=date_title)
dr.add(polyline)
def name(self):
if logging_enabled == True:
print(
"- Entered dist_sim_kernel::GaussianKernel::name Public Method"
)
return 'Gaussian_yeta={}'.format(format_float(self.yeta))
def autolabel(rects, metric):
special_float_format = 3 if metric == 'mse' else None
for rect in rects:
height = rect.get_height()
plt.text(
rect.get_x() + rect.get_width() / 2., 1.005 * height,
format_float(height, special_float_format),
ha='center', va='bottom')
def _update_products(self):
counter = 0
updated_prices = 0
update_names = 0
created_products = 0
for key, value in self.df.iterrows():
if counter == 0:
counter += 1
continue
code = value[2]
if str(code) != 'nan':
brand = value[0]
refence = value[1]
price = format_float(value[5])
name = value[3].replace("Ð", "Ñ").replace("║", "|")
try:
product = Product.get(code=code)
except Exception:
Product.create(brand=brand,
reference=refence,
code=code,
name=name,
price=price)
counter += 1
created_products += 1
continue
if product.name != name:
product.name = name
product.save()
update_names += 1
if es_casi_igual(product.price, price):
pass
else:
# Actualizar precio.
product.price = price
product.save()
updated_prices += 1
counter += 1
if updated_prices or update_names or created_products:
messagebox.showinfo(
"Precios Actualizados!",
f"{updated_prices} precios actualizados, {update_names} nombre modificados, {created_products} productos nuevos."
)
def get_annual_profitability(col):
"""
HTML Col Types:
1. 7,57%
2. SELIC + 0,03%
3. IPCA + 3,08%
"""
col = col.find('span').text.lower()
col_clean = col.replace('selic', '').replace('ipca',
'').replace('+', '')
col_clean = format_float(col_clean)
if 'selic' in col:
annual_profitability = (col_clean, 'SELIC')
elif 'ipca' in col:
annual_profitability = (col_clean, 'IPCA')
else:
annual_profitability = (col_clean, )
return annual_profitability
def __draw_footer(self, d):
text_color = self.colors["text"]
header_style = "font-size:4px; font-family:Arial"
value_style = "font-size:9px; font-family:Arial"
small_value_style = "font-size:3px; font-family:Arial"
(
total_length,
average_length,
min_length,
max_length,
weeks,
) = self.__compute_track_statistics()
d.add(
d.text(
self.trans("ATHLETE"),
insert=(10, self.height - 20),
fill=text_color,
style=header_style,
))
d.add(
d.text(
self.athlete,
insert=(10, self.height - 10),
fill=text_color,
style=value_style,
))
d.add(
d.text(
self.trans("STATISTICS"),
insert=(120, self.height - 20),
fill=text_color,
style=header_style,
))
d.add(
d.text(
self.trans("Number") + f": {len(self.tracks)}",
insert=(120, self.height - 15),
fill=text_color,
style=small_value_style,
))
d.add(
d.text(
self.trans("Weekly") + ": " +
format_float(len(self.tracks) / weeks),
insert=(120, self.height - 10),
fill=text_color,
style=small_value_style,
))
d.add(
d.text(
self.trans("Total") + ": " +
self.format_distance(total_length),
insert=(141, self.height - 15),
fill=text_color,
style=small_value_style,
))
d.add(
d.text(
self.trans("Avg") + ": " +
self.format_distance(average_length),
insert=(141, self.height - 10),
fill=text_color,
style=small_value_style,
))
d.add(
d.text(
self.trans("Min") + ": " + self.format_distance(min_length),
insert=(167, self.height - 15),
fill=text_color,
style=small_value_style,
))
d.add(
d.text(
self.trans("Max") + ": " + self.format_distance(max_length),
insert=(167, self.height - 10),
fill=text_color,
style=small_value_style,
))
def format_distance(self, d: float) -> str:
"""Formats a distance using the locale specific float format and the selected unit."""
return format_float(self.m2u(d)) + " " + self.u()
def name(self):
return 'Inverse_scale={}'.format(format_float(self.scale))
def name(self):
return 'Exp_scale={}'.format(format_float(self.scale))
def parse_data(self):
self.ipca_value = format_float(self.ipca_html.text)
def update_layers_warper(service):
"""
Update layers for a Warper service.
"""
params = {'field': 'title', 'query': '', 'show_warped': '1', 'format': 'json'}
headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
request = requests.get(service.url, headers=headers, params=params)
records = json.loads(request.content)
total_pages = int(records['total_pages'])
for i in range(1, total_pages + 1):
params = {'field': 'title', 'query': '', 'show_warped': '1', 'format': 'json', 'page': i}
request = requests.get(service.url, headers=headers, params=params)
records = json.loads(request.content)
print 'Fetched %s' % request.url
layers = records['items']
for layer in layers:
name = layer['id']
title = layer['title']
abstract = layer['description']
bbox = layer['bbox']
# dates
dates = []
if 'published_date' in layer:
dates.append(layer['published_date'])
if 'date_depicted' in layer:
dates.append(layer['date_depicted'])
if 'depicts_year' in layer:
dates.append(layer['depicts_year'])
if 'issue_year' in layer:
dates.append(layer['issue_year'])
layer, created = Layer.objects.get_or_create(name=name, service=service)
if layer.active:
# update fields
layer.type = 'Hypermap:WARPER'
layer.title = title
layer.abstract = abstract
layer.is_public = True
layer.url = '%s/wms/%s?' % (service.url, name)
layer.page_url = '%s/%s' % (service.url, name)
# bbox
x0 = None
y0 = None
x1 = None
y1 = None
if bbox:
bbox_list = bbox.split(',')
x0 = format_float(bbox_list[0])
y0 = format_float(bbox_list[1])
x1 = format_float(bbox_list[2])
y1 = format_float(bbox_list[3])
layer.bbox_x0 = x0
layer.bbox_y0 = y0
layer.bbox_x1 = x1
layer.bbox_y1 = y1
# crsOptions
for crs_code in [3857, 4326, 900913]:
srs, created = SpatialReferenceSystem.objects.get_or_create(code=crs_code)
layer.srs.add(srs)
layer.save()
# dates
add_mined_dates(layer)
add_metadata_dates_to_layer(dates, layer)
def update_layers_wm(service):
"""
Update layers for an WorldMap.
"""
response = requests.get('http://worldmap.harvard.edu/data/search/api?start=0&limit=10')
data = json.loads(response.content)
total = data['total']
for i in range(0, total, 10):
url = 'http://worldmap.harvard.edu/data/search/api?start=%s&limit=10' % i
print 'Fetching %s' % url
response = requests.get(url)
data = json.loads(response.content)
for row in data['rows']:
name = row['name']
title = row['title']
abstract = row['abstract']
bbox = row['bbox']
page_url = row['detail']
category = ''
if 'topic_category' in row:
category = row['topic_category']
username = ''
if 'owner_username' in row:
username = row['owner_username']
temporal_extent_start = ''
if 'temporal_extent_start' in row:
temporal_extent_start = row['temporal_extent_start']
temporal_extent_end = ''
if 'temporal_extent_end' in row:
temporal_extent_end = row['temporal_extent_end']
# we use the geoserver virtual layer getcapabilities for wm endpoint
endpoint = 'http://worldmap.harvard.edu/geoserver/geonode/%s/wms?' % name
is_public = True
if '_permissions' in row:
if not row['_permissions']['view']:
is_public = False
layer, created = Layer.objects.get_or_create(name=name, service=service)
if layer.active:
# update fields
layer.type = 'Hypermap:WorldMap'
layer.title = title
layer.abstract = abstract
layer.is_public = is_public
layer.url = endpoint
layer.page_url = page_url
# category and owner username
layer_wm, created = LayerWM.objects.get_or_create(layer=layer)
layer_wm.category = category
layer_wm.username = username
layer_wm.temporal_extent_start = temporal_extent_start
layer_wm.temporal_extent_end = temporal_extent_end
layer_wm.save()
# bbox
x0 = format_float(bbox['minx'])
y0 = format_float(bbox['miny'])
x1 = format_float(bbox['maxx'])
y1 = format_float(bbox['maxy'])
# In many cases for some reason to be fixed GeoServer has x coordinates flipped in WM.
x0, x1 = flip_coordinates(x0, x1)
y0, y1 = flip_coordinates(y0, y1)
layer.bbox_x0 = x0
layer.bbox_y0 = y0
layer.bbox_x1 = x1
layer.bbox_y1 = y1
# keywords
for keyword in row['keywords']:
layer.keywords.add(keyword)
# crsOptions
for crs_code in [3857, 4326, 900913]:
srs, created = SpatialReferenceSystem.objects.get_or_create(code=crs_code)
layer.srs.add(srs)
layer.save()
# dates
add_mined_dates(layer)
add_metadata_dates_to_layer([layer_wm.temporal_extent_start, layer_wm.temporal_extent_end], layer)
def get_unit_price(col):
unit_price = format_float(col.find('span').text)
return unit_price
def get_minimum_investment(col):
minimum_investment = format_float(col.find('span').text)
return minimum_investment
def name(self):
return 'Gaussian_yeta={}'.format(format_float(self.yeta))
def draw(self, dr: svgwrite.Drawing, size: XY, offset: XY):
if self.poster.tracks is None:
raise PosterError("No tracks to draw")
year_size = 200 * 4.0 / 80.0
year_style = f"font-size:{year_size}px; font-family:Arial;"
year_length_style = f"font-size:{110 * 3.0 / 80.0}px; font-family:Arial;"
month_names_style = f"font-size:2.5px; font-family:Arial"
total_length_year_dict = self.poster.total_length_year_dict
for year in range(self.poster.years.from_year, self.poster.years.to_year + 1):
start_date_weekday, _ = calendar.monthrange(year, 1)
github_rect_first_day = datetime.date(year, 1, 1)
# Github profile the first day start from the last Monday of the last year or the first Monday of this year
# It depands on if the first day of this year is Monday or not.
github_rect_day = github_rect_first_day + datetime.timedelta(
-start_date_weekday
)
year_length = total_length_year_dict.get(year, 0)
year_length = utils.format_float(self.poster.m2u(year_length))
month_names = [
locale.nl_langinfo(day)[:3] # Get only first three letters
for day in [
locale.MON_1,
locale.MON_2,
locale.MON_3,
locale.MON_4,
locale.MON_5,
locale.MON_6,
locale.MON_7,
locale.MON_8,
locale.MON_9,
locale.MON_10,
locale.MON_11,
locale.MON_12,
]
]
km_or_mi = "mi"
if self.poster.units == "metric":
km_or_mi = "km"
dr.add(
dr.text(
f"{year}",
insert=offset.tuple(),
fill=self.poster.colors["text"],
alignment_baseline="hanging",
style=year_style,
)
)
dr.add(
dr.text(
f"{year_length} {km_or_mi}",
insert=(offset.tuple()[0] + 165, offset.tuple()[1] + 2),
fill=self.poster.colors["text"],
alignment_baseline="hanging",
style=year_length_style,
)
)
# add month name up to the poster one by one because of svg text auto trim the spaces.
for num, name in enumerate(month_names):
dr.add(
dr.text(
f"{name}",
insert=(offset.tuple()[0] + 15.5 * num, offset.tuple()[1] + 14),
fill=self.poster.colors["text"],
style=month_names_style,
)
)
rect_x = 10.0
dom = (2.6, 2.6)
# add every day of this year for 53 weeks and per week has 7 days
for i in range(54):
rect_y = offset.y + year_size + 2
for j in range(7):
if int(github_rect_day.year) > year:
break
rect_y += 3.5
color = "#444444"
date_title = str(github_rect_day)
if date_title in self.poster.tracks_by_date:
tracks = self.poster.tracks_by_date[date_title]
length = sum([t.length for t in tracks])
distance1 = self.poster.special_distance["special_distance"]
distance2 = self.poster.special_distance["special_distance2"]
has_special = distance1 < length / 1000 < distance2
color = self.color(
self.poster.length_range_by_date, length, has_special
)
if length / 1000 >= distance2:
color = self.poster.colors.get(
"special2"
) or self.poster.colors.get("special")
str_length = utils.format_float(self.poster.m2u(length))
date_title = f"{date_title} {str_length} {km_or_mi}"
rect = dr.rect((rect_x, rect_y), dom, fill=color)
rect.set_desc(title=date_title)
dr.add(rect)
github_rect_day += datetime.timedelta(1)
rect_x += 3.5
offset.y += 3.5 * 9 + year_size + 1.5
def test_format_float(self):
self.assertEqual("3.14", format_float(3.1415926))
self.assertEqual("3.142", format_float(3.1415926, 3))
self.assertEqual("3.1416", format_float(3.1415926, 4))
self.assertEqual("3", format_float(3.1415926, 0))
def name(self):
if logging_enabled == True:
print(
"- Entered dist_sim_kernel::InverseKernel::name Public Method")
return 'Inverse_scale={}'.format(format_float(self.scale))
def _draw(self, dr: svgwrite.Drawing, size: XY, offset: XY, year: int):
min_size = min(size.x, size.y)
year_size = min_size * 4.0 / 80.0
year_style = f"font-size:{year_size}px; font-family:Arial;"
month_style = f"font-size:{min_size * 3.0 / 80.0}px; font-family:Arial;"
day_style = f"dominant-baseline: central; font-size:{min_size * 1.0 / 80.0}px; font-family:Arial;"
day_length_style = f"font-size:{min_size * 1.0 / 80.0}px; font-family:Arial;"
dr.add(
dr.text(
f"{year}",
insert=offset.tuple(),
fill=self.poster.colors["text"],
alignment_baseline="hanging",
style=year_style,
))
offset.y += year_size
size.y -= year_size
count_x = 31
for month in range(1, 13):
date = datetime.date(year, month, 1)
(_, last_day) = calendar.monthrange(year, month)
count_x = max(count_x, date.weekday() + last_day)
cell_size = min(size.x / count_x, size.y / 36)
spacing = XY(
(size.x - cell_size * count_x) / (count_x - 1),
(size.y - cell_size * 3 * 12) / 11,
)
# chinese weekday key number is the third.
keyword_num = 0
if locale.getlocale()[0] == "zh_CN":
keyword_num = 2
# first character of localized day names, starting with Monday.
dow = [
locale.nl_langinfo(day)[keyword_num].upper() for day in [
locale.DAY_2,
locale.DAY_3,
locale.DAY_4,
locale.DAY_5,
locale.DAY_6,
locale.DAY_7,
locale.DAY_1,
]
]
for month in range(1, 13):
date = datetime.date(year, month, 1)
y = month - 1
y_pos = offset.y + (y * 3 + 1) * cell_size + y * spacing.y
dr.add(
dr.text(
date.strftime("%B"),
insert=(offset.x, y_pos - 2),
fill=self.poster.colors["text"],
alignment_baseline="hanging",
style=month_style,
))
day_offset = date.weekday()
while date.month == month:
x = date.day - 1
x_pos = offset.x + (day_offset + x) * cell_size + x * spacing.x
pos = (x_pos + 0.05 * cell_size, y_pos + 1.15 * cell_size)
dim = (cell_size * 0.9, cell_size * 0.9)
text_date = date.strftime("%Y-%m-%d")
if text_date in self.poster.tracks_by_date:
tracks = self.poster.tracks_by_date[text_date]
length = sum([t.length for t in tracks])
has_special = len([t for t in tracks if t.special]) > 0
color = self.color(self.poster.length_range_by_date,
length, has_special)
dr.add(dr.rect(pos, dim, fill=color))
dr.add(
dr.text(
utils.format_float(self.poster.m2u(length)),
insert=(
pos[0] + cell_size / 2,
pos[1] + cell_size + cell_size / 2,
),
text_anchor="middle",
style=day_length_style,
fill=self.poster.colors["text"],
))
else:
dr.add(dr.rect(pos, dim, fill="#444444"))
dr.add(
dr.text(
dow[date.weekday()],
insert=(
offset.x + (day_offset + x) * cell_size +
cell_size / 2,
pos[1] + cell_size / 2,
),
text_anchor="middle",
alignment_baseline="middle",
style=day_style,
))
date += datetime.timedelta(1)
