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

udata/harvest/tests/test_filters.py

@@ -1,6 +1,6 @@
 import logging
-import pytest
 
+import pytest
 from voluptuous import Invalid
 
 from udata.harvest import filters
@@ -10,11 +10,23 @@ log = logging.getLogger(__name__)
 
 class FiltersTest:
     def test_boolean(self):
-        true_values = ('1', 'on', 't', 'TRUE', 'true', 'y', 'yes', '  1  ',
-                       '  tRuE  ', True, 1, 2, -1)
-        false_values = ('0', 'f', 'FALSE', 'false', 'n', 'no', 'off', '  0  ',
-                        '  f  ', False, 0)
-        none_values = ('', '   ', None)
+        true_values = (
+            "1",
+            "on",
+            "t",
+            "TRUE",
+            "true",
+            "y",
+            "yes",
+            "  1  ",
+            "  tRuE  ",
+            True,
+            1,
+            2,
+            -1,
+        )
+        false_values = ("0", "f", "FALSE", "false", "n", "no", "off", "  0  ", "  f  ", False, 0)
+        none_values = ("", "   ", None)
 
         for value in true_values:
             assert filters.boolean(value)
@@ -26,11 +38,11 @@ class FiltersTest:
             assert filters.boolean(value) is None
 
         with pytest.raises(Invalid):
-            filters.boolean('vrai')
+            filters.boolean("vrai")
 
     def test_empty_none(self):
-        empty_values = 0, '', [], {}
-        non_empty_values = 'hello', '  hello  '
+        empty_values = 0, "", [], {}
+        non_empty_values = "hello", "  hello  "
 
         for value in empty_values:
             assert filters.empty_none(value) is None
@@ -39,39 +51,38 @@ class FiltersTest:
             assert filters.empty_none(value) == value
 
     def test_strip(self):
-        assert filters.strip('  hello   ') == 'hello'
-        assert filters.strip('    ') is None
+        assert filters.strip("  hello   ") == "hello"
+        assert filters.strip("    ") is None
 
     def test_line_endings(self):
-        result = filters.line_endings('hello\r\nworld!\r ')
-        assert result == 'hello\nworld!\n '
+        result = filters.line_endings("hello\r\nworld!\r ")
+        assert result == "hello\nworld!\n "
 
     def test_hash(self):
         hashes = {
-            'md5': 'bd8668597bfba2d1843441d7199bea65',
-            'sha1': 'f2f0249827f501286b4713683e526d541d2cc7e2',
-            'sha256': ('c4373e1d81eb44882bf9ff539d0e5f'
-                       'faf03a114abf9306591117d781966268f9')
+            "md5": "bd8668597bfba2d1843441d7199bea65",
+            "sha1": "f2f0249827f501286b4713683e526d541d2cc7e2",
+            "sha256": ("c4373e1d81eb44882bf9ff539d0e5f" "faf03a114abf9306591117d781966268f9"),
         }
 
         for type, value in hashes.items():
-            assert filters.hash(value) == {'type': type, 'value': value}
+            assert filters.hash(value) == {"type": type, "value": value}
 
     def test_unknown_hash(self):
-        assert filters.hash('xxxx') is None
+        assert filters.hash("xxxx") is None
         assert filters.hash(None) is None
 
 
 class IsUrlFilterTest:
     def test_valid_url_with_defaults(self):
         f = filters.is_url()
-        assert f('https://somewhere.com/path') == 'https://somewhere.com/path'
+        assert f("https://somewhere.com/path") == "https://somewhere.com/path"
 
     def test_allowed_scheme_not_allowed(self):
         f = filters.is_url()
         with pytest.raises(Invalid):
-            f('not-allowed://somewhere.com')
+            f("not-allowed://somewhere.com")
 
     def test_valid_url_with_default_scheme(self):
         f = filters.is_url()
-        assert f('somewhere.com/path') == 'http://somewhere.com/path'
+        assert f("somewhere.com/path") == "http://somewhere.com/path"

udata/harvest/tests/test_models.py

@@ -1,30 +1,27 @@
 import logging
+
 import pytest
 
 from udata.utils import faker
 
 from ..models import HarvestSource
 
-
 log = logging.getLogger(__name__)
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class HarvestSourceTest:
     def test_defaults(self):
-        source = HarvestSource.objects.create(name='Test', url=faker.url(), backend='factory')
-        assert source.name == 'Test'
-        assert source.slug == 'test'
+        source = HarvestSource.objects.create(name="Test", url=faker.url(), backend="factory")
+        assert source.name == "Test"
+        assert source.slug == "test"
 
     def test_domain(self):
