hdx-python-api 6.7.2__py3-none-any.whl → 6.7.4__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.2'
-__version_tuple__ = version_tuple = (6, 7, 2)
+__version__ = version = '6.7.4'
+__version_tuple__ = version_tuple = (6, 7, 4)
 
 __commit_id__ = commit_id = None

hdx/api/utilities/hdx_stats.py

@@ -0,0 +1,86 @@
+"""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, data: dict | None = None
+) -> dict:
+    """Call an HDX statistics action
+
+    Args:
+        action: CKAN action name
+        configuration: HDX configuration. Defaults to global configuration.
+        data: Parameters to pass to the action. Defaults to None.
+
+    Returns:
+        Statistics dictionary
+    """
+    if configuration is None:
+        configuration = Configuration.read()
+    try:
+        return configuration.call_remoteckan(action, data or {})
+    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)
+
+
+def get_user_statistics(
+    start_date: str | None = None,
+    end_date: str | None = None,
+    configuration: Configuration | None = None,
+) -> dict:
+    """Get the number of activities of each active user on HDX, optionally
+    between start and end dates. Requires sysadmin.
+
+    Args:
+        start_date: Count activities on or after this date eg. 2026-01-01. Defaults to None.
+        end_date: Count activities on or before this date. Defaults to None.
+        configuration: HDX configuration. Defaults to global configuration.
+
+    Returns:
+        Dictionary from user id to dictionary with keys id, name and no_of_activities
+    """
+    data = {}
+    if start_date:
+        data["start_date"] = start_date
+    if end_date:
+        data["end_date"] = end_date
+    return _call_stats_action("hdx_user_statistics", configuration, data)
+
+
+def get_organization_statistics(configuration: Configuration | None = None) -> dict:
+    """Get active and inactive organizations on HDX. Requires sysadmin.
+
+    Args:
+        configuration: HDX configuration. Defaults to global configuration.
+
+    Returns:
+        Dictionary with keys active_organizations and inactive_organizations
+    """
+    return _call_stats_action("hdx_organization_statistics", configuration)

hdx/data/activity.py

@@ -129,7 +129,9 @@ class Activity(HDXObject):
             result = activity._write_to_hdx(action, data)
             return [cls(x, configuration=configuration) for x in result]
         data = dict(data)
-        limit = data.setdefault("limit", 100)
+        # 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:

hdx/data/dataset.py

@@ -147,6 +147,14 @@ class Dataset(HDXObject):
             "list": "package_list",
             "autocomplete": "package_autocomplete",
             "create_default_views": "package_create_default_resource_views",
+            "fs_check_info": "fs_check_info_show",
+            "fs_check_reset": "hdx_fs_check_package_reset",
+            "shape_info": "shape_info_show",
+            "recommend_tags": "hdx_recommend_tags",
+            "allowed_for_datastore": "hdx_is_package_allowed_for_datastore",
+            "push_to_datastore": "hdx_push_resource_to_datastore",
+            "qa_completed": "hdx_mark_qa_completed",
+            "qa_revise_resources": "hdx_qa_package_revise_resource",
         }
 
     def __setitem__(self, key: Any, value: Any) -> None:
@@ -1447,13 +1455,7 @@ class Dataset(HDXObject):
         Returns:
             List of Activity objects
         """
