udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30382__py2.py3-none-any.whl

udata/forms/validators.py

@@ -1,8 +1,7 @@
 from urlextract import URLExtract
-
 from wtforms import validators
 from wtforms.validators import *  # noqa
-from wtforms.validators import ValidationError, StopValidation  # noqa
+from wtforms.validators import StopValidation, ValidationError  # noqa
 
 
 def _(s):
@@ -10,10 +9,11 @@ def _(s):
 
 
 class NoURLs(object):
-    '''
+    """
     Check no url is present on this field
-    '''
-    def __init__(self, message=''):
+    """
+
+    def __init__(self, message=""):
         self.extractor = URLExtract()
         self.message = message
 
@@ -23,10 +23,11 @@ class NoURLs(object):
 
 
 class RequiredIf(validators.DataRequired):
-    '''
+    """
     A validator which makes a field required
     only if another field is set and has a truthy value.
-    '''
+    """
+
     def __init__(self, other_field_name, *args, **kwargs):
         self.other_field_name = other_field_name
         super(RequiredIf, self).__init__(*args, **kwargs)
@@ -34,16 +35,16 @@ class RequiredIf(validators.DataRequired):
     def __call__(self, form, field):
         other_field = form._fields.get(self.other_field_name)
         if other_field is None:
-            raise Exception(
-                'No field named "%s" in form' % self.other_field_name)
+            raise Exception('No field named "%s" in form' % self.other_field_name)
         if bool(other_field.data):
             super(RequiredIf, self).__call__(form, field)
 
 
 class Requires(object):
-    '''
+    """
     A validator which makes a field required another field.
-    '''
+    """
+
     def __init__(self, other_field_name, *args, **kwargs):
         self.other_field_name = other_field_name
         super(Requires, self).__init__(*args, **kwargs)
@@ -53,32 +54,28 @@ class Requires(object):
             return
         other_field = form._fields.get(self.other_field_name)
         if other_field is None:
-            raise Exception(
-                'No field named "%s" in form' % self.other_field_name)
+            raise Exception('No field named "%s" in form' % self.other_field_name)
         if not bool(other_field.data):
             msg = field._('This field requires "%(name)s" to be set')
-            raise validators.ValidationError(
-                msg % {'name': field._(other_field.label.text)})
+            raise validators.ValidationError(msg % {"name": field._(other_field.label.text)})
 
 
 class RequiredIfVal(validators.DataRequired):