-        source = HarvestSource(name='Test',
-                               url='http://www.somewhere.com/path/')
-        assert source.domain == 'www.somewhere.com'
+        source = HarvestSource(name="Test", url="http://www.somewhere.com/path/")
+        assert source.domain == "www.somewhere.com"
 
-        source = HarvestSource(name='Test',
-                               url='https://www.somewhere.com/path/')
-        assert source.domain == 'www.somewhere.com'
+        source = HarvestSource(name="Test", url="https://www.somewhere.com/path/")
+        assert source.domain == "www.somewhere.com"
 
-        source = HarvestSource(name='Test',
-                               url='http://www.somewhere.com:666/path/')
-        assert source.domain == 'www.somewhere.com'
+        source = HarvestSource(name="Test", url="http://www.somewhere.com:666/path/")
+        assert source.domain == "www.somewhere.com"

udata/harvest/tests/test_notifications.py

@@ -1,14 +1,13 @@
 import pytest
 
-from udata.core.user.factories import UserFactory, AdminFactory
-
-from .factories import HarvestSourceFactory
-
+from udata.core.user.factories import AdminFactory, UserFactory
 from udata.harvest.notifications import validate_harvester_notifications
 from udata.tests.helpers import assert_equal_dates
 
+from .factories import HarvestSourceFactory
+
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class HarvestNotificationsTest:
     def test_pending_harvester_validations(self):
         source = HarvestSourceFactory()
@@ -22,5 +21,5 @@ class HarvestNotificationsTest:
         assert len(notifications) == 1
         dt, details = notifications[0]
         assert_equal_dates(dt, source.created_at)
-        assert details['id'] == source.id
-        assert details['name'] == source.name
+        assert details["id"] == source.id
+        assert details["name"] == source.name

udata/harvest/tests/test_tasks.py

@@ -1,21 +1,22 @@
 import logging
+
 import pytest
 
-from ..tasks import purge_harvest_sources, purge_harvest_jobs
+from ..tasks import purge_harvest_jobs, purge_harvest_sources
 
 log = logging.getLogger(__name__)
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class HarvestActionsTest:
     def test_purge_sources(self, mocker):
-        '''It should purge from DB sources flagged as deleted'''
-        mock = mocker.patch('udata.harvest.actions.purge_sources')
+        """It should purge from DB sources flagged as deleted"""
+        mock = mocker.patch("udata.harvest.actions.purge_sources")
         purge_harvest_sources()
         mock.assert_called_once_with()
 
     def test_purge_jobs(self, mocker):
-        '''It should purge from DB jobs older than retention policy'''
-        mock = mocker.patch('udata.harvest.actions.purge_jobs')
+        """It should purge from DB jobs older than retention policy"""
+        mock = mocker.patch("udata.harvest.actions.purge_jobs")
         purge_harvest_jobs()
         mock.assert_called_once_with()

udata/i18n.py

@@ -1,23 +1,23 @@
 import importlib.util
-
 from contextlib import contextmanager
-from os.path import join, dirname, basename
+from datetime import datetime
 from glob import iglob
+from os.path import basename, dirname, join
 
+import flask_babel
+from babel.dates import format_timedelta as babel_format_timedelta
 from flask import (  # noqa
-    g, request, current_app, abort, redirect, url_for, has_request_context
+    abort,
+    current_app,
+    g,
+    has_request_context,
+    redirect,
+    request,
+    url_for,
 )
 from flask.blueprints import BlueprintSetupState, _endpoint_from_view_func
-
-from babel.dates import format_timedelta as babel_format_timedelta
-
-from datetime import datetime
-
-import flask_babel
-from flask_babel import Babel, refresh
-from flask_babel import format_date, format_datetime  # noqa
+from flask_babel import Babel, format_date, format_datetime, refresh  # noqa
 from flask_babel import get_locale as get_current_locale  # noqa
-
 from werkzeug.local import LocalProxy
 
 from udata import entrypoints
@@ -36,8 +36,9 @@ def get_translation_directories_and_domains():
         spec = importlib.util.find_spec(pkg)
         path = dirname(spec.origin)
         plugin_domains = [
-            f.replace(path, '').replace('.pot', '')[1:]
-            for f in iglob(join(path, '**/translations/*.pot'), recursive=True)]
+            f.replace(path, "").replace(".pot", "")[1:]
+            for f in iglob(join(path, "**/translations/*.pot"), recursive=True)
+        ]
         for domain in plugin_domains:
             translations_dir.append(join(path, dirname(domain)))
             domains.append(basename(domain))
@@ -46,7 +47,7 @@ def get_translation_directories_and_domains():
 
 
 def get_locale():
