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

udata/core/user/api_fields.py

@@ -1,115 +1,147 @@
+from udata.api import api, base_reference, fields
 from udata.auth.helpers import current_user_is_admin_or_self
-from udata.api import api, fields, base_reference
 
 from .constants import BIGGEST_AVATAR_SIZE
 
-
-user_ref_fields = api.inherit('UserReference', base_reference, {
-    'first_name': fields.String(
-        description='The user first name', readonly=True),
-    'last_name': fields.String(
-        description='The user larst name', readonly=True),
-    'slug': fields.String(
-        description='The user permalink string', required=True),
-    'page': fields.UrlFor(
-        'users.show', lambda u: {'user': u},
-        description='The user profile page URL', readonly=True, fallback_endpoint='api.user'),
-    'uri': fields.UrlFor(
-        'api.user', lambda o: {'user': o},
-        description='The user API URI', required=True),
-    'avatar': fields.ImageField(original=True,
-        description='The user avatar URL'),
-    'avatar_thumbnail': fields.ImageField(attribute='avatar', size=BIGGEST_AVATAR_SIZE,
-        description='The user avatar thumbnail URL. This is the square '
-        '({0}x{0}) and cropped version.'.format(BIGGEST_AVATAR_SIZE)),
-})
+user_ref_fields = api.inherit(
+    "UserReference",
+    base_reference,
+    {
+        "first_name": fields.String(description="The user first name", readonly=True),
+        "last_name": fields.String(description="The user larst name", readonly=True),
+        "slug": fields.String(description="The user permalink string", required=True),
+        "page": fields.UrlFor(
+            "users.show",
+            lambda u: {"user": u},
+            description="The user profile page URL",
+            readonly=True,
+            fallback_endpoint="api.user",
+        ),
+        "uri": fields.UrlFor(
+            "api.user", lambda o: {"user": o}, description="The user API URI", required=True
+        ),
+        "avatar": fields.ImageField(original=True, description="The user avatar URL"),
+        "avatar_thumbnail": fields.ImageField(
+            attribute="avatar",
+            size=BIGGEST_AVATAR_SIZE,
+            description="The user avatar thumbnail URL. This is the square "
+            "({0}x{0}) and cropped version.".format(BIGGEST_AVATAR_SIZE),
+        ),
+    },
+)
 
 from udata.core.organization.api_fields import org_ref_fields  # noqa
 
-user_fields = api.model('User', {
-    'id': fields.String(
-        description='The user identifier', required=True),
-    'slug': fields.String(
-        description='The user permalink string', required=True),
-    'first_name': fields.String(
-        description='The user first name', required=True),
-    'last_name': fields.String(
-        description='The user last name', required=True),
-    'email': fields.Raw(
-        attribute=lambda o: o.email if current_user_is_admin_or_self() else None,
-        description='The user email', readonly=True),
-    'avatar': fields.ImageField(original=True,
-        description='The user avatar URL'),
-    'avatar_thumbnail': fields.ImageField(attribute='avatar', size=BIGGEST_AVATAR_SIZE,
-        description='The user avatar thumbnail URL. This is the square '
-        '({0}x{0}) and cropped version.'.format(BIGGEST_AVATAR_SIZE)),
-    'website': fields.String(description='The user website'),
-    'about': fields.Markdown(description='The user self description'),
-    'roles': fields.List(fields.String, description='Site wide user roles'),
-    'active': fields.Boolean(),
-    'organizations': fields.List(
-        fields.Nested(org_ref_fields),
-        description='The organization the user belongs to'),
-    'since': fields.ISODateTime(
-        attribute='created_at',
-        description='The registeration date', required=True),
-    'page': fields.UrlFor(
-        'users.show', lambda u: {'user': u},
-        description='The user profile page URL', readonly=True, fallback_endpoint='api.user'),
-    'uri': fields.UrlFor(
-        'api.user', lambda o: {'user': o},
-        description='The user API URI', required=True),
-    'metrics': fields.Raw(attribute=lambda o: o.get_metrics(),
-        description='The user metrics', readonly=True),
-})
+user_fields = api.model(
+    "User",
+    {
+        "id": fields.String(description="The user identifier", required=True),
+        "slug": fields.String(description="The user permalink string", required=True),
+        "first_name": fields.String(description="The user first name", required=True),
+        "last_name": fields.String(description="The user last name", required=True),
+        "email": fields.Raw(
+            attribute=lambda o: o.email if current_user_is_admin_or_self() else None,
+            description="The user email",
+            readonly=True,
+        ),
+        "avatar": fields.ImageField(original=True, description="The user avatar URL"),
+        "avatar_thumbnail": fields.ImageField(
+            attribute="avatar",
+            size=BIGGEST_AVATAR_SIZE,
+            description="The user avatar thumbnail URL. This is the square "
+            "({0}x{0}) and cropped version.".format(BIGGEST_AVATAR_SIZE),
+        ),
+        "website": fields.String(description="The user website"),
+        "about": fields.Markdown(description="The user self description"),
+        "roles": fields.List(fields.String, description="Site wide user roles"),
+        "active": fields.Boolean(),
+        "organizations": fields.List(
+            fields.Nested(org_ref_fields), description="The organization the user belongs to"
+        ),
+        "since": fields.ISODateTime(
+            attribute="created_at", description="The registeration date", required=True
+        ),
+        "page": fields.UrlFor(
+            "users.show",
+            lambda u: {"user": u},
+            description="The user profile page URL",
+            readonly=True,
+            fallback_endpoint="api.user",
+        ),
+        "uri": fields.UrlFor(
+            "api.user", lambda o: {"user": o}, description="The user API URI", required=True
+        ),
+        "metrics": fields.Raw(
+            attribute=lambda o: o.get_metrics(), description="The user metrics", readonly=True
+        ),
+    },
+)
 
