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

udata/api/__init__.py

@@ -1,67 +1,70 @@
-import itertools
 import inspect
+import itertools
 import logging
 import urllib.parse
-
 from functools import wraps
 from importlib import import_module
 
 from flask import (
-    current_app, g, request, url_for, json, make_response, redirect, Blueprint
+    Blueprint,
+    current_app,
+    g,
+    json,
+    make_response,
+    redirect,
+    request,
+    url_for,
 )
-from flask_storage import UnauthorizedFileType
-from flask_restx import Api, Resource
 from flask_cors import CORS
+from flask_restx import Api, Resource
+from flask_storage import UnauthorizedFileType
 
-from udata import tracking, entrypoints
+from udata import entrypoints, tracking
 from udata.app import csrf
+from udata.auth import Permission, PermissionDenied, RoleNeed, current_user, login_user
 from udata.i18n import get_locale
-from udata.auth import (
-    current_user, login_user, Permission, RoleNeed, PermissionDenied
-)
-from udata.utils import safe_unicode
 from udata.mongo.errors import FieldValidationError
+from udata.utils import safe_unicode
 
 from . import fields
 from .signals import on_api_call
 
-
 log = logging.getLogger(__name__)
 
-apiv1_blueprint = Blueprint('api', __name__, url_prefix='/api/1')
-apiv2_blueprint = Blueprint('apiv2', __name__, url_prefix='/api/2')
+apiv1_blueprint = Blueprint("api", __name__, url_prefix="/api/1")
+apiv2_blueprint = Blueprint("apiv2", __name__, url_prefix="/api/2")
 
 DEFAULT_PAGE_SIZE = 50
-HEADER_API_KEY = 'X-API-KEY'
+HEADER_API_KEY = "X-API-KEY"
 
 # TODO: make upstream flask-restplus automatically handle
 # flask-restplus headers and allow lazy evaluation
 # of headers (ie. callable)
 PREFLIGHT_HEADERS = (
     HEADER_API_KEY,
-    'X-Fields',
-    'Content-Type',
-    'Accept',
-    'Accept-Charset',
-    'Accept-Language',
-    'Authorization',
-    'Cache-Control',
-    'Content-Encoding',
-    'Content-Length',
-    'Content-Security-Policy',
-    'Content-Type',
-    'Cookie',
-    'ETag',
-    'Host',
-    'If-Modified-Since',
-    'Keep-Alive',
-    'Last-Modified',
-    'Origin',
-    'Referer',
-    'User-Agent',
-    'X-Forwarded-For',
-    'X-Forwarded-Port',
-    'X-Forwarded-Proto',
+    "X-Fields",
+    "Content-Type",
+    "Accept",
+    "Accept-Charset",
+    "Accept-Language",
+    "Authorization",
+    "Cache-Control",
+    "Content-Encoding",
+    "Content-Length",
+    "Content-Security-Policy",
+    "Content-Type",
+    "Cookie",
+    "ETag",
+    "Host",
+    "If-Modified-Since",
+    "Keep-Alive",
+    "Last-Modified",
+    "Origin",
+    "Referer",
+    "User-Agent",
+    "X-Forwarded-For",
+    "X-Forwarded-Port",
+    "X-Forwarded-Proto",
 )
 
 cors = CORS(allow_headers=PREFLIGHT_HEADERS)
@@ -69,21 +72,15 @@ cors = CORS(allow_headers=PREFLIGHT_HEADERS)
 
 class UDataApi(Api):
     def __init__(self, app=None, **kwargs):
-        decorators = kwargs.pop('decorators', []) or []
-        kwargs['decorators'] = [self.authentify] + decorators
+        decorators = kwargs.pop("decorators", []) or []
+        kwargs["decorators"] = [self.authentify] + decorators
         super(UDataApi, self).__init__(app, **kwargs)
-        self.authorizations = {
-            'apikey': {
-                'type': 'apiKey',
-                'in': 'header',
-                'name': HEADER_API_KEY
-            }
-        }
+        self.authorizations = {"apikey": {"type": "apiKey", "in": "header", "name": HEADER_API_KEY}}
 
     def secure(self, func):
