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

hdx/data/activity.py

@@ -0,0 +1,245 @@
+"""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)
+        limit = data.setdefault("limit", 100)
+        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
 
@@ -1428,6 +1429,32 @@ 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 Activity.get_activities(
+            "package",
+            self.data.get("id") or self.data.get("name"),
+            self.configuration,
+            all_pages,
+            **kwargs,
+        )
+
     @classmethod
     def autocomplete(
         cls,

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,28 @@ 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 Activity.get_activities(
+            "group",
+            self.data.get("id") or self.data.get("name"),
+            self.configuration,
+            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,28 @@ 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 Activity.get_activities(
+            "organization",
+            self.data.get("id") or self.data.get("name"),
+            self.configuration,
+            all_pages,
+            **kwargs,
+        )
+
     @classmethod
     def autocomplete(
         cls,

hdx/data/resource.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from collections.abc import Sequence
+from collections.abc import Iterator, Sequence
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Optional
@@ -34,6 +34,7 @@ class Resource(HDXObject):
     """
 
     _formats_dict = None
+    _valid_datastore_dump_formats = frozenset({"csv", "tsv", "json", "xml"})
     _valid_data_dictionary_types = frozenset(
         {"text", "numeric", "date", "timestamp without time zone"}
     )
@@ -70,6 +71,7 @@ class Resource(HDXObject):
             "datastore_insert": "datastore_insert",
             "datastore_upsert": "datastore_upsert",
             "datastore_search": "datastore_search",
+            "datastore_search_sql": "datastore_search_sql",
         }
 
     def update_from_yaml(
@@ -711,6 +713,62 @@ class Resource(HDXObject):
             path = downloader.download_file(url, folder=folder, filename=filename)
             return url, path
 
+    def get_datastore_dump_url(self, file_format: str = "csv") -> str:
+        """Get the URL from which the resource datastore can be downloaded in
+        full.
+
+        Args:
+            file_format: Dump format (csv, tsv, json or xml). Defaults to csv.
+
+        Returns:
+            Datastore dump URL
+        """
+        file_format = file_format.lower()
+        if file_format not in self._valid_datastore_dump_formats:
+            valid_formats = ", ".join(sorted(self._valid_datastore_dump_formats))
+            raise HDXError(
+                f"Invalid datastore dump format '{file_format}'! Must be one of: {valid_formats}"
+            )
+        url = (
+            f"{self.configuration.get_hdx_site_url()}/datastore/dump/{self.data['id']}"
+        )
+        if file_format != "csv":
+            url = f"{url}?format={file_format}"
+        return url
+
+    def download_datastore(
+        self,
+        folder: Path | str | None = None,
+        filename: str | None = None,
+        file_format: str = "csv",
+        retriever: Retrieve | None = None,
+    ) -> tuple[str, Path]:
+        """Download the resource datastore in full to provided folder or
+        temporary folder if no folder supplied
+
+        Args:
+            folder: Folder to download datastore to. Defaults to None.
+            filename: Filename to use. Defaults to None (resource name with file_format extension).
+            file_format: Dump format (csv, tsv, json or xml). Defaults to csv.
+            retriever: Retrieve object to use. Defaults to None.
+
+        Returns:
+            (URL downloaded, Path to downloaded file)
+        """
+        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()}"
+            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
+
     @staticmethod
     def get_all_resource_ids_in_datastore(
         configuration: Configuration | None = None,
@@ -805,6 +863,127 @@ class Resource(HDXObject):
         }
         self._write_to_hdx("datastore_upsert", data, "resource_id")
 
