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

udata/mongo/engine.py

@@ -1,24 +1,24 @@
-from bson import ObjectId, DBRef
+from bson import DBRef, ObjectId
 from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
+from flask_storage.mongo import FileField, ImageField
 from mongoengine.base import TopLevelDocumentMetaclass, get_document
 from mongoengine.errors import ValidationError
-from mongoengine.signals import pre_save, post_save
-
-from flask_storage.mongo import FileField, ImageField
+from mongoengine.signals import post_save, pre_save
 
 from .badges_field import BadgesField
-from .taglist_field import TagListField
 from .datetime_fields import DateField, DateRange, Datetimed
+from .document import DomainModel, UDataDocument
 from .extras_fields import ExtrasField, OrganizationExtrasField
+from .queryset import UDataQuerySet
 from .slug_fields import SlugField
+from .taglist_field import TagListField
 from .url_field import URLField
 from .uuid_fields import AutoUUIDField
-from .queryset import UDataQuerySet
-from .document import UDataDocument, DomainModel
 
 
 class UDataMongoEngine(MongoEngine):
-    '''Customized mongoengine with extra fields types and helpers'''
+    """Customized mongoengine with extra fields types and helpers"""
+
     def __init__(self, app=None):
         super(UDataMongoEngine, self).__init__(app)
         self.BadgesField = BadgesField
@@ -44,19 +44,19 @@ class UDataMongoEngine(MongoEngine):
         self.pre_save = pre_save
 
     def resolve_model(self, model):