-    '''
+    """
     A validator which makes a field required
     only if another field is set and has a specified value.
-    '''
+    """
+
     def __init__(self, other_field_name, expected_value, *args, **kwargs):
         self.other_field_name = other_field_name
         self.expected_values = (
-            expected_value
-            if isinstance(expected_value, (list, tuple))
-            else (expected_value,)
+            expected_value if isinstance(expected_value, (list, tuple)) else (expected_value,)
         )
         super(RequiredIfVal, self).__init__(*args, **kwargs)
 
     def __call__(self, form, field):
         other_field = form._fields.get(self.other_field_name)
         if other_field is None:
-            raise Exception(
-                'No field named "%s" in form' % self.other_field_name)
+            raise Exception('No field named "%s" in form' % self.other_field_name)
         if other_field.data in self.expected_values:
             super(RequiredIfVal, self).__call__(form, field)

udata/forms/widgets.py

@@ -10,14 +10,10 @@ class WidgetHelper(object):
 
     def __call__(self, field, **kwargs):
         # Handle extra classes
-        classes = (kwargs.pop('class', '') or kwargs.pop('class_', '')).split()
-        extra_classes = (
-            self.classes
-            if isinstance(self.classes, (list, tuple))
-            else [self.classes]
-        )
+        classes = (kwargs.pop("class", "") or kwargs.pop("class_", "")).split()
+        extra_classes = self.classes if isinstance(self.classes, (list, tuple)) else [self.classes]
         classes.extend([cls for cls in extra_classes if cls not in classes])
-        kwargs['class'] = ' '.join(classes)
+        kwargs["class"] = " ".join(classes)
 
         # Handle defaults
         for key, value in self.attributes.items():
@@ -35,19 +31,19 @@ class TextArea(WidgetHelper, widgets.TextArea):
 
 
 class SelectPicker(WidgetHelper, widgets.Select):
-    classes = 'selectpicker'
+    classes = "selectpicker"
 
 
 class MarkdownEditor(WidgetHelper, widgets.TextArea):
-    classes = 'md'
-    attributes = {'rows': 8}
+    classes = "md"
+    attributes = {"rows": 8}
 
 
 class DateRangePicker(WidgetHelper, widgets.HiddenInput):
-    classes = 'dtpicker'
+    classes = "dtpicker"
 
     def __call__(self, field, **kwargs):
         if field.data:
-            kwargs['data-start-date'] = field.data.start
-            kwargs['data-end-date'] = field.data.end
+            kwargs["data-start-date"] = field.data.start
+            kwargs["data-end-date"] = field.data.end
         return super(DateRangePicker, self).__call__(field, **kwargs)

udata/frontend/__init__.py

@@ -1,23 +1,23 @@
 import inspect
 import logging
-import pkg_resources
-
-from time import time
 from importlib import import_module
+from time import time
+
+import pkg_resources
+from flask import current_app
 from jinja2 import pass_context
 from markupsafe import Markup
-from flask import current_app
 
 from udata import assets, entrypoints
 from udata.i18n import I18nBlueprint
 
-from .markdown import UdataCleaner, init_app as init_markdown
-
+from .markdown import UdataCleaner
+from .markdown import init_app as init_markdown
 
 log = logging.getLogger(__name__)
 
 
-hook = I18nBlueprint('hook', __name__)
+hook = I18nBlueprint("hook", __name__)
 
 _template_hooks = {}
 
@@ -27,15 +27,15 @@ def package_version(name):
     return pkg_resources.get_distribution(name).version
 
 
-@hook.app_template_global(name='static')
+@hook.app_template_global(name="static")
 def static_global(filename, _burst=True, **kwargs):
-    if current_app.config['DEBUG'] or current_app.config['TESTING']:
+    if current_app.config["DEBUG"] or current_app.config["TESTING"]:
         burst = time()
     else:
-        burst = package_version('udata')
+        burst = package_version("udata")
     if _burst:
-        kwargs['_'] = burst
-    return assets.cdn_for('static', filename=filename, **kwargs)
+        kwargs["_"] = burst
+    return assets.cdn_for("static", filename=filename, **kwargs)
 
 
 def _wrapper(func, name=None, when=None):
@@ -50,8 +50,10 @@ def template_hook(func_or_name, when=None):
     if callable(func_or_name):
         return _wrapper(func_or_name)
     elif isinstance(func_or_name, str):
+
         def wrapper(func):
             return _wrapper(func, func_or_name, when=when)
+
         return wrapper
 
 
@@ -67,11 +69,13 @@ class HookRenderer:
         self.kwargs = kwargs
 
     def __html__(self):
-        return Markup(''.join(
-            f(self.ctx, *self.args, **self.kwargs)
-            for f, w in self.funcs
-            if w is None or w(self.ctx)
-        ))
+        return Markup(
+            "".join(
+                f(self.ctx, *self.args, **self.kwargs)
+                for f, w in self.funcs
+                if w is None or w(self.ctx)
+            )
+        )
 
     def __iter__(self):
         for func, when in self.funcs:
@@ -82,20 +86,21 @@ class HookRenderer:
 @pass_context
 def render_template_hook(ctx, name, *args, **kwargs):
     if not has_template_hook(name):
-        return ''
+        return ""
     return HookRenderer(_template_hooks[name], ctx, *args, **kwargs)
 
 
 @hook.app_context_processor
 def inject_hooks():
     return {
-        'hook': render_template_hook,
-        'has_hook': has_template_hook,
+        "hook": render_template_hook,
+        "has_hook": has_template_hook,
     }
 
 
 class SafeMarkup(Markup):
-    '''Markup object bypasses Jinja's escaping. This override allows to sanitize the resulting html.'''
+    """Markup object bypasses Jinja's escaping. This override allows to sanitize the resulting html."""
+
     def __new__(cls, base, *args, **kwargs):
         cleaner = UdataCleaner()
         return super().__new__(cls, cleaner.clean(base), *args, **kwargs)