-    if getattr(g, 'lang_code', None):
+    if getattr(g, "lang_code", None):
         return g.lang_code
     return str(default_lang)
 
@@ -88,22 +89,25 @@ def lazy_pgettext(*args, **kwargs):
     return flask_babel.lazy_pgettext(*args, **kwargs)
 
 
-def format_timedelta(datetime_or_timedelta, granularity='second',
-                     add_direction=False, threshold=0.85):
-    '''This is format_timedelta from Flask-Babel'''
-    '''Flask-BabelEx missed the add_direction parameter'''
+def format_timedelta(
+    datetime_or_timedelta, granularity="second", add_direction=False, threshold=0.85
+):
+    """This is format_timedelta from Flask-Babel"""
+    """Flask-BabelEx missed the add_direction parameter"""
     if isinstance(datetime_or_timedelta, datetime):
         datetime_or_timedelta = datetime.utcnow() - datetime_or_timedelta
-    return babel_format_timedelta(datetime_or_timedelta,
-                                  granularity,
-                                  threshold=threshold,
-                                  add_direction=add_direction,
-                                  locale=get_current_locale())
+    return babel_format_timedelta(
+        datetime_or_timedelta,
+        granularity,
+        threshold=threshold,
+        add_direction=add_direction,
+        locale=get_current_locale(),
+    )
 
 
 def _default_lang(user=None):
-    lang = getattr(user or current_user, 'prefered_language', None)
-    return lang or current_app.config['DEFAULT_LANGUAGE']
+    lang = getattr(user or current_user, "prefered_language", None)
+    return lang or current_app.config["DEFAULT_LANGUAGE"]
 
 
 default_lang = LocalProxy(lambda: _default_lang())
@@ -111,12 +115,12 @@ default_lang = LocalProxy(lambda: _default_lang())
 
 @contextmanager
 def language(lang_code):
-    '''Force a given language'''
+    """Force a given language"""
     ctx = None
     if not request:
         ctx = current_app.test_request_context()
         ctx.push()
-    backup = g.get('lang_code')
+    backup = g.get("lang_code")
     g.lang_code = lang_code
     refresh()
     yield
@@ -127,10 +131,13 @@ def language(lang_code):
 
 
 def check_config(cfg):
-    default_language = cfg['DEFAULT_LANGUAGE']
-    if default_language not in cfg.get('LANGUAGES', []):
-        raise ConfigError('You are using a DEFAULT_LANGUAGE {0} not defined '
-                          'into LANGUAGES'.format(default_language))
+    default_language = cfg["DEFAULT_LANGUAGE"]
+    if default_language not in cfg.get("LANGUAGES", []):
+        raise ConfigError(
+            "You are using a DEFAULT_LANGUAGE {0} not defined " "into LANGUAGES".format(
+                default_language
+            )
+        )
 
 
 def init_app(app):
@@ -138,44 +145,43 @@ def init_app(app):
     translations_dir, domains = get_translation_directories_and_domains()
     Babel(
         app,
-        default_locale=app.config['DEFAULT_LANGUAGE'],
-        default_translation_directories=';'.join(translations_dir),
-        default_domain=';'.join(domains),
-        locale_selector=get_locale
+        default_locale=app.config["DEFAULT_LANGUAGE"],
+        default_translation_directories=";".join(translations_dir),
+        default_domain=";".join(domains),
+        locale_selector=get_locale,
     )
 
 
 def _add_language_code(endpoint, values):
     try:
-        if current_app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
-            values.setdefault('lang_code', g.get('lang_code') or get_locale())
+        if current_app.url_map.is_endpoint_expecting(endpoint, "lang_code"):
+            values.setdefault("lang_code", g.get("lang_code") or get_locale())
     except KeyError:  # Endpoint does not exist
         pass
 
 
 def _pull_lang_code(endpoint, values):
-    lang_code = values.pop('lang_code', g.get('lang_code') or get_locale())
-    if lang_code not in current_app.config['LANGUAGES']:
-        abort(redirect(
-            url_for(endpoint, lang_code=default_lang, **values)))
+    lang_code = values.pop("lang_code", g.get("lang_code") or get_locale())
+    if lang_code not in current_app.config["LANGUAGES"]:
+        abort(redirect(url_for(endpoint, lang_code=default_lang, **values)))
     g.lang_code = lang_code
 
 
 def redirect_to_lang(*args, **kwargs):
-    '''Redirect non lang-prefixed urls to default language.'''
-    endpoint = request.endpoint.replace('_redirect', '')
+    """Redirect non lang-prefixed urls to default language."""
+    endpoint = request.endpoint.replace("_redirect", "")
     kwargs = multi_to_dict(request.args)
     kwargs.update(request.view_args)
