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

udata/entrypoints.py

@@ -2,16 +2,16 @@ import pkg_resources
 
 # Here for documentation purpose
 ENTRYPOINTS = {
-    'udata.avatars': 'Avatar rendering backends',
-    'udata.harvesters': 'Harvest backends',
-    'udata.linkcheckers': 'Link checker backends',
-    'udata.metrics': 'Extra metrics',
-    'udata.models': 'Models and migrations',
-    'udata.preview': 'Displays preview for resources',
-    'udata.plugins': 'Generic plugin',
-    'udata.tasks': 'Tasks and jobs',
-    'udata.themes': 'Themes',
-    'udata.views': 'Extra views',
+    "udata.avatars": "Avatar rendering backends",
+    "udata.harvesters": "Harvest backends",
+    "udata.linkcheckers": "Link checker backends",
+    "udata.metrics": "Extra metrics",
+    "udata.models": "Models and migrations",
+    "udata.preview": "Displays preview for resources",
+    "udata.plugins": "Generic plugin",
+    "udata.tasks": "Tasks and jobs",
+    "udata.themes": "Themes",
+    "udata.views": "Extra views",
 }
 
 
@@ -20,73 +20,77 @@ class EntrypointError(Exception):
 
 
 def iter_all(name):
-    '''Iter all entrypoints registered on a given key'''
+    """Iter all entrypoints registered on a given key"""
     return pkg_resources.iter_entry_points(name)
 
 
 def get_all(entrypoint_key):
-    '''Load all entrypoints registered on a given key'''
+    """Load all entrypoints registered on a given key"""
     return dict(_ep_to_kv(e) for e in iter_all(entrypoint_key))
 
 
 def get_enabled(name, app):
-    '''
+    """
     Get (and load) entrypoints registered on name
     and enabled for the given app.
-    '''
-    plugins = app.config['PLUGINS']
-    return dict(_ep_to_kv(e) for e in iter_all(name) if e.name in plugins or e.name.startswith(tuple(plugins)))
+    """
+    plugins = app.config["PLUGINS"]
+    return dict(
+        _ep_to_kv(e)
+        for e in iter_all(name)
+        if e.name in plugins or e.name.startswith(tuple(plugins))
+    )
 
 
 def get_plugin_module(name, app, plugin):
-    '''
+    """
     Get the module for a given plugin
-    '''
+    """
     return next((m for p, m in get_enabled(name, app).items() if p == plugin), None)
 
 
 def _ep_to_kv(entrypoint):
-    '''
+    """
     Transform an entrypoint into a key-value tuple where:
     - key is the entrypoint name
     - value is the entrypoint class with the name attribute
       matching from entrypoint name
-    '''
+    """
     cls = entrypoint.load()
     cls.name = entrypoint.name
     return (entrypoint.name, cls)
 
 
 def known_dists():
-    '''Return a list of all Distributions exporting udata.* entrypoints'''
+    """Return a list of all Distributions exporting udata.* entrypoints"""
     return (
-        dist for dist in pkg_resources.working_set
+        dist
+        for dist in pkg_resources.working_set
         if any(k in ENTRYPOINTS for k in dist.get_entry_map().keys())
     )
 
 
 def get_plugins_dists(app, name=None):
-    '''Return a list of Distributions with enabled udata plugins'''
+    """Return a list of Distributions with enabled udata plugins"""
     if name:
-        plugins = set(e.name for e in iter_all(name) if e.name in app.config['PLUGINS'])
+        plugins = set(e.name for e in iter_all(name) if e.name in app.config["PLUGINS"])
     else:
-        plugins = set(app.config['PLUGINS'])
+        plugins = set(app.config["PLUGINS"])
     return [
-        d for d in known_dists()
-        if any(set(v.keys()) & plugins for v in d.get_entry_map().values())
+        d for d in known_dists() if any(set(v.keys()) & plugins for v in d.get_entry_map().values())
     ]
 
 
 def get_roots(app=None):
