hdx-python-api 6.7.1__py3-none-any.whl → 6.7.3__py3-none-any.whl

hdx/api/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '6.7.1'
-__version_tuple__ = version_tuple = (6, 7, 1)
+__version__ = version = '6.7.3'
+__version_tuple__ = version_tuple = (6, 7, 3)
 
 __commit_id__ = commit_id = None

hdx/api/utilities/hdx_stats.py

@@ -0,0 +1,47 @@
+"""HDX site-wide statistics"""
+
+from hdx.api.configuration import Configuration
+from hdx.data.hdxobject import HDXError
+
+
+def _call_stats_action(action: str, configuration: Configuration | None) -> dict:
+    """Call an HDX statistics action
+
+    Args:
+        action: CKAN action name
+        configuration: HDX configuration. Defaults to global configuration.
+
+    Returns:
+        Statistics dictionary
+    """
+    if configuration is None:
+        configuration = Configuration.read()
+    try:
+        return configuration.call_remoteckan(action, {})
+    except Exception as e:
+        raise HDXError(f"Failed when trying to call {action}!") from e
+
+
+def get_general_statistics(configuration: Configuration | None = None) -> dict:
+    """Get general statistics about datasets, organizations and users on HDX
+
+    Args:
+        configuration: HDX configuration. Defaults to global configuration.
+
+    Returns:
+        Dictionary with keys datasets, organizations and users
+    """
+    return _call_stats_action("hdx_general_statistics", configuration)
+
+
+def push_general_stats(configuration: Configuration | None = None) -> dict:
+    """Compute general statistics on HDX and push them to analytics. Requires
+    permission to manage basic scheduled tasks.
+
+    Args:
+        configuration: HDX configuration. Defaults to global configuration.
+
+    Returns:
+        Statistics that were pushed
+    """
+    return _call_stats_action("hdx_push_general_stats", configuration)

hdx/data/activity.py

