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

udata/search/query.py

@@ -1,9 +1,9 @@
 import copy
 import logging
-import requests
 import urllib.parse
 
-from flask import request, current_app, url_for
+import requests
+from flask import current_app, request, url_for
 
 from udata.search.result import SearchResult
 
@@ -16,10 +16,10 @@ class SearchQuery:
     model = None
 
     def __init__(self, params):
-        self.page = int(params.pop('page', 1))
-        self.page_size = int(params.pop('page_size', DEFAULT_PAGE_SIZE))
-        self._query = params.pop('q', '')
-        self.sort = params.pop('sort', None)
+        self.page = int(params.pop("page", 1))
+        self.page_size = int(params.pop("page_size", DEFAULT_PAGE_SIZE))
+        self._query = params.pop("q", "")
+        self.sort = params.pop("sort", None)
         self._filters = {}
         self.extract_filters(params)
 
@@ -36,31 +36,36 @@ class SearchQuery:
     def execute_search(self):
         # If SEARCH_SERVICE_API_URL is set, the remote search service will be queried.
         # Otherwise mongo search will be used instead.
-        if current_app.config['SEARCH_SERVICE_API_URL']:
+        if current_app.config["SEARCH_SERVICE_API_URL"]:
             url = f"{current_app.config['SEARCH_SERVICE_API_URL']}{self.adapter.search_url}?q={self._query}&page={self.page}&page_size={self.page_size}"
             if self.sort:
-                url = url + f'&sort={self.sort}'
+                url = url + f"&sort={self.sort}"
             for name, value in self._filters.items():
-                url = url + f'&{name}={value}'
-            r = requests.get(url, timeout=current_app.config['SEARCH_SERVICE_REQUEST_TIMEOUT'])
+                url = url + f"&{name}={value}"
+            r = requests.get(url, timeout=current_app.config["SEARCH_SERVICE_REQUEST_TIMEOUT"])
             r.raise_for_status()
             result = r.json()
-            return SearchResult(query=self, result=result.pop('data'), **result)
+            return SearchResult(query=self, result=result.pop("data"), **result)
         else:
-            query_args = {'q': self._query, 'page': self.page, 'page_size': self.page_size, 'sort': self.sort}
+            query_args = {
+                "q": self._query,
+                "page": self.page,
+                "page_size": self.page_size,
+                "sort": self.sort,
+            }
             query_args.update(self._filters)
             result, total = self.adapter.mongo_search(query_args)
             return SearchResult(query=self, mongo_objects=result, total=total, **query_args)
 
     def to_url(self, url=None, replace=False, **kwargs):
-        '''Serialize the query into an URL'''
+        """Serialize the query into an URL"""
         params = copy.deepcopy(self._filters)
         if self._query:
-            params['q'] = self._query
+            params["q"] = self._query
         if self.page_size != DEFAULT_PAGE_SIZE:
-            params['page_size'] = self.page_size
+            params["page_size"] = self.page_size
         if self.sort:
-            params['sort'] = self.sort
+            params["sort"] = self.sort
         if kwargs:
             for key, value in kwargs.items():
                 if not replace and key in params:
@@ -71,5 +76,5 @@ class SearchQuery:
                 else:
                     params[key] = value
         else:
-            params['page'] = self.page
-        return f'{url or request.base_url}?{urllib.parse.urlencode(params)}'
+            params["page"] = self.page
+        return f"{url or request.base_url}?{urllib.parse.urlencode(params)}"

udata/search/result.py

@@ -4,19 +4,19 @@ from bson.objectid import ObjectId
 
 from udata.utils import Paginable
 
-
 log = logging.getLogger(__name__)
 
 
 class SearchResult(Paginable):
-    '''An ElasticSearch result wrapper for easy property access'''
+    """An ElasticSearch result wrapper for easy property access"""
+
     def __init__(self, query, **kwargs):
         self.query = query
-        self.result = kwargs.get('result', None)
-        self.mongo_objects = kwargs.get('mongo_objects', None)
-        self._page = kwargs.pop('page')
-        self._page_size = kwargs.pop('page_size')
-        self._total = kwargs.pop('total')
+        self.result = kwargs.get("result", None)
+        self.mongo_objects = kwargs.get("mongo_objects", None)
+        self._page = kwargs.pop("page")
+        self._page_size = kwargs.pop("page_size")
+        self._total = kwargs.pop("total")
 
     @property
     def query_string(self):
@@ -43,7 +43,7 @@ class SearchResult(Paginable):
 
     def get_ids(self):
         try:
-            return [elem['id'] for elem in self.result]
+            return [elem["id"] for elem in self.result]
         except (KeyError, TypeError):
             return []
 
@@ -53,8 +53,7 @@ class SearchResult(Paginable):
             objects = self.query.model.objects.in_bulk(ids)
             self.mongo_objects = [objects.get(id) for id in ids]
             # Filter out DBref ie. indexed object not found in DB