-    '''
+    """
     Returns the list of root packages/modules exposing endpoints.
 
     If app is provided, only returns those of enabled plugins
-    '''
+    """
     roots = set()
-    plugins = app.config['PLUGINS'] if app else None
+    plugins = app.config["PLUGINS"] if app else None
     for name in ENTRYPOINTS.keys():
         for ep in iter_all(name):
             if plugins is None or ep.name in plugins:
-                roots.add(ep.module_name.split('.', 1)[0])
+                roots.add(ep.module_name.split(".", 1)[0])
     return list(roots)

udata/errors.py

@@ -1,3 +1,4 @@
 class ConfigError(ValueError):
-    '''Exception raised when an error is detected into the configuration'''
+    """Exception raised when an error is detected into the configuration"""
+
     pass

udata/event/values.py

@@ -2,9 +2,9 @@ from enum import Enum
 
 
 class EventMessageType(Enum):
-    INDEX = 'index'
-    REINDEX = 'reindex'
-    UNINDEX = 'unindex'
-    CREATED = 'created'
-    MODIFIED = 'modified'
-    DELETED = 'deleted'
+    INDEX = "index"
+    REINDEX = "reindex"
+    UNINDEX = "unindex"
+    CREATED = "created"
+    MODIFIED = "modified"
+    DELETED = "deleted"

udata/factories.py

@@ -16,5 +16,5 @@ class DateRangeFactory(ModelFactory):
     class Meta:
         model = db.DateRange
 
-    start = factory.Faker('date_between', start_date='-10y', end_date='-5y')
-    end = factory.Faker('date_between', start_date='-5y', end_date='-2y')
+    start = factory.Faker("date_between", start_date="-10y", end_date="-5y")
+    end = factory.Faker("date_between", start_date="-5y", end_date="-2y")

udata/features/identicon/api.py

@@ -1,14 +1,13 @@
-from udata.api import api, API
-
+from udata.api import API, api
 
 from . import backends
 
-ns = api.namespace('avatars', 'Avatars')
+ns = api.namespace("avatars", "Avatars")
 
 
-@ns.route('/<identifier>/<int:size>', endpoint='avatar')
+@ns.route("/<identifier>/<int:size>", endpoint="avatar")
 class IdenticonAPI(API):
-    @api.doc('avatars')
+    @api.doc("avatars")
     def get(self, identifier, size):
-        '''Get a deterministic avatar given an identifier at a given size'''
+        """Get a deterministic avatar given an identifier at a given size"""
         return backends.get_identicon(identifier, size)

udata/features/identicon/backends.py

@@ -2,137 +2,130 @@ import hashlib
 import io
 
 import pydenticon
-
-from flask import redirect, send_file, current_app
+from flask import current_app, redirect, send_file
 
 from udata import entrypoints
 from udata.app import cache
 
-ADORABLE_AVATARS_URL = 'https://api.adorable.io/avatars/{size}/{identifier}.png'  # noqa
-ROBOHASH_URL = 'https://robohash.org/{identifier}.png?size={size}x{size}&set={skin}&bgset={bg}'  # noqa
+ADORABLE_AVATARS_URL = "https://api.adorable.io/avatars/{size}/{identifier}.png"  # noqa
+ROBOHASH_URL = "https://robohash.org/{identifier}.png?size={size}x{size}&set={skin}&bgset={bg}"  # noqa
 
 
 # Default values overriden by theme default and local config
 DEFAULTS = {
-    'AVATAR_PROVIDER': 'internal',
+    "AVATAR_PROVIDER": "internal",
     # Internal provider
-    'AVATAR_INTERNAL_SIZE': 7,
-    'AVATAR_INTERNAL_FOREGROUND': [
-        'rgb(45,79,255)',
-        'rgb(254,180,44)',
-        'rgb(226,121,234)',
-        'rgb(30,179,253)',
-        'rgb(232,77,65)',
-        'rgb(49,203,115)',
-        'rgb(141,69,170)'
+    "AVATAR_INTERNAL_SIZE": 7,
+    "AVATAR_INTERNAL_FOREGROUND": [
+        "rgb(45,79,255)",
+        "rgb(254,180,44)",
+        "rgb(226,121,234)",
+        "rgb(30,179,253)",
+        "rgb(232,77,65)",
+        "rgb(49,203,115)",
+        "rgb(141,69,170)",
     ],
-    'AVATAR_INTERNAL_BACKGROUND': 'rgb(224,224,224)',
-    'AVATAR_INTERNAL_PADDING': 10,
-
+    "AVATAR_INTERNAL_BACKGROUND": "rgb(224,224,224)",
+    "AVATAR_INTERNAL_PADDING": 10,
     # robohash prodiver
-    'AVATAR_ROBOHASH_SKIN': 'set1',
-    'AVATAR_ROBOHASH_BACKGROUND': 'bg1',
+    "AVATAR_ROBOHASH_SKIN": "set1",
+    "AVATAR_ROBOHASH_BACKGROUND": "bg1",
 }
 
 
 def get_config(key):
-    '''
+    """
     Get an identicon configuration parameter.
 
     Precedance order is:
         - application config (`udata.cfg`)
         - default