@@ -0,0 +1,247 @@
+"""Activity class containing all logic for reading activity streams."""
+
+import logging
+from collections.abc import Sequence
+from typing import Any, Optional
+
+from hdx.api.configuration import Configuration
+from hdx.data.hdxobject import HDXError, HDXObject
+
+logger = logging.getLogger(__name__)
+
+
+class Activity(HDXObject):
+    """Activity class containing all logic for reading activity streams. Activities
+    are read only.
+
+    Args:
+        initial_data: Initial activity metadata dictionary. Defaults to None.
+        configuration: HDX configuration. Defaults to global configuration.
+    """
+
+    def __init__(
+        self,
+        initial_data: dict | None = None,
+        configuration: Configuration | None = None,
+    ) -> None:
+        if not initial_data:
+            initial_data = {}
+        super().__init__(initial_data, configuration=configuration)
+
+    @staticmethod
+    def actions() -> dict[str, str]:
+        """Dictionary of actions that can be performed on object
+
+        Returns:
+            Dictionary of actions that can be performed on object
+        """
+        return {
+            "show": "activity_show",
+            "data_show": "activity_data_show",
+            "diff": "activity_diff",
+            "package_list": "package_activity_list",
+            "organization_list": "organization_activity_list",
+            "group_list": "group_activity_list",
+            "user_list": "user_activity_list",
+            "recently_changed_packages": "recently_changed_packages_activity_list",
+        }
+
+    @classmethod
+    def read_from_hdx(
+        cls, identifier: str, configuration: Configuration | None = None
+    ) -> Optional["Activity"]:
+        """Reads the activity given by identifier from HDX and returns Activity object.
+        HDX requires permission to edit the object the activity relates to.
+
+        Args:
+            identifier: Identifier of activity
+            configuration: HDX configuration. Defaults to global configuration.
+
+        Returns:
+            Activity object if successful read, None if not
+        """
+        return cls._read_from_hdx_class("activity", identifier, configuration)
+
+    def get_object_type(self) -> str:
+        """Get the CKAN object type the activity relates to eg. package,
+        organization, group or user. This is the last word of the activity type
+        (eg. "changed package") with "dataset" (from "follow dataset") mapped to
+        "package".
+
+        Returns:
+            Object type
+        """
+        object_type = self.data["activity_type"].split(" ")[-1]
+        if object_type == "dataset":
+            return "package"
+        return object_type
+
+    def get_data(self) -> dict:
+        """Get the data of the activity which includes a snapshot of the object
+        at the time of the activity. HDX requires permission to edit the object
+        the activity relates to.
+
+        Returns:
+            Activity data
+        """
+        return self._write_to_hdx("data_show", {"id": self.data["id"]}, "id")
+
+    def get_diff(self, diff_type: str = "unified") -> dict:
+        """Get a diff of the object compared to its previous version. HDX requires
+        permission to edit the object the activity relates to.
+
+        Args:
+            diff_type: One of unified, context or html. Defaults to unified.
+
+        Returns:
+            Activity diff
+        """
+        data = {
+            "id": self.data["id"],
+            "object_type": self.get_object_type(),
+            "diff_type": diff_type,
+        }
+        return self._write_to_hdx("diff", data, "id")
+
+    @classmethod
+    def _get_list(
+        cls,
+        action: str,
+        data: dict,
+        configuration: Configuration | None = None,
+        all_pages: bool = False,
+        max_activities: int | None = None,
+    ) -> list["Activity"]:
+        """Helper method to get a list of activities from HDX
+
+        Args:
+            action: Action to perform
+            data: Data to pass to CKAN including any offset and limit
+            configuration: HDX configuration. Defaults to global configuration.
+            all_pages: Whether to get all pages of results. Defaults to False.
+            max_activities: Maximum number of activities if all_pages is True. Defaults to None (no maximum).
+
+        Returns:
+            List of Activity objects
+        """
+        activity = cls(configuration=configuration)
+        if not all_pages:
+            result = activity._write_to_hdx(action, data)
+            return [cls(x, configuration=configuration) for x in result]
+        data = dict(data)
+        # HDX silently caps limit at ckan.activity_list_limit_max
+        limit = min(data.get("limit", 100), 100)
+        data["limit"] = limit
+        offset = data.get("offset", 0)
+        activities = []
+        while True:
+            data["offset"] = offset
+            result = activity._write_to_hdx(action, data)
+            activities.extend(cls(x, configuration=configuration) for x in result)
+            if max_activities is not None and len(activities) >= max_activities:
+                return activities[:max_activities]
+            if len(result) < limit:
+                return activities
+            offset += limit
+
+    @classmethod
+    def get_activities(
+        cls,
+        object_type: str,
+        identifier: str,
+        configuration: Configuration | None = None,
+        all_pages: bool = False,
+        **kwargs: Any,
+    ) -> list["Activity"]:
+        """Get the activity stream of a CKAN object. One page of results (whose
+        size is given by limit) is returned unless all_pages is True.
+
+        Args:
+            object_type: One of package, organization, group or user
+            identifier: Id or name of object
+            configuration: HDX configuration. Defaults to global configuration.
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+            after (int | str): Only activities after this timestamp (package and user only)
+            before (int | str): Only activities before this timestamp (package and user only)
+            include_hidden_activity (bool): Include hidden activity, sysadmins only (package, organization and group only)
+            activity_types (list): Activity types to include (package only)
+            exclude_activity_types (list): Activity types to exclude (package only)
+
+        Returns:
+            List of Activity objects
+        """
+        if not identifier:
+            raise HDXError(f"No id or name for {object_type} to get activities!")
+        data = {"id": identifier}
+        data.update(kwargs)
+        return cls._get_list(f"{object_type}_list", data, configuration, all_pages)
+
+    @classmethod
+    def get_recently_changed_packages(
+        cls,
+        configuration: Configuration | None = None,
+        all_pages: bool = False,
+        max_activities: int | None = 1000,
+        **kwargs: Any,
+    ) -> list["Activity"]:
+        """Get the activity stream of all recently added or changed datasets.
+        One page of results (whose size is given by limit) is returned unless
+        all_pages is True. all_pages is capped by max_activities because the
+        stream covers the whole history of HDX.
+
+        Args:
+            configuration: HDX configuration. Defaults to global configuration.
+            all_pages: Whether to get all pages of results. Defaults to False.
+            max_activities: Maximum number of activities if all_pages is True. Defaults to 1000. None means no maximum (very slow).
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+
+        Returns:
+            List of Activity objects
+        """
+        return cls._get_list(
+            "recently_changed_packages",
+            kwargs,
+            configuration,
+            all_pages,
+            max_activities,
+        )
+
+    def check_required_fields(self, ignore_fields: Sequence[str] = ()) -> None:
+        """Activities are read only so this raises an exception
+
+        Args:
+            ignore_fields: Fields to ignore. Default is ().
+
+        Returns:
+            None
+        """
+        raise HDXError("Activities are read only!")
+
+    def update_in_hdx(self, **kwargs: Any) -> None:
+        """Activities are read only so this raises an exception
+
+        Returns:
+            None
+        """
+        raise HDXError("Activities are read only!")
+
+    def create_in_hdx(self, **kwargs: Any) -> None:
+        """Activities are read only so this raises an exception
+
+        Returns:
+            None
+        """
+        raise HDXError("Activities are read only!")
+
+    def delete_from_hdx(self) -> None:
+        """Activities are read only so this raises an exception
+
+        Returns:
+            None
+        """
+        raise HDXError("Activities are read only!")