@@ -103,12 +108,12 @@ class SafeMarkup(Markup):
 
 def _load_views(app, module):
     views = module if inspect.ismodule(module) else import_module(module)
-    blueprint = getattr(views, 'blueprint', None)
+    blueprint = getattr(views, "blueprint", None)
     if blueprint:
         app.register_blueprint(blueprint)
 
 
-VIEWS = ['core.storages', 'core.tags', 'admin']
+VIEWS = ["core.storages", "core.tags", "admin"]
 
 
 def init_app(app, views=None):
@@ -117,16 +122,16 @@ def init_app(app, views=None):
     init_markdown(app)
 
     for view in views:
-        _load_views(app, 'udata.{}.views'.format(view))
+        _load_views(app, "udata.{}.views".format(view))
 
     # Load hook blueprint
     app.register_blueprint(hook)
 
     # Load all plugins views and blueprints
-    for module in entrypoints.get_enabled('udata.views', app).values():
+    for module in entrypoints.get_enabled("udata.views", app).values():
         _load_views(app, module)
 
     # Load all plugins views and blueprints
-    for module in entrypoints.get_enabled('udata.front', app).values():
+    for module in entrypoints.get_enabled("udata.front", app).values():
         front_module = module if inspect.ismodule(module) else import_module(module)
         front_module.init_app(app)

udata/frontend/csv.py

@@ -1,29 +1,26 @@
+import csv
+import itertools
 import logging
-
+from datetime import date, datetime
 from io import StringIO
-import itertools
-import csv
-
-from datetime import datetime, date
 
 from flask import Response, stream_with_context
 
 from udata.mongo import db
 from udata.utils import recursive_get
 
-
 log = logging.getLogger(__name__)
 
 _adapters = {}
 
 CONFIG = {
-    'delimiter': ';',
-    'quotechar': '"',
+    "delimiter": ";",
+    "quotechar": '"',
 }
 
 
 def safestr(value):
-    '''Ensure type to string serialization'''
+    """Ensure type to string serialization"""
     if not value or isinstance(value, (int, float, bool)):
         return value
     elif isinstance(value, (date, datetime)):
@@ -33,7 +30,8 @@ def safestr(value):
 
 
 class Adapter(object):
-    '''A Base model CSV adapter'''
+    """A Base model CSV adapter"""
+
     fields = None
 
     def __init__(self, queryset):
@@ -43,7 +41,7 @@ class Adapter(object):
     def get_fields(self):
         if not self._fields:
             if not isinstance(self.fields, (list, tuple)):
-                raise ValueError('Unsupported fields format')
+                raise ValueError("Unsupported fields format")
             self._fields = []
             for field in itertools.chain(self.fields, self.dynamic_fields()):
                 name = field if isinstance(field, str) else field[0]
@@ -58,39 +56,46 @@ class Adapter(object):
                     else:
                         field_tuple = (name, self.getter(*field))
                 except Exception as e:  # Catch all errors intentionally.