-        '''Enforce authentication on a given method/verb
+        """Enforce authentication on a given method/verb
         and optionally check a given permission
-        '''
+        """
         if isinstance(func, str):
             return self._apply_permission(Permission(RoleNeed(func)))
         elif isinstance(func, Permission):
@@ -94,21 +91,25 @@ class UDataApi(Api):
     def _apply_permission(self, permission):
         def wrapper(func):
             return self._apply_secure(func, permission)
+
         return wrapper
 
     def _apply_secure(self, func, permission=None):
-        '''Enforce authentication on a given method/verb'''
-        self._build_doc(func, {'security': 'apikey'})
+        """Enforce authentication on a given method/verb"""
+        self._build_doc(func, {"security": "apikey"})
 
         @wraps(func)
         def wrapper(*args, **kwargs):
             if (
-                not current_user.is_anonymous and
-                not current_user.sysadmin and
-                current_app.config['READ_ONLY_MODE'] and
-                any(ext in str(func) for ext in current_app.config['METHOD_BLOCKLIST'])
+                not current_user.is_anonymous
+                and not current_user.sysadmin
+                and current_app.config["READ_ONLY_MODE"]
+                and any(ext in str(func) for ext in current_app.config["METHOD_BLOCKLIST"])
             ):
-                self.abort(423, 'Due to security reasons, the creation of new content is currently disabled.')
+                self.abort(
+                    423,
+                    "Due to security reasons, the creation of new content is currently disabled.",
+                )
 
             if not current_user.is_authenticated:
                 self.abort(401)
@@ -125,11 +126,12 @@ class UDataApi(Api):
         return wrapper
 
     def authentify(self, func):
-        '''Authentify the user if credentials are given'''
+        """Authentify the user if credentials are given"""
+
         @wraps(func)
         def wrapper(*args, **kwargs):
-            from udata.core.user.models import User
             from udata.api.oauth2 import check_credentials
+            from udata.core.user.models import User
 
             if current_user.is_authenticated:
                 return func(*args, **kwargs)
@@ -139,72 +141,79 @@ class UDataApi(Api):
                 try:
                     user = User.objects.get(apikey=apikey)
                 except User.DoesNotExist:
-                    self.abort(401, 'Invalid API Key')
+                    self.abort(401, "Invalid API Key")
 
                 if not login_user(user, False):
-                    self.abort(401, 'Inactive user')
+                    self.abort(401, "Inactive user")
             else:
                 check_credentials()
             return func(*args, **kwargs)
+
         return wrapper
 
     def validate(self, form_cls, obj=None):
-        '''Validate a form from the request and handle errors'''
-        if 'application/json' not in request.headers.get('Content-Type', ''):
-            errors = {'Content-Type': 'expecting application/json'}
+        """Validate a form from the request and handle errors"""
+        if "application/json" not in request.headers.get("Content-Type", ""):
+            errors = {"Content-Type": "expecting application/json"}
             self.abort(400, errors=errors)
-        form = form_cls.from_json(request.json, obj=obj, instance=obj,
-                                  meta={'csrf': False})
+        form = form_cls.from_json(request.json, obj=obj, instance=obj, meta={"csrf": False})
         if not form.validate():
             self.abort(400, errors=form.errors)
         return form
 
     def render_ui(self):
-        return redirect(current_app.config.get('API_DOC_EXTERNAL_LINK'))
+        return redirect(current_app.config.get("API_DOC_EXTERNAL_LINK"))
 
     def unauthorized(self, response):
-        '''Override to change the WWW-Authenticate challenge'''
-        realm = current_app.config.get('HTTP_OAUTH_REALM', 'uData')
+        """Override to change the WWW-Authenticate challenge"""
+        realm = current_app.config.get("HTTP_OAUTH_REALM", "uData")
         challenge = 'Bearer realm="{0}"'.format(realm)
 
-        response.headers['WWW-Authenticate'] = challenge
+        response.headers["WWW-Authenticate"] = challenge
         return response
 
     def page_parser(self):
         parser = self.parser()
-        parser.add_argument('page', type=int, default=1, location='args',
-                            help='The page to fetch')
-        parser.add_argument('page_size', type=int, default=20, location='args',
-                            help='The page size to fetch')
+        parser.add_argument("page", type=int, default=1, location="args", help="The page to fetch")
+        parser.add_argument(
+            "page_size", type=int, default=20, location="args", help="The page size to fetch"
+        )
         return parser
 
 
 api = UDataApi(
     apiv1_blueprint,
     decorators=[csrf.exempt],
-    version='1.0', title='uData API',
-    description='uData API', default='site',
-    default_label='Site global namespace'
+    version="1.0",
+    title="uData API",
+    description="uData API",
+    default="site",
+    default_label="Site global namespace",
 )
 
 apiv2 = UDataApi(
     apiv2_blueprint,
     decorators=[csrf.exempt],
-    version='2.0', title='uData API',
-    description='udata API v2', default='site',
-    default_label='Site global namespace',
+    version="2.0",
+    title="uData API",
+    description="udata API v2",
+    default="site",
+    default_label="Site global namespace",
 )
 
 
-api.model_reference = api.model('ModelReference', {
-    'class': fields.ClassName(description='The model class', required=True),
-    'id': fields.String(description='The object identifier', required=True),
-})
+api.model_reference = api.model(
+    "ModelReference",
+    {
+        "class": fields.ClassName(description="The model class", required=True),
+        "id": fields.String(description="The object identifier", required=True),
+    },
+)
 
 
-@api.representation('application/json')
+@api.representation("application/json")
 def output_json(data, code, headers=None):
-    '''Use Flask JSON to serialize'''
+    """Use Flask JSON to serialize"""
     resp = make_response(json.dumps(data), code)
     resp.headers.extend(headers or {})
     return resp
@@ -213,8 +222,8 @@ def output_json(data, code, headers=None):
 @apiv1_blueprint.before_request
 @apiv2_blueprint.before_request
 def set_api_language():
-    if 'lang' in request.args:
-        g.lang_code = request.args['lang']
+    if "lang" in request.args:
+        g.lang_code = request.args["lang"]
     else:
         g.lang_code = get_locale()
 
@@ -225,17 +234,18 @@ def extract_name_from_path(path):
     Useful to log requests on Piwik with categories tree structure.
     See: http://piwik.org/faq/how-to/#faq_62
     """
