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

udata/features/identicon/backends.py

@@ -1,131 +0,0 @@
-import hashlib
-import io
-
-import pydenticon
-from flask import current_app, redirect, send_file
-
-from udata import entrypoints
-from udata.app import cache
-
-ADORABLE_AVATARS_URL = "https://api.adorable.io/avatars/{size}/{identifier}.png"  # noqa
-ROBOHASH_URL = "https://robohash.org/{identifier}.png?size={size}x{size}&set={skin}&bgset={bg}"  # noqa
-
-
-# Default values overriden by theme default and local config
-DEFAULTS = {
-    "AVATAR_PROVIDER": "internal",
-    # Internal provider
-    "AVATAR_INTERNAL_SIZE": 7,
-    "AVATAR_INTERNAL_FOREGROUND": [
-        "rgb(45,79,255)",
-        "rgb(254,180,44)",
-        "rgb(226,121,234)",
-        "rgb(30,179,253)",
-        "rgb(232,77,65)",
-        "rgb(49,203,115)",
-        "rgb(141,69,170)",
-    ],
-    "AVATAR_INTERNAL_BACKGROUND": "rgb(224,224,224)",
-    "AVATAR_INTERNAL_PADDING": 10,
-    # robohash prodiver
-    "AVATAR_ROBOHASH_SKIN": "set1",
-    "AVATAR_ROBOHASH_BACKGROUND": "bg1",
-}
-
-
-def get_config(key):
-    """
-    Get an identicon configuration parameter.
-
-    Precedance order is:
-        - application config (`udata.cfg`)
-        - default
-    """
-    key = "AVATAR_{0}".format(key.upper())
-    local_config = current_app.config.get(key)
-    return local_config or DEFAULTS[key]
-
-
-def get_internal_config(key):
-    return get_config("internal_{0}".format(key))
-
-
-def get_provider():
-    """Get the current provider from config"""
-    name = get_config("provider")
-    available = entrypoints.get_all("udata.avatars")
-    if name not in available:
-        raise ValueError("Unknown avatar provider: {0}".format(name))
-    return available[name]
-
-
-def get_identicon(identifier, size):
-    """
-    Get an identicon for a given identifier at a given size.
-
-    Automatically select the provider from `AVATAR_PROVIDER`
-
-    :returns: a HTTP response, either an image or a redirect
-    """
-    return get_provider()(identifier, size)
-
-
-@cache.memoize()
-def generate_pydenticon(identifier, size):
-    """
-    Use pydenticon to generate an identicon image.
-    All parameters are extracted from configuration.
-    """
-    blocks_size = get_internal_config("size")
-    foreground = get_internal_config("foreground")
-    background = get_internal_config("background")
-    generator = pydenticon.Generator(
-        blocks_size, blocks_size, digest=hashlib.sha1, foreground=foreground, background=background
-    )
-
-    # Pydenticon adds padding to the size and as a consequence
-    # we need to compute the size without the padding
-    padding = int(round(get_internal_config("padding") * size / 100.0))
-    size = size - 2 * padding
-    padding = (padding,) * 4
-    return generator.generate(identifier, size, size, padding=padding, output_format="png")
-
-
-def internal(identifier, size):
-    """
-    Internal provider
-
-    Use pydenticon to generate an identicon.
-    """
-    identicon = generate_pydenticon(identifier, size)
-    response = send_file(io.BytesIO(identicon), mimetype="image/png")
-    etag = hashlib.sha1(identicon).hexdigest()
-    response.set_etag(etag)
-    return response
-
-
-def adorable(identifier, size):
-    """
-    Adorable Avatars provider
-
-    Simply redirect to the external API.
-
-    See: http://avatars.adorable.io/
-    """
-    url = ADORABLE_AVATARS_URL.format(identifier=identifier, size=size)
-    return redirect(url)
-
-
-def robohash(identifier, size):
-    """
-    Robohash provider
-
-    Redirect to the Robohash API
-    with parameters extracted from configuration.
-
-    See: https://robohash.org/
-    """
-    skin = get_config("robohash_skin")
-    background = get_config("robohash_background")
-    url = ROBOHASH_URL.format(identifier=identifier, size=size, skin=skin, bg=background)
-    return redirect(url)