-me_fields = api.inherit('Me', user_fields, {
-    'apikey': fields.String(description='The user API Key', readonly=True),
-})
+me_fields = api.inherit(
+    "Me",
+    user_fields,
+    {
+        "apikey": fields.String(description="The user API Key", readonly=True),
+    },
+)
 
-me_metrics_fields = api.model('MyMetrics', {
-    'id': fields.String(
-        description='The user identifier', required=True),
-    'resources_availability': fields.Float(
-        description="The user's resources availability percentage",
-        readonly=True),
-    'datasets_org_count': fields.Integer(
-        description="The user's orgs datasets number", readonly=True),
-    'followers_org_count': fields.Integer(
-        description="The user's orgs followers number", readonly=True),
-    'datasets_count': fields.Integer(
-        description="The user's datasets number", readonly=True),
-    'followers_count': fields.Integer(
-        description="The user's followers number", readonly=True),
-})
+me_metrics_fields = api.model(
+    "MyMetrics",
+    {
+        "id": fields.String(description="The user identifier", required=True),
+        "resources_availability": fields.Float(
+            description="The user's resources availability percentage", readonly=True
+        ),
+        "datasets_org_count": fields.Integer(
+            description="The user's orgs datasets number", readonly=True
+        ),
+        "followers_org_count": fields.Integer(
+            description="The user's orgs followers number", readonly=True
+        ),
+        "datasets_count": fields.Integer(description="The user's datasets number", readonly=True),
+        "followers_count": fields.Integer(description="The user's followers number", readonly=True),
+    },
+)
 
-apikey_fields = api.model('ApiKey', {
-    'apikey': fields.String(description='The user API Key', readonly=True),
-})
+apikey_fields = api.model(
+    "ApiKey",
+    {
+        "apikey": fields.String(description="The user API Key", readonly=True),
+    },
+)
 
-user_page_fields = api.model('UserPage', fields.pager(user_fields))
+user_page_fields = api.model("UserPage", fields.pager(user_fields))
 
-user_suggestion_fields = api.model('UserSuggestion', {
-    'id': fields.String(description='The user identifier', readonly=True),
-    'first_name': fields.String(description='The user first name',
-                                readonly=True),
-    'last_name': fields.String(description='The user last name',
-                               readonly=True),
-    'avatar_url': fields.ImageField(size=BIGGEST_AVATAR_SIZE, description='The user avatar URL', readonly=True),
-    'slug': fields.String(
-        description='The user permalink string', readonly=True),
-})
+user_suggestion_fields = api.model(
+    "UserSuggestion",
+    {
+        "id": fields.String(description="The user identifier", readonly=True),
+        "first_name": fields.String(description="The user first name", readonly=True),
+        "last_name": fields.String(description="The user last name", readonly=True),
+        "avatar_url": fields.ImageField(
+            size=BIGGEST_AVATAR_SIZE, description="The user avatar URL", readonly=True
+        ),
+        "slug": fields.String(description="The user permalink string", 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)
-})
+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
+        ),
+    },
+)
 
 
-user_role_fields = api.model('UserRole', {
-    'name': fields.String(description='The role name', readonly=True),
-})
+user_role_fields = api.model(
+    "UserRole",
+    {
+        "name": fields.String(description="The role name", readonly=True),
+    },
+)

udata/core/user/apiv2.py

@@ -1,28 +1,28 @@
 from flask_security import current_user
 
-from udata.api import apiv2, API
+from udata.api import API, apiv2
 from udata.core.topic.apiv2 import topic_page_fields
 from udata.core.topic.parsers import TopicApiParser
 from udata.models import Topic
 
