udata 13.0.1.dev12__py3-none-any.whl → 14.0.0__py3-none-any.whl

udata/cors.py

@@ -1,6 +1,6 @@
 import logging
 
-from flask import current_app, g, request
+from flask import current_app, request
 from werkzeug.datastructures import Headers
 
 log = logging.getLogger(__name__)
@@ -32,10 +32,7 @@ def is_preflight_request() -> bool:
 
 
 def is_allowed_cors_route():
-    if g and hasattr(g, "lang_code"):
-        path: str = request.path.removeprefix(f"/{g.lang_code}")
-    else:
-        path: str = request.path
+    path: str = request.path
 
     # Allow to keep clean CORS when `udata` and the frontend are on the same domain
     # (as it's the case in data.gouv with cdata/udata).

udata/db/migrations.py

@@ -0,0 +1,279 @@
+"""
+Data migrations logic
+"""
+
+import importlib.util
+import inspect
+import logging
+import os
+import queue
+import traceback
+from datetime import datetime
+from logging.handlers import QueueHandler
+
+from mongoengine.connection import get_db
+from pymongo import ReturnDocument
+
+log = logging.getLogger(__name__)
+
+
+class MigrationError(Exception):
+    """
+    Raised on migration execution error.
+
+    :param msg str: A human readable message (a reason)
+    :param output str: An optionnal array of logging output
+    :param exc Exception: An optionnal underlying exception
+    """
+
+    def __init__(self, msg, output=None, exc=None, traceback=None):
+        super().__init__(msg)
+        self.msg = msg
+        self.output = output
+        self.exc = exc
+        self.traceback = traceback
+
+
+class Record(dict):
+    """
+    A simple wrapper to migrations document
+    """
+
+    __getattr__ = dict.get
+
+    def load(self):
+        specs = {"filename": self["filename"]}
+        self.clear()
+        data = get_db().migrations.find_one(specs)
+        self.update(data or specs)
+
+    def exists(self):
+        return bool(self._id)
+
+    def __bool__(self):
+        return self.exists()
+
+    @property
+    def collection(self):
+        return get_db().migrations
+
+    @property
+    def status(self):
+        """
+        Status is the status of the last operation.
+
+        Will be `None` if the record doesn't exist.
+        Returns "success" or "error".
+        """
+        if not self.exists():
+            return None
+        op = self.ops[-1]
+        return "success" if op["success"] else "error"
+
+    @property
+    def last_date(self):
+        if not self.exists():
+            return
+        op = self.ops[-1]
+        return op["date"]
+
+    @property
+    def ok(self):
+        """
+        Is true if the migration is considered as successfully applied
+        """
+        if not self.exists():
+            return False
+        op = self.ops[-1]
+        return op["success"] and op["type"] in ("migrate", "record")
+
+    def add(self, _type, migration, output, state, success):
+        script = inspect.getsource(migration)
+        return Record(
+            self.collection.find_one_and_update(
+                {"filename": self.filename},
+                {
+                    "$push": {
+                        "ops": {
+                            "date": datetime.utcnow(),
+                            "type": _type,
+                            "script": script,
+                            "output": output,
+                            "state": state,
+                            "success": success,
+                        }
+                    }
+                },
+                upsert=True,
+                return_document=ReturnDocument.AFTER,
+            )
+        )
+
+    def delete(self):
+        return self.collection.delete_one({"_id": self._id})
+
+
+class Migration:
+    def __init__(self, filename):
+        self.filename = filename
+        self._record = None
+        # Load module immediately - migration must exist on disk
+        module = load_migration(self.filename)
+        if module is None:
+            raise FileNotFoundError(f"Migration {self.filename} file not found")
+        # Extract and store the migrate function
+        if not hasattr(module, "migrate"):
+            raise MigrationError(
+                f"Migration {self.filename} is missing required migrate() function"
+            )
+        self.module = module
+        self.migrate = module.migrate
+
+    @property
+    def collection(self):
+        return get_db().migrations
+
+    @property
+    def db_query(self):
+        return {"filename": self.filename}
+
+    @property
+    def label(self):
+        return self.filename
+
+    @property
+    def record(self):
+        if self._record is None:
+            specs = {"filename": self.filename}
+            data = get_db().migrations.find_one(specs)
+            self._record = Record(data or specs)
+        return self._record
+
+    def __eq__(self, value):
+        return isinstance(value, Migration) and getattr(value, "filename") == self.filename
+
+    def execute(self, recordonly=False, dryrun=False):
+        """
+        Execute a migration
+
+        If recordonly is True, the migration is only recorded
+        If dryrun is True, the migration is neither executed nor recorded
+        """
+        q = queue.Queue()
+        logger = getattr(self.module, "log", logging.getLogger(self.module.__name__))
+
+        # Logs only go to the queue handler are not shown.
+        # They will be formatted below to be shown all at once at the end
+        # of the migration.
+        logger.addHandler(QueueHandler(q))
+        logger.propagate = False
+
+        out = [["info", "Recorded only"]] if recordonly else []
+
+        if not recordonly and not dryrun:
+            db = get_db()
+            try:
+                self.migrate(db)
+                out = _extract_output(q)
+            except Exception as e:
+                out = _extract_output(q)
+                tb = traceback.format_exc()
+                self.add_record("migrate", out, False, traceback=tb)
+                raise MigrationError(
+                    "Error while executing migration", output=out, exc=e, traceback=tb
+                )
+
+        if not dryrun:
+            self.add_record("migrate", out, True)
+
+        return out
+
+    def add_record(self, type, output, success, traceback=None):
+        script = inspect.getsource(self.module)
+        return Record(
+            self.collection.find_one_and_update(
+                self.db_query,
+                {
+                    "$push": {
+                        "ops": {
+                            "date": datetime.utcnow(),
+                            "type": type,
+                            "script": script,
+                            "output": output,
+                            "success": success,
+                            "traceback": traceback,
+                        }
+                    }
+                },
+                upsert=True,
+                return_document=ReturnDocument.AFTER,
+            )
+        )
+
+
+def get(filename):
+    """Get a migration"""
+    return Migration(filename)
+
+
+def unrecord(filename):
+    """
+    Delete a migration record from database
+
+    :returns: True if record was deleted, False if it didn't exist
+    """
+    specs = {"filename": filename}
+    db = get_db()
+    record = db.migrations.find_one(specs)
+    if not record:
+        return False
+    return bool(db.migrations.delete_one(specs).deleted_count)
+
+
+def list_available():
+    """
+    List available migrations from udata/migrations
+
+    Returns a list of Migration objects sorted by filename
+    """
+    from importlib.resources import files
+
+    migrations_path = files("udata").joinpath("migrations")
+
+    migrations = [Migration(item.name) for item in migrations_path.iterdir() if item.is_file()]
+
+    return sorted(migrations, key=lambda m: m.filename)
+
+
+def load_migration(filename):
+    """
+    Load a migration from its python file
+
+    :returns: the loaded module or None if file doesn't exist
+    """
+    from importlib.resources import files
+
+    basename = os.path.splitext(os.path.basename(filename))[0]
+    name = f"udata.migrations.{basename}"
+
+    try:
+        script = files("udata").joinpath("migrations", filename).read_bytes()
+    except Exception:
+        # Return None if file doesn't exist instead of raising
+        return None
+
+    spec = importlib.util.spec_from_loader(name, loader=None)
+    module = importlib.util.module_from_spec(spec)
+    exec(script, module.__dict__)
+    module.__file__ = str(files("udata").joinpath("migrations", filename))
+    return module
+
+
+def _extract_output(q):
+    """Extract log output from a QueueHandler queue"""
+    out = []
+    while not q.empty():
+        record = q.get()
+        # Use list instead of tuple to have the same data before and after mongo persist
+        out.append([record.levelname.lower(), record.getMessage()])
+    return out