udata/features/identicon/tests/test_backends.py

@@ -1,18 +0,0 @@
-from udata.features.identicon.backends import internal
-from udata.tests.api import PytestOnlyAPITestCase
-from udata.tests.helpers import assert200
-from udata.utils import faker
-
-
-class InternalBackendTest(PytestOnlyAPITestCase):
-    def test_base_rendering(self):
-        response = internal(faker.word(), 32)
-        assert200(response)
-        assert response.mimetype == "image/png"
-        assert response.is_streamed
-        etag, weak = response.get_etag()
-        assert etag is not None
-
-    def test_render_twice_the_same(self):
-        identifier = faker.word()
-        self.assertStreamEqual(internal(identifier, 32), internal(identifier, 32))

udata/features/territories/__init__.py

@@ -1,49 +0,0 @@
-from flask import current_app
-
-from udata.models import GeoZone, db
-
-
-def check_for_territories(query):
-    """
-    Return a geozone queryset of territories given the `query`.
-
-    Results are sorted by population and area (biggest first).
-    """
-    if not query or not current_app.config.get("ACTIVATE_TERRITORIES"):
-        return []
-
-    dbqs = db.Q()
-    query = query.lower()
-    is_digit = query.isdigit()
-    query_length = len(query)
-    for level in current_app.config.get("HANDLED_LEVELS"):
-        if level == "country":
-            continue  # Level not fully handled yet.
-        q = db.Q(level=level)
-        if query_length == 2 and level == "fr:departement" and (is_digit or query in ("2a", "2b")):
-            # Counties + Corsica.
-            q &= db.Q(code=query)
-        elif query_length == 3 and level == "fr:departement" and is_digit:
-            # French DROM-COM.
-            q &= db.Q(code=query)
-        elif (
-            query_length == 5
-            and level == "fr:commune"
-            and (is_digit or query.startswith("2a") or query.startswith("2b"))
-        ):
-            # INSEE code then postal codes with Corsica exceptions.
-            q &= db.Q(code=query)
-        elif query_length >= 4:
-            # Check names starting with query or exact match.
-            q &= db.Q(name__istartswith=query) | db.Q(name__iexact=query)
-        else:
-            continue
-
-        # Meta Q object, ready to be passed to a queryset.
-        dbqs |= q
-
-    if dbqs.empty:
-        return []
-
-    # Sort matching results by population and area.
-    return GeoZone.objects(dbqs).order_by("-population", "-area")

udata/features/territories/api.py

@@ -1,25 +0,0 @@
-from udata.api import API, api
-from udata.features.territories import check_for_territories
-
-suggest_parser = api.parser()
-suggest_parser.add_argument(
-    "q", type=str, help="The string to autocomplete/suggest", location="args", required=True
-)
-suggest_parser.add_argument(
-    "size", type=int, help="The maximum result size", location="args", required=False
-)
-
-
-@api.route("/territory/suggest/", endpoint="suggest_territory")
-class SuggestTerritoriesAPI(API):
-    @api.doc("suggest_territory")
-    @api.expect(suggest_parser)
-    def get(self):
-        args = suggest_parser.parse_args()
-        territories = check_for_territories(args["q"])
-        if args["size"]:
-            territories = territories[: args["size"]]
-        return [
-            {"id": territory.id, "title": territory.name, "page": territory.external_url}
-            for territory in territories
-        ]

udata/features/territories/models.py