-me = apiv2.namespace('me', 'Connected user related operations (v2)')
+me = apiv2.namespace("me", "Connected user related operations (v2)")
 
 # we will force include_private to True, no need for this arg
 topic_parser = TopicApiParser(with_include_private=False)
 
 
-@me.route('/org_topics/', endpoint='my_org_topics')
+@me.route("/org_topics/", endpoint="my_org_topics")
 class MyOrgTopicsAPI(API):
     @apiv2.secure
-    @apiv2.doc('my_org_topics')
+    @apiv2.doc("my_org_topics")
     @apiv2.expect(topic_parser.parser)
     @apiv2.marshal_list_with(topic_page_fields)
     def get(self):
-        '''List all topics related to me and my organizations.'''
+        """List all topics related to me and my organizations."""
         args = topic_parser.parse()
         args["include_private"] = True
         owners = list(current_user.organizations) + [current_user.id]
         topics = Topic.objects.owned_by(*owners)
         topics = topic_parser.parse_filters(topics, args)
-        sort = args['sort'] or ('$text_score' if args['q'] else None) or '-last-modified'
-        return topics.order_by(sort).paginate(args['page'], args['page_size'])
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or "-last-modified"
+        return topics.order_by(sort).paginate(args["page"], args["page_size"])

udata/core/user/commands.py

@@ -1,100 +1,100 @@
-import click
 import logging
-
 from datetime import datetime
+
+import click
 from flask import current_app
 from flask_security.forms import RegisterForm
 from flask_security.utils import hash_password
 from werkzeug.datastructures import MultiDict
 
+from udata.commands import cli, exit_with_error, success
 from udata.models import User, datastore
 
-from udata.commands import cli, success, exit_with_error
-
 log = logging.getLogger(__name__)
 
 
-@cli.group('user')
+@cli.group("user")
 def grp():
-    '''User related operations'''
+    """User related operations"""
     pass
 
 
 @grp.command()
 def create():
-    '''Create a new user'''
+    """Create a new user"""
     data = {
-        'first_name': click.prompt('First name'),
-        'last_name': click.prompt('Last name'),
-        'email': click.prompt('Email'),
-        'password': click.prompt('Password', hide_input=True),
-        'password_confirm': click.prompt('Confirm Password', hide_input=True),
+        "first_name": click.prompt("First name"),
+        "last_name": click.prompt("Last name"),
+        "email": click.prompt("Email"),
+        "password": click.prompt("Password", hide_input=True),
+        "password_confirm": click.prompt("Confirm Password", hide_input=True),
     }
     # Until https://github.com/mattupstate/flask-security/issues/672 is fixed
     with current_app.test_request_context():
-        form = RegisterForm(MultiDict(data), meta={'csrf': False})
+        form = RegisterForm(MultiDict(data), meta={"csrf": False})
     if form.validate():
-        data['password'] = hash_password(data['password'])
-        del data['password_confirm']
-        data['confirmed_at'] = datetime.utcnow()
+        data["password"] = hash_password(data["password"])
+        del data["password_confirm"]
+        data["confirmed_at"] = datetime.utcnow()
         user = datastore.create_user(**data)
-        success('User(id={u.id} email={u.email}) created'.format(u=user))
+        success("User(id={u.id} email={u.email}) created".format(u=user))
         return user
-    errors = '\n'.join('\n'.join([str(m) for m in e]) for e in form.errors.values())
-    exit_with_error('Error creating user', errors)
+    errors = "\n".join("\n".join([str(m) for m in e]) for e in form.errors.values())
+    exit_with_error("Error creating user", errors)
 
 
 @grp.command()
 def activate():
-    '''Activate an existing user (validate their email confirmation)'''
-    email = click.prompt('Email')
+    """Activate an existing user (validate their email confirmation)"""
+    email = click.prompt("Email")
     user = User.objects(email=email).first()
     if not user:
-        exit_with_error('Invalid user')
+        exit_with_error("Invalid user")
     if user.confirmed_at is not None:
-        exit_with_error('User email address already confirmed')
+        exit_with_error("User email address already confirmed")
         return
     user.confirmed_at = datetime.utcnow()
     user.save()
-    success('User activated successfully')
+    success("User activated successfully")
 
 
 @grp.command()
 def delete():
-    '''Delete an existing user'''
-    email = click.prompt('Email')
+    """Delete an existing user"""
+    email = click.prompt("Email")
     user = User.objects(email=email).first()
     if not user:
-        exit_with_error('Invalid user')
+        exit_with_error("Invalid user")
     user.mark_as_deleted()
-    success('User marked as deleted successfully')
+    success("User marked as deleted successfully")
 
 
 @grp.command()
-@click.argument('email')
+@click.argument("email")
 def set_admin(email):