udata/frontend/__init__.py

@@ -1,132 +1,13 @@
-import inspect
 import logging
-from importlib import import_module
 
-import pkg_resources
-from jinja2 import pass_context
-from markupsafe import Markup
-
-from udata import entrypoints
-from udata.i18n import I18nBlueprint
-
-from .markdown import UdataCleaner
 from .markdown import init_app as init_markdown
 
 log = logging.getLogger(__name__)
 
 
-hook = I18nBlueprint("hook", __name__)
-
-_template_hooks = {}
-
-
-@hook.app_template_global()
-def package_version(name: str) -> str:
-    return pkg_resources.get_distribution(name).version
-
-
-@hook.app_template_filter()
-def avatar_placeholder(url):
-    if url:
-        return url
-
-    return "data:image/png;base64,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"
-
-
-def _wrapper(func, name=None, when=None):
-    name = name or func.__name__
-    if name not in _template_hooks:
-        _template_hooks[name] = []
-    _template_hooks[name].append((func, when))
-    return func
-
-
-def template_hook(func_or_name, when=None):
-    if callable(func_or_name):
-        return _wrapper(func_or_name)
-    elif isinstance(func_or_name, str):
-
-        def wrapper(func):
-            return _wrapper(func, func_or_name, when=when)
-
-        return wrapper
-
-
-def has_template_hook(name):
-    return name in _template_hooks
-
-
-class HookRenderer:
-    def __init__(self, funcs, ctx, *args, **kwargs):
-        self.funcs = funcs
-        self.ctx = ctx
-        self.args = args
-        self.kwargs = kwargs
-
-    def __html__(self):
-        return Markup(
-            "".join(
-                f(self.ctx, *self.args, **self.kwargs)
-                for f, w in self.funcs
-                if w is None or w(self.ctx)
-            )
-        )
-
-    def __iter__(self):
-        for func, when in self.funcs:
-            if when is None or when(self.ctx):
-                yield Markup(func(self.ctx, *self.args, **self.kwargs))
-
-
-@pass_context
-def render_template_hook(ctx, name, *args, **kwargs):
-    if not has_template_hook(name):
-        return ""
-    return HookRenderer(_template_hooks[name], ctx, *args, **kwargs)
-
-
-@hook.app_context_processor
-def inject_hooks():
-    return {
-        "hook": render_template_hook,
-        "has_hook": has_template_hook,
-    }
-
-
-class SafeMarkup(Markup):
-    """Markup object bypasses Jinja's escaping. This override allows to sanitize the resulting html."""
-
-    def __new__(cls, base, *args, **kwargs):
-        cleaner = UdataCleaner()
-        return super().__new__(cls, cleaner.clean(base), *args, **kwargs)
-
-
-def _load_views(app, module):
-    views = module if inspect.ismodule(module) else import_module(module)
-    blueprint = getattr(views, "blueprint", None)
-    if blueprint:
-        app.register_blueprint(blueprint)
-
-
-VIEWS = ["core.storages"]
-
-
-def init_app(app, views=None):
-    views = views or VIEWS
+def init_app(app):
+    from udata.core.storages.views import blueprint as storage_blueprint
 
     init_markdown(app)
 
