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

udata/features/territories/models.py

@@ -2,27 +2,20 @@ from flask import url_for
 
 from udata.models import License, Organization
 
-__all__ = (
-    'TerritoryDataset', 'ResourceBasedTerritoryDataset', 'TERRITORY_DATASETS'
-)
+__all__ = ("TerritoryDataset", "ResourceBasedTerritoryDataset", "TERRITORY_DATASETS")
 
 
-TERRITORY_DATASETS = {
-    'commune': {},
-    'departement': {},
-    'region': {},
-    'country': {}
-}
+TERRITORY_DATASETS = {"commune": {}, "departement": {}, "region": {}, "country": {}}
 
 
 class TerritoryDataset(object):
     order = 0
-    id = ''
-    title = ''
-    organization_id = ''
-    url_template = ''
-    description = ''
-    license_id = 'fr-lo'
+    id = ""
+    title = ""
+    organization_id = ""
+    url_template = ""
+    description = ""
+    license_id = "fr-lo"
 
     def __init__(self, territory):
         self.territory = territory
@@ -33,8 +26,7 @@ class TerritoryDataset(object):
 
     @property
     def slug(self):
-        return '{territory_id}:{id}'.format(
-            territory_id=self.territory.id, id=self.id)
+        return "{territory_id}:{id}".format(territory_id=self.territory.id, id=self.id)
 
     @property
     def organization(self):
@@ -46,19 +38,22 @@ class TerritoryDataset(object):
 
 
 class ResourceBasedTerritoryDataset(TerritoryDataset):
-    dataset_id = ''
-    resource_id = ''
-    territory_attr = ''
-    csv_column = ''
+    dataset_id = ""
+    resource_id = ""
+    territory_attr = ""
+    csv_column = ""
 
     def url_for(self, external=False):
-        return url_for('territories.territory_dataset_resource',
-                       territory=self.territory,
-                       dataset=self.dataset_id,
-                       resource_id=self.resource_id,
-                       territory_attr=self.territory_attr,
-                       csv_column=self.csv_column,
-                       _external=external)
+        return url_for(
+            "territories.territory_dataset_resource",
+            territory=self.territory,
+            dataset=self.dataset_id,
+            resource_id=self.resource_id,
+            territory_attr=self.territory_attr,
+            csv_column=self.csv_column,
+            _external=external,
+        )
+
     url = property(url_for)
 
     @property

udata/features/transfer/actions.py

@@ -1,9 +1,7 @@
 import logging
-
 from datetime import datetime
 
-
-from udata.auth import login_required, current_user
+from udata.auth import current_user, login_required
 from udata.models import Organization, User
 
 from .models import Transfer
@@ -14,28 +12,27 @@ log = logging.getLogger(__name__)
 
 @login_required
 def request_transfer(subject, recipient, comment):
-    '''Initiate a transfer request'''
+    """Initiate a transfer request"""
     TransferPermission(subject).test()
     if recipient == (subject.organization or subject.owner):
-        raise ValueError(
-            'Recipient should be different than the current owner')
+        raise ValueError("Recipient should be different than the current owner")
     transfer = Transfer.objects.create(
         owner=subject.organization or subject.owner,
         recipient=recipient,
         subject=subject,
-        comment=comment
+        comment=comment,
     )
     return transfer
 
 
 @login_required
 def accept_transfer(transfer, comment=None):
-    '''Accept an incoming a transfer request'''
+    """Accept an incoming a transfer request"""
     TransferResponsePermission(transfer).test()
 
     transfer.responded = datetime.utcnow()
     transfer.responder = current_user._get_current_object()
-    transfer.status = 'accepted'
+    transfer.status = "accepted"
     transfer.response_comment = comment
     transfer.save()
 
@@ -53,12 +50,12 @@ def accept_transfer(transfer, comment=None):
 
 @login_required
 def refuse_transfer(transfer, comment=None):
-    '''Refuse an incoming a transfer request'''
+    """Refuse an incoming a transfer request"""
     TransferResponsePermission(transfer).test()
 
     transfer.responded = datetime.utcnow()
     transfer.responder = current_user._get_current_object()
-    transfer.status = 'refused'
+    transfer.status = "refused"
     transfer.response_comment = comment
     transfer.save()
 