-        '''
+        """
         Resolve a model given a name or dict with `class` entry.
 
         :raises ValueError: model specification is wrong or does not exists
-        '''
+        """
         if not model:
-            raise ValueError('Unsupported model specifications')
+            raise ValueError("Unsupported model specifications")
         if isinstance(model, str):
             classname = model
-        elif isinstance(model, dict) and 'class' in model:
-            classname = model['class']
+        elif isinstance(model, dict) and "class" in model:
+            classname = model["class"]
         else:
-            raise ValueError('Unsupported model specifications')
+            raise ValueError("Unsupported model specifications")
 
         try:
             return get_document(classname)
@@ -65,6 +65,5 @@ class UDataMongoEngine(MongoEngine):
             raise ValueError(message)
 
 
-
 db = UDataMongoEngine()
-session_interface = MongoEngineSessionInterface(db)
+session_interface = MongoEngineSessionInterface(db)

udata/mongo/errors.py

@@ -1,8 +1,9 @@
 from mongoengine.errors import ValidationError
 
+
 class FieldValidationError(ValidationError):
     field: str
 
     def __init__(self, *args, field: str, **kwargs):
         self.field = field
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)

udata/mongo/extras_fields.py

@@ -1,9 +1,8 @@
 import logging
-
 from datetime import date, datetime
 
 from mongoengine import EmbeddedDocument
-from mongoengine.fields import DictField, BaseField
+from mongoengine.fields import BaseField, DictField
 
 log = logging.getLogger(__name__)
 
@@ -17,9 +16,9 @@ class ExtrasField(DictField):
         super(ExtrasField, self).__init__()
 
     def register(self, key, dbtype):
-        '''Register a DB type to add constraint on a given extra key'''
+        """Register a DB type to add constraint on a given extra key"""
         if not issubclass(dbtype, (BaseField, EmbeddedDocument)):
-            msg = 'ExtrasField can only register MongoEngine fields'
+            msg = "ExtrasField can only register MongoEngine fields"
             raise TypeError(msg)
         self.registered[key] = dbtype
 
@@ -32,28 +31,31 @@ class ExtrasField(DictField):
 
             if not extra_cls:
                 if not isinstance(value, ALLOWED_TYPES):
-                    types = ', '.join(t.__name__ for t in ALLOWED_TYPES)
-                    msg = 'Value should be an instance of: {types}'
+                    types = ", ".join(t.__name__ for t in ALLOWED_TYPES)
+                    msg = "Value should be an instance of: {types}"
                     errors[key] = msg.format(types=types)
                 continue
 
             try:
                 if issubclass(extra_cls, EmbeddedDocument):
-                    (value.validate()
-                     if isinstance(value, extra_cls)
-                     else extra_cls(**value).validate())
+                    (
+                        value.validate()
+                        if isinstance(value, extra_cls)
+                        else extra_cls(**value).validate()
+                    )
                 else:
                     extra_cls().validate(value)
             except Exception as e:
-                errors[key] = getattr(e, 'message', str(e))
+                errors[key] = getattr(e, "message", str(e))
 
         if errors:
-            self.error('Unsupported types', errors=errors)
+            self.error("Unsupported types", errors=errors)
 
     def __call__(self, key):
         def inner(cls):
             self.register(key, cls)
             return cls
+
         return inner
 
     def to_python(self, value):
@@ -75,29 +77,37 @@ class OrganizationExtrasField(ExtrasField):
         optional_keys = ["choices"]
         valid_types = ["str", "int", "float", "bool", "datetime", "date", "choice"]
 
-        for elem in values.get('custom', []):
+        for elem in values.get("custom", []):
             # Check if all mandatory keys are in the dictionary
             if not all(key in elem for key in mandatory_keys):
-                errors['custom'] = 'The dictionary does not contain the mandatory keys: \'title\', \'description\', \'type\'.'
+                errors["custom"] = (
+                    "The dictionary does not contain the mandatory keys: 'title', 'description', 'type'."
+                )
 
             # Check if the dictionary contains only keys that are either mandatory or optional
             if not all(key in mandatory_keys + optional_keys for key in elem):
-                errors['custom'] = 'The dictionary does contains extra keys than allowed ones.'
+                errors["custom"] = "The dictionary does contains extra keys than allowed ones."
 
             # Check if the "type" value is one of the valid types
             if elem.get("type") not in valid_types:
-                errors['type'] = ('Type \'{type}\' of \'{title}\' should be one of: {types}'
-                                  .format(type=elem.get("type"), title=elem.get("title"), types=valid_types))
+                errors["type"] = "Type '{type}' of '{title}' should be one of: {types}".format(
+                    type=elem.get("type"), title=elem.get("title"), types=valid_types
+                )
 
             # Check if the "choices" key is present only if the type is "choice" and it's not an empty list
             is_choices_valid = True
             if elem.get("type") == "choice":
-                is_choices_valid = "choices" in elem and isinstance(elem["choices"], list) and len(
-                    elem["choices"]) > 0
+                is_choices_valid = (
+                    "choices" in elem
+                    and isinstance(elem["choices"], list)
+                    and len(elem["choices"]) > 0
+                )
             elif "choices" in elem:
                 is_choices_valid = False
             if not is_choices_valid:
-                errors['choices'] = 'The \'choices\' key must be an non empty list and can only be present when type \'choice\' is selected.'
+                errors["choices"] = (
+                    "The 'choices' key must be an non empty list and can only be present when type 'choice' is selected."
+                )
 
         if errors:
-            self.error('Custom extras error', errors=errors)
+            self.error("Custom extras error", errors=errors)

udata/mongo/queryset.py

@@ -1,6 +1,6 @@
 import logging
 
-from bson import ObjectId, DBRef
+from bson import DBRef, ObjectId
 from flask_mongoengine import BaseQuerySet
 
 from udata.utils import Paginable
@@ -9,7 +9,8 @@ log = logging.getLogger(__name__)
 
 
 class DBPaginator(Paginable):
-    '''A simple paginable implementation'''
+    """A simple paginable implementation"""
+
     def __init__(self, queryset):
         self.queryset = queryset
 
@@ -45,8 +46,7 @@ class UDataQuerySet(BaseQuerySet):
         data = self.in_bulk(ids)
         return [data[id] for id in ids]
 
-    def get_or_create(self, write_concern=None, auto_save=True,
-                      *q_objs, **query):
+    def get_or_create(self, write_concern=None, auto_save=True, *q_objs, **query):
         """Retrieve unique object or create, if it doesn't exist.
 
         Returns a tuple of ``(object, created)``, where ``object`` is