-    '''
-    key = 'AVATAR_{0}'.format(key.upper())
+    """
+    key = "AVATAR_{0}".format(key.upper())
     local_config = current_app.config.get(key)
     return local_config or DEFAULTS[key]
 
 
 def get_internal_config(key):
-    return get_config('internal_{0}'.format(key))
+    return get_config("internal_{0}".format(key))
 
 
 def get_provider():
-    '''Get the current provider from config'''
-    name = get_config('provider')
-    available = entrypoints.get_all('udata.avatars')
+    """Get the current provider from config"""
+    name = get_config("provider")
+    available = entrypoints.get_all("udata.avatars")
     if name not in available:
-        raise ValueError('Unknown avatar provider: {0}'.format(name))
+        raise ValueError("Unknown avatar provider: {0}".format(name))
     return available[name]
 
 
 def get_identicon(identifier, size):
-    '''
+    """
     Get an identicon for a given identifier at a given size.
 
     Automatically select the provider from `AVATAR_PROVIDER`
 
     :returns: a HTTP response, either an image or a redirect
-    '''
+    """
     return get_provider()(identifier, size)
 
 
 @cache.memoize()
 def generate_pydenticon(identifier, size):
-    '''
+    """
     Use pydenticon to generate an identicon image.
     All parameters are extracted from configuration.
-    '''
-    blocks_size = get_internal_config('size')
-    foreground = get_internal_config('foreground')
-    background = get_internal_config('background')
-    generator = pydenticon.Generator(blocks_size, blocks_size,
-                                     digest=hashlib.sha1,
-                                     foreground=foreground,
-                                     background=background)
+    """
+    blocks_size = get_internal_config("size")
+    foreground = get_internal_config("foreground")
+    background = get_internal_config("background")
+    generator = pydenticon.Generator(
+        blocks_size, blocks_size, digest=hashlib.sha1, foreground=foreground, background=background
+    )
 
     # Pydenticon adds padding to the size and as a consequence
     # we need to compute the size without the padding
-    padding = int(round(get_internal_config('padding') * size / 100.))
+    padding = int(round(get_internal_config("padding") * size / 100.0))
     size = size - 2 * padding
-    padding = (padding, ) * 4
-    return generator.generate(identifier, size, size,
-                              padding=padding,
-                              output_format='png')
+    padding = (padding,) * 4
+    return generator.generate(identifier, size, size, padding=padding, output_format="png")
 
 
 def internal(identifier, size):
-    '''
+    """
     Internal provider
 
     Use pydenticon to generate an identicon.
-    '''
+    """
     identicon = generate_pydenticon(identifier, size)
-    response = send_file(io.BytesIO(identicon), mimetype='image/png')
+    response = send_file(io.BytesIO(identicon), mimetype="image/png")
     etag = hashlib.sha1(identicon).hexdigest()
     response.set_etag(etag)
     return response
 
 
 def adorable(identifier, size):
-    '''
+    """
     Adorable Avatars provider
 
     Simply redirect to the external API.
 
     See: http://avatars.adorable.io/
-    '''
+    """
     url = ADORABLE_AVATARS_URL.format(identifier=identifier, size=size)
     return redirect(url)
 
 
 def robohash(identifier, size):