@@ -1,51 +0,0 @@
-from udata.models import License, Organization
-
-__all__ = ("TerritoryDataset", "ResourceBasedTerritoryDataset", "TERRITORY_DATASETS")
-
-
-TERRITORY_DATASETS = {"commune": {}, "departement": {}, "region": {}, "country": {}}
-
-
-class TerritoryDataset(object):
-    order = 0
-    id = ""
-    title = ""
-    organization_id = ""
-    url_template = ""
-    description = ""
-    license_id = "fr-lo"
-
-    def __init__(self, territory):
-        self.territory = territory
-
-    @property
-    def url(self):
-        return self.url_template.format(code=self.territory.code)
-
-    @property
-    def slug(self):
-        return "{territory_id}:{id}".format(territory_id=self.territory.id, id=self.id)
-
-    @property
-    def organization(self):
-        return Organization.objects.get(id=self.organization_id)
-
-    @property
-    def license(self):
-        return License.objects(id=self.license_id).first()
-
-
-class ResourceBasedTerritoryDataset(TerritoryDataset):
-    dataset_id = ""
-    resource_id = ""
-    territory_attr = ""
-    csv_column = ""
-
-    def url_for(self, external=False):
-        return None
-
-    url = property(url_for)
-
-    @property
-    def external_url(self):
-        return self.url_for(external=True)

udata/migrations/__init__.py