hdx/data/dataset.py

@@ -40,6 +40,7 @@ from hdx.api.configuration import Configuration
 from hdx.api.locations import Locations
 from hdx.api.utilities.date_helper import DateHelper
 from hdx.api.utilities.filestore_helper import FilestoreHelper
+from hdx.data.activity import Activity
 from hdx.data.hdxobject import HDXError, HDXObject
 from hdx.data.resource_matcher import ResourceMatcher
 
@@ -146,6 +147,7 @@ class Dataset(HDXObject):
             "list": "package_list",
             "autocomplete": "package_autocomplete",
             "create_default_views": "package_create_default_resource_views",
+            "fs_check_info": "fs_check_info_show",
         }
 
     def __setitem__(self, key: Any, value: Any) -> None:
@@ -1428,6 +1430,26 @@ class Dataset(HDXObject):
                 resources.append(resource)
         return resources
 
+    def get_activities(self, all_pages: bool = False, **kwargs: Any) -> list[Activity]:
+        """Get the activity stream of this dataset. One page of results (whose size
+        is given by limit) is returned unless all_pages is True.
+
+        Args:
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+            after (int | str): Only activities after this timestamp
+            before (int | str): Only activities before this timestamp
+            include_hidden_activity (bool): Include hidden activity (sysadmins only)
+            activity_types (list): Activity types to include
+            exclude_activity_types (list): Activity types to exclude
+
+        Returns:
+            List of Activity objects
+        """
+        return self._get_activities("package", all_pages, **kwargs)
+
     @classmethod
     def autocomplete(
         cls,
@@ -2306,6 +2328,25 @@ class Dataset(HDXObject):
             return None
         return f"{self.configuration.get_hdx_site_url()}/api/3/action/package_show?id={name_or_id}"
 
+    def get_fs_check_info(self) -> list[dict]:
+        """Get file structure check information for the dataset's resources
+        from HDX. Each list item is a dictionary from resource name to a list
+        of check events, each of which can have keys such as state, timestamp,
+        sheet_changes and hxl_proxy_response.
+
+        Returns:
+            List of dictionaries from resource name to file structure checks
+        """
+        success, result = self._read_from_hdx(
+            "dataset",
+            self.get_name_or_id(prefer_name=False),
+            "id",
+            self.actions()["fs_check_info"],
+        )
+        if success:
+            return result
+        return []
+
     def generate_resource(
         self,
         folder: Path | str,

hdx/data/hdxobject.py

@@ -9,7 +9,7 @@ from collections import UserDict
 from collections.abc import Sequence
 from os.path import isfile
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from ckanapi.errors import NotFound
 from hdx.utilities.dictandlist import merge_two_dictionaries
@@ -20,6 +20,9 @@ from hdx.utilities.loader import (
 
 from hdx.api.configuration import Configuration
 
+if TYPE_CHECKING:
+    from hdx.data.activity import Activity
+
 logger = logging.getLogger(__name__)
 
 
@@ -376,6 +379,30 @@ class HDXObject(UserDict, ABC):
             **kwargs,
         )
 
+    def _get_activities(
+        self, object_type: str, all_pages: bool = False, **kwargs: Any
+    ) -> list["Activity"]:
+        """Helper method to get the activity stream of this object
+
+        Args:
+            object_type: One of package, organization, group or user
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: Parameters to pass to Activity.get_activities
+
+        Returns:
+            List of Activity objects
+        """
+        # Imported here as hdx.data.activity imports this module
+        from hdx.data.activity import Activity
+
+        return Activity.get_activities(
+            object_type,
+            self.data.get("id") or self.data.get("name"),
+            self.configuration,
+            all_pages,
+            **kwargs,
+        )
+
     def _write_to_hdx(
         self,
         action: str,

hdx/data/location.py

@@ -5,6 +5,7 @@ from collections.abc import Sequence
 from typing import Any, Optional
 
 from hdx.api.configuration import Configuration
+from hdx.data.activity import Activity
 from hdx.data.hdxobject import HDXObject
 
 logger = logging.getLogger(__name__)
@@ -217,6 +218,22 @@ class Location(HDXObject):
             if len(group["name"]) == 3 and group.get("data_completeness") == "active"
         )
 
+    def get_activities(self, all_pages: bool = False, **kwargs: Any) -> list[Activity]:
+        """Get the activity stream of this location. One page of results (whose size
+        is given by limit) is returned unless all_pages is True.
+
+        Args:
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+            include_hidden_activity (bool): Include hidden activity (sysadmins only)
+
+        Returns:
+            List of Activity objects
+        """
+        return self._get_activities("group", all_pages, **kwargs)
+
     @classmethod
     def autocomplete(
         cls,

hdx/data/organization.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 import hdx.data.dataset
 import hdx.data.user as user_module
 from hdx.api.configuration import Configuration
+from hdx.data.activity import Activity
 from hdx.data.hdxobject import HDXError, HDXObject
 
 if TYPE_CHECKING:
@@ -311,6 +312,22 @@ class Organization(HDXObject):
 
         return final_orgs
 
+    def get_activities(self, all_pages: bool = False, **kwargs: Any) -> list[Activity]:
+        """Get the activity stream of this organization. One page of results (whose size
+        is given by limit) is returned unless all_pages is True.
+
+        Args:
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+            include_hidden_activity (bool): Include hidden activity (sysadmins only)
+
+        Returns:
+            List of Activity objects
+        """
+        return self._get_activities("organization", all_pages, **kwargs)
+
     @classmethod
     def autocomplete(
         cls,

hdx/data/resource.py

@@ -72,6 +72,8 @@ class Resource(HDXObject):
             "datastore_upsert": "datastore_upsert",
             "datastore_search": "datastore_search",
             "datastore_search_sql": "datastore_search_sql",
+            "datapusher_submit": "datapusher_submit",
+            "datapusher_status": "datapusher_status",
         }
 
     def update_from_yaml(
@@ -319,6 +321,69 @@ class Resource(HDXObject):
             data_dictionary, separators=(",", ":")
         )
 
+    def update_hdx_data_dictionary(
+        self,
+        data_dictionary: Sequence[dict],
+        replace: bool = False,
+        update_datastore: bool = True,
+    ) -> None:
+        """Update the resource's data dictionary (column definitions) in HDX
+        without changing last_modified, so no dataset update notifications are
+        sent. Column definitions are as for set_hdx_data_dictionary. Unless
+        replace is True, they are merged by field into the existing data
+        dictionary in the resource metadata (so call read_from_hdx first).
+        The resource's hdx_data_dictionary field is patched, then if
+        update_datastore is True and the resource has a datastore, the
+        datastore field labels and descriptions are updated using
+        datastore_create without reloading the data.
+
+        Args:
+            data_dictionary: Sequence of column definition dictionaries
+            replace: Replace rather than merge into existing data dictionary. Defaults to False.
+            update_datastore: Update datastore field labels and descriptions. Defaults to True.
+
+        Returns:
+            None
+        """
+        if replace:
+            merged = [dict(column) for column in data_dictionary]
+        else:
+            new_columns = {column["field"]: column for column in data_dictionary}
+            merged = []
+            for column in self.get_hdx_data_dictionary() or []:
+                new_column = new_columns.pop(column.get("field"), None)
+                merged.append({**column, **new_column} if new_column else column)
+            merged.extend(new_columns.values())
+        self.set_hdx_data_dictionary(merged)
+        self._write_to_hdx(
+            "patch",
+            {
+                "id": self.data["id"],
+                "hdx_data_dictionary": self.data["hdx_data_dictionary"],
+            },
+            "id",
+        )
+        if not update_datastore or not self.has_datastore():
+            return
+        columns = {column["field"]: column for column in merged}
+        fields = []
+        for field in self.get_datastore_fields():
+            info = dict(field.get("info") or {})
+            column = columns.pop(field["id"], None)
+            if column:
+                info["label"] = column["label"]
+                info["notes"] = column["description"]
+            fields.append({"id": field["id"], "type": field["type"], "info": info})
+        if columns:
+            logger.warning(
+                f"Data dictionary fields {', '.join(columns)} not in datastore for resource {self.data['id']}!"
+            )
+        self._write_to_hdx(
+            "datastore_create",
+            {"resource_id": self.data["id"], "force": True, "fields": fields},
+            "resource_id",
+        )
+
     def clean_format(self) -> str:
         """Clean the resource's format, setting it to None if it is invalid and
         cannot be mapped
@@ -683,6 +748,30 @@ class Resource(HDXObject):
             logger.debug(result)
         return resources
 
+    def _download_file(
+        self,
+        url: str,
+        folder: Path | str | None,
+        filename: str,
+        retriever: Retrieve | None,
+    ) -> Path:
+        """Helper method to download a file from HDX
+
+        Args:
+            url: URL to download
+            folder: Folder to download file to. None means temporary folder.
+            filename: Filename to use
+            retriever: Retrieve object to use. None means do not use one.
+
+        Returns:
+            Path to downloaded file
+        """
+        session = hdx.api.utilities.url_utils.get_ckan_ready_session(self.configuration)
+        with Download(session=session) as downloader:
+            if retriever:
+                downloader = retriever.clone(downloader)
+            return downloader.download_file(url, folder=folder, filename=filename)
+
     def download(
         self, folder: Path | str | None = None, retriever: Retrieve | None = None
     ) -> tuple[str, Path]:
@@ -706,12 +795,7 @@ class Resource(HDXObject):
         file_format = f".{self.get_format()}"
         if not filename.endswith(file_format):
             filename = f"{filename}{file_format}"
-        session = hdx.api.utilities.url_utils.get_ckan_ready_session(self.configuration)
-        with Download(session=session) as downloader:
-            if retriever:
-                downloader = retriever.clone(downloader)
-            path = downloader.download_file(url, folder=folder, filename=filename)
-            return url, path
+        return url, self._download_file(url, folder, filename, retriever)
 
     def get_datastore_dump_url(self, file_format: str = "csv") -> str:
         """Get the URL from which the resource datastore can be downloaded in
@@ -755,19 +839,15 @@ class Resource(HDXObject):
         Returns:
             (URL downloaded, Path to downloaded file)
         """
+        file_format = file_format.lower()
         url = self.get_datastore_dump_url(file_format)
         logger.debug(f"Downloading {url}")
         if filename is None:
             filename = self.data["name"]
-            extension = f".{file_format.lower()}"
+            extension = f".{file_format}"
             if not filename.endswith(extension):
                 filename = f"{filename}{extension}"
-        session = hdx.api.utilities.url_utils.get_ckan_ready_session(self.configuration)
-        with Download(session=session) as downloader:
-            if retriever:
-                downloader = retriever.clone(downloader)
-            path = downloader.download_file(url, folder=folder, filename=filename)
-            return url, path
+        return url, self._download_file(url, folder, filename, retriever)
 
     @staticmethod
     def get_all_resource_ids_in_datastore(
@@ -930,11 +1010,18 @@ class Resource(HDXObject):
             sort: Comma separated field names with optional asc/desc eg. "code desc". Defaults to None.
             distinct: Whether to return only distinct rows. Defaults to False.
             page_size: Number of rows to request per call. Defaults to 10000.
-            **kwargs: Other parameters to pass to datastore_search eg. plain, language.
+            **kwargs: Other parameters to pass to datastore_search eg. plain, language. records_format csv and tsv are not supported.
 
         Returns:
             Iterator of record dictionaries
         """
+        if page_size < 1:
+            raise HDXError("page_size must be at least 1!")
+        records_format = kwargs.get("records_format")
+        if records_format in ("csv", "tsv"):
+            raise HDXError(
+                f"records_format {records_format} is not supported! Use search_datastore instead."
+            )
         offset = 0
         while True:
             result = self.search_datastore(
@@ -950,9 +1037,11 @@ class Resource(HDXObject):
             )
             records = result["records"]
             yield from records
-            if len(records) < page_size:
+            # HDX caps limit at its maximum rows per call and returns the limit applied
+            limit = result["limit"]
+            if len(records) < limit:
                 return
-            offset += page_size
+            offset += limit
 
     def get_datastore_fields(self) -> list[dict]:
         """Get the field definitions of the resource datastore excluding the
@@ -971,7 +1060,8 @@ class Resource(HDXObject):
     ) -> list[dict]:
         """Run a read-only SQL query against the HDX datastore using CKAN
         datastore_search_sql. Tables are named by resource id, which must be
-        double quoted eg. SELECT * FROM "RESOURCE_ID".
+        double quoted eg. SELECT * FROM "RESOURCE_ID". Logs a warning if HDX
+        truncates the results.
 
         Args:
             sql: SQL SELECT statement
@@ -982,7 +1072,12 @@ class Resource(HDXObject):
         """
         resource = Resource(configuration=configuration)
         result = resource._write_to_hdx("datastore_search_sql", {"sql": sql})
-        return result["records"]
+        records = result["records"]
+        if result.get("records_truncated"):
+            logger.warning(
+                f"SQL query results truncated by HDX to {len(records)} rows!"
+            )
+        return records
 
     def delete_datastore(self) -> None:
         """Delete a resource from the HDX datastore
@@ -1000,6 +1095,41 @@ class Resource(HDXObject):
         if not success:
             logger.debug(result)
 
+    def submit_to_datapusher(self, ignore_hash: bool = False) -> bool:
+        """Submit the resource to DataPusher+ to load its file into the
+        datastore. This does not change last_modified. Unlike the automatic
+        submission on file upload, HDX's datastore allowlist and format checks
+        are not applied.
+
+        Args:
+            ignore_hash: Reload even if the file hash is unchanged. Defaults to False.
+
+        Returns:
+            True if submitted, False if not (eg. a job is already pending)
+        """
+        return self._write_to_hdx(
+            "datapusher_submit",
+            {"resource_id": self.data["id"], "ignore_hash": ignore_hash},
+            "resource_id",
+        )
+
+    def get_datapusher_status(self) -> dict | None:
+        """Get the status of the resource's latest DataPusher+ job
+
+        Returns:
+            Status dictionary with keys including status and error or None if no job
+        """
+        success, result = self._read_from_hdx(
+            "datapusher",
+            self.data["id"],
+            "resource_id",
+            self.actions()["datapusher_status"],
+        )
+        if success:
+            return result
+        logger.debug(result)
+        return None
+
     def get_resource_views(self) -> list[ResourceView]:
         """Get any resource views in the resource
 
@@ -1159,6 +1289,21 @@ class Resource(HDXObject):
         else:
             logger.debug(result)
 
+    def get_fs_check_info(self) -> list[dict]:
+        """Get file structure check information for the resource from its
+        fs_check_info field. Each check event can have keys such as state,
+        timestamp, sheet_changes and hxl_proxy_response.
+
+        Returns:
+            List of file structure check events
+        """
+        fs_check_info = self.data.get("fs_check_info")
+        if not fs_check_info:
+            return []
+        if isinstance(fs_check_info, str):
+            return json.loads(fs_check_info)
+        return fs_check_info
+
     def is_marked_data_updated(self) -> bool:
         """Return if the resource's data is marked to be updated
 

hdx/data/user.py

@@ -7,6 +7,7 @@ from typing import Any, Optional
 
 import hdx.data.organization
 from hdx.api.configuration import Configuration
+from hdx.data.activity import Activity
 from hdx.data.hdxobject import HDXError, HDXObject
 
 logger = logging.getLogger(__name__)
@@ -44,6 +45,7 @@ class User(HDXObject):
             "list": "user_list",
             "listorgs": "organization_list_for_user",
             "token_list": "api_token_list",
+            "token_info": "hdx_token_info",
             "autocomplete": "user_autocomplete",
         }
 
@@ -333,7 +335,7 @@ class User(HDXObject):
         Returns:
             List of organization dicts in HDX that logged in user is a member of
         """
-        user = User(configuration=configuration)
+        user = cls(configuration=configuration)
         try:
             return user.configuration.call_remoteckan(
                 cls.actions()["listorgs"], {"permission": permission}
@@ -453,6 +455,42 @@ class User(HDXObject):
             return result
         return []
 
+    def get_activities(self, all_pages: bool = False, **kwargs: Any) -> list[Activity]:
+        """Get the activity stream of this user. One page of results (whose size
+        is given by limit) is returned unless all_pages is True. HDX requires
+        authorisation to view the user's profile.
+
+        Args:
+            all_pages: Whether to get all pages of results. Defaults to False.
+            **kwargs: See below
+            offset (int): Where to start getting activity items from. Defaults to 0.
+            limit (int): Maximum number of activities per page. Defaults to 31 (HDX maximum 100) or 100 if all_pages is True.
+            after (int | str): Only activities after this timestamp
+            before (int | str): Only activities before this timestamp
+
+        Returns:
+            List of Activity objects
+        """
+        return self._get_activities("user", all_pages, **kwargs)
+
+    @classmethod
+    def get_current_token_info(cls, configuration: Configuration | None = None) -> dict:
+        """Get information about the API token in the configuration: the md5
+        hash of the token owner's email (email_hash) and the token name
+        (token_name).
+
+        Args:
+            configuration: HDX configuration. Defaults to global configuration.
+
+        Returns:
+            Dictionary with keys email_hash and token_name
+        """
+        user = cls(configuration=configuration)
+        try:
+            return user.configuration.call_remoteckan(cls.actions()["token_info"], {})
+        except Exception as e:
+            raise HDXError("Failed when trying to get API token info!") from e
+
     @classmethod
     def autocomplete(
         cls,

{hdx_python_api-6.7.1.dist-info → hdx_python_api-6.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hdx-python-api
-Version: 6.7.1
+Version: 6.7.3
 Summary: HDX Python API for interacting with the Humanitarian Data Exchange
 Project-URL: Homepage, https://github.com/OCHA-DAP/hdx-python-api
 Author: Michael Rans

{hdx_python_api-6.7.1.dist-info → hdx_python_api-6.7.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hdx/api/__init__.py,sha256=11ozJKiUsqDCZ3_mcAHhGYUyGK_Unl54djVSBBExFB4,59
-hdx/api/_version.py,sha256=7uXJAam46P0GVJ-CiBxd6tVnUUkt-epJdnvQ6m2fpb4,520
+hdx/api/_version.py,sha256=O7pvZmvSWCf7hJuRAdEJClOMPVWnCFeffbn1fVR7KII,520
 hdx/api/configuration.py,sha256=9WvuVI-3th2Dv70_t_4VoyrlJwB_9qUSN5_zUKbp4sQ,23805
 hdx/api/hdx_base_configuration.yaml,sha256=jj2t5b7NnI499rHVwOjj3Q5BAjE8i7NDGVKnWZ5P5-4,2222
 hdx/api/locations.py,sha256=bFl_cKz_AEQzkE_xWOkrRlUQ0GT2LMPSk-G_LsbV-Ns,4099
@@ -9,23 +9,25 @@ hdx/api/utilities/date_helper.py,sha256=sXxjRtXz-2rpBVZBbJAk80gfjpYKl_AtHplWr-rn
 hdx/api/utilities/filestore_helper.py,sha256=0FcUpGHpYlAzlNDpDxdXbSqV6VHFfGCLakCmK37hieU,6917
 hdx/api/utilities/hdx_error_handler.py,sha256=x1rb2qBO0C6CJjqToSFj_XB1F3pf3nHpA8otxXfTFzA,8711
 hdx/api/utilities/hdx_state.py,sha256=KzrK0A-H5R6cRPqwF4d23_S_zfIa1ow4K5u46FesGmY,2442
+hdx/api/utilities/hdx_stats.py,sha256=Vc3CesIbROeumOmSyVItmUaGjFv0MF4r4mlKbpI0rxo,1474
 hdx/api/utilities/url_utils.py,sha256=Pb4r-BAqIHYmeoB_i7QjutDp6nOAUh_OHvCtiNLda3Y,4534
 hdx/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hdx/data/dataset.py,sha256=0gS7tQSswTgG0g8YeXg0FL8pFVkocBQSRPFpQAurN00,99455
-hdx/data/hdxobject.py,sha256=_jlwYjb_CcjaXsTXObknMfq-OiNOcpJfLJ9b1vKV1Zo,27494
-hdx/data/location.py,sha256=WIQRdY1boy6xPweIWRczWNiJLFrp4w0DVUwppHeNccU,8765
-hdx/data/organization.py,sha256=HGopFsCYOWrR7sUtZzZSXq6wLFw4djus2gzg6yNXOqc,12296
-hdx/data/resource.py,sha256=iVARfA3_8gGsGjXgNxomm7umAadvxzFsGGqxTpBB3WQ,45196
+hdx/data/activity.py,sha256=YNa7hAgsMP96EIUX7UMInxAXnJ8TynE1KpecRrv8Vso,9200
+hdx/data/dataset.py,sha256=BdNPybJklyhI_IeyY0QGrohau6yTEv-jeFVFLjs5CeQ,101301
+hdx/data/hdxobject.py,sha256=EG5KkVpi-yF6m6HVF79EqDneq1W7mo5M-bPJHG79T0I,28383
+hdx/data/location.py,sha256=CvDGfzQnPIB0aT7WOc60zhnAfvDFMJFcrbfacOsYR-U,9598
+hdx/data/organization.py,sha256=IRen2F2NsXLC8r-PVTS9eQp7LTn_44OcDUa1S7SCKiQ,13140
+hdx/data/resource.py,sha256=KuO9UB6OP7G2rcKcwTCjdfseQpcub-aK6LscXtI8IM8,50909
 hdx/data/resource_matcher.py,sha256=Yzk9pWa4zk1p09m6zcZMj0XZf5Y16Pa3KToOdUt7rP8,4247
 hdx/data/resource_view.py,sha256=GcYkh0iDAe6_m2ErY_A6i3Z7ZFX949eGt1TLnLZv_8s,7346
 hdx/data/showcase.py,sha256=vnRZ45xd9Ct65eFQkWZtMIJPFifZfKOrH4obO5D5Pvc,14062
-hdx/data/user.py,sha256=STWtZtFHMyXPjLyEioK4rV5Cj2eH88uZJG8gIH8NdqM,15613
+hdx/data/user.py,sha256=NXBuvUu-pNVSEelL59wdNQgeWmDgeWke_6JxViww3Cc,17320
 hdx/data/vocabulary.py,sha256=sDDVh9ivCbZlPKXIdOoj0ltTdRufL0ypfGZUirIb2IA,20776
 hdx/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hdx/facades/infer_arguments.py,sha256=DvyDuozfOPmoaV7HjhQySojGIrMWW9nos31auQBVVl8,4032
 hdx/facades/keyword_arguments.py,sha256=aVapHCfqBO6H7xxBgTdK9ISdgrBFsNypPDWihfQ3edU,1125
 hdx/facades/simple.py,sha256=QWsBkaHG_UM6X3Zu2u3LWVOQzeR24q-EUClrfsL_mkM,1064
-hdx_python_api-6.7.1.dist-info/METADATA,sha256=7SaqX2zZKJ828e94hbPjvjJ_3q5obaL0NU9Ghut_86A,4946
-hdx_python_api-6.7.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-hdx_python_api-6.7.1.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
-hdx_python_api-6.7.1.dist-info/RECORD,,
+hdx_python_api-6.7.3.dist-info/METADATA,sha256=UI9iCTmytO8zgeetqK5dfGaRHW3d4qzu0ex1r8WE8c0,4946
+hdx_python_api-6.7.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hdx_python_api-6.7.3.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
+hdx_python_api-6.7.3.dist-info/RECORD,,