@@ -58,7 +58,7 @@ class UDataQuerySet(BaseQuerySet):
         https://github.com/MongoEngine/mongoengine/
         pull/1029/files#diff-05c70acbd0634d6d05e4a6e3a9b7d66b
         """
-        defaults = query.pop('defaults', {})
+        defaults = query.pop("defaults", {})
         try:
             doc = self.get(*q_objs, **query)
             return doc, False
@@ -71,7 +71,7 @@ class UDataQuerySet(BaseQuerySet):
             return doc, True
 
     def generic_in(self, **kwargs):
-        '''Bypass buggy GenericReferenceField querying issue'''
+        """Bypass buggy GenericReferenceField querying issue"""
         query = {}
         for key, value in kwargs.items():
             if not value:
@@ -82,15 +82,15 @@ class UDataQuerySet(BaseQuerySet):
             if isinstance(value, (list, tuple)):
                 if all(isinstance(v, str) for v in value):
                     ids = [ObjectId(v) for v in value]
-                    query['{0}._ref.$id'.format(key)] = {'$in': ids}
+                    query["{0}._ref.$id".format(key)] = {"$in": ids}
                 elif all(isinstance(v, DBRef) for v in value):
-                    query['{0}._ref'.format(key)] = {'$in': value}
+                    query["{0}._ref".format(key)] = {"$in": value}
                 elif all(isinstance(v, ObjectId) for v in value):
-                    query['{0}._ref.$id'.format(key)] = {'$in': value}
+                    query["{0}._ref.$id".format(key)] = {"$in": value}
             elif isinstance(value, ObjectId):
-                query['{0}._ref.$id'.format(key)] = value
+                query["{0}._ref.$id".format(key)] = value
             elif isinstance(value, str):
-                query['{0}._ref.$id'.format(key)] = ObjectId(value)
+                query["{0}._ref.$id".format(key)] = ObjectId(value)
             else:
-                self.error('expect a list of string, ObjectId or DBRef')
+                self.error("expect a list of string, ObjectId or DBRef")
         return self(__raw__=query)

udata/mongo/slug_fields.py

@@ -1,27 +1,36 @@
 import logging
-import slugify
 
+import slugify
 from flask_mongoengine import Document
 from mongoengine.fields import StringField
-from mongoengine.signals import pre_save, post_delete
+from mongoengine.signals import post_delete, pre_save
 
-from .queryset import UDataQuerySet
 from udata.utils import is_uuid
 
+from .queryset import UDataQuerySet
+
 log = logging.getLogger(__name__)
 
 
 class SlugField(StringField):
-    '''
+    """
     A field that that produces a slug from the inputs and auto-
     increments the slug if the value already exists.
-    '''
+    """
+
     # Do not remove, this is required to trigger field population
     _auto_gen = True
 
-    def __init__(self, populate_from=None, update=False, lower_case=True,
-                 separator='-', follow=False, **kwargs):
-        kwargs.setdefault('unique', True)
+    def __init__(
+        self,
+        populate_from=None,
+        update=False,
+        lower_case=True,
+        separator="-",
+        follow=False,
+        **kwargs,
+    ):
+        kwargs.setdefault("unique", True)
         self.populate_from = populate_from
         self.update = update
         self.lower_case = lower_case
@@ -33,7 +42,7 @@ class SlugField(StringField):
     def __get__(self, instance, owner):
         # mongoengine calls this after document initialization
         # We register signals handlers here to have a owner reference
-        if not hasattr(self, 'owner'):
+        if not hasattr(self, "owner"):
             self.owner = owner
             pre_save.connect(self.populate_on_pre_save, sender=owner)
             if self.follow:
@@ -51,20 +60,20 @@ class SlugField(StringField):
         pass
 
     def slugify(self, value):
-        '''
+        """
         Apply slugification according to specified field rules
-        '''
+        """
         if value is None:
             return
 
-        return slugify.slugify(value, max_length=self.max_length,
-                               separator=self.separator,
-                               to_lower=self.lower_case)
+        return slugify.slugify(
+            value, max_length=self.max_length, separator=self.separator, to_lower=self.lower_case
+        )
 
     def latest(self, value):
-        '''
+        """
         Get the latest object for a given old slug
-        '''
+        """
         namespace = self.owner_document.__name__
         follow = SlugFollow.objects(namespace=namespace, old_slug=value).first()
         if follow:
@@ -72,9 +81,9 @@ class SlugField(StringField):
         return None
 
     def cleanup_on_delete(self, sender, document, **kwargs):
-        '''
+        """
         Clean up slug redirections on object deletion