-    for view in views:
-        _load_views(app, "udata.{}.views".format(view))
-
-    # Load hook blueprint
-    app.register_blueprint(hook)
-
-    # Load all plugins views and blueprints
-    for module in entrypoints.get_enabled("udata.views", app).values():
-        _load_views(app, module)
-
-    # Load all plugins views and blueprints
-    for module in entrypoints.get_enabled("udata.front", app).values():
-        front_module = module if inspect.ismodule(module) else import_module(module)
-        front_module.init_app(app)
+    app.register_blueprint(storage_blueprint)

udata/harvest/actions.py

@@ -34,11 +34,6 @@ def get_source(ident):
     return HarvestSource.get(ident)
 
 
-def list_backends():
-    """List all available backends"""
-    return backends.get_all(current_app).values()
-
-
 def list_sources(owner=None, deleted=False):
     """List all harvest sources"""
     sources = HarvestSource.objects
@@ -177,7 +172,7 @@ def purge_jobs():
 
 def run(source: HarvestSource):
     """Launch or resume an harvesting for a given source if none is running"""
-    cls = backends.get(current_app, source.backend)
+    cls = backends.get_backend(source.backend)
     backend = cls(source)
     backend.harvest()
 
@@ -189,7 +184,7 @@ def launch(source: HarvestSource):
 
 def preview(source: HarvestSource):
     """Preview an harvesting for a given source"""