-        return Activity.get_activities(
-            "package",
-            self.data.get("id") or self.data.get("name"),
-            self.configuration,
-            all_pages,
-            **kwargs,
-        )
+        return self._get_activities("package", all_pages, **kwargs)
 
     @classmethod
     def autocomplete(
@@ -2333,6 +2335,155 @@ 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 _set_from_package(self, package: dict) -> None:
+        """Set the dataset's metadata and resources from a package metadata
+        dictionary returned by HDX
+
+        Args:
+            package: Package metadata dictionary
+
+        Returns:
+            None
+        """
+        self.data = package
+        self.init_resources()
+        self.separate_resources()
+
+    def reset_fs_check(self, key: str = "fs_check_info") -> None:
+        """Clear a file structure check field of all the dataset's resources
+        in HDX. Requires sysadmin or permission to manage QA.
+
+        Args:
+            key: Resource field to clear. Defaults to fs_check_info.
+
+        Returns:
+            None
+        """
+        result = self._write_to_hdx(
+            "fs_check_reset", {"package_id": self.data["id"], "key": key}, "package_id"
+        )
+        self._set_from_package(result["package"])
+
+    def set_qa_completed(self, qa_completed: bool) -> None:
+        """Mark QA of the dataset in HDX as completed or not. Requires
+        sysadmin or permission to manage QA.
+
+        Args:
+            qa_completed: Whether QA is completed
+
+        Returns:
+            None
+        """
+        result = self._write_to_hdx(
+            "qa_completed", {"id": self.data["id"], "qa_completed": qa_completed}, "id"
+        )
+        self._set_from_package(result["package"])
+
+    def qa_revise_resources(self, key: str, value: Any) -> None:
+        """Set a QA field of all the dataset's resources in HDX. Requires
+        sysadmin or permission to manage QA.
+
+        Args:
+            key: Resource field eg. pii
+            value: Value to set
+
+        Returns:
+            None
+        """
+        result = self._write_to_hdx(
+            "qa_revise_resources",
+            {"id": self.data["id"], "key": key, "value": value},
+            "id",
+        )
+        self._set_from_package(result["package"])
+
+    def get_shape_info(self) -> list[dict]:
+        """Get geopreview shape information for the dataset's resources from
+        HDX
+
+        Returns:
+            List of dictionaries from resource name to shape information
+        """
+        success, result = self._read_from_hdx(
+            "dataset",
+            self.get_name_or_id(prefer_name=False),
+            "id",
+            self.actions()["shape_info"],
+        )
+        if success:
+            return result
+        return []
+
+    def get_recommended_tags(self) -> list[str]:
+        """Get tags recommended by HDX for the dataset based on its title and
+        organization. Tags are ordered from most to least recommended.
+
+        Returns:
+            List of recommended tags
+        """
+        data = {"title": self.data.get("title")}
+        organization = self.data.get("owner_org")
+        if organization:
+            data["organization"] = organization
+        try:
+            result = self.configuration.call_remoteckan(
+                self.actions()["recommend_tags"], data
+            )
+        except Exception as e:
+            raise HDXError("Failed when trying to get recommended tags!") from e
+        return [tag["name"] for tag in result]
+
+    def is_allowed_for_datastore(self) -> bool:
+        """Return if the dataset or its organization is in HDX's allowlist for
+        automatic loading of resources into the datastore
+
+        Returns:
+            Whether dataset is allowed for datastore
+        """
+        success, result = self._read_from_hdx(
+            "dataset",
+            self.data["id"],
+            "package_id",
+            self.actions()["allowed_for_datastore"],
+        )
+        if success:
+            return result
+        logger.debug(result)
+        return False
+
+    def push_to_datastore(self) -> bool:
+        """Submit all the dataset's CSV resources to DataPusher+ using HDX's
+        wrapper action. Requires sysadmin.
+
+        Returns:
+            True if submitted, False if not (eg. no CSV resources)
+        """
+        result = self._write_to_hdx(
+            "push_to_datastore", {"dataset_id": self.data["id"]}, "dataset_id"
+        )
+        if not result["success"]:
+            logger.debug(result["message"])
+        return result["success"]
+
     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

@@ -43,6 +43,8 @@ class Location(HDXObject):
             "delete": "group_delete",
             "list": "group_list",
             "autocomplete": "group_autocomplete",
+            "data_grid": "hdx_datagrid_show",
+            "invalidate_data_grid": "invalidate_data_completeness_for_location",
         }
 
     @classmethod
@@ -218,6 +220,47 @@ class Location(HDXObject):
             if len(group["name"]) == 3 and group.get("data_completeness") == "active"
         )
 