-        '''
+        """
         if not self.follow or sender is not self.owner_document:
             return
         slug = getattr(document, self.db_field)
@@ -88,30 +97,31 @@ class SlugField(StringField):
 
 
 class SlugFollow(Document):
-    '''
+    """
     Keeps track of slug changes for a given namespace/class.
     Fields are:
         * namespace - A namespace under which this slug falls
             (e.g. match, team, user etc)
         * old_slug - Before change slug.
         * new_slug - After change slug
-    '''
+    """
+
     namespace = StringField(required=True)
     old_slug = StringField(required=True)
     new_slug = StringField(required=True)
 
     meta = {
-        'indexes': [
-            ('namespace', 'old_slug'),
+        "indexes": [
+            ("namespace", "old_slug"),
         ],
-        'queryset_class': UDataQuerySet,
+        "queryset_class": UDataQuerySet,
     }
 
 
 def populate_slug(instance, field):
-    '''
+    """
     Populate a slug field if needed.
-    '''
+    """
     value = getattr(instance, field.db_field)
 
     try:
@@ -164,14 +174,14 @@ def populate_slug(instance, field):
 
         while exists(slug):
             # keep space for index suffix, trim slug if needed
-            slug_overflow = len('{0}-{1}'.format(base_slug, index)) - field.max_length
+            slug_overflow = len("{0}-{1}".format(base_slug, index)) - field.max_length
             if slug_overflow >= 1:
                 base_slug = base_slug[:-slug_overflow]
-            slug = '{0}-{1}'.format(base_slug, index)
+            slug = "{0}-{1}".format(base_slug, index)
             index += 1
 
         if is_uuid(slug):
-            slug = '{0}-uuid'.format(slug)
+            slug = "{0}-uuid".format(slug)
 
     # Track old slugs for this class
     if field.follow and old_slug != slug:

udata/mongo/taglist_field.py

@@ -1,6 +1,5 @@
-from slugify import slugify
-
 from mongoengine.fields import ListField, StringField
+from slugify import slugify
 
 
 class TagListField(ListField):

udata/mongo/url_field.py

@@ -4,7 +4,7 @@ from udata import uris
 
 
 class URLField(StringField):
-    '''
+    """
     An URL field using the udata URL normalization and validation rules.
 
     The URL spaces are automatically stripped.
@@ -18,9 +18,9 @@ class URLField(StringField):
     :params list schemes: List of allowed schemes
     :params list tlds: List of allowed TLDs
 
-    '''
-    def __init__(self, private=None, local=None, schemes=None, tlds=None,
-                 **kwargs):
+    """
+
+    def __init__(self, private=None, local=None, schemes=None, tlds=None, **kwargs):
         super(URLField, self).__init__(**kwargs)
         self.private = private
         self.local = local
@@ -36,7 +36,7 @@ class URLField(StringField):
         super(URLField, self).validate(value)
         kwargs = {
             a: getattr(self, a)
-            for a in ('private', 'local', 'schemes', 'tlds')
+            for a in ("private", "local", "schemes", "tlds")
             if getattr(self, a) is not None
         }
         try:

udata/mongo/uuid_fields.py

@@ -7,11 +7,12 @@ log = logging.getLogger(__name__)
 
 
 class AutoUUIDField(UUIDField):
-    '''
+    """
     An autopopulated UUID field.
-    '''
+    """
+
     def __init__(self, **kwargs):
-        kwargs.setdefault('binary', False)
+        kwargs.setdefault("binary", False)
         super(AutoUUIDField, self).__init__(**kwargs)
 
     def __set__(self, instance, value):

udata/notifications/__init__.py

@@ -1 +1 @@
-from .mattermost import notify_potential_spam #noqa
+from .mattermost import notify_potential_spam  # noqa

udata/notifications/mattermost.py

@@ -1,21 +1,22 @@
 import requests
-from udata.core.spam.signals import on_new_potential_spam
 from flask import current_app
 
+from udata.core.spam.signals import on_new_potential_spam
+
 
 @on_new_potential_spam.connect
 def notify_potential_spam(sender, **kwargs):
-    message = kwargs.get('message')
-    reason = kwargs.get('reason')
-    text = kwargs.get('text')
+    message = kwargs.get("message")
+    reason = kwargs.get("reason")
+    text = kwargs.get("text")
 
-    message = f':warning: @all {message}'
+    message = f":warning: @all {message}"
 
     if reason:
-        message += f' ({reason})'
+        message += f" ({reason})"
 
     if text:
-        message += f'\n\n> {text}'
+        message += f"\n\n> {text}"
 
     send_message(message)
 
@@ -26,11 +27,11 @@ def send_message(text: str):
     Args:
         text (str): Text to send to a channel
     """
-    webhook = current_app.config.get('MATTERMOST_WEBHOOK')
+    webhook = current_app.config.get("MATTERMOST_WEBHOOK")
     if not webhook:
         return
 
-    data = {'text': text}
+    data = {"text": text}
 
     r = requests.post(webhook, json=data)
     r.raise_for_status()