-    '''
+    """
     Robohash provider
 
     Redirect to the Robohash API
     with parameters extracted from configuration.
 
     See: https://robohash.org/
-    '''
-    skin = get_config('robohash_skin')
-    background = get_config('robohash_background')
-    url = ROBOHASH_URL.format(
-        identifier=identifier, size=size, skin=skin, bg=background
-    )
+    """
+    skin = get_config("robohash_skin")
+    background = get_config("robohash_background")
+    url = ROBOHASH_URL.format(identifier=identifier, size=size, skin=skin, bg=background)
     return redirect(url)

udata/features/identicon/tests/test_backends.py

@@ -1,10 +1,10 @@
 import pytest
 
 from udata.features.identicon.backends import internal
-from udata.utils import faker
 from udata.tests.helpers import assert200
+from udata.utils import faker
 
-pytestmark = pytest.mark.usefixtures('app')
+pytestmark = pytest.mark.usefixtures("app")
 
 
 def assert_stream_equal(response1, response2):
@@ -18,12 +18,11 @@ class InternalBackendTest:
     def test_base_rendering(self):
         response = internal(faker.word(), 32)
         assert200(response)
-        assert response.mimetype == 'image/png'
+        assert response.mimetype == "image/png"
         assert response.is_streamed
         etag, weak = response.get_etag()
         assert etag is not None
 
     def test_render_twice_the_same(self):
         identifier = faker.word()
-        assert_stream_equal(internal(identifier, 32),
-                            internal(identifier, 32))
+        assert_stream_equal(internal(identifier, 32), internal(identifier, 32))

udata/features/notifications/__init__.py

@@ -1,4 +1,3 @@
-
 import logging
 
 log = logging.getLogger(__name__)

udata/features/notifications/actions.py

@@ -6,32 +6,32 @@ _providers = {}
 
 
 def register_provider(name, func):
-    '''Register a notification provder'''
+    """Register a notification provder"""
     _providers[name] = func
 
 
 def list_providers():
-    '''List registere notifcation provider'''
+    """List registere notifcation provider"""
     return _providers.keys()
 
 
 def notifier(name):
-    '''A decorator registering a function as provider'''
+    """A decorator registering a function as provider"""
+
     def wrapper(func):
         register_provider(name, func)
         return func
+
     return wrapper
 
 
 def get_notifications(user):
-    '''List notification for a given user'''
+    """List notification for a given user"""
     notifications = []
 
     for name, func in _providers.items():
-        notifications.extend([{
-            'type': name,
-            'created_on': dt,
-            'details': details
-        } for dt, details in func(user)])
+        notifications.extend(
+            [{"type": name, "created_on": dt, "details": details} for dt, details in func(user)]
+        )
 
     return notifications

udata/features/notifications/api.py

@@ -1,26 +1,30 @@
-from udata.api import api, fields, API
+from udata.api import API, api, fields
 from udata.auth import current_user
 
 from .actions import get_notifications
 
-notifs = api.namespace('notifications', 'Notifications API')
+notifs = api.namespace("notifications", "Notifications API")
 
-notifications_fields = api.model('Notification', {
-    'type': fields.String(description='The notification type', readonly=True),
-    'created_on': fields.ISODateTime(
-        description='The notification creation datetime', readonly=True),
-    'details': fields.Raw(
-        description='Key-Value details depending on notification type',
-        readonly=True)
-})
+notifications_fields = api.model(
+    "Notification",
+    {
+        "type": fields.String(description="The notification type", readonly=True),
+        "created_on": fields.ISODateTime(
+            description="The notification creation datetime", readonly=True
+        ),
+        "details": fields.Raw(
+            description="Key-Value details depending on notification type", readonly=True
+        ),
+    },
+)
 
 
-@notifs.route('/', endpoint='notifications')
+@notifs.route("/", endpoint="notifications")
 class NotificationsAPI(API):
     @api.secure
-    @api.doc('get_notifications')
+    @api.doc("get_notifications")
     @api.marshal_list_with(notifications_fields)
     def get(self):
-        '''List all current user pending notifications'''
+        """List all current user pending notifications"""
         user = current_user._get_current_object()
         return get_notifications(user)

udata/features/territories/__init__.py

@@ -1,6 +1,6 @@
 from flask import current_app
 
-from udata.models import db, GeoZone
+from udata.models import GeoZone, db
 
 
 def check_for_territories(query):
@@ -9,26 +9,28 @@ def check_for_territories(query):
 
     Results are sorted by population and area (biggest first).
     """
