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

udata/core/dataset/factories.py

@@ -1,33 +1,28 @@
-import factory
-
 import json
 from os.path import join
 
-from udata.app import ROOT_DIR
-from udata.factories import ModelFactory
-
-from .models import Dataset, Resource, Checksum, CommunityResource, License
+import factory
 
+from udata.app import ROOT_DIR
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.spatial.factories import SpatialCoverageFactory
+from udata.factories import ModelFactory
+
+from .models import Checksum, CommunityResource, Dataset, License, Resource
 
 
 class DatasetFactory(ModelFactory):
     class Meta:
         model = Dataset
 
-    title = factory.Faker('sentence')
-    description = factory.Faker('text')
-    frequency = 'unknown'
+    title = factory.Faker("sentence")
+    description = factory.Faker("text")
+    frequency = "unknown"
     resources = factory.LazyAttribute(lambda o: ResourceFactory.build_batch(o.nb_resources))
 
     class Params:
-        geo = factory.Trait(
-            spatial=factory.SubFactory(SpatialCoverageFactory)
-        )
-        visible = factory.Trait(
-            resources=factory.LazyAttribute(lambda o: [ResourceFactory()])
-        )
+        geo = factory.Trait(spatial=factory.SubFactory(SpatialCoverageFactory))
+        visible = factory.Trait(resources=factory.LazyAttribute(lambda o: [ResourceFactory()]))
         org = factory.Trait(
             organization=factory.SubFactory(OrganizationFactory),
         )
@@ -42,19 +37,19 @@ class ChecksumFactory(ModelFactory):
     class Meta:
         model = Checksum
 
-    type = 'sha1'
-    value = factory.Faker('sha1')
+    type = "sha1"
+    value = factory.Faker("sha1")
 
 
 class BaseResourceFactory(ModelFactory):
-    title = factory.Faker('sentence')
-    description = factory.Faker('text')
-    filetype = 'file'
-    type = 'documentation'
-    url = factory.Faker('url')
+    title = factory.Faker("sentence")
+    description = factory.Faker("text")
+    filetype = "file"
+    type = "documentation"
+    url = factory.Faker("url")
     checksum = factory.SubFactory(ChecksumFactory)
-    mime = factory.Faker('mime_type', category='text')
-    filesize = factory.Faker('pyint')
+    mime = factory.Faker("mime_type", category="text")
+    filesize = factory.Faker("pyint")
 
 
 class CommunityResourceFactory(BaseResourceFactory):
@@ -71,21 +66,24 @@ class LicenseFactory(ModelFactory):
     class Meta:
         model = License
 
-    id = factory.Faker('unique_string')
-    title = factory.Faker('sentence')
-    url = factory.Faker('uri')
+    id = factory.Faker("unique_string")
+    title = factory.Faker("sentence")
+    url = factory.Faker("uri")
+
 
-class ResourceSchemaMockData():
+class ResourceSchemaMockData:
     @staticmethod
     def get_mock_data():
-        return json.load(open(join(ROOT_DIR, 'tests', 'schemas.json')))
-    
+        return json.load(open(join(ROOT_DIR, "tests", "schemas.json")))
+
     @staticmethod
-    def get_all_schemas_from_mock_data(with_datapackage_info = True):
-        '''
+    def get_all_schemas_from_mock_data(with_datapackage_info=True):
+        """
         with_datapackage_info is here to allow testing with or without marshalling (marshalling add None for inexistant datapackage_* fields)
-        '''
-        schemas = ResourceSchemaMockData.get_expected_assignable_schemas_from_mock_data(with_datapackage_info)
+        """
+        schemas = ResourceSchemaMockData.get_expected_assignable_schemas_from_mock_data(
+            with_datapackage_info
+        )
 
         datapackage = {
             "name": "etalab/schema-irve",
@@ -95,28 +93,25 @@ class ResourceSchemaMockData():
             "schema_type": "datapackage",
             "contact": "contact@transport.beta.gouv.fr",
             "examples": [],
-            "labels": [
-                "Socle Commun des Donn\u00e9es Locales",
-                "transport.data.gouv.fr"
-            ],
+            "labels": ["Socle Commun des Donn\u00e9es Locales", "transport.data.gouv.fr"],
             "consolidation_dataset_id": "5448d3e0c751df01f85d0572",
             "versions": [
                 {
                     "version_name": "2.2.0",
-                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.2.0/datapackage.json"
+                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.2.0/datapackage.json",
                 },
                 {
                     "version_name": "2.2.1",
-                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.2.1/datapackage.json"
+                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.2.1/datapackage.json",
                 },
                 {
                     "version_name": "2.3.0",
-                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.3.0/datapackage.json"
+                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.3.0/datapackage.json",
                 },
                 {
                     "version_name": "2.3.1",
-                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.3.1/datapackage.json"
-                }
+                    "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve/2.3.1/datapackage.json",
+                },
             ],
             "external_doc": "https://doc.transport.data.gouv.fr/producteurs/infrastructures-de-recharge-de-vehicules-electriques-irve",
             "external_tool": None,
@@ -129,12 +124,12 @@ class ResourceSchemaMockData():
             datapackage["datapackage_description"] = None
 
         return [datapackage] + schemas
-    
+
     @staticmethod
-    def get_expected_assignable_schemas_from_mock_data(with_datapackage_info = True):
-        '''
+    def get_expected_assignable_schemas_from_mock_data(with_datapackage_info=True):
+        """
         with_datapackage_info is here to allow testing with or without marshalling (marshalling add None for inexistant datapackage_* fields)