+    def search_datastore(
+        self,
+        filters: dict | None = None,
+        q: str | dict | None = None,
+        fields: Sequence[str] | None = None,
+        sort: str | None = None,
+        distinct: bool = False,
+        limit: int = 100,
+        offset: int = 0,
+        include_total: bool = True,
+        **kwargs: Any,
+    ) -> dict:
+        """Search the resource datastore using CKAN datastore_search.
+
+        Args:
+            filters: Dictionary of field name to value(s) to match. Defaults to None.
+            q: Full text query string or dictionary of field name to query. Defaults to None.
+            fields: Fields to return. Defaults to None (all fields).
+            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.
+            limit: Maximum number of rows to return. Defaults to 100.
+            offset: Number of rows to skip. Defaults to 0.
+            include_total: Whether to include total number of matching rows. Defaults to True.
+            **kwargs: Other parameters to pass to datastore_search eg. plain, language.
+
+        Returns:
+            datastore_search result dictionary with keys including records, fields and total
+        """
+        data: dict = {
+            "resource_id": self.data["id"],
+            "limit": limit,
+            "offset": offset,
+            "include_total": include_total,
+        }
+        if filters is not None:
+            data["filters"] = filters
+        if q is not None:
+            data["q"] = q
+        if fields is not None:
+            data["fields"] = ",".join(fields)
+        if sort is not None:
+            data["sort"] = sort
+        if distinct:
+            data["distinct"] = True
+        data.update(kwargs)
+        return self._write_to_hdx("datastore_search", data, "resource_id")
+
+    def get_datastore_records(
+        self,
+        filters: dict | None = None,
+        q: str | dict | None = None,
+        fields: Sequence[str] | None = None,
+        sort: str | None = None,
+        distinct: bool = False,
+        page_size: int = 10000,
+        **kwargs: Any,
+    ) -> Iterator[dict]:
+        """Iterate over all matching records in the resource datastore, paging
+        through datastore_search results.
+
+        Args:
+            filters: Dictionary of field name to value(s) to match. Defaults to None.
+            q: Full text query string or dictionary of field name to query. Defaults to None.
+            fields: Fields to return. Defaults to None (all fields).
+            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.
+
+        Returns:
+            Iterator of record dictionaries
+        """
+        offset = 0
+        while True:
+            result = self.search_datastore(
+                filters=filters,
+                q=q,
+                fields=fields,
+                sort=sort,
+                distinct=distinct,
+                limit=page_size,
+                offset=offset,
+                include_total=False,
+                **kwargs,
+            )
+            records = result["records"]
+            yield from records
+            if len(records) < page_size:
+                return
+            offset += page_size
+
+    def get_datastore_fields(self) -> list[dict]:
+        """Get the field definitions of the resource datastore excluding the
+        internal _id field.
+
+        Returns:
+            List of field dictionaries each with id and type keys
+        """
+        result = self.search_datastore(limit=0, include_total=False)
+        return [field for field in result["fields"] if field["id"] != "_id"]
+
+    @staticmethod
+    def search_datastore_sql(
+        sql: str,
+        configuration: Configuration | None = None,
+    ) -> 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".
+
+        Args:
+            sql: SQL SELECT statement
+            configuration: HDX configuration. Defaults to global configuration.
+
+        Returns:
+            List of record dictionaries
+        """
+        resource = Resource(configuration=configuration)
+        result = resource._write_to_hdx("datastore_search_sql", {"sql": sql})
+        return result["records"]
+
     def delete_datastore(self) -> None:
         """Delete a resource from the HDX datastore
 

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__)
@@ -453,6 +454,30 @@ 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 Activity.get_activities(
+            "user",
+            self.data.get("id") or self.data.get("name"),
+            self.configuration,
+            all_pages,
+            **kwargs,
+        )
+
     @classmethod
     def autocomplete(
         cls,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hdx-python-api
-Version: 6.7.0
+Version: 6.7.2
 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
@@ -28,8 +28,8 @@ Requires-Python: >=3.10
 Requires-Dist: ckanapi>=4.11
 Requires-Dist: defopt>=7.0.0
 Requires-Dist: email-validator
-Requires-Dist: hdx-python-country>=4.1.3
-Requires-Dist: hdx-python-utilities>=4.1.2
+Requires-Dist: hdx-python-country>=4.2.3
+Requires-Dist: hdx-python-utilities>=4.2.1
 Requires-Dist: makefun
 Requires-Dist: requests
 Provides-Extra: docs

{hdx_python_api-6.7.0.dist-info → hdx_python_api-6.7.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hdx/api/__init__.py,sha256=11ozJKiUsqDCZ3_mcAHhGYUyGK_Unl54djVSBBExFB4,59
-hdx/api/_version.py,sha256=ySRWjy-IYGDZdNB2wR2G-LZ8vwxqmQqgeGjL_1f7wkc,520
+hdx/api/_version.py,sha256=CgL0y60DiHh1gIc1CUZuiYkj-TMX2gdAy0attQGD48w,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
@@ -11,21 +11,22 @@ hdx/api/utilities/hdx_error_handler.py,sha256=x1rb2qBO0C6CJjqToSFj_XB1F3pf3nHpA8
 hdx/api/utilities/hdx_state.py,sha256=KzrK0A-H5R6cRPqwF4d23_S_zfIa1ow4K5u46FesGmY,2442
 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/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=WIQRdY1boy6xPweIWRczWNiJLFrp4w0DVUwppHeNccU,8765
-hdx/data/organization.py,sha256=HGopFsCYOWrR7sUtZzZSXq6wLFw4djus2gzg6yNXOqc,12296
-hdx/data/resource.py,sha256=SBAEou9Fj5sgpfoDmQ6j33W0srMMmhlsj00hiTuW86Y,38097
+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/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=rHyFPzGR_u_LmXvgMQ6uqKkYFIW3uG89-M6nnG3pkkU,16697
 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.0.dist-info/METADATA,sha256=RYuk0RvwKnxNcRzipF3cYH0_Vk-16d0XRt7lbt8x6yo,4946
-hdx_python_api-6.7.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-hdx_python_api-6.7.0.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
-hdx_python_api-6.7.0.dist-info/RECORD,,
+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.0.dist-info → hdx_python_api-6.7.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any