-    if not query or not current_app.config.get('ACTIVATE_TERRITORIES'):
+    if not query or not current_app.config.get("ACTIVATE_TERRITORIES"):
         return []
 
     dbqs = db.Q()
     query = query.lower()
     is_digit = query.isdigit()
     query_length = len(query)
-    for level in current_app.config.get('HANDLED_LEVELS'):
-        if level == 'country':
+    for level in current_app.config.get("HANDLED_LEVELS"):
+        if level == "country":
             continue  # Level not fully handled yet.
         q = db.Q(level=level)
-        if (query_length == 2 and level == 'fr:departement' and
-                (is_digit or query in ('2a', '2b'))):
+        if query_length == 2 and level == "fr:departement" and (is_digit or query in ("2a", "2b")):
             # Counties + Corsica.
             q &= db.Q(code=query)
-        elif query_length == 3 and level == 'fr:departement' and is_digit:
+        elif query_length == 3 and level == "fr:departement" and is_digit:
             # French DROM-COM.
             q &= db.Q(code=query)
-        elif query_length == 5 and level == 'fr:commune' and (
-                is_digit or query.startswith('2a') or query.startswith('2b')):
+        elif (
+            query_length == 5
+            and level == "fr:commune"
+            and (is_digit or query.startswith("2a") or query.startswith("2b"))
+        ):
             # INSEE code then postal codes with Corsica exceptions.
             q &= db.Q(code=query)
         elif query_length >= 4:
@@ -44,4 +46,4 @@ def check_for_territories(query):
         return []
 
     # Sort matching results by population and area.
-    return GeoZone.objects(dbqs).order_by('-population', '-area')
+    return GeoZone.objects(dbqs).order_by("-population", "-area")

udata/features/territories/api.py

@@ -1,26 +1,25 @@
-from udata.api import api, API
+from udata.api import API, api
 from udata.features.territories import check_for_territories
 
 suggest_parser = api.parser()
 suggest_parser.add_argument(
-    'q', type=str, help='The string to autocomplete/suggest',
-    location='args', required=True)
+    "q", type=str, help="The string to autocomplete/suggest", location="args", required=True
+)
 suggest_parser.add_argument(
-    'size', type=int, help='The maximum result size',
-    location='args', required=False)
+    "size", type=int, help="The maximum result size", location="args", required=False
+)
 
 
-@api.route('/territory/suggest/', endpoint='suggest_territory')
+@api.route("/territory/suggest/", endpoint="suggest_territory")
 class SuggestTerritoriesAPI(API):
-    @api.doc('suggest_territory')
+    @api.doc("suggest_territory")
     @api.expect(suggest_parser)
     def get(self):
         args = suggest_parser.parse_args()
-        territories = check_for_territories(args['q'])
-        if args['size']:
-            territories = territories[:args['size']]
-        return [{
-            'id': territory.id,
-            'title': territory.name,
-            'page': territory.external_url
-        } for territory in territories]
+        territories = check_for_territories(args["q"])
+        if args["size"]:
+            territories = territories[: args["size"]]
+        return [
+            {"id": territory.id, "title": territory.name, "page": territory.external_url}
+            for territory in territories
+        ]