-                    log.exception('Error exporting CSV for {name}: {error_class} {error}'.format(
-                        name=self.__class__.__name__, error_class=e.__class__.__name__, error=e), stack_info=True)
+                    log.exception(
+                        "Error exporting CSV for {name}: {error_class} {error}".format(
+                            name=self.__class__.__name__, error_class=e.__class__.__name__, error=e
+                        ),
+                        stack_info=True,
+                    )
                 self._fields.append(field_tuple)
         return self._fields
 
     def getter(self, name, getter=None):
         if not getter:
-            method = 'field_{0}'.format(name)
-            return (getattr(self, method)
-                    if hasattr(self, method)
-                    else lambda o: recursive_get(o, name))
-        return ((lambda o: recursive_get(o, getter))
-                if isinstance(getter, str) else getter)
+            method = "field_{0}".format(name)
+            return (
+                getattr(self, method) if hasattr(self, method) else lambda o: recursive_get(o, name)
+            )
+        return (lambda o: recursive_get(o, getter)) if isinstance(getter, str) else getter
 
     def header(self):
-        '''Generate the CSV header row'''
+        """Generate the CSV header row"""
         return [name for name, getter in self.get_fields()]
 
     def rows(self):
-        '''Iterate over queryset objects'''
+        """Iterate over queryset objects"""
         return (self.to_row(o) for o in self.queryset)
 
     def to_row(self, obj):
-        '''Convert an object into a flat csv row'''
+        """Convert an object into a flat csv row"""
         row = []
         for name, getter in self.get_fields():
-            content = ''
+            content = ""
             if getter is not None:
                 try:
                     content = safestr(getter(obj))
                 except Exception as e:  # Catch all errors intentionally.
-                    log.exception('Error exporting CSV for {name}: {error_class} {error}'.format(
-                        name=self.__class__.__name__, error_class=e.__class__.__name__, error=e), stack_info=True)
+                    log.exception(
+                        "Error exporting CSV for {name}: {error_class} {error}".format(
+                            name=self.__class__.__name__, error_class=e.__class__.__name__, error=e
+                        ),
+                        stack_info=True,
+                    )
             row.append(content)
         return row
 
@@ -107,17 +112,17 @@ class NestedAdapter(Adapter):
         self._nested_fields = None
 
     def header(self):
-        '''Generate the CSV header row'''
-        return (super(NestedAdapter, self).header() +
-                [name for name, getter in self.get_nested_fields()])
+        """Generate the CSV header row"""
+        return super(NestedAdapter, self).header() + [
+            name for name, getter in self.get_nested_fields()
+        ]
 
     def get_nested_fields(self):
         if not self._nested_fields:
             if not isinstance(self.nested_fields, (list, tuple)):
-                raise ValueError('Unsupported nested fields format')
+                raise ValueError("Unsupported nested fields format")
             self._nested_fields = []
-            for field in itertools.chain(self.nested_fields,
-                                         self.nested_dynamic_fields()):
+            for field in itertools.chain(self.nested_fields, self.nested_dynamic_fields()):
                 name = field if isinstance(field, str) else field[0]
                 # Retrieving (dynamically) fields is prone to errors,
                 # we don't want to break the CSV generation for a unique
@@ -130,33 +135,39 @@ class NestedAdapter(Adapter):
                     else:
                         field_tuple = (name, self.getter(*field))
                 except Exception as e:  # Catch all errors intentionally.
-                    log.exception('Error exporting CSV for {name}: {error_class} {error}'.format(
-                        name=self.__class__.__name__, error_class=e.__class__.__name__, error=e), stack_info=True)
+                    log.exception(
+                        "Error exporting CSV for {name}: {error_class} {error}".format(
+                            name=self.__class__.__name__, error_class=e.__class__.__name__, error=e
+                        ),
+                        stack_info=True,
+                    )
                 self._nested_fields.append(field_tuple)
         return self._nested_fields
 
     def get_queryset(self):
-        return ((o, n)
-                for o in self.queryset
-                for n in getattr(o, self.attribute))
+        return ((o, n) for o in self.queryset for n in getattr(o, self.attribute))
 
     def rows(self):