@@ -1,367 +0,0 @@
-"""
-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 flask import current_app
-from mongoengine.connection import get_db
-from pkg_resources import (
-    resource_filename,
-    resource_isdir,
-    resource_listdir,
-    resource_string,
-)
-from pymongo import ReturnDocument
-
-from udata import entrypoints
-
-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 RollbackError(MigrationError):
-    """
-    Raised on rollback.
-    Hold the initial migration error and rollback exception (if any)
-    """
-
-    def __init__(self, msg, output=None, exc=None, migrate_exc=None):
-        super().__init__(msg)
-        self.msg = msg
-        self.output = output
-        self.exc = exc
-        self.migrate_exc = migrate_exc
-
-
-class MigrationFormatter(logging.Formatter):
-    pass
-
-
-class Record(dict):
-    """
-    A simple wrapper to migrations document
-    """
-
-    __getattr__ = dict.get
-
-    def load(self):
-        specs = {"plugin": self["plugin"], "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 exists.
-        Possible values are:
-          - success
-          - rollback
-          - rollback-error
-          - error
-          - recorded
-        """
-        if not self.exists():
-            return
-        op = self.ops[-1]
-        if op["success"]:
-            if op["type"] == "migrate":
-                return "success"
-            elif op["type"] == "rollback":
-                return "rollback"
-            elif op["type"] == "record":
-                return "recorded"
-            else:
-                return "unknown"
-        else:
-            return "rollback-error" if op["type"] == "rollback" 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(
-                {"plugin": self.plugin, "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, plugin_or_specs, filename, module_name=None):
-        if filename is None and ":" in plugin_or_specs:
-            plugin, filename = plugin_or_specs.split(":")
-        else:
-            plugin = plugin_or_specs
-        if not filename.endswith(".py"):
-            filename += ".py"
-
-        self.plugin = plugin
-        self.filename = filename
-        self.module_name = module_name
-        self._record = None
-        self._module = None
-
-    @property
-    def collection(self):
-        return get_db().migrations
-
-    @property
-    def db_query(self):
-        return {"plugin": self.plugin, "filename": self.filename}
-
-    @property
-    def label(self):
-        return ":".join((self.plugin, self.filename))
-
-    @property
-    def record(self):
-        if self._record is None:
-            specs = {"plugin": self.plugin, "filename": self.filename}
-            data = get_db().migrations.find_one(specs)
-            self._record = Record(data or specs)
-        return self._record
-
-    @property
-    def module(self):
-        if self._module is None:
-            self._module = load_migration(self.plugin, self.filename, module_name=self.module_name)
-        return self._module
-
-    def __eq__(self, value):
-        return (
-            isinstance(value, Migration)
-            and getattr(value, "plugin") == self.plugin
-            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(-1)  # no limit on size
-        handler = QueueHandler(q)
-        handler.setFormatter(MigrationFormatter())
-        logger = getattr(self.module, "log", logging.getLogger(self.module.__name__))
-        logger.propagate = False
-        for h in logger.handlers:
-            logger.removeHandler(h)
-        logger.addHandler(handler)
-
-        if not hasattr(self.module, "migrate"):
-            error = SyntaxError("A migration should at least have a migrate(db) function")
-            raise MigrationError("Error while executing migration", exc=error)
-
-        out = [["info", "Recorded only"]] if recordonly else []
-        state = {}
-
-        if not recordonly and not dryrun:
-            db = get_db()
-            db._state = state
-            try:
-                self.module.migrate(db)
-                out = _extract_output(q)
-            except Exception as e:
-                out = _extract_output(q)
-                tb = traceback.format_exc()
-                self.add_record("migrate", out, db._state, False, traceback=tb)
-                fe = MigrationError(
-                    "Error while executing migration", output=out, exc=e, traceback=tb
-                )
-                if hasattr(self.module, "rollback"):
-                    try:
-                        self.module.rollback(db)
-                        out = _extract_output(q)
-                        self.add_record("rollback", out, db._state, True)
-                        msg = "Error while executing migration, rollback has been applied"
-                        fe = RollbackError(msg, output=out, migrate_exc=fe)
-                    except Exception as re:
-                        out = _extract_output(q)
-                        self.add_record("rollback", out, db._state, False)
-                        msg = "Error while executing migration rollback"
-                        fe = RollbackError(msg, output=out, exc=re, migrate_exc=fe)
-                raise fe
-
-        if not dryrun:
-            self.add_record("migrate", out, state, True)
-
-        return out
-
-    def unrecord(self):
-        """Delete a migration record"""
-        if not self.record.exists():
-            return False
-        return bool(self.collection.delete_one(self.db_query).deleted_count)
-
-    def add_record(self, type, output, state, 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,
-                            "state": state,
-                            "success": success,
-                            "traceback": traceback,
-                        }
-                    }
-                },
-                upsert=True,
-                return_document=ReturnDocument.AFTER,
-            )
-        )
-
-
-def get(plugin, filename):
-    """Get a migration"""
-    return Migration(plugin, filename)
-
-
-def list_available():
-    """
-    List available migrations for udata and enabled plugins
-
-    Each row is a tuple with following signature:
-
-        (plugin, package, filename)
-    """
-    migrations = []
-
-    migrations.extend(_iter("udata", "udata"))
-
-    plugins = entrypoints.get_enabled("udata.models", current_app)
-    for plugin, module in plugins.items():
-        migrations.extend(_iter(plugin, module))
-    return sorted(migrations, key=lambda m: m.filename)
-
-
-def _iter(plugin, module):
-    """
-    Iterate over migrations for a given plugin module
-
-    Yield tuples in the form (plugin_name, module_name, filename)
-    """
-    module_name = module if isinstance(module, str) else module.__name__
-    if not resource_isdir(module_name, "migrations"):
-        return
-    for filename in resource_listdir(module_name, "migrations"):
-        if filename.endswith(".py") and not filename.startswith("__"):
-            yield Migration(plugin, filename, module_name)
-
-
-def _module_name(plugin):
-    """Get the module name for a given plugin"""
-    if plugin == "udata":
-        return "udata"
-    module = entrypoints.get_plugin_module("udata.models", current_app, plugin)
-    if module is None:
-        raise MigrationError("Plugin {} not found".format(plugin))
-    return module.__name__
-
-
-def load_migration(plugin, filename, module_name=None):
-    """
-    Load a migration from its python file
-
-    :returns: the loaded module
-    """
-    module_name = module_name or _module_name(plugin)
-    basename = os.path.splitext(os.path.basename(filename))[0]
-    name = ".".join((module_name, "migrations", basename))
-    filename = os.path.join("migrations", filename)
-    try:
-        script = resource_string(module_name, filename)
-    except Exception:
-        msg = "Unable to load file {} from module {}".format(filename, module_name)
-        raise MigrationError(msg)
-    spec = importlib.util.spec_from_loader(name, loader=None)
-    module = importlib.util.module_from_spec(spec)
-    exec(script, module.__dict__)
-    module.__file__ = resource_filename(module_name, 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