udata 13.0.1.dev12__py3-none-any.whl → 14.4.1.dev7__py3-none-any.whl

{udata-13.0.1.dev12.dist-info → udata-14.4.1.dev7.dist-info}/entry_points.txt

@@ -4,11 +4,6 @@ udata = udata.commands:cli
 [pytest11]
 udata = udata.tests.plugin
 
-[udata.avatars]
-adorable = udata.features.identicon.backends:adorable
-internal = udata.features.identicon.backends:internal
-robohash = udata.features.identicon.backends:robohash
-
 [udata.harvesters]
 ckan = udata.harvest.backends.ckan.harvesters:CkanBackend
 csw-dcat = udata.harvest.backends.dcat:CswDcatBackend
@@ -16,3 +11,6 @@ csw-iso-19139 = udata.harvest.backends.dcat:CswIso19139DcatBackend
 dcat = udata.harvest.backends.dcat:DcatBackend
 dkan = udata.harvest.backends.ckan.harvesters:DkanBackend
 maaf = udata.harvest.backends.maaf:MaafBackend
+
+[udata.i18n]
+udata = udata.translations

udata/core/followers/views.py

@@ -1,15 +0,0 @@
-# from udata.auth import current_user
-
-# from udata.i18n import I18nBlueprint
-
-# from .models import Follow
-
-# blueprint = I18nBlueprint('followers', __name__)
-
-
-# @blueprint.app_template_global()
-# @blueprint.app_template_filter()
-# def is_following(obj):
-#     if not current_user.is_authenticated:
-#         return False
-#     return Follow.objects.is_following(current_user._get_current_object(), obj)

udata/core/post/forms.py

@@ -1,30 +0,0 @@
-from udata.forms import ModelForm, fields, validators, widgets
-from udata.i18n import lazy_gettext as _
-
-from .constants import IMAGE_SIZES
-from .models import Post
-
-__all__ = ("PostForm",)
-
-
-class PostForm(ModelForm):
-    model_class = Post
-
-    owner = fields.CurrentUserField()
-
-    name = fields.StringField(_("Name"), [validators.DataRequired()])
-    headline = fields.StringField(_("Headline"), widget=widgets.TextArea())
-    content = fields.MarkdownField(_("Content"), [validators.DataRequired()])
-
-    datasets = fields.DatasetListField(_("Associated datasets"))
-    reuses = fields.ReuseListField(_("Associated reuses"))
-
-    image = fields.ImageField(_("Image"), sizes=IMAGE_SIZES)
-    credit_to = fields.StringField(_("Image credits"))
-    credit_url = fields.URLField(_("Credit URL"))
-
-    tags = fields.TagField(_("Tags"))
-
-    body_type = fields.StringField(
-        _("body type"), description=_("Specify your body type (HTML or markdown)")
-    )

udata/entrypoints.py

@@ -1,93 +0,0 @@
-import pkg_resources
-
-# Here for documentation purpose
-ENTRYPOINTS = {
-    "udata.avatars": "Avatar rendering backends",
-    "udata.harvesters": "Harvest backends",
-    "udata.metrics": "Extra metrics",
-    "udata.models": "Models and migrations",
-    "udata.plugins": "Generic plugin",
-    "udata.tasks": "Tasks and jobs",
-    "udata.views": "Extra views",
-}
-
-
-class EntrypointError(Exception):
-    pass
-
-
-def iter_all(name):
-    """Iter all entrypoints registered on a given key"""
-    return pkg_resources.iter_entry_points(name)
-
-
-def get_all(entrypoint_key):
-    """Load all entrypoints registered on a given key"""
-    return dict(_ep_to_kv(e) for e in iter_all(entrypoint_key))
-
-
-def get_enabled(name, app):
-    """
-    Get (and load) entrypoints registered on name
-    and enabled for the given app.
-    """
-    plugins = app.config["PLUGINS"]
-    return dict(
-        _ep_to_kv(e)
-        for e in iter_all(name)
-        if e.name in plugins or e.name.startswith(tuple(plugins))
-    )
-
-
-def get_plugin_module(name, app, plugin):
-    """
-    Get the module for a given plugin
-    """
-    return next((m for p, m in get_enabled(name, app).items() if p == plugin), None)
-
-
-def _ep_to_kv(entrypoint):
-    """
-    Transform an entrypoint into a key-value tuple where:
-    - key is the entrypoint name
-    - value is the entrypoint class with the name attribute
-      matching from entrypoint name
-    """
-    cls = entrypoint.load()
-    cls.name = entrypoint.name
-    return (entrypoint.name, cls)
-
-
-def known_dists():
-    """Return a list of all Distributions exporting udata.* entrypoints"""
-    return (
-        dist
-        for dist in pkg_resources.working_set
-        if any(k in ENTRYPOINTS for k in dist.get_entry_map().keys())
-    )
-
-
-def get_plugins_dists(app, name=None):
-    """Return a list of Distributions with enabled udata plugins"""
-    if name:
-        plugins = set(e.name for e in iter_all(name) if e.name in app.config["PLUGINS"])
-    else:
-        plugins = set(app.config["PLUGINS"])
-    return [
-        d for d in known_dists() if any(set(v.keys()) & plugins for v in d.get_entry_map().values())
-    ]
-
-
-def get_roots(app=None):
-    """
-    Returns the list of root packages/modules exposing endpoints.
-
-    If app is provided, only returns those of enabled plugins
-    """
-    roots = set()
-    plugins = app.config["PLUGINS"] if app else None
-    for name in ENTRYPOINTS.keys():
-        for ep in iter_all(name):
-            if plugins is None or ep.name in plugins:
-                roots.add(ep.module_name.split(".", 1)[0])
-    return list(roots)

udata/features/identicon/api.py

@@ -1,13 +0,0 @@
-from udata.api import API, api
-
-from . import backends
-
-ns = api.namespace("avatars", "Avatars")
-
-
-@ns.route("/<identifier>/<int:size>/", endpoint="avatar")
-class IdenticonAPI(API):
-    @api.doc("avatars")
-    def get(self, identifier, size):
-        """Get a deterministic avatar given an identifier at a given size"""
-        return backends.get_identicon(identifier, size)

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/flask_mongoengine/json.py

@@ -1,38 +0,0 @@
-from bson import json_util
-from flask.json import JSONEncoder
-from mongoengine.base import BaseDocument
-from mongoengine.queryset import QuerySet
-
-
-def _make_encoder(superclass):
-    class MongoEngineJSONEncoder(superclass):
-        """
-        A JSONEncoder which provides serialization of MongoEngine
-        documents and queryset objects.
-        """
-
-        def default(self, obj):
-            if isinstance(obj, BaseDocument):
-                return json_util._json_convert(obj.to_mongo())
-            elif isinstance(obj, QuerySet):
-                return json_util._json_convert(obj.as_pymongo())
-            return superclass.default(self, obj)
-
-    return MongoEngineJSONEncoder
-
-
-MongoEngineJSONEncoder = _make_encoder(JSONEncoder)
-
-
-def override_json_encoder(app):
-    """
-    A function to dynamically create a new MongoEngineJSONEncoder class
-    based upon a custom base class.
-    This function allows us to combine MongoEngine serialization with
-    any changes to Flask's JSONEncoder which a user may have made
-    prior to calling init_app.
-
-    NOTE: This does not cover situations where users override
-    an instance's json_encoder after calling init_app.
-    """
-    app.json_encoder = _make_encoder(app.json_encoder)