+    @staticmethod
+    def get_data_grid(
+        iso3: str, configuration: Configuration | None = None
+    ) -> dict | None:
+        """Get the Data Grid of a country. The dictionary has keys including
+        title, date, stats and categories. Each category has subcategories,
+        each with a list of datasets. Complementary datasets have
+        is_complementary set to True. Requires sysadmin.
+
+        Args:
+            iso3: Country ISO 3-letter code
+            configuration: HDX configuration. Defaults to global configuration.
+
+        Returns:
+            Data Grid dictionary or None if not found
+        """
+        location = Location(configuration=configuration)
+        success, result = location._read_from_hdx(
+            "location", iso3.lower(), "id", location.actions()["data_grid"]
+        )
+        if success:
+            return result
+        logger.debug(result)
+        return None
+
+    @staticmethod
+    def invalidate_data_grid(
+        iso3: str, configuration: Configuration | None = None
+    ) -> None:
+        """Clear HDX's cached Data Grid of a country. Requires sysadmin.
+
+        Args:
+            iso3: Country ISO 3-letter code
+            configuration: HDX configuration. Defaults to global configuration.
+
+        Returns:
+            None
+        """
+        location = Location(configuration=configuration)
+        location._write_to_hdx("invalidate_data_grid", {"name": iso3.lower()}, "name")
+
     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.
@@ -232,13 +275,7 @@ class Location(HDXObject):
         Returns:
             List of Activity objects
         """
-        return Activity.get_activities(
-            "group",
-            self.data.get("id") or self.data.get("name"),
-            self.configuration,
-            all_pages,
-            **kwargs,
-        )
+        return self._get_activities("group", all_pages, **kwargs)
 
     @classmethod
     def autocomplete(

hdx/data/organization.py

@@ -326,13 +326,7 @@ class Organization(HDXObject):
         Returns:
             List of Activity objects
         """