-    cls = backends.get(current_app, source.backend)
+    cls = backends.get_backend(source.backend)
     max_items = current_app.config["HARVEST_PREVIEW_MAX_ITEMS"]
     backend = cls(source, dryrun=True, max_items=max_items)
     return backend.harvest()
@@ -226,7 +221,7 @@ def preview_from_config(
         active=active,
         autoarchive=autoarchive,
     )
-    cls = backends.get(current_app, source.backend)
+    cls = backends.get_backend(source.backend)
     max_items = current_app.config["HARVEST_PREVIEW_MAX_ITEMS"]
     backend = cls(source, dryrun=True, max_items=max_items)
     return backend.harvest()

udata/harvest/api.py

@@ -10,6 +10,7 @@ from udata.core.dataset.permissions import OwnablePermission
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.organization.permissions import EditOrganizationPermission
 from udata.core.user.api_fields import user_ref_fields
+from udata.harvest.backends import get_enabled_backends
 
 from . import actions
 from .forms import HarvestSourceForm, HarvestSourceValidationForm
@@ -25,10 +26,6 @@ from .models import (
 ns = api.namespace("harvest", "Harvest related operations")
 
 
-def backends_ids():
-    return [b.name for b in actions.list_backends()]
-
-
 error_fields = api.model(
     "HarvestError",
     {
@@ -126,7 +123,9 @@ source_fields = api.model(
         "description": fields.Markdown(description="The source description"),
         "url": fields.String(description="The source base URL", required=True),
         "backend": fields.String(
-            description="The source backend", enum=backends_ids, required=True
+            description="The source backend",
+            enum=lambda: list(get_enabled_backends().keys()),
+            required=True,
         ),
         "config": fields.Raw(description="The configuration as key-value pairs"),
         "created_at": fields.ISODateTime(
@@ -457,15 +456,7 @@ class ListBackendsAPI(API):
                     "features": [f.as_dict() for f in b.features],
                     "extra_configs": [f.as_dict() for f in b.extra_configs],
                 }
-                for b in actions.list_backends()
+                for b in get_enabled_backends().values()
             ],
             key=lambda b: b["label"],
         )
-
-
-@ns.route("/job_status/", endpoint="havest_job_status")
-class ListHarvesterAPI(API):
-    @api.doc(model=[str])
-    def get(self):
-        """List all available harvesters"""
-        return actions.list_backends()

udata/harvest/backends/__init__.py

@@ -1,17 +1,29 @@
-from udata.entrypoints import EntrypointError, get_enabled
+from fnmatch import fnmatch
+from importlib.metadata import entry_points
 
+from flask import current_app
 
-def get(app, name):
-    """Get a backend given its name"""
-    backend = get_all(app).get(name)
+from .base import BaseBackend, HarvestExtraConfig, HarvestFeature, HarvestFilter  # noqa
+
+
+def get_backend(name: str) -> type[BaseBackend] | None:
+    backend = get_enabled_backends().get(name)
     if not backend:
-        msg = 'Harvest backend "{0}" is not registered'.format(name)
-        raise EntrypointError(msg)
+        raise ValueError(f"Backend {name} unknown. Make sure it is declared in HARVESTER_BACKENDS.")
     return backend
 
 
-def get_all(app):
-    return get_enabled("udata.harvesters", app)
+def get_all_backends() -> dict[str, type[BaseBackend]]:
+    # Note that we use the `BaseBackend.name` and not `ep.name`. The entrypoint name
+    # is not used anymore.
+    return {ep.load().name: ep.load() for ep in entry_points(group="udata.harvesters")}
+
+
+def is_backend_enabled(backend: type[BaseBackend]) -> bool:
+    return any(fnmatch(backend.name, g) for g in current_app.config["HARVESTER_BACKENDS"])
 
 
-from .base import BaseBackend, HarvestFeature, HarvestFilter, HarvestExtraConfig  # noqa
+def get_enabled_backends() -> dict[str, type[BaseBackend]]:
+    return {
+        name: backend for name, backend in get_all_backends().items() if is_backend_enabled(backend)
+    }

udata/harvest/backends/base.py

@@ -85,8 +85,8 @@ class BaseBackend(object):
     Also provides a few helpers needed on all or some backends.
     """
 
-    name = None
-    display_name = None
+    name: str
+    display_name: str | None = None
     verify_ssl = True
 
     # Define some allowed filters on the backend

udata/harvest/backends/ckan/harvesters.py

@@ -25,6 +25,7 @@ ALLOWED_RESOURCE_TYPES = ("dkan", "file", "file.upload", "api", "metadata")
 
 
 class CkanBackend(BaseBackend):
+    name = "ckan"
     display_name = "CKAN"
     filters = (
         HarvestFilter(_("Organization"), "organization", str, _("A CKAN Organization name")),
@@ -265,5 +266,6 @@ class CkanBackend(BaseBackend):
 
 
 class DkanBackend(CkanBackend):
+    name = "dkan"
     schema = dkan_schema
     filters = []

udata/harvest/backends/dcat.py

@@ -63,6 +63,7 @@ def extract_graph(source, target, node, specs):
 
 
 class DcatBackend(BaseBackend):
+    name = "dcat"
     display_name = "DCAT"
 
     def __init__(self, *args, **kwargs):
@@ -256,6 +257,7 @@ class CswDcatBackend(DcatBackend):
     The parsing of items is then the same as for the DcatBackend.
     """
 
+    name = "csw-dcat"
     display_name = "CSW-DCAT"
 
     # CSW_REQUEST is based on:
@@ -424,6 +426,7 @@ class CswIso19139DcatBackend(CswDcatBackend):
     The parsing of items is then the same as for the DcatBackend.
     """
 
+    name = "csw-iso-19139"
     display_name = "CSW-ISO-19139"
 
     extra_configs = (

udata/harvest/backends/maaf.py

@@ -129,6 +129,7 @@ def dictize(element):
 
 
 class MaafBackend(BaseBackend):
+    name = "maaf"
     display_name = "MAAF"
     verify_ssl = False
 

udata/harvest/commands.py

@@ -2,7 +2,8 @@ import logging
 
 import click
 
-from udata.commands import cli
+from udata.commands import KO, OK, cli, green, red
+from udata.harvest.backends import get_all_backends, is_backend_enabled
 
 from . import actions
 
@@ -89,9 +90,10 @@ def sources(scheduled=False):
 @grp.command()
 def backends():
     """List available backends"""
-    log.info("Available backends:")
-    for backend in actions.list_backends():
-        log.info("%s (%s)", backend.name, backend.display_name or backend.name)
+    print("Available backends:")
+    for backend in get_all_backends().values():
+        status = green(OK) if is_backend_enabled(backend) else red(KO)
+        click.echo("{0} {1} ({2})".format(status, backend.display_name, backend.name))
 
 
 @grp.command()