hdx-python-api 6.7.1__tar.gz → 6.7.3__tar.gz

{hdx_python_api-6.7.1 → hdx_python_api-6.7.3}/PKG-INFO

@@ -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 → hdx_python_api-6.7.3}/documentation/index.md

@@ -35,6 +35,8 @@ upload your datasets to HDX.
     -   [Organization Management](#organization-management)
     -   [Location Management](#location-management)
     -   [Vocabulary Management](#vocabulary-management)
+    -   [Activity Streams](#activity-streams)
+    -   [HDX Statistics](#hdx-statistics)
     -   [Pipeline State](#pipeline-state)
 -   [Working Examples](#working-examples)
 -   [Project Framework](#project-framework)
@@ -635,6 +637,16 @@ function, for example:
 
     dataset.remove_showcase(showcase)
 
+HDX runs file structure checks on resources, recording schema changes (eg.
+column names, order or types) and whether sheets have merged cells. You can get
+these checks for all of a dataset's resources from HDX:
+
+    fs_check_info = dataset.get_fs_check_info()
+
+This returns a list of dictionaries, each from a resource name to a list of
+check events with keys such as `state`, `timestamp`, `sheet_changes` and
+`hxl_proxy_response`.
+
 ### Time Period
 
 Time Period is a mandatory field in HDX. It is the earliest start date and
@@ -946,6 +958,12 @@ If the method **set_file_to_upload** is used to supply a file, the resource
 `last_modified` field is set to now automatically regardless of the value of
 `data_updated` or whether **mark_data_updated** has been called.
 
+The file structure check events of a resource (see Dataset Specific
+Operations) can be obtained from its `fs_check_info` field without a call to
+HDX:
+
+    events = resource.get_fs_check_info()
+
 ### Data Dictionary
 
 A resource can have a data dictionary describing the columns in the data it
@@ -973,11 +991,36 @@ using the getter:
 
     data_dictionary = resource.get_hdx_data_dictionary()
 
+To change the data dictionary of a resource already in HDX without sending
+dataset update notifications, use **update_hdx_data_dictionary**. It patches
+only the `hdx_data_dictionary` field (so `last_modified` is unchanged), then,
+if the resource has a datastore, updates the datastore field labels and
+descriptions without reloading the data. The given columns are merged by
+`field` into the existing data dictionary in the resource metadata, so read
+the resource from HDX first. Pass `replace=True` to replace the data
+dictionary instead and `update_datastore=False` to leave the datastore alone:
+
+    resource = Resource.read_from_hdx(RESOURCE_ID)
+    resource.update_hdx_data_dictionary([
+        {
+            "field": "col_name",
+            "label": "Column Label",
+            "description": "New description.",
+        },
+    ])
+
+Columns are matched to datastore fields by `field`. A warning is logged for
+any column with no matching datastore field.
+
 ### Datastore
 
-A resource's data can be loaded into the HDX datastore and queried. HDX
-requires an API key for all datastore actions and dumps, including reads of
-public resources. To create, update or delete the datastore for a resource:
+A resource's data can be loaded into the HDX datastore and queried. HDX calls this
+[Tabular Data Endpoints (TDE)](https://docs.humdata.org/build/hdx-apis/tabular-data-endpoints),
+and it is available only for resources with TDE enabled (their `datastore_active`
+field is true). Contact hdx@un.org to request TDE for your datasets. HDX requires an
+API key for all datastore actions and dumps, including reads of public resources,
+and limits each IP address to 60 requests per minute. To create, update or delete
+the datastore for a resource:
 
     resource.create_datastore(
         [{"id": "code", "type": "text"}, {"id": "value", "type": "numeric"}],
@@ -987,6 +1030,17 @@ public resources. To create, update or delete the datastore for a resource:
     has_datastore = resource.has_datastore()
     resource.delete_datastore()
 
+HDX loads uploaded files into the datastore using DataPusher+. To reload a
+resource's file into the datastore without uploading it again (so
+`last_modified` is unchanged), use **submit_to_datapusher**. It returns False
+if the job was not submitted, eg. because one is already pending. HDX's
+datastore allowlist and format checks, which apply to automatic submissions
+on upload, are not applied. **get_datapusher_status** returns the status of
+the latest job or None if there is none:
+
+    submitted = resource.submit_to_datapusher(ignore_hash=True)
+    status = resource.get_datapusher_status()  # eg. status["status"] == "complete"
+
 To download the whole datastore (rather than the resource's file) use
 **download_datastore**, which returns the URL and path like **download**.
 `file_format` can be `csv` (default), `tsv`, `json` or `xml`, and `filename`
@@ -1007,7 +1061,8 @@ and `include_total`, and passes any other keyword arguments to CKAN:
     records = result["records"]
 
 **get_datastore_records** takes the same query parameters but pages through
-all matching rows, yielding each record (`page_size` defaults to 10000):
+all matching rows, yielding each record (`page_size` defaults to 10000).
+`records_format` csv and tsv are not supported; use `search_datastore` for those:
 
     for record in resource.get_datastore_records(filters={"code": "A"}):
         ...
@@ -1019,7 +1074,9 @@ internal `_id` field:
 
 **search_datastore_sql** wraps CKAN's `datastore_search_sql`, running a
 SELECT statement where tables are named by double quoted resource id and
-returning the list of records:
+returning the list of records. HDX returns at most 32,000 rows per query and
+cuts off larger results, in which case a warning is logged (see
+[paging in the TDE docs](https://docs.humdata.org/build/hdx-apis/tabular-data-endpoints/troubleshooting-and-error-handling#pagination)):
 
     records = Resource.search_datastore_sql(
         'SELECT code, SUM(value) AS total FROM "RESOURCE_ID" GROUP BY code'
@@ -1066,6 +1123,11 @@ configuration):
 
     user = User.get_current_user()
 
+You can get the name of the API token in the configuration and the md5 hash
+of its owner's email:
+
+    token_info = User.get_current_token_info()  # {"email_hash": ..., "token_name": ...}
+
 You can check that the current user has a particular permission to a specific
 organization:
 
@@ -1188,6 +1250,54 @@ If you want to add a list of tags, you do it as follows:
 
     vocabulary.add_tags(["TAG","TAG","TAG"...])
 
+## Activity Streams
+
+The **Activity** class wraps CKAN activities, which record who changed what and when.
+Activities are read only. You can get the activity stream of a dataset, organization,
+location or user:
+
+    activities = dataset.get_activities(**kwargs)
+    activities = organization.get_activities(**kwargs)
+    activities = location.get_activities(**kwargs)
+    activities = user.get_activities(**kwargs)
+
+These return a list of **Activity** objects, each with fields like `timestamp`,
+`user_id`, `object_id` and `activity_type` (eg. "changed package"). One page of results
+is returned. Its size is set by `limit` (default 31, HDX maximum 100) and where it starts
+by `offset`. Passing `all_pages=True` gets every page. Other arguments (`**kwargs`) like
+`after`, `before` and `activity_types` depend on the object type and are detailed in the
+API documentation. Getting a user's activity stream requires authorisation to view the
+user's profile.
+
+You can get the activity stream of all recently added or changed datasets:
+
+    activities = Activity.get_recently_changed_packages(limit=10)
+
+With `all_pages=True`, this stream covers the whole history of HDX so it is capped by
+`max_activities` (default 1000). Pass `max_activities=None` to remove the cap.
+
+You can read a single activity, get its data (including a snapshot of the object at the
+time of the activity) or get a diff against the object's previous version. HDX requires
+permission to edit the object the activity relates to for these:
+
+    activity = Activity.read_from_hdx("ACTIVITY_ID")
+    data = activity.get_data()
+    diff = activity.get_diff(diff_type="unified")  # or "context" or "html"
+
+## HDX Statistics
+
+General statistics about datasets, organizations and users on HDX can be
+obtained as follows:
+
+    from hdx.api.utilities.hdx_stats import get_general_statistics, push_general_stats
+
+    stats = get_general_statistics()
+
+Users with permission to manage basic scheduled tasks can compute the statistics
+and push them to analytics:
+
+    pushed_stats = push_general_stats()
+
 ## Pipeline State
 
 The HDXState class allows the reading and writing of state to a given dataset. Input

{hdx_python_api-6.7.1 → hdx_python_api-6.7.3}/src/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_python_api-6.7.3/src/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_python_api-6.7.3/src/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_python_api-6.7.1 → hdx_python_api-6.7.3}/src/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_python_api-6.7.1 → hdx_python_api-6.7.3}/src/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_python_api-6.7.1 → hdx_python_api-6.7.3}/src/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_python_api-6.7.1 → hdx_python_api-6.7.3}/src/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,