-        '''
+        """
         schemas = [
             {
                 "name": "etalab/schema-irve-statique",
@@ -145,31 +140,28 @@ class ResourceSchemaMockData():
                 "contact": "contact@transport.beta.gouv.fr",
                 "examples": [
                     {
-                    "title": "Exemple de fichier IRVE valide",
-                    "path": "https://github.com/etalab/schema-irve/raw/v2.2.1/exemple-valide.csv"
+                        "title": "Exemple de fichier IRVE valide",
+                        "path": "https://github.com/etalab/schema-irve/raw/v2.2.1/exemple-valide.csv",
                     }
                 ],
-                "labels": [
-                    "Socle Commun des Donn\u00e9es Locales",
-                    "transport.data.gouv.fr"
-                ],
+                "labels": ["Socle Commun des Donn\u00e9es Locales", "transport.data.gouv.fr"],
                 "consolidation_dataset_id": "5448d3e0c751df01f85d0572",
                 "versions": [
                     {
                         "version_name": "2.2.0",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve-statique/2.2.0/schema-statique.json"
+                        "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve-statique/2.2.0/schema-statique.json",
                     },
                     {
                         "version_name": "2.2.1",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve-statique/2.2.1/schema-statique.json"
-                    }
+                        "schema_url": "https://schema.data.gouv.fr/schemas/etalab/schema-irve-statique/2.2.1/schema-statique.json",
+                    },
                 ],
                 "external_doc": "https://doc.transport.data.gouv.fr/producteurs/infrastructures-de-recharge-de-vehicules-electriques-irve",
                 "external_tool": None,
                 "homepage": "https://github.com/etalab/schema-irve.git",
                 "datapackage_title": "Infrastructures de recharges pour v\u00e9hicules \u00e9lectriques (IRVE)",
                 "datapackage_name": "etalab/schema-irve",
-                "datapackage_description": "data package contenant 2 sch\u00e9mas : IRVE statique et IRVE dynamique"
+                "datapackage_description": "data package contenant 2 sch\u00e9mas : IRVE statique et IRVE dynamique",
             },
             {
                 "name": "139bercy/format-commande-publique",
@@ -184,29 +176,29 @@ class ResourceSchemaMockData():
                 "versions": [
                     {
                         "version_name": "1.3.0",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.3.0/sch\u00e9mas/json/contrats-concessions.json"
+                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.3.0/sch\u00e9mas/json/contrats-concessions.json",
                     },
                     {
                         "version_name": "1.4.0",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.4.0/marches.json"
+                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.4.0/marches.json",
                     },
                     {
                         "version_name": "1.5.0",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.5.0/marches.json"
+                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/1.5.0/marches.json",
                     },
                     {
                         "version_name": "2.0.0",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/2.0.0/marches.json"
+                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/2.0.0/marches.json",
                     },
                     {
                         "version_name": "2.0.1",
-                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/2.0.1/marches.json"
-                    }
+                        "schema_url": "https://schema.data.gouv.fr/schemas/139bercy/format-commande-publique/2.0.1/marches.json",
+                    },
                 ],
                 "external_doc": None,
                 "external_tool": None,
                 "homepage": "https://github.com/139bercy/format-commande-publique",
-            }
+            },
         ]
 
         if with_datapackage_info:
@@ -214,4 +206,4 @@ class ResourceSchemaMockData():
             schemas[1]["datapackage_name"] = None
             schemas[1]["datapackage_description"] = None
 
-        return schemas
+        return schemas

udata/core/dataset/forms.py

@@ -1,46 +1,59 @@
 from mongoengine import ValidationError
 
+from udata.core.spatial.forms import SpatialCoverageField
+from udata.core.storages import resources
 from udata.forms import ModelForm, fields, validators
 from udata.i18n import lazy_gettext as _
-
-from udata.core.storages import resources
-from udata.core.spatial.forms import SpatialCoverageField
 from udata.mongo.errors import FieldValidationError
 
-from .models import (
-    Dataset, Resource, Schema, License, Checksum, CommunityResource,
-)
 from .constants import (
-    UPDATE_FREQUENCIES, DEFAULT_FREQUENCY, RESOURCE_FILETYPES, CHECKSUM_TYPES,
-    LEGACY_FREQUENCIES, RESOURCE_TYPES, TITLE_SIZE_LIMIT, DESCRIPTION_SIZE_LIMIT,
+    CHECKSUM_TYPES,
+    DEFAULT_FREQUENCY,
+    DESCRIPTION_SIZE_LIMIT,
+    LEGACY_FREQUENCIES,
+    RESOURCE_FILETYPES,
+    RESOURCE_TYPES,
+    TITLE_SIZE_LIMIT,
+    UPDATE_FREQUENCIES,
+)
+from .models import (
+    Checksum,
+    CommunityResource,
+    Dataset,
+    License,
+    Resource,
+    Schema,
 )
 
-__all__ = ('DatasetForm', 'ResourceForm', 'CommunityResourceForm')
+__all__ = ("DatasetForm", "ResourceForm", "CommunityResourceForm")
+
 
 class ChecksumForm(ModelForm):
     model_class = Checksum
     choices = list(zip(CHECKSUM_TYPES, CHECKSUM_TYPES))
-    type = fields.SelectField(choices=choices, default='sha1')
-    value = fields.StringField(_('Checksum value'), [validators.DataRequired()])
+    type = fields.SelectField(choices=choices, default="sha1")
+    value = fields.StringField(_("Checksum value"), [validators.DataRequired()])
 
 
 def normalize_format(data):
-    '''Normalize format field: strip and lowercase'''
+    """Normalize format field: strip and lowercase"""
     if data:
         return data.strip().lower()
 
 
 class SchemaForm(ModelForm):
     model_class = Schema
-    url = fields.URLField(_('URL of the schema'))
-    name = fields.StringField(_('Name of the schema'))
-    version = fields.StringField(_('Version of the schema'))
+    url = fields.URLField(_("URL of the schema"))
+    name = fields.StringField(_("Name of the schema"))
+    version = fields.StringField(_("Version of the schema"))
 
-    def validate(self, extra_validators = None):
+    def validate(self, extra_validators=None):
         validation = super().validate(extra_validators)
 
         try:
-            Schema(url=self.url.data, name=self.name.data, version=self.version.data).clean(check_schema_in_catalog=True)
+            Schema(url=self.url.data, name=self.name.data, version=self.version.data).clean(
+                check_schema_in_catalog=True
+            )
         except FieldValidationError as err:
             field = getattr(self, err.field)
             field.errors.append(err.message)
@@ -51,32 +64,38 @@ class SchemaForm(ModelForm):
 
 class BaseResourceForm(ModelForm):
     title = fields.StringField(
-        _('Title'), [validators.DataRequired(), validators.Length(max=TITLE_SIZE_LIMIT)])
+        _("Title"), [validators.DataRequired(), validators.Length(max=TITLE_SIZE_LIMIT)]
+    )
     description = fields.MarkdownField(
-        _('Description'), [validators.Length(max=DESCRIPTION_SIZE_LIMIT)])
+        _("Description"), [validators.Length(max=DESCRIPTION_SIZE_LIMIT)]
+    )
     filetype = fields.RadioField(
-        _('File type'), [validators.DataRequired()],
-        choices=list(RESOURCE_FILETYPES.items()), default='file',
-        description=_('Whether the resource is an uploaded file, '
-                      'a remote file or an API'))
+        _("File type"),
+        [validators.DataRequired()],
+        choices=list(RESOURCE_FILETYPES.items()),
+        default="file",
+        description=_("Whether the resource is an uploaded file, " "a remote file or an API"),
+    )
     type = fields.RadioField(
-        _('Type'), [validators.DataRequired()],
-        choices=list(RESOURCE_TYPES.items()), default='other',
-        description=_('Resource type (documentation, API...)'))
-    url = fields.UploadableURLField(
-        _('URL'), [validators.DataRequired()], storage=resources)
+        _("Type"),
+        [validators.DataRequired()],
+        choices=list(RESOURCE_TYPES.items()),
+        default="other",
+        description=_("Resource type (documentation, API...)"),
+    )
+    url = fields.UploadableURLField(_("URL"), [validators.DataRequired()], storage=resources)
     format = fields.StringField(
-        _('Format'),
+        _("Format"),
         filters=[normalize_format],
     )
     checksum = fields.FormField(ChecksumForm)
     mime = fields.StringField(
-        _('Mime type'),
-        description=_('The mime type associated to the extension. '
-                      '(ex: text/plain)'))
+        _("Mime type"),
+        description=_("The mime type associated to the extension. " "(ex: text/plain)"),
+    )
     filesize = fields.IntegerField(
-        _('Size'), [validators.optional()],
-        description=_('The file size in bytes'))
+        _("Size"), [validators.optional()], description=_("The file size in bytes")
+    )
     extras = fields.ExtrasField()
     schema = fields.FormField(SchemaForm)
 
@@ -90,67 +109,72 @@ class ResourceForm(BaseResourceForm):
 class CommunityResourceForm(BaseResourceForm):
     model_class = CommunityResource
 
-    dataset = fields.DatasetField(_('Related dataset'))
+    dataset = fields.DatasetField(_("Related dataset"))
     owner = fields.CurrentUserField()
-    organization = fields.PublishAsField(_('Publish as'))
+    organization = fields.PublishAsField(_("Publish as"))
 
 
 def map_legacy_frequencies(form, field):
-    ''' Map legacy frequencies to new ones'''
+    """Map legacy frequencies to new ones"""
     if field.data in LEGACY_FREQUENCIES:
         field.data = LEGACY_FREQUENCIES[field.data]
 
 
 def validate_contact_point(form, field):
-    '''Validates contact point with dataset's org or owner'''
+    """Validates contact point with dataset's org or owner"""
     from udata.models import ContactPoint