-    base_path, query_string = path.split('?')
-    infos = base_path.strip('/').split('/')[2:]  # Removes api/version.
-    if base_path == '/api/1/' or base_path == '/api/2/':  # The API root endpoint redirects to swagger doc.
-        return safe_unicode('apidoc')
+    base_path, query_string = path.split("?")
+    infos = base_path.strip("/").split("/")[2:]  # Removes api/version.
+    if (
+        base_path == "/api/1/" or base_path == "/api/2/"
+    ):  # The API root endpoint redirects to swagger doc.
+        return safe_unicode("apidoc")
     if len(infos) > 1:  # This is an object.
-        name = '{category} / {name}'.format(
-            category=infos[0].title(),
-            name=infos[1].replace('-', ' ').title()
+        name = "{category} / {name}".format(
+            category=infos[0].title(), name=infos[1].replace("-", " ").title()
         )
     else:  # This is a collection.
-        name = '{category}'.format(category=infos[0].title())
+        name = "{category}".format(category=infos[0].title())
     return safe_unicode(name)
 
 
@@ -243,71 +253,71 @@ def extract_name_from_path(path):
 @apiv2_blueprint.after_request
 def collect_stats(response):
     action_name = extract_name_from_path(request.full_path)
-    blacklist = current_app.config.get('TRACKING_BLACKLIST', [])
-    if (not current_app.config['TESTING'] and
-            request.endpoint not in blacklist):
+    blacklist = current_app.config.get("TRACKING_BLACKLIST", [])
+    if not current_app.config["TESTING"] and request.endpoint not in blacklist:
         extras = {
-            'action_name': urllib.parse.quote(action_name),
+            "action_name": urllib.parse.quote(action_name),
         }
         tracking.send_signal(on_api_call, request, current_user, **extras)
     return response
 
 
-default_error = api.model('Error', {
-    'message': fields.String
-})
+default_error = api.model("Error", {"message": fields.String})
 
 
 @api.errorhandler(PermissionDenied)
 @api.marshal_with(default_error, code=403)
 def handle_permission_denied(error):
-    '''Error occuring when the user does not have the required permissions'''
-    message = 'You do not have the permission to modify that object.'
-    return {'message': message}, 403
+    """Error occuring when the user does not have the required permissions"""
+    message = "You do not have the permission to modify that object."
+    return {"message": message}, 403
 
 
 @api.errorhandler(ValueError)
 @api.marshal_with(default_error, code=400)
 def handle_value_error(error):
-    '''A generic value error'''
-    return {'message': str(error)}, 400
+    """A generic value error"""
+    return {"message": str(error)}, 400
 
 
 @api.errorhandler(UnauthorizedFileType)
 @api.marshal_with(default_error, code=400)
 def handle_unauthorized_file_type(error):
-    '''Error occuring when the user try to upload a non-allowed file type'''
-    url = url_for('api.allowed_extensions', _external=True)
+    """Error occuring when the user try to upload a non-allowed file type"""
+    url = url_for("api.allowed_extensions", _external=True)
     msg = (
-        'This file type is not allowed.'
-        'The allowed file type list is available at {url}'
+        "This file type is not allowed." "The allowed file type list is available at {url}"
     ).format(url=url)
-    return {'message': msg}, 400
+    return {"message": msg}, 400
+
 
+validation_error_fields = api.model("ValidationError", {"errors": fields.Raw})
 
-validation_error_fields = api.model('ValidationError', {
-    'errors': fields.Raw
-})
 
 @api.errorhandler(FieldValidationError)
 @api.marshal_with(validation_error_fields, code=400)
 def handle_validation_error(error: FieldValidationError):
-    '''A validation error'''
+    """A validation error"""
     errors = {}
     errors[error.field] = [error.message]
 
-    return { 'errors': errors}, 400
+    return {"errors": errors}, 400
+
 
 class API(Resource):  # Avoid name collision as resource is a core model
     pass
 
 
-base_reference = api.model('BaseReference', {
-    'id': fields.String(description='The object unique identifier',
-                        required=True),
-    'class': fields.ClassName(description='The object class',
-                              discriminator=True, required=True),
-}, description='Base model for reference field, aka. inline model reference')
+base_reference = api.model(
+    "BaseReference",
+    {
+        "id": fields.String(description="The object unique identifier", required=True),
+        "class": fields.ClassName(
+            description="The object class", discriminator=True, required=True
+        ),
+    },
+    description="Base model for reference field, aka. inline model reference",
+)
 
 
 def marshal_page(page, page_fields):
@@ -340,14 +350,14 @@ def init_app(app):
     import udata.core.topic.api  # noqa
     import udata.core.topic.apiv2  # noqa
     import udata.core.post.api  # noqa
-    import udata.core.contact_point.api # noqa
+    import udata.core.contact_point.api  # noqa
     import udata.features.transfer.api  # noqa
     import udata.features.notifications.api  # noqa
     import udata.features.identicon.api  # noqa
     import udata.features.territories.api  # noqa
     import udata.harvest.api  # noqa
 
-    for module in entrypoints.get_enabled('udata.apis', app).values():
+    for module in entrypoints.get_enabled("udata.apis", app).values():
         api_module = module if inspect.ismodule(module) else import_module(module)
 
     # api.init_app(app)
@@ -355,5 +365,6 @@ def init_app(app):
     app.register_blueprint(apiv2_blueprint)
 
     from udata.api.oauth2 import init_app as oauth2_init_app
+
     oauth2_init_app(app)
     cors.init_app(app)

udata/api/commands.py

@@ -2,79 +2,87 @@ import logging
 import os
 
 import click
-
-from werkzeug.security import gen_salt
-from flask import json, current_app
+from flask import current_app, json
 from flask_restx import schemas
+from werkzeug.security import gen_salt
 
 from udata.api import api
-from udata.commands import cli, success, exit_with_error
-from udata.models import User
 from udata.api.oauth2 import OAuth2Client
+from udata.commands import cli, exit_with_error, success
+from udata.models import User
 
 log = logging.getLogger(__name__)
 
 
-@cli.group('api')
+@cli.group("api")
 def grp():
-    '''API related operations'''
+    """API related operations"""
 
 
 def json_to_file(data, filename, pretty=False):
-    '''Dump JSON data to a file'''
+    """Dump JSON data to a file"""
     kwargs = dict(indent=4) if pretty else {}
     dirname = os.path.dirname(filename)
     if not os.path.exists(dirname):
         os.makedirs(dirname)
     dump = json.dumps(api.__schema__, **kwargs)
-    with open(filename, 'wb') as f:
-        f.write(dump.encode('utf-8'))
+    with open(filename, "wb") as f:
+        f.write(dump.encode("utf-8"))
 
 
 @grp.command()
-@click.argument('filename')
-@click.option('-p', '--pretty', is_flag=True, help='Pretty print')
+@click.argument("filename")
+@click.option("-p", "--pretty", is_flag=True, help="Pretty print")
 def swagger(filename, pretty):
-    '''Dump the swagger specifications'''
+    """Dump the swagger specifications"""
     json_to_file(api.__schema__, filename, pretty)
 
 
 @grp.command()
-@click.argument('filename')
-@click.option('-p', '--pretty', is_flag=True, help='Pretty print')
-@click.option('-u', '--urlvars', is_flag=True, help='Export query strings')
-@click.option('-s', '--swagger', is_flag=True,
-              help='Export Swagger specifications')
+@click.argument("filename")
+@click.option("-p", "--pretty", is_flag=True, help="Pretty print")
+@click.option("-u", "--urlvars", is_flag=True, help="Export query strings")
+@click.option("-s", "--swagger", is_flag=True, help="Export Swagger specifications")
 def postman(filename, pretty, urlvars, swagger):
-    '''Dump the API as a Postman collection'''
+    """Dump the API as a Postman collection"""
     data = api.as_postman(urlvars=urlvars, swagger=swagger)
     json_to_file(data, filename, pretty)
 
 
 @grp.command()
 def validate():
-    '''Validate the Swagger/OpenAPI specification with your config'''
+    """Validate the Swagger/OpenAPI specification with your config"""
     with current_app.test_request_context():
         schema = json.loads(json.dumps(api.__schema__))
     try:
         schemas.validate(schema)
-        success('API specifications are valid')
+        success("API specifications are valid")
     except schemas.SchemaValidationError as e:
-        exit_with_error('API specifications are not valid', e)
+        exit_with_error("API specifications are not valid", e)
 
 
 @grp.command()
-@click.option('-n', '--client-name', default='client-01', help='Client\'s name')
-@click.option('-u', '--user-email', help='User\'s email')
-@click.option('--uri', multiple=True, default=['http://localhost:8080/login'], help='Client\'s redirect uri')
-@click.option('-g', '--grant-types', multiple=True, default=['authorization_code'], help='Client\'s grant types')
-@click.option('-s', '--scope', default='default', help='Client\'s scope')
-@click.option('-r', '--response-types', multiple=True, default=['code'], help='Client\'s response types')
+@click.option("-n", "--client-name", default="client-01", help="Client's name")
+@click.option("-u", "--user-email", help="User's email")
+@click.option(
+    "--uri", multiple=True, default=["http://localhost:8080/login"], help="Client's redirect uri"
+)
+@click.option(
+    "-g",
+    "--grant-types",
+    multiple=True,
+    default=["authorization_code"],
+    help="Client's grant types",
+)
+@click.option("-s", "--scope", default="default", help="Client's scope")
+@click.option(
+    "-r", "--response-types", multiple=True, default=["code"], help="Client's response types"
+)
 def create_oauth_client(client_name, user_email, uri, grant_types, scope, response_types):
-    '''Creates an OAuth2Client instance in DB'''
+    """Creates an OAuth2Client instance in DB"""
     user = User.objects(email=user_email).first()
     if user is None:
-        exit_with_error('No matching user to email')
+        exit_with_error("No matching user to email")
 
     client = OAuth2Client.objects.create(
         name=client_name,
@@ -82,12 +90,12 @@ def create_oauth_client(client_name, user_email, uri, grant_types, scope, respon
         grant_types=grant_types,
         scope=scope,
         response_types=response_types,
-        redirect_uris=uri
+        redirect_uris=uri,
     )
 
-    click.echo(f'New OAuth client: {client.name}')
-    click.echo(f'Client\'s ID {client.id}')
-    click.echo(f'Client\'s secret {client.secret}')
-    click.echo(f'Client\'s grant_types {client.grant_types}')
-    click.echo(f'Client\'s response_types {client.response_types}')
-    click.echo(f'Client\'s URI {client.redirect_uris}')
+    click.echo(f"New OAuth client: {client.name}")
+    click.echo(f"Client's ID {client.id}")
+    click.echo(f"Client's secret {client.secret}")
+    click.echo(f"Client's grant_types {client.grant_types}")
+    click.echo(f"Client's response_types {client.response_types}")
+    click.echo(f"Client's URI {client.redirect_uris}")

udata/api/errors.py

@@ -1,6 +1,7 @@
 from udata.i18n import gettext as _
 
-
-VALIDATION_ERROR = _('Validation error: your data cannot be updated for '
-                     'now, we have been notified of the error and we will '
-                     'fix it as soon as possible.')
+VALIDATION_ERROR = _(
+    "Validation error: your data cannot be updated for "
+    "now, we have been notified of the error and we will "
+    "fix it as soon as possible."
+)