-            self.mongo_objects = [o for o in self.mongo_objects
-                                    if isinstance(o, self.query.model)]
+            self.mongo_objects = [o for o in self.mongo_objects if isinstance(o, self.query.model)]
         return self.mongo_objects
 
     @property

udata/sentry.py

@@ -1,28 +1,31 @@
 import logging
-import pkg_resources
 import re
 import warnings
 
+import pkg_resources
 from werkzeug.exceptions import HTTPException
+
 from udata import entrypoints
 from udata.core.storages.api import UploadProgress
-from .auth import PermissionDenied
 
+from .auth import PermissionDenied
 
 log = logging.getLogger(__name__)
 
 RE_DSN = re.compile(
-    r'(?P<scheme>https?)://(?P<client_id>[0-9a-f]+)(?::(?P<secret>[0-9a-f]+))?'
-    r'@(?P<domain>.+)/(?P<site_id>\d+)')
+    r"(?P<scheme>https?)://(?P<client_id>[0-9a-f]+)(?::(?P<secret>[0-9a-f]+))?"
+    r"@(?P<domain>.+)/(?P<site_id>\d+)"
+)
 
-SECRET_DSN_DEPRECATED_MSG = 'DSN with secret is deprecated, use a public DSN instead'
-ERROR_PARSE_DSN_MSG = 'Unable to parse Sentry DSN'
+SECRET_DSN_DEPRECATED_MSG = "DSN with secret is deprecated, use a public DSN instead"
+ERROR_PARSE_DSN_MSG = "Unable to parse Sentry DSN"
 
 # Controlled exceptions that Sentry should ignore
 IGNORED_EXCEPTIONS = HTTPException, PermissionDenied, UploadProgress
 
+
 def public_dsn(dsn):
-    '''Check if DSN is public or raise a warning and turn it into a public one'''
+    """Check if DSN is public or raise a warning and turn it into a public one"""
     m = RE_DSN.match(dsn)
     if not m:
         log.error(ERROR_PARSE_DSN_MSG)
@@ -34,42 +37,41 @@ def public_dsn(dsn):
     log.warning(SECRET_DSN_DEPRECATED_MSG)
     warnings.warn(SECRET_DSN_DEPRECATED_MSG, category=DeprecationWarning)
 
-    public = '{scheme}://{client_id}@{domain}/{site_id}'.format(
-        **m.groupdict())
+    public = "{scheme}://{client_id}@{domain}/{site_id}".format(**m.groupdict())
     return public
 
 
 def init_app(app):
-    if app.config['SENTRY_DSN']:
+    if app.config["SENTRY_DSN"]:
         try:
             import sentry_sdk
-            from sentry_sdk.integrations.flask import FlaskIntegration
             from sentry_sdk.integrations.celery import CeleryIntegration
+            from sentry_sdk.integrations.flask import FlaskIntegration
         except ImportError:
-            log.error('sentry-sdk is required to use Sentry')
+            log.error("sentry-sdk is required to use Sentry")
             return
 
-        app.config['SENTRY_PUBLIC_DSN'] = public_dsn(app.config['SENTRY_DSN'])
+        app.config["SENTRY_PUBLIC_DSN"] = public_dsn(app.config["SENTRY_DSN"])
 
         # Do not send HTTPExceptions
-        exceptions = set(app.config['SENTRY_IGNORE_EXCEPTIONS'])
+        exceptions = set(app.config["SENTRY_IGNORE_EXCEPTIONS"])
         for exception in IGNORED_EXCEPTIONS:
             exceptions.add(exception)
 
         sentry_sdk.init(
-            dsn=app.config['SENTRY_PUBLIC_DSN'],
+            dsn=app.config["SENTRY_PUBLIC_DSN"],
             integrations=[FlaskIntegration(), CeleryIntegration()],
-            ignore_errors=list(exceptions)
+            ignore_errors=list(exceptions),
         )
 
         # Set log level
-        log_level_name = app.config['SENTRY_LOGGING']
+        log_level_name = app.config["SENTRY_LOGGING"]
         if log_level_name:
             log_level = getattr(logging, log_level_name.upper())
             sentry_sdk.set_level(log_level)
 
         # Set sentry tags
-        tags = app.config['SENTRY_TAGS']
+        tags = app.config["SENTRY_TAGS"]
         for tag_key in tags:
             sentry_sdk.set_tag(tag_key, tags[tag_key])
         # Versions Management: uData and plugins versions as tags.
@@ -77,4 +79,4 @@ def init_app(app):
             if dist.version:
                 sentry_sdk.set_tag(dist.project_name, dist.version)
         # Do not forget udata itself
-        sentry_sdk.set_tag('udata', pkg_resources.get_distribution('udata').version)
+        sentry_sdk.set_tag("udata", pkg_resources.get_distribution("udata").version)