+
     if field.data:
         if form.organization.data:
             contact_point = ContactPoint.objects(
-                id=field.data.id, organization=form.organization.data).first()
+                id=field.data.id, organization=form.organization.data
+            ).first()
         elif form.owner.data:
-            contact_point = ContactPoint.objects(
-                id=field.data.id, owner=form.owner.data).first()
+            contact_point = ContactPoint.objects(id=field.data.id, owner=form.owner.data).first()
         if not contact_point:
-            raise validators.ValidationError(_('Wrong contact point id or contact point ownership mismatch'))
+            raise validators.ValidationError(
+                _("Wrong contact point id or contact point ownership mismatch")
+            )
 
 
 class DatasetForm(ModelForm):
     model_class = Dataset
 
     title = fields.StringField(
-        _('Title'), [validators.DataRequired(), validators.Length(max=TITLE_SIZE_LIMIT)])
-    acronym = fields.StringField(_('Acronym'),
-                                 description=_('An optional acronym'))
+        _("Title"), [validators.DataRequired(), validators.Length(max=TITLE_SIZE_LIMIT)]
+    )
+    acronym = fields.StringField(_("Acronym"), description=_("An optional acronym"))
     description = fields.MarkdownField(
-        _('Description'), [validators.DataRequired(), validators.Length(max=DESCRIPTION_SIZE_LIMIT)],
-        description=_('The details about the dataset '
-                      '(collection process, specifics...).'))
-    license = fields.ModelSelectField(
-        _('License'), model=License, allow_blank=True)
+        _("Description"),
+        [validators.DataRequired(), validators.Length(max=DESCRIPTION_SIZE_LIMIT)],
+        description=_("The details about the dataset " "(collection process, specifics...)."),
+    )
+    license = fields.ModelSelectField(_("License"), model=License, allow_blank=True)
     frequency = fields.SelectField(
-        _('Update frequency'),
-        choices=list(UPDATE_FREQUENCIES.items()), default=DEFAULT_FREQUENCY,
+        _("Update frequency"),
+        choices=list(UPDATE_FREQUENCIES.items()),
+        default=DEFAULT_FREQUENCY,
         validators=[validators.optional()],
         preprocessors=[map_legacy_frequencies],
-        description=_('The frequency at which data are updated.'))
-    frequency_date = fields.DateTimeField(_('Expected frequency date'))
+        description=_("The frequency at which data are updated."),
+    )
+    frequency_date = fields.DateTimeField(_("Expected frequency date"))
     deleted = fields.DateTimeField()
     archived = fields.DateTimeField()
     temporal_coverage = fields.DateRangeField(
-        _('Temporal coverage'),
-        description=_('The period covered by the data'))
+        _("Temporal coverage"), description=_("The period covered by the data")
+    )
     spatial = SpatialCoverageField(
-        _('Spatial coverage'),
-        description=_('The geographical area covered by the data.'))
-    tags = fields.TagField(_('Tags'), description=_('Some taxonomy keywords'))
+        _("Spatial coverage"), description=_("The geographical area covered by the data.")
+    )
+    tags = fields.TagField(_("Tags"), description=_("Some taxonomy keywords"))
     private = fields.BooleanField(
-        _('Private'),
-        description=_('Restrict the dataset visibility to you or '
-                      'your organization only.'))
+        _("Private"),
+        description=_("Restrict the dataset visibility to you or " "your organization only."),
+    )
 
     owner = fields.CurrentUserField()
-    organization = fields.PublishAsField(_('Publish as'))
+    organization = fields.PublishAsField(_("Publish as"))
     extras = fields.ExtrasField()
     resources = fields.NestedModelList(ResourceForm)
     contact_point = fields.ContactPointField(validators=[validate_contact_point])