udata/features/transfer/api.py

@@ -1,40 +1,44 @@
 from flask import request
 
-from udata.api import api, fields, API, base_reference
+from udata.api import API, api, base_reference, fields
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.reuse.api_fields import reuse_ref_fields
 from udata.core.user.api_fields import user_ref_fields
-from udata.models import db, User, Organization, Dataset, Reuse
+from udata.models import Dataset, Organization, Reuse, User, db
 from udata.utils import id_or_404
 
-from .actions import request_transfer, accept_transfer, refuse_transfer
+from .actions import accept_transfer, refuse_transfer, request_transfer
 from .models import TRANSFER_STATUS, Transfer
 
-
-RESPONSE_TYPES = ['accept', 'refuse']
-
-
-transfer_request_fields = api.model('TransferRequest', {
-    'subject': fields.Nested(
-        base_reference, required=True,
-        description='The transfered subject'),
-    'recipient': fields.Nested(
-        base_reference, required=True,
-        description=('The transfer recipient, '
-                     'either an user or an organization')),
-    'comment': fields.String(
-        description='An explanation about the transfer request',
-        required=True),
-})
-
-
-transfer_response_fields = api.model('TransferResponse', {
-    'response': fields.String(description='The response', required=True,
-                              enum=RESPONSE_TYPES),
-    'comment': fields.String(
-        description='An optional comment about the transfer response'),
-})
+RESPONSE_TYPES = ["accept", "refuse"]
+
+
+transfer_request_fields = api.model(
+    "TransferRequest",
+    {
+        "subject": fields.Nested(
+            base_reference, required=True, description="The transfered subject"
+        ),
+        "recipient": fields.Nested(
+            base_reference,
+            required=True,
+            description=("The transfer recipient, " "either an user or an organization"),
+        ),
+        "comment": fields.String(
+            description="An explanation about the transfer request", required=True
+        ),
+    },
+)
+
+
+transfer_response_fields = api.model(
+    "TransferResponse",
+    {
+        "response": fields.String(description="The response", required=True, enum=RESPONSE_TYPES),
+        "comment": fields.String(description="An optional comment about the transfer response"),
+    },
+)
 
 person_mapping = {
     User: user_ref_fields,
@@ -46,95 +50,98 @@ subject_mapping = {
     Reuse: reuse_ref_fields,
 }
 
-transfer_fields = api.model('Transfer', {
-    'id': fields.String(
-        readonly=True, description='The transfer unique identifier'),
-    'owner': fields.Polymorph(
-        person_mapping, readonly=True,
-        description=('The user or organization currently owning '
-                     'the transfered object')),
-    'recipient': fields.Polymorph(
-        person_mapping, readonly=True,
-        description=('The user or organization receiving '
-                     'the transfered object')),
-    'subject': fields.Polymorph(
-        subject_mapping, readonly=True, description='The transfered object'),
-    'comment': fields.String(
-        readonly=True, description='A comment about the transfer request'),
-    'created': fields.ISODateTime(
-        description='The transfer request date', readonly=True),
-    'status': fields.String(
-        enum=list(TRANSFER_STATUS),
-        description='The current transfer request status'),
-    'responded': fields.ISODateTime(
-        description='The transfer response date', readonly=True),
-    'reponse_comment': fields.String(
-        readonly=True, description='A comment about the transfer response'),
-})
-
-
-ns = api.namespace('transfer')
-
-
-@ns.route('/', endpoint='transfers')
+transfer_fields = api.model(
+    "Transfer",
+    {
+        "id": fields.String(readonly=True, description="The transfer unique identifier"),
+        "owner": fields.Polymorph(
+            person_mapping,
+            readonly=True,
+            description=("The user or organization currently owning " "the transfered object"),
+        ),
+        "recipient": fields.Polymorph(
+            person_mapping,
+            readonly=True,
+            description=("The user or organization receiving " "the transfered object"),
+        ),
+        "subject": fields.Polymorph(
+            subject_mapping, readonly=True, description="The transfered object"
+        ),
+        "comment": fields.String(readonly=True, description="A comment about the transfer request"),
+        "created": fields.ISODateTime(description="The transfer request date", readonly=True),
+        "status": fields.String(
+            enum=list(TRANSFER_STATUS), description="The current transfer request status"
+        ),
+        "responded": fields.ISODateTime(description="The transfer response date", readonly=True),
+        "reponse_comment": fields.String(
+            readonly=True, description="A comment about the transfer response"
+        ),
+    },
+)
+
+
+ns = api.namespace("transfer")
+
+
+@ns.route("/", endpoint="transfers")
 class TransferRequestsAPI(API):
-    @api.doc('list_transfers')
+    @api.doc("list_transfers")
     @api.marshal_list_with(transfer_fields)
     def get(self):
-        '''List all transfer requests'''
+        """List all transfer requests"""
         pass
 
-    @api.doc('request_transfer')
+    @api.doc("request_transfer")
     @api.expect(transfer_request_fields)
     @api.marshal_with(transfer_fields)
     def post(self):
-        '''Initiate transfer request'''
+        """Initiate transfer request"""
         data = request.json
 
-        subject_model = db.resolve_model(data['subject'])
-        subject_id = data['subject']['id']
+        subject_model = db.resolve_model(data["subject"])
+        subject_id = data["subject"]["id"]
         try:
             subject = subject_model.objects.get(id=subject_id)
         except subject_model.DoesNotExist:
             msg = 'Unkown subject id "{0}"'.format(subject_id)
-            ns.abort(400, errors={'subject': msg})
+            ns.abort(400, errors={"subject": msg})
 
-        recipient_model = db.resolve_model(data['recipient'])
-        recipient_id = data['recipient']['id']
+        recipient_model = db.resolve_model(data["recipient"])
+        recipient_id = data["recipient"]["id"]
         try:
             recipient = recipient_model.objects.get(id=recipient_id)
         except recipient_model.DoesNotExist:
             msg = 'Unkown recipient id "{0}"'.format(recipient_id)
-            ns.abort(400, errors={'recipient': msg})
+            ns.abort(400, errors={"recipient": msg})
 
-        comment = data.get('comment')
+        comment = data.get("comment")
 
         transfer = request_transfer(subject, recipient, comment)
 
         return transfer, 201
 
 
-@ns.route('/<id>/', endpoint='transfer')
+@ns.route("/<id>/", endpoint="transfer")
 class TransferRequestAPI(API):
-    @api.doc('get_transfer')
+    @api.doc("get_transfer")
     @api.marshal_with(transfer_fields)
     def get(self, id):
-        '''Fetch a transfer request given its identifier'''
+        """Fetch a transfer request given its identifier"""
         return Transfer.objects.get_or_404(id=id_or_404(id))
 
-    @api.doc('respond_to_transfer')
+    @api.doc("respond_to_transfer")
     @api.expect(transfer_response_fields)
     @api.marshal_with(transfer_fields)
     def post(self, id):
-        '''Respond to a transfer request'''
+        """Respond to a transfer request"""
         transfer = Transfer.objects.get_or_404(id=id_or_404(id))
 
         data = request.json
-        comment = data.get('comment')
+        comment = data.get("comment")
 
-        if data['response'] == 'accept':
+        if data["response"] == "accept":
             return accept_transfer(transfer, comment)
-        elif data['response'] == 'refuse':
+        elif data["response"] == "refuse":
             return refuse_transfer(transfer, comment)
         else:
             raise ValueError()

udata/features/transfer/factories.py

@@ -8,4 +8,5 @@ from .models import Transfer
 class TransferFactory(ModelFactory):
     class Meta:
         model = Transfer
-    comment = factory.Faker('sentence')
+
+    comment = factory.Faker("sentence")

udata/features/transfer/models.py

@@ -1,5 +1,4 @@
 import logging
-
 from datetime import datetime
 
 from udata.i18n import lazy_gettext as _
@@ -7,13 +6,13 @@ from udata.mongo import db
 
 log = logging.getLogger(__name__)
 
-__all__ = ('Transfer',)
+__all__ = ("Transfer",)
 
 
 TRANSFER_STATUS = {
-    'pending': _('Pending'),
-    'accepted': _('Accepted'),
-    'refused': _('Refused'),
+    "pending": _("Pending"),
+    "accepted": _("Accepted"),
+    "refused": _("Refused"),
 }
 
 
@@ -22,19 +21,19 @@ class Transfer(db.Document):
     recipient = db.GenericReferenceField(required=True)
     subject = db.GenericReferenceField(required=True)
     comment = db.StringField()
-    status = db.StringField(choices=list(TRANSFER_STATUS), default='pending')
+    status = db.StringField(choices=list(TRANSFER_STATUS), default="pending")
 
     created = db.DateTimeField(default=datetime.utcnow, required=True)
 
     responded = db.DateTimeField()
-    responder = db.ReferenceField('User')
+    responder = db.ReferenceField("User")
     response_comment = db.StringField()
 
     meta = {
-        'indexes': [
-            'owner',
-            'recipient',
-            'created',
-            'status',
+        "indexes": [
+            "owner",
+            "recipient",
+            "created",
+            "status",
         ]
     }

udata/features/transfer/notifications.py

@@ -1,32 +1,36 @@
-from udata.models import Transfer
-from udata.features.notifications.actions import notifier
-
-
 import logging
 
+from udata.features.notifications.actions import notifier
+from udata.models import Transfer
+
 log = logging.getLogger(__name__)
 
 
-@notifier('transfer_request')
+@notifier("transfer_request")
 def transfer_request_notifications(user):
-    '''Notify user about pending transfer requests'''
+    """Notify user about pending transfer requests"""
     orgs = [o for o in user.organizations if o.is_member(user)]
     notifications = []
 
-    qs = Transfer.objects(recipient__in=[user] + orgs, status='pending')
+    qs = Transfer.objects(recipient__in=[user] + orgs, status="pending")
     # Only fetch required fields for notification serialization
     # Greatly improve performances and memory usage
-    qs = qs.only('id', 'created', 'subject')
+    qs = qs.only("id", "created", "subject")
 
     # Do not dereference subject (so it's a DBRef)
     # Also improve performances and memory usage
     for transfer in qs.no_dereference():
-        notifications.append((transfer.created, {
-            'id': transfer.id,
-            'subject': {
-                'class': transfer.subject['_cls'].lower(),
-                'id': transfer.subject['_ref'].id
-            }
-        }))
+        notifications.append(
+            (
+                transfer.created,
+                {
+                    "id": transfer.id,
+                    "subject": {
+                        "class": transfer.subject["_cls"].lower(),
+                        "id": transfer.subject["_ref"].id,
+                    },
+                },
+            )
+        )
 
     return notifications

udata/features/transfer/permissions.py

@@ -1,12 +1,11 @@
 from udata.auth import Permission, UserNeed
-
-from udata.models import User, Organization
-
 from udata.core.organization.permissions import OrganizationAdminNeed
+from udata.models import Organization, User
 
 
 class TransferPermission(Permission):
-    '''Permissions to transfer an object assets'''
+    """Permissions to transfer an object assets"""
+
     def __init__(self, subject):
         if subject.organization:
             need = OrganizationAdminNeed(subject.organization.id)
@@ -16,7 +15,8 @@ class TransferPermission(Permission):
 
 
 class TransferResponsePermission(Permission):
-    '''Permissions to transfer an object assets'''
+    """Permissions to transfer an object assets"""
+
     def __init__(self, transfer):
         if isinstance(transfer.recipient, Organization):
             need = OrganizationAdminNeed(transfer.recipient.id)

udata/forms/__init__.py

@@ -1,6 +1,7 @@
 import logging
 
 import wtforms_json
+
 wtforms_json.init()
 from flask_mongoengine.wtf import model_form  # noqa
 
@@ -14,9 +15,11 @@ log = logging.getLogger(__name__)
 
 class CommonFormMixin(object):
     def process(self, formdata=None, obj=None, data=None, extra_filters=None, **kwargs):
-        '''Wrap the process method to store the current object instance'''
+        """Wrap the process method to store the current object instance"""
         self._obj = obj
-        super(CommonFormMixin, self).process(formdata, obj, data, extra_filters=extra_filters, **kwargs)
+        super(CommonFormMixin, self).process(
+            formdata, obj, data, extra_filters=extra_filters, **kwargs
+        )
 
 
 class Form(CommonFormMixin, FlaskForm):