-    '''Set an user as administrator'''
+    """Set an user as administrator"""
     user = datastore.find_user(email=email)
-    log.info('Adding admin role to user %s (%s)', user.fullname, user.email)
-    role = datastore.find_or_create_role('admin')
+    log.info("Adding admin role to user %s (%s)", user.fullname, user.email)
+    role = datastore.find_or_create_role("admin")
     datastore.add_role_to_user(user, role)
-    success('User %s (%s) is now administrator' % (user.fullname, user.email))
+    success("User %s (%s) is now administrator" % (user.fullname, user.email))
 
 
 @grp.command()
-@click.argument('email')
+@click.argument("email")
 def password(email):
     user = datastore.find_user(email=email)
-    password = click.prompt('Enter new password', hide_input=True)
+    password = click.prompt("Enter new password", hide_input=True)
     user.password = hash_password(password)
     user.save()
 
+
 @grp.command()
-@click.argument('email')
+@click.argument("email")
 def rotate_password(email):
-    '''
+    """
     Ask user for password rotation on next login and reset any current session
-    '''
+    """
     user = datastore.find_user(email=email)
     user.password_rotation_demanded = datetime.utcnow()
     user.save()

udata/core/user/factories.py

@@ -1,32 +1,31 @@
 import factory
-
 from flask_security.utils import hash_password
 
 from udata.factories import ModelFactory
 
-from .models import User, Role
+from .models import Role, User
 
 
 class UserFactory(ModelFactory):
     class Meta:
         model = User
 
-    first_name = factory.Faker('first_name')
-    last_name = factory.Faker('last_name')
-    email = factory.Faker('email')
-    fs_uniquifier = factory.Faker('uuid4')
+    first_name = factory.Faker("first_name")
+    last_name = factory.Faker("last_name")
+    email = factory.Faker("email")
+    fs_uniquifier = factory.Faker("uuid4")
     active = True
 
     @classmethod
     def _adjust_kwargs(cls, **kwargs):
-        if 'password' in kwargs:
+        if "password" in kwargs:
             # Password is stored hashed
-            kwargs['password'] = hash_password(kwargs['password'])
+            kwargs["password"] = hash_password(kwargs["password"])
         return kwargs
 
 
 class AdminFactory(UserFactory):
     @factory.lazy_attribute
     def roles(self):
-        admin_role, _ = Role.objects.get_or_create(name='admin')
+        admin_role, _ = Role.objects.get_or_create(name="admin")
         return [admin_role]

udata/core/user/forms.py

@@ -4,23 +4,26 @@ from udata.models import User
 
 from .constants import AVATAR_SIZES
 
-
-__all__ = ('UserProfileForm', 'UserProfileAdminForm')
+__all__ = ("UserProfileForm", "UserProfileAdminForm")
 
 
 class UserProfileForm(ModelForm):
     model_class = User
 
-    first_name = fields.StringField(_('First name'), [validators.DataRequired(),
-                                    validators.NoURLs(_('URLs not allowed in this field'))])
-    last_name = fields.StringField(_('Last name'), [validators.DataRequired(),
-                                   validators.NoURLs(_('URLs not allowed in this field'))])
-    email = fields.StringField(_('Email'), [validators.DataRequired(), validators.Email()])
-    avatar = fields.ImageField(_('Avatar'), sizes=AVATAR_SIZES)
-    website = fields.URLField(_('Website'))
-    about = fields.MarkdownField(_('About'))
+    first_name = fields.StringField(
+        _("First name"),
+        [validators.DataRequired(), validators.NoURLs(_("URLs not allowed in this field"))],
+    )
+    last_name = fields.StringField(
+        _("Last name"),
+        [validators.DataRequired(), validators.NoURLs(_("URLs not allowed in this field"))],
+    )
+    email = fields.StringField(_("Email"), [validators.DataRequired(), validators.Email()])
+    avatar = fields.ImageField(_("Avatar"), sizes=AVATAR_SIZES)
+    website = fields.URLField(_("Website"))
+    about = fields.MarkdownField(_("About"))
 
 
 class UserProfileAdminForm(UserProfileForm):
-    roles = fields.RolesField(_('Roles'))
+    roles = fields.RolesField(_("Roles"))
     active = fields.BooleanField()

udata/core/user/metrics.py

@@ -1,6 +1,7 @@
-from udata.models import db, Dataset, Reuse, User
 from udata.core.followers.signals import on_follow, on_unfollow
 from udata.core.owned import Owned
+from udata.models import Dataset, Reuse, User, db
+
 
 @Dataset.on_create.connect
 @Dataset.on_update.connect
@@ -32,4 +33,3 @@ def update_owner_metrics(document, previous):
         previous.count_datasets()
     elif isinstance(document, Reuse):
         previous.count_reuses()
-