udata 10.6.1.dev36110__py2.py3-none-any.whl → 10.6.1.dev36176__py2.py3-none-any.whl

udata/core/dataservices/api.py

@@ -63,9 +63,7 @@ class DataservicesAtomFeedAPI(API):
         )
 
         dataservices: List[Dataservice] = (
-            Dataservice.objects.visible()
-            .order_by("-created_at_internal")
-            .limit(current_site.feed_size)
+            Dataservice.objects.visible().order_by("-created_at").limit(current_site.feed_size)
         )
         for dataservice in dataservices:
             author_name = None

udata/core/dataset/models.py

@@ -20,6 +20,7 @@ from udata.api_fields import field
 from udata.app import cache
 from udata.core import storages
 from udata.core.activity.models import Auditable
+from udata.core.dataset.preview import TabularAPIPreview
 from udata.core.linkable import Linkable
 from udata.core.metrics.helpers import get_stock_metrics
 from udata.core.owned import Owned, OwnedQuerySet
@@ -47,7 +48,6 @@ from .exceptions import (
     SchemasCacheUnavailableException,
     SchemasCatalogNotFoundException,
 )
-from .preview import get_preview_url
 
 __all__ = (
     "License",
@@ -393,9 +393,9 @@ class ResourceMixin(object):
         if not self.urlhash or "url" in self._get_changed_fields():
             self.urlhash = hash_url(self.url)
 
-    @cached_property  # Accessed at least 2 times in front rendering
+    @property
     def preview_url(self):
-        return get_preview_url(self)
+        return TabularAPIPreview().preview_url(self)
 
     @property
     def closed_or_no_format(self):
@@ -1156,12 +1156,17 @@ class ResourceSchema(object):
                     f"Schemas catalog does not exist at {endpoint}"
                 )
             response.raise_for_status()
-        except requests.exceptions.RequestException:
-            log.exception(f"Error while getting schema catalog from {endpoint}")
+            data = response.json()
+        except requests.exceptions.RequestException as err:
+            log.exception(f"Error while getting schema catalog from {endpoint}: {err}")
+            schemas = cache.get(cache_key)
+        except requests.exceptions.JSONDecodeError as err:
+            log.exception(f"Error while getting schema catalog from {endpoint}: {err}")
             schemas = cache.get(cache_key)
         else:
-            schemas = response.json().get("schemas", [])
+            schemas = data.get("schemas", [])
             cache.set(cache_key, schemas)
+
         # no cached version or no content
         if not schemas:
             log.error("No content found inc. from cache for schema catalog")

udata/core/dataset/preview.py

@@ -1,84 +1,31 @@
-import warnings
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
 
 from flask import current_app
 
-from udata import entrypoints
-from udata.app import cache
-
-# Cache available plugins for a day
-# Don't forget to flush cache on new configuration or plugin
-CACHE_DURATION = 60 * 60 * 24
-CACHE_KEY = "udata.preview.enabled_plugins"
-
-
-class PreviewWarning(UserWarning):
-    pass
-
-
-class PreviewPlugin(ABC):
-    """
-    An abstract preview plugin.
+if TYPE_CHECKING:
+    from udata.models import Resource
 
-    In order to register a functionnal PreviewPlugin,
-    extension developpers need to:
-    - inherit this class
-    - implement abstract methods
-    - expose the class on the ``udata.preview`` endpoint
-    """
-
-    #: Default previews are given only if no specific preview match.
-    #: Typically plugins only relying on mimetype or format
-    #: should have `fallback = True`
-    fallback = False
-
-    @abstractmethod
-    def can_preview(self, resource):
-        """
-        Whether or not this plugin can provide a preview for the given resource
-
-        :param ResourceMixin resource: the (community) resource to preview
-        :return: ``True`` if this plugin can provide a preview
-        :rtype: bool
-        """
-        pass
 
+# Define an abstract class
+class Preview(ABC):
     @abstractmethod
-    def preview_url(self, resource):
-        """
-        Returns the absolute preview URL associated to the resource
-
-        :param ResourceMixin resource: the (community) resource to preview
-        :return: a preview url to be displayed into an iframe or a new window
-        :rtype: str
-        """
-        pass
-
+    def preview_url(self, resource: Resource) -> Optional[str]:
+        return None
 
-@cache.cached(timeout=CACHE_DURATION, key_prefix=CACHE_KEY)
-def get_enabled_plugins():
-    """
-    Returns enabled preview plugins.
 
-    Plugins are sorted, defaults come last
-    """
-    plugins = entrypoints.get_enabled("udata.preview", current_app).values()
-    valid = [p for p in plugins if issubclass(p, PreviewPlugin)]
-    for plugin in plugins:
-        if plugin not in valid:
-            clsname = plugin.__name__
-            msg = "{0} is not a valid preview plugin".format(clsname)
-            warnings.warn(msg, PreviewWarning)
-    return [p() for p in sorted(valid, key=lambda p: 1 if p.fallback else 0)]
+class TabularAPIPreview(Preview):
+    def preview_url(self, resource: Resource) -> Optional[str]:
+        preview_base_url = current_app.config["TABULAR_EXPLORE_URL"]
+        if not preview_base_url:
+            return None
 
+        if "analysis:parsing:parsing_table" not in resource.extras:
+            return None
 
-def get_preview_url(resource):
-    """
-    Returns the most pertinent preview URL associated to the resource, if any.
+        if resource.filetype == "remote" and not current_app.config["TABULAR_ALLOW_REMOTE"]:
+            return None
 
-    :param ResourceMixin resource: the (community) resource to preview
-    :return: a preview url to be displayed into an iframe or a new window
-    :rtype: HttpResponse
-    """
-    candidates = (p.preview_url(resource) for p in get_enabled_plugins() if p.can_preview(resource))
-    return next(iter(candidates), None)
+        return f"{preview_base_url}/resources/{resource.id}"

udata/core/organization/api.py

@@ -76,6 +76,16 @@ class OrgApiParser(ModelApiParser):
             choices=list(Organization.__badges__),
             location="args",
         )
+        self.parser.add_argument(
+            "name",
+            type=str,
+            location="args",
+        )
+        self.parser.add_argument(
+            "business_number_id",
+            type=str,
+            location="args",
+        )
 
     @staticmethod
     def parse_filters(organizations, args):
@@ -88,6 +98,10 @@ class OrgApiParser(ModelApiParser):
             organizations = organizations.search_text(phrase_query)
         if args.get("badge"):
             organizations = organizations.with_badge(args["badge"])
+        if args.get("name"):
+            organizations = organizations.filter(name=args["name"])
+        if args.get("business_number_id"):
+            organizations = organizations.filter(business_number_id=args["business_number_id"])
         return organizations
 
 

udata/settings.py

@@ -582,6 +582,9 @@ class Defaults(object):
     ###########################################################################
     TABULAR_API_DATASERVICE_ID = None
 
+    TABULAR_EXPLORE_URL = None
+    TABULAR_ALLOW_REMOTE = True
+
     # JSON-LD settings
     ###########################################################################
     MAX_RESOURCES_IN_JSON_LD = 20