-    kwargs['lang_code'] = default_lang
+    kwargs["lang_code"] = default_lang
     return redirect(url_for(endpoint, **kwargs))
 
 
 def redirect_to_unlocalized(*args, **kwargs):
-    '''Redirect lang-prefixed urls to no prefixed URL.'''
-    endpoint = request.endpoint.replace('_redirect', '')
+    """Redirect lang-prefixed urls to no prefixed URL."""
+    endpoint = request.endpoint.replace("_redirect", "")
     kwargs = multi_to_dict(request.args)
     kwargs.update(request.view_args)
-    kwargs.pop('lang_code', None)
+    kwargs.pop("lang_code", None)
     return redirect(url_for(endpoint, **kwargs))
 
 
@@ -187,35 +193,51 @@ class I18nBlueprintSetupState(BlueprintSetupState):
         The URL rule is registered twice.
         """
         # Static assets are not localized
-        if endpoint == 'static':
+        if endpoint == "static":
             return super(I18nBlueprintSetupState, self).add_url_rule(
-                rule, endpoint=endpoint, view_func=view_func, **options)
+                rule, endpoint=endpoint, view_func=view_func, **options
+            )
         if self.url_prefix:
             rule = self.url_prefix + rule
-        options.setdefault('subdomain', self.subdomain)
+        options.setdefault("subdomain", self.subdomain)
         if endpoint is None:
             endpoint = _endpoint_from_view_func(view_func)
         defaults = self.url_defaults
-        if 'defaults' in options:
-            defaults = dict(defaults, **options.pop('defaults'))
+        if "defaults" in options:
+            defaults = dict(defaults, **options.pop("defaults"))
 
-        if options.pop('localize', True):
-            self.app.add_url_rule('/<lang:lang_code>' + rule,
-                                  '%s.%s' % (self.blueprint.name, endpoint),
-                                  view_func, defaults=defaults, **options)
+        if options.pop("localize", True):
+            self.app.add_url_rule(
+                "/<lang:lang_code>" + rule,
+                "%s.%s" % (self.blueprint.name, endpoint),
+                view_func,
+                defaults=defaults,
+                **options,
+            )
 
             self.app.add_url_rule(
-                rule, '%s.%s_redirect' % (self.blueprint.name, endpoint),
-                redirect_to_lang, defaults=defaults, **options)
+                rule,
+                "%s.%s_redirect" % (self.blueprint.name, endpoint),
+                redirect_to_lang,
+                defaults=defaults,
+                **options,
+            )
         else:
-            self.app.add_url_rule(rule,
-                                  '%s.%s' % (self.blueprint.name, endpoint),
-                                  view_func, defaults=defaults, **options)
+            self.app.add_url_rule(
+                rule,
+                "%s.%s" % (self.blueprint.name, endpoint),
+                view_func,
+                defaults=defaults,
+                **options,
+            )
 
             self.app.add_url_rule(
-                '/<lang:lang_code>' + rule,
-                '%s.%s_redirect' % (self.blueprint.name, endpoint),
-                redirect_to_unlocalized, defaults=defaults, **options)
+                "/<lang:lang_code>" + rule,
+                "%s.%s_redirect" % (self.blueprint.name, endpoint),
+                redirect_to_unlocalized,
+                defaults=defaults,
+                **options,
+            )
 
 
 class I18nBlueprint(Blueprint):
@@ -229,17 +251,154 @@ class I18nBlueprint(Blueprint):
 
 
 ISO_639_1_CODES = (
-    'aa', 'ab', 'af', 'am', 'an', 'ar', 'as', 'ay', 'az', 'ba', 'be', 'bg',
-    'bh', 'bi', 'bn', 'bo', 'br', 'ca', 'co', 'cs', 'cy', 'da', 'de', 'dz',
-    'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'fi', 'fj', 'fo', 'fr', 'fy',
-    'ga', 'gd', 'gl', 'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'hr', 'ht', 'hu',
-    'hy', 'ia', 'id', 'ie', 'ii', 'ik', 'in', 'io', 'is', 'it', 'iu', 'iw',
-    'ja', 'ji', 'jv', 'ka', 'kk', 'kl', 'km', 'kn', 'ko', 'ks', 'ku', 'ky',
-    'la', 'li', 'ln', 'lo', 'lt', 'lv', 'mg', 'mi', 'mk', 'ml', 'mn', 'mo',
-    'mr', 'ms', 'mt', 'my', 'na', 'ne', 'nl', 'no', 'oc', 'om', 'or', 'pa',
-    'pl', 'ps', 'pt', 'qu', 'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sd', 'sg',
-    'sh', 'si', 'sk', 'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su',
-    'sv', 'sw', 'ta', 'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr',
-    'ts', 'tt', 'tw', 'ug', 'uk', 'ur', 'uz', 'vi', 'vo', 'wa', 'wo', 'xh',
-    'yi', 'yo', 'zh', 'zh-Hans', 'zh-Hant', 'zu'
+    "aa",
+    "ab",
+    "af",
+    "am",
+    "an",
+    "ar",
+    "as",
+    "ay",
+    "az",
+    "ba",
+    "be",
+    "bg",
+    "bh",
+    "bi",
+    "bn",
+    "bo",
+    "br",
+    "ca",
+    "co",
+    "cs",
+    "cy",
+    "da",
+    "de",
+    "dz",
+    "el",
+    "en",
+    "eo",
+    "es",
+    "et",
+    "eu",
+    "fa",
+    "fi",
+    "fj",
+    "fo",
+    "fr",
+    "fy",
+    "ga",
+    "gd",
+    "gl",
+    "gn",
+    "gu",
+    "gv",
+    "ha",
+    "he",
+    "hi",
+    "hr",
+    "ht",
+    "hu",
+    "hy",
+    "ia",
+    "id",
+    "ie",
+    "ii",
+    "ik",
+    "in",
+    "io",
+    "is",
+    "it",
+    "iu",
+    "iw",
+    "ja",
+    "ji",
+    "jv",
+    "ka",
+    "kk",
+    "kl",
+    "km",
+    "kn",
+    "ko",
+    "ks",
+    "ku",
+    "ky",
+    "la",
+    "li",
+    "ln",
+    "lo",
+    "lt",
+    "lv",
+    "mg",
+    "mi",
+    "mk",
+    "ml",
+    "mn",
+    "mo",
+    "mr",
+    "ms",
+    "mt",
+    "my",
+    "na",
+    "ne",
+    "nl",
+    "no",
+    "oc",
+    "om",
+    "or",
+    "pa",
+    "pl",
+    "ps",
+    "pt",
+    "qu",
+    "rm",
+    "rn",
+    "ro",
+    "ru",
+    "rw",
+    "sa",
+    "sd",
+    "sg",
+    "sh",
+    "si",
+    "sk",
+    "sl",
+    "sm",
+    "sn",
+    "so",
+    "sq",
+    "sr",
+    "ss",
+    "st",
+    "su",
+    "sv",
+    "sw",
+    "ta",
+    "te",
+    "tg",
+    "th",
+    "ti",
+    "tk",
+    "tl",
+    "tn",
+    "to",
+    "tr",
+    "ts",
+    "tt",
+    "tw",
+    "ug",
+    "uk",
+    "ur",
+    "uz",
+    "vi",
+    "vo",
+    "wa",
+    "wo",
+    "xh",
+    "yi",
+    "yo",
+    "zh",
+    "zh-Hans",
+    "zh-Hant",
+    "zu",
 )

udata/linkchecker/backends.py

@@ -8,30 +8,24 @@ from udata.entrypoints import get_enabled
 log = logging.getLogger(__name__)
 
 
-ENTRYPOINT = 'udata.linkcheckers'
+ENTRYPOINT = "udata.linkcheckers"
 
 
 class NoCheckLinkchecker(object):
     """Dummy linkchecker for resources that need no check"""
 
     def check(self, _):
-        return {
-            'check:status': 204,
-            'check:available': True,
-            'check:date': datetime.utcnow()
-        }
+        return {"check:status": 204, "check:available": True, "check:date": datetime.utcnow()}
 
 
 def get(name):
-    '''Get a linkchecker given its name or fallback on default'''
+    """Get a linkchecker given its name or fallback on default"""
     linkcheckers = get_enabled(ENTRYPOINT, current_app)
     linkcheckers.update(no_check=NoCheckLinkchecker)  # no_check always enabled
     selected_linkchecker = linkcheckers.get(name)
     if not selected_linkchecker:
-        default_linkchecker = current_app.config.get(
-                                'LINKCHECKING_DEFAULT_LINKCHECKER')
+        default_linkchecker = current_app.config.get("LINKCHECKING_DEFAULT_LINKCHECKER")
         selected_linkchecker = linkcheckers.get(default_linkchecker)
     if not selected_linkchecker:
-        log.error('No linkchecker found ({} requested and no fallback)'.format(
-                  name))
+        log.error("No linkchecker found ({} requested and no fallback)".format(name))
     return selected_linkchecker