def test_fields_to_uppercase_modifies_all_lowercase_fields(self):
fields = {
'csv': 10,
'json': 30,
}
expected = {'CSV': 10, 'JSON': 30}
self.assertEqual(fields_to_uppercase(fields), expected)
def test_fields_to_uppercase_modifies_mixed_fields(self):
fields = {
'csv': 5,
'Csv': 10,
'CSV': 7,
'Json': 30,
'GeoJSON': 47,
}
expected = {'CSV': 22, 'JSON': 30, 'GEOJSON': 47}
self.assertEqual(fields_to_uppercase(fields), expected)
def normalize_values(apps, model):
queryset = model.objects.filter(indicador_tipo__nombre__in=[
'distribuciones_formatos_cant', 'datasets_frecuencia_cant'])
for indicator in queryset:
try:
value = json.loads(indicator.indicador_valor)
if isinstance(value, dict):
normalized_value = fields_to_uppercase(value)
if normalized_value != value:
# No quiero hacer un save si los valores no cambian
indicator.indicador_valor = json.dumps(normalized_value)
indicator.save()
except json.JSONDecodeError:
msg = f'error parseando el indicador:{indicator.pk}'
LOGGER.warning(msg)
def test_fields_to_uppercase_keeps_uppercase_fields_intact(self):
fields = {'CSV': 30, 'JSON': 70}
expected = {'CSV': 30, 'JSON': 70}
self.assertEqual(fields_to_uppercase(fields), expected)
def test_fields_to_uppercase_returns_unique_uppercase_keys(self):
fields = {'csv': 10, 'CSV': 20, 'json': 30, 'JSON': 40}
expected = {'CSV': 30, 'JSON': 70}
self.assertEqual(fields_to_uppercase(fields), expected)
def _generate_indicators(catalog,
validator=None,
only_numeric=False,
broken_links=False,
verify_ssl=True,
url_check_timeout=1,
broken_links_threads=1):
"""Genera los indicadores de un catálogo individual.
Args:
catalog (dict): diccionario de un data.json parseado
Returns:
dict: diccionario con los indicadores del catálogo provisto
"""
result = {}
# Obtengo summary para los indicadores del estado de los metadatos
result.update(
_generate_status_indicators(catalog,
validator=validator,
verify_ssl=verify_ssl))
# Genero indicadores relacionados con validacion de urls
if broken_links:
result.update(
_generate_valid_urls_indicators(
catalog,
validator=validator,
verify_ssl=verify_ssl,
url_check_timeout=url_check_timeout,
threads_count=broken_links_threads))
# Genero los indicadores relacionados con fechas, y los agrego
result.update(_generate_date_indicators(catalog,
only_numeric=only_numeric))
# Agrego la cuenta de los formatos de las distribuciones
if not only_numeric:
if 'dataset' in catalog:
format_count = count_fields(get_distributions(catalog), 'format')
format_count = fields_to_uppercase(format_count)
type_count = count_fields(get_distributions(catalog), 'type')
license_count = count_fields(get_datasets(catalog), 'license')
else:
format_count = type_count = license_count = {}
result.update({
'distribuciones_formatos_cant': format_count,
'distribuciones_tipos_cant': type_count,
'datasets_licencias_cant': license_count,
})
# Agrego porcentaje de campos recomendados/optativos usados
fields_count = _count_required_and_optional_fields(catalog)
recomendados_pct = float(fields_count['recomendado']) / \
fields_count['total_recomendado']
optativos_pct = float(fields_count['optativo']) / \
fields_count['total_optativo']
result.update({
'campos_recomendados_pct': round(recomendados_pct, 4),
'campos_optativos_pct': round(optativos_pct, 4)
})
return fields_count, result