-        return Activity.get_activities(
-            "organization",
-            self.data.get("id") or self.data.get("name"),
-            self.configuration,
-            all_pages,
-            **kwargs,
-        )
+        return self._get_activities("organization", all_pages, **kwargs)
 
     @classmethod
     def autocomplete(

hdx/data/resource.py

@@ -72,6 +72,15 @@ 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",
+            "push_to_datastore": "hdx_push_resource_to_datastore",
+            "p_coded": "hdx_p_coded_resource_update",
+            "in_hapi": "hdx_mark_resource_in_hapi",
+            "in_quarantine": "hdx_mark_resource_in_quarantine",
+            "qa_patch": "hdx_qa_resource_patch",
+            "fs_check_revise": "hdx_fs_check_resource_revise",
+            "fs_check_reset": "hdx_fs_check_resource_reset",
         }
 
     def update_from_yaml(
@@ -319,6 +328,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 +755,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 +802,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 +846,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 +1017,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 +1044,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 +1067,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 +1079,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 +1102,55 @@ 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 push_to_datastore(self) -> bool:
+        """Submit the resource to DataPusher+ using HDX's wrapper action.
+        Unlike submit_to_datapusher, this requires sysadmin.
+
+        Returns:
+            True if submitted, False if not
+        """
+        result = self._write_to_hdx(
+            "push_to_datastore", {"resource_id": self.data["id"]}, "resource_id"
+        )
+        if not result["success"]:
+            logger.debug(result["message"])
+        return result["success"]
+
+    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 +1310,174 @@ 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 _set_from_package(self, package: dict) -> None:
+        """Set the resource's metadata from the matching resource in a package
+        metadata dictionary returned by HDX
+
+        Args:
+            package: Package metadata dictionary
+
+        Returns:
+            None
+        """
+        for resource in package.get("resources", []):
+            if resource["id"] == self.data["id"]:
+                self.data = resource
+                return
+
+    def revise_fs_check(self, key: str, value: Any) -> None:
+        """Set a file structure check field of the resource in HDX. If key is
+        fs_check_info and value is a dictionary, it is appended to the
+        existing check events (the last 20 are kept) rather than replacing
+        them. Requires sysadmin or permission to manage QA.
+
+        Args:
+            key: Resource field eg. fs_check_info
+            value: Value to set
+
+        Returns:
+            None
+        """
+        result = self._write_to_hdx(
+            "fs_check_revise",
+            {
+                "package_id": self.data["package_id"],
+                "id": self.data["id"],
+                "key": key,
+                "value": value,
+            },
+            "id",
+        )
+        self._set_from_package(result["package"])
+
+    def reset_fs_check(self, key: str = "fs_check_info") -> None:
+        """Clear a file structure check field of the resource in HDX. Requires
+        sysadmin or permission to manage QA.
+
+        Args:
+            key: Resource field to clear. Defaults to fs_check_info.
+
+        Returns:
+            None
+        """
+        result = self._write_to_hdx(
+            "fs_check_reset",
+            {"package_id": self.data["package_id"], "id": self.data["id"], "key": key},
+            "id",
+        )
+        self._set_from_package(result["package"])
+
+    def is_p_coded(self) -> bool | None:
+        """Return if the resource is marked as containing p-codes
+
+        Returns:
+            Whether resource is p-coded or None if not set
+        """
+        p_coded = self.data.get("p_coded")
+        if p_coded is None:
+            return None
+        if isinstance(p_coded, str):
+            return p_coded.lower() == "true"
+        return p_coded
+
+    def set_p_coded(self, p_coded: bool) -> None:
+        """Mark the resource in HDX as containing p-codes or not. Requires
+        sysadmin or permission to manage p-codes.
+
+        Args:
+            p_coded: Whether resource is p-coded
+
+        Returns:
+            None
+        """
+        self.data = self._write_to_hdx(
+            "p_coded", {"id": self.data["id"], "p_coded": p_coded}, "id"
+        )
+
+    def is_in_hapi(self) -> bool:
+        """Return if the resource is marked as being in HAPI
+
+        Returns:
+            Whether resource is in HAPI
+        """
+        return self.data.get("in_hapi") == "yes"
+
+    def set_in_hapi(self, in_hapi: bool) -> None:
+        """Mark the resource in HDX as being in HAPI or not. Requires sysadmin
+        or permission to manage the in HAPI flag.
+
+        Args:
+            in_hapi: Whether resource is in HAPI
+
+        Returns:
+            None
+        """
+        self.data = self._write_to_hdx(
+            "in_hapi",
+            {"id": self.data["id"], "in_hapi": "yes" if in_hapi else "no-data"},
+            "id",
+        )
+
+    def is_in_quarantine(self) -> bool:
+        """Return if the resource is in quarantine
+
+        Returns:
+            Whether resource is in quarantine
+        """
+        in_quarantine = self.data.get("in_quarantine", False)
+        if isinstance(in_quarantine, str):
+            return in_quarantine.lower() == "true"
+        return in_quarantine
+
+    def set_in_quarantine(self, in_quarantine: bool) -> None:
+        """Put the resource in HDX in quarantine or take it out. Quarantining
+        also removes the resource's shape_info and geopreview. Requires
+        sysadmin or permission to manage QA.
+
+        Args:
+            in_quarantine: Whether resource is in quarantine
+
+        Returns:
+            None
+        """
+        self.data = self._write_to_hdx(
+            "in_quarantine",
+            {
+                "id": self.data["id"],
+                "in_quarantine": "true" if in_quarantine else "false",
+            },
+            "id",
+        )
+
+    def qa_patch(self, **kwargs: Any) -> None:
+        """Patch QA fields of the resource in HDX eg. pii, sdc_report_flag,
+        broken_link. Requires sysadmin or permission to manage QA.
+
+        Args:
+            **kwargs: Resource fields to patch
+
+        Returns:
+            None
+        """
+        self.data = self._write_to_hdx(
+            "qa_patch", {"id": self.data["id"], **kwargs}, "id"
+        )
+
     def is_marked_data_updated(self) -> bool:
         """Return if the resource's data is marked to be updated
 

hdx/data/user.py

@@ -45,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",
         }
 
@@ -334,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}
@@ -470,13 +471,25 @@ class User(HDXObject):
         Returns:
             List of Activity objects
         """
-        return Activity.get_activities(
-            "user",
-            self.data.get("id") or self.data.get("name"),
-            self.configuration,
-            all_pages,
-            **kwargs,
-        )
+        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(

{hdx_python_api-6.7.2.dist-info → hdx_python_api-6.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hdx-python-api
-Version: 6.7.2
+Version: 6.7.4
 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.2.dist-info → hdx_python_api-6.7.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hdx/api/__init__.py,sha256=11ozJKiUsqDCZ3_mcAHhGYUyGK_Unl54djVSBBExFB4,59
-hdx/api/_version.py,sha256=CgL0y60DiHh1gIc1CUZuiYkj-TMX2gdAy0attQGD48w,520
+hdx/api/_version.py,sha256=Dbk4PNxS0tMC6IYkWs454Z4ZwWohuENXxYAfScTC2M8,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,24 +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=JlEcF9LN-OjcVeh6C0te-nAlcO7W-JIpD5JJWTiWxs0,2847
 hdx/api/utilities/url_utils.py,sha256=Pb4r-BAqIHYmeoB_i7QjutDp6nOAUh_OHvCtiNLda3Y,4534
 hdx/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hdx/data/activity.py,sha256=vBnkaL7QVaa05Y1dzZ484dzqgaijb8dTCe60cERlAJQ,9101
-hdx/data/dataset.py,sha256=cPccjApN5td3DDW9r2PrmLM30ThzKNwf3hwlb60OxzU,100697
-hdx/data/hdxobject.py,sha256=_jlwYjb_CcjaXsTXObknMfq-OiNOcpJfLJ9b1vKV1Zo,27494
-hdx/data/location.py,sha256=HonWohDZOHSvlwoiv4vc5-9BzZ2iIG8FIos1C1Q814w,9738
-hdx/data/organization.py,sha256=JVxyrbobBDcAREKJzSq5Rc7uUfkH-tzLj1jwQDyMnBs,13280
-hdx/data/resource.py,sha256=iVARfA3_8gGsGjXgNxomm7umAadvxzFsGGqxTpBB3WQ,45196
+hdx/data/activity.py,sha256=YNa7hAgsMP96EIUX7UMInxAXnJ8TynE1KpecRrv8Vso,9200
+hdx/data/dataset.py,sha256=-GQO08PK8u19O0qRWttg3AuPskPCwjffcE2mPq-7dQE,105903
+hdx/data/hdxobject.py,sha256=EG5KkVpi-yF6m6HVF79EqDneq1W7mo5M-bPJHG79T0I,28383
+hdx/data/location.py,sha256=UJPGKc8euAYFJsUFkdQtViLUwqNWYOWwaLELApAMHk4,11168
+hdx/data/organization.py,sha256=IRen2F2NsXLC8r-PVTS9eQp7LTn_44OcDUa1S7SCKiQ,13140
+hdx/data/resource.py,sha256=QDQJp7XoCDn9DmyWPgA2YCn8Z4HGwezEkFyae_YlFKI,56507
 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=rHyFPzGR_u_LmXvgMQ6uqKkYFIW3uG89-M6nnG3pkkU,16697
+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.2.dist-info/METADATA,sha256=lv8ylKpAePSbZ6KMPwYlnHeNlOnfI4FrRA_30YKUilM,4946
-hdx_python_api-6.7.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-hdx_python_api-6.7.2.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
-hdx_python_api-6.7.2.dist-info/RECORD,,
+hdx_python_api-6.7.4.dist-info/METADATA,sha256=k7b1Nasb2yiwkyq-LG1-aBgVTy-D6aaAwjOaooTOS2Q,4946
+hdx_python_api-6.7.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hdx_python_api-6.7.4.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
+hdx_python_api-6.7.4.dist-info/RECORD,,