-        '''Iterate over queryset objects'''
-        return (self.nested_row(o, n)
-                for o in self.queryset
-                for n in getattr(o, self.attribute, []))
+        """Iterate over queryset objects"""
+        return (
+            self.nested_row(o, n) for o in self.queryset for n in getattr(o, self.attribute, [])
+        )
 
     def nested_row(self, obj, nested):
-        '''Convert an object into a flat csv row'''
+        """Convert an object into a flat csv row"""
         row = self.to_row(obj)
         for name, getter in self.get_nested_fields():
-            content = ''
+            content = ""
             if getter is not None:
                 try:
                     content = safestr(getter(nested))
                 except Exception as e:  # Catch all errors intentionally.
-                    log.exception('Error exporting CSV for {name}: {error_class} {error}'.format(
-                        name=self.__class__.__name__, error_class=e.__class__.__name__, error=e), stack_info=True)
+                    log.exception(
+                        "Error exporting CSV for {name}: {error_class} {error}".format(
+                            name=self.__class__.__name__, error_class=e.__class__.__name__, error=e
+                        ),
+                        stack_info=True,
+                    )
             row.append(content)
         return row
 
@@ -165,10 +176,12 @@ class NestedAdapter(Adapter):
 
 
 def adapter(model):
-    '''Register an adapter class for a given model'''
+    """Register an adapter class for a given model"""
+
     def inner(cls):
         _adapters[model] = cls
         return cls
+
     return inner
 
 
@@ -181,24 +194,21 @@ def _metric_getter(key):
 
 
 def metric_fields(cls):
-    return [
-        ('metric.{0}'.format(key), _metric_getter(key))
-        for key in cls.__metrics_keys__
-    ]
+    return [("metric.{0}".format(key), _metric_getter(key)) for key in cls.__metrics_keys__]
 
 
 def get_writer(out):
-    '''Get a preconfigured CSV writer for a given output file'''
+    """Get a preconfigured CSV writer for a given output file"""
     return csv.writer(out, quoting=csv.QUOTE_NONNUMERIC, **CONFIG)
 
 
 def get_reader(infile):
-    '''Get a preconfigured CSV reader for a given input file'''
+    """Get a preconfigured CSV reader for a given input file"""
     return csv.reader(infile, **CONFIG)
 
 
 def yield_rows(adapter):
-    '''Yield a dataset catalog line by line'''
+    """Yield a dataset catalog line by line"""
     csvfile = StringIO()
     writer = get_writer(csvfile)
     # Generate header
@@ -223,20 +233,20 @@ def stream(queryset_or_adapter, basename=None):
         adapter = queryset_or_adapter
     elif isinstance(queryset_or_adapter, (list, tuple)):
         if not queryset_or_adapter:
-            raise ValueError(
-                'Type detection is not possible with an empty list')
+            raise ValueError("Type detection is not possible with an empty list")
         cls = _adapters.get(queryset_or_adapter[0].__class__)
         adapter = cls(queryset_or_adapter)
     elif isinstance(queryset_or_adapter, db.BaseQuerySet):
         cls = _adapters.get(queryset_or_adapter._document)
         adapter = cls(queryset_or_adapter)
     else:
-        raise ValueError('Unsupported object type')
+        raise ValueError("Unsupported object type")
 
-    timestamp = datetime.utcnow().strftime('%Y-%m-%d-%H-%M')
+    timestamp = datetime.utcnow().strftime("%Y-%m-%d-%H-%M")
     headers = {
-        'Content-Disposition': 'attachment; filename={0}-{1}.csv'.format(
-            basename or 'export', timestamp),
+        "Content-Disposition": "attachment; filename={0}-{1}.csv".format(
+            basename or "export", timestamp
+        ),
     }
     streamer = stream_with_context(yield_rows(adapter))
     return Response(streamer, mimetype="text/csv", headers=headers)