plone.api 2.4.0__tar.gz → 2.5.0__tar.gz

{plone_api-2.4.0 → plone_api-2.5.0}/CHANGES.md

@@ -9,6 +9,20 @@
 
 <!-- towncrier release notes start -->
 
+## 2.5.0 (2025-03-25)
+
+
+### New features:
+
+- Implement `plone.api.addon` module. @ericof, @ujsquared, @stevepiercy #505
+
+## 2.4.1 (2025-03-17)
+
+
+### Bug fixes:
+
+- Attempt to generate a random temporary id for a content type up to 100 times, else continue to raise a `zExceptions.BadRequest` error. @rohnsha0 #445
+
 ## 2.4.0 (2025-03-14)
 
 

{plone_api-2.4.0 → plone_api-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: plone.api
-Version: 2.4.0
+Version: 2.5.0
 Summary: A Plone API.
 Home-page: https://github.com/plone/plone.api
 Author: Plone Foundation
@@ -127,6 +127,20 @@ Continuous Integration
 
 <!-- towncrier release notes start -->
 
+## 2.5.0 (2025-03-25)
+
+
+### New features:
+
+- Implement `plone.api.addon` module. @ericof, @ujsquared, @stevepiercy #505
+
+## 2.4.1 (2025-03-17)
+
+
+### Bug fixes:
+
+- Attempt to generate a random temporary id for a content type up to 100 times, else continue to raise a `zExceptions.BadRequest` error. @rohnsha0 #445
+
 ## 2.4.0 (2025-03-14)
 
 

plone_api-2.5.0/docs/addon.md

@@ -0,0 +1,155 @@
+---
+myst:
+  html_meta:
+    "description": "Get, modify, and manage Plone add-ons"
+    "property=og:description": "Get, modify, and manage Plone add-ons"
+    "property=og:title": "Get, modify, and manage Plone add-ons"
+    "keywords": "Plone, API, development, add-on, manage"
+---
+
+```{eval-rst}
+.. module:: plone
+```
+
+(chapter-addons)=
+
+# Add-ons
+
+This chapter describes how to get, update, install, uninstall, and manage Plone add-ons.
+
+
+(addons-get-addons)=
+
+## Get add-ons
+
+To get all the add-ons present in the current Plone site, use the {func}`api.addon.get_addons` function.
+The function accepts an optional `limit` parameter to filter the returned add-ons.
+`limit` may be one of the following strings.
+
+`available`
+:   Products that are not installed, but could be.
+
+`broken`
+:   Uninstallable products with broken dependencies.
+
+`installed`
+:   Only products that are installed and not hidden.
+
+`non_installable`
+:   Non-installable products.
+
+`upgradable`
+:   Only products with upgrades.
+
+The following examples demonstrate usage of the {func}`api.addon.get_addons` function.
+
+```python
+from plone import api
+
+# Get all add-ons
+addons = api.addon.get_addons()
+
+# Get only installed add-ons
+installed = api.addon.get_addons(limit="installed")
+
+# Get only upgradable add-ons
+upgradable = api.addon.get_addons(limit="upgradable")
+
+# Get only broken add-ons
+broken = api.addon.get_addons(limit="broken")
+```
+
+(addons-get-addon-ids)=
+
+## Get add-on IDs
+
+To get the IDs of all the add-ons present in the current Plone site, use the {func}`api.addon.get_addon_ids` function.
+The function accepts an optional `limit` parameter to filter the returned add-ons, exactly the same as the {func}`api.addon.get_addons` function.
+`limit` may be one of the following strings.
+
+`available`
+:   Products that are not installed, but could be.
+
+`broken`
+:   Uninstallable products with broken dependencies.
+
+`installed`
+:   Only products that are installed and not hidden.
+
+`non_installable`
+:   Non-installable products.
+
+`upgradable`
+:   Only products with upgrades.
+
+The following example demonstrates usage of the {func}`api.addon.get_addon_ids` function.
+
+```python
+# Get IDs of installed add-ons
+addon_ids = api.addon.get_addon_ids(limit="installed")
+```
+
+## Get add-on information
+
+To get information about a specific add-on, use the {func}`api.addon.get` function, passing in the name of the add-on as a string.
+
+```python
+from plone import api
+
+addon = api.addon.get("plone.session")
+print(addon.id)           # ID of the add-on
+print(addon.version)      # Version string
+print(addon.title)        # Display title
+print(addon.description)  # Description
+print(addon.flags)        # List of flags like ["installed", "upgradable"]
+```
+
+## Install and uninstall add-ons
+
+To install an add-on, use the {func}`api.addon.install` function, passing in the name of the add-on as a string, as shown in the following example.
+
+```python
+from plone import api
+
+success = api.addon.install("plone.session")
+```
+
+This function returns a `false` boolean value in the following cases.
+- The installation fails due to an error.
+- The add-on is already installed.
+- The add-on is not found among the available add-ons.
+
+
+To uninstall an add-on, use the {func}`api.addon.uninstall` function, passing in the name of the add-on as a string, as shown in the following example.
+
+
+```python
+from plone import api
+
+success = api.addon.uninstall("plone.session")
+```
+
+This function returns a `false` boolean value in the following cases.
+- The removal of add-on fails due to an error.
+- The add-on is not installed.
+
+## Get add-on version
+
+To get the version of an add-on, use the {func}`api.addon.get_version` function, passing in the name of the add-on as a string, as shown in the following example.
+
+```python
+from plone import api
+
+version = api.addon.get_version("plone.session")
+```
+
+Note that this returns the version of the Python package installed from _PyPI_, not the version of the add-on's _GenericSetup_ profile.
+
+(addons-exceptions)=
+
+## Exceptions
+
+The {exc}`~plone.api.exc.InvalidParameterError` exception may be raised in the following cases.
+
+- When using the {func}`api.addon.get` function, trying to get information about a non-existent add-on.
+- When using either function {func}`api.addon.get_addons` or {func}`api.addon.get_addon_ids`, using an invalid `limit` parameter value.

{plone_api-2.4.0 → plone_api-2.5.0}/docs/index.md

@@ -39,12 +39,13 @@ Backward-incompatible changes to the API will be restricted to major versions (1
 :maxdepth: 2
 
 about
-portal
+addon
 content
-user
-group
 env
+group
+portal
 relation
+user
 ```
 
 
@@ -58,13 +59,14 @@ api/index
 ```
 
 -   {doc}`api/index`
--   [`plone.api.portal`](api/portal)
+-   [`plone.api.addon`](api/addon)
 -   [`plone.api.content`](api/content)
--   [`plone.api.user`](api/user)
--   [`plone.api.group`](api/group)
 -   [`plone.api.env`](api/env)
--   [`plone.api.relation`](api/relation)
 -   [`plone.api.exceptions`](api/exceptions)
+-   [`plone.api.group`](api/group)
+-   [`plone.api.portal`](api/portal)
+-   [`plone.api.relation`](api/relation)
+-   [`plone.api.user`](api/user)
 
 
 ## Contribute

{plone_api-2.4.0 → plone_api-2.5.0}/pyproject.toml

@@ -2,7 +2,7 @@
 # https://github.com/plone/meta/tree/main/config/default
 # See the inline comments on how to expand/tweak this configuration file
 [build-system]
-requires = ["setuptools>=68.2"]
+requires = ["setuptools>=68.2,<77"]
 
 [tool.towncrier]
 directory = "news/"

{plone_api-2.4.0 → plone_api-2.5.0}/setup.py

@@ -3,7 +3,7 @@ from setuptools import find_packages
 from setuptools import setup
 
 
-version = "2.4.0"
+version = "2.5.0"
 
 long_description = "\n".join(
     [Path("README.md").read_text(), Path("CHANGES.md").read_text()]

{plone_api-2.4.0 → plone_api-2.5.0}/src/plone/api/__init__.py

@@ -1,5 +1,6 @@
 # flake8: NOQA: S401
 
+from plone.api import addon
 from plone.api import content
 from plone.api import env
 from plone.api import group

plone_api-2.5.0/src/plone/api/addon.py

@@ -0,0 +1,303 @@
+"""API to handle add-on management."""
+
+from dataclasses import dataclass
+from functools import lru_cache
+from plone.api import portal
+from plone.api.exc import InvalidParameterError
+from plone.api.validation import required_parameters
+from Products.CMFPlone.controlpanel.browser.quickinstaller import InstallerView
+from Products.CMFPlone.interfaces import INonInstallable
+from Products.CMFPlone.utils import get_installer
+from Products.GenericSetup import EXTENSION
+from typing import Dict
+from typing import List
+from typing import Tuple
+from zope.component import getAllUtilitiesRegisteredFor
+from zope.globalrequest import getRequest
+
+import logging
+import pkg_resources
+
+
+logger = logging.getLogger("plone.api.addon")
+
+
+__all__ = [
+    "AddonInformation",
+    "NonInstallableAddons",
+    "get_addons",
+    "get_addon_ids",
+    "get_version",
+    "get",
+    "install",
+    "uninstall",
+]
+
+
+@dataclass
+class NonInstallableAddons:
+    """Set of add-ons not available for installation."""
+
+    profiles: List[str]
+    products: List[str]
+
+
+@dataclass
+class AddonInformation:
+    """Add-on information."""
+
+    id: str  # noQA
+    version: str
+    title: str
+    description: str
+
+    upgrade_profiles: Dict
+    other_profiles: List[List]
+    install_profile: Dict
+    uninstall_profile: Dict
+    profile_type: str
+    upgrade_info: Dict
+    valid: bool
+    flags: List[str]
+
+    def __repr__(self) -> str:
+        """Return a string representation of this object."""
+        return f"<AddonInformation id='{self.id}' flags='{self.flags}'>"
+
+
+def _get_installer() -> InstallerView:
+    """Return the InstallerView."""
+    portal_obj = portal.get()
+    return get_installer(portal_obj, getRequest())
+
+
+@lru_cache(maxsize=1)
+def _get_non_installable_addons() -> NonInstallableAddons:
+    """Return information about non installable add-ons.
+
+    We cache this on first use, as those utilities are registered
+    during the application startup
+
+    :returns: NonInstallableAddons instance.
+    """
+    ignore_profiles = []
+    ignore_products = []
+    utils = getAllUtilitiesRegisteredFor(INonInstallable)
+    for util in utils:
+        ni_profiles = getattr(util, "getNonInstallableProfiles", None)
+        if ni_profiles is not None:
+            ignore_profiles.extend(ni_profiles())
+        ni_products = getattr(util, "getNonInstallableProducts", None)
+        if ni_products is not None:
+            ignore_products.extend(ni_products())
+    return NonInstallableAddons(
+        profiles=ignore_profiles,
+        products=ignore_products,
+    )
+
+
+@lru_cache(maxsize=1)
+def _cached_addons() -> Tuple[Tuple[str, AddonInformation]]:
+    """Return information about add-ons in this installation.
+
+    :returns: Tuple of tuples with add-on id and AddonInformation.
+    :rtype: Tuple
+    """
+    installer = _get_installer()
+    setup_tool = installer.ps
+    addons = {}
+    non_installable = _get_non_installable_addons()
+    # Known profiles:
+    profiles = setup_tool.listProfileInfo()
+
+    for profile in profiles:
+        if profile["type"] != EXTENSION:
+            continue
+
+        pid = profile["id"]
+        if pid in non_installable.profiles:
+            continue
+        pid_parts = pid.split(":")
+        if len(pid_parts) != 2:
+            logger.error(f"Profile with id '{pid}' is invalid.")
+        # Which package (product) is this from?
+        product_id = profile["product"]
+        flags = []
+        is_broken = not installer.is_product_installable(product_id, allow_hidden=True)
+        is_non_installable = product_id in non_installable.products
+        valid = not (is_broken or is_non_installable)
+        if is_broken:
+            flags.append("broken")
+        if is_non_installable:
+            flags.append("non_installable")
+        profile_type = pid_parts[-1]
+        if product_id not in addons:
+            # get some basic information on the product
+            product = {
+                "id": product_id,
+                "version": get_version(product_id),
+                "title": product_id,
+                "description": "",
+                "upgrade_profiles": {},
+                "other_profiles": [],
+                "install_profile": {},
+                "uninstall_profile": {},
+                "upgrade_info": {},
+                "profile_type": profile_type,
+                "valid": valid,
+                "flags": flags,
+            }
+            install_profile = installer.get_install_profile(product_id)
+            if install_profile is not None:
+                product["title"] = install_profile["title"]
+                product["description"] = install_profile["description"]
+                product["install_profile"] = install_profile
+                product["profile_type"] = "default"
+            uninstall_profile = installer.get_uninstall_profile(product_id)
+            if uninstall_profile is not None:
+                product["uninstall_profile"] = uninstall_profile
+                # Do not override profile_type.
+                if not product["profile_type"]:
+                    product["profile_type"] = "uninstall"
+        if "version" in profile:
+            product["upgrade_profiles"][profile["version"]] = profile
+        else:
+            product["other_profiles"].append(profile)
+        addons[product_id] = AddonInformation(**product)
+    return tuple(addons.items())
+
+
+def _update_addon_info(
+    addon: AddonInformation, installer: InstallerView
+) -> AddonInformation:
+    """Update information about an add-on.
+
+    :param addon: [required] Add-on object to be updated
+    :type addon: AddonInformation object
+    :param installer: InstallerView object to check for add-on info
+    :type installer: InstallerView object
+
+    :returns: Updated AddonInformation object
+    :rtype: AddonInformation object
+    """
+    addon_id = addon.id
+    if addon.valid:
+        flags = []
+        # Update only what could be changed
+        is_installed = installer.is_product_installed(addon_id)
+        if is_installed:
+            addon.upgrade_info = installer.upgrade_info(addon_id) or {}
+            if addon.upgrade_info.get("available"):
+                flags.append("upgradable")
+            else:
+                flags.append("installed")
+        else:
+            flags.append("available")
+        addon.flags = flags
+    return addon
+
+
+def _get_addons() -> List[AddonInformation]:
+    """Return an updated list of add-on information.
+
+    :returns: List of AddonInformation.
+    :rtype: List
+    """
+    installer = _get_installer()
+    addons = dict(_cached_addons())
+    result = []
+    for addon in addons.values():
+        result.append(_update_addon_info(addon, installer))
+    return result
+
+
+def get_addons(limit: str = "") -> List[AddonInformation]:
+    """List add-ons in this Plone site.
+
+    :param limit: Limit list of add-ons.
+        'installed': only products that are installed and not hidden
+        'upgradable': only products with upgrades
+        'available': products that are not installed but could be
+        'non_installable': Non installable products
+        'broken': uninstallable products with broken dependencies
+    :type limit: string
+    :returns: List of AddonInformation.
+    :raises:
+        InvalidParameterError
+    :Example: :ref:`addons-get-addons`
+    """
+    addons = _get_addons()
+    if limit in ("non_installable", "broken"):
+        return [addon for addon in addons if limit in addon.flags]
+
+    addons = [addon for addon in addons if addon.valid]
+    if limit in ("installed", "upgradable", "available"):
+        addons = [addon for addon in addons if limit in addon.flags]
+    elif limit != "":
+        raise InvalidParameterError(f"Parameter limit='{limit}' is not valid.")
+    return addons
+
+
+def get_addon_ids(limit: str = "") -> List[str]:
+    """List add-ons ids in this Plone site.
+
+    :param limit: Limit list of add-ons.
+        'installed': only products that are installed and not hidden
+        'upgradable': only products with upgrades
+        'available': products that are not installed but could be
+        'non_installable': Non installable products
+        'broken': uninstallable products with broken dependencies
+    :type limit: string
+    :returns: List of add-on ids.
+    """
+    addons = get_addons(limit=limit)
+    return [addon.id for addon in addons]
+
+
+@required_parameters("addon")
+def get_version(addon: str) -> str:
+    """Return the version of the product (package)."""
+    try:
+        dist = pkg_resources.get_distribution(addon)
+        return dist.version
+    except pkg_resources.DistributionNotFound:
+        if "." in addon:
+            return ""
+    return get_version(f"Products.{addon}")
+
+
+@required_parameters("addon")
+def get(addon: str) -> AddonInformation:
+    """Information about an Add-on.
+
+    :param addon: ID of the add-on to be retrieved.
+    :returns: Add-on information.
+    :rtype: string
+    """
+    addons = dict(_cached_addons())
+    if addon not in addons:
+        raise InvalidParameterError(f"No add-on {addon} found.")
+    return _update_addon_info(addons.get(addon), _get_installer())
+
+
+@required_parameters("addon")
+def install(addon: str) -> bool:
+    """Install an add-on.
+
+    :param addon: ID of the add-on to be installed.
+    :returns: Status of the installation.
+    """
+    installer = _get_installer()
+    return installer.install_product(addon)
+
+
+@required_parameters("addon")
+def uninstall(addon: str) -> bool:
+    """Uninstall an add-on.
+
+    :param addon: ID of the add-on to be uninstalled.
+    :returns: Status of the uninstallation.
+    :rtype: Boolean value representing the status of the uninstallation.
+    """
+    installer = _get_installer()
+    return installer.uninstall_product(addon)

{plone_api-2.4.0 → plone_api-2.5.0}/src/plone/api/content.py

@@ -22,12 +22,15 @@ from zope.globalrequest import getRequest
 from zope.interface import Interface
 from zope.interface import providedBy
 
-import random
 import transaction
+import uuid
 
 
 _marker = []
 
+# Maximum number of attempts to generate a unique random ID
+MAX_UNIQUE_ID_ATTEMPTS = 100
+
 
 @required_parameters("container", "type")
 @at_least_one_of("id", "title")
@@ -67,7 +70,19 @@ def create(
     :Example: :ref:`content-create-example`
     """
     # Create a temporary id if the id is not given
-    content_id = not safe_id and id or str(random.randint(0, 99999999))
+    if not safe_id and id:
+        content_id = id
+    else:
+        # Try to generate a unique random ID using UUID4
+        attempts = 0
+        while attempts < MAX_UNIQUE_ID_ATTEMPTS:
+            content_id = str(uuid.uuid4())
+            if content_id not in container:
+                break
+            attempts += 1
+        # If we couldn't find a unique ID after max attempts, raise ValueError
+        if attempts >= MAX_UNIQUE_ID_ATTEMPTS:
+            raise ValueError("Could not find unique id while creating content.")
 
     if title:
         kwargs["title"] = title

plone_api-2.5.0/src/plone/api/tests/doctests/addon.md

@@ -0,0 +1,155 @@
+---
+myst:
+  html_meta:
+    "description": "Get, modify, and manage Plone add-ons"
+    "property=og:description": "Get, modify, and manage Plone add-ons"
+    "property=og:title": "Get, modify, and manage Plone add-ons"
+    "keywords": "Plone, API, development, add-on, manage"
+---
+
+```{eval-rst}
+.. module:: plone
+```
+
+(chapter-addons)=
+
+# Add-ons
+
+This chapter describes how to get, update, install, uninstall, and manage Plone add-ons.
+
+
+(addons-get-addons)=
+
+## Get add-ons
+
+To get all the add-ons present in the current Plone site, use the {func}`api.addon.get_addons` function.
+The function accepts an optional `limit` parameter to filter the returned add-ons.
+`limit` may be one of the following strings.
+
+`available`
+:   Products that are not installed, but could be.
+
+`broken`
+:   Uninstallable products with broken dependencies.
+
+`installed`
+:   Only products that are installed and not hidden.
+
+`non_installable`
+:   Non-installable products.
+
+`upgradable`
+:   Only products with upgrades.
+
+The following examples demonstrate usage of the {func}`api.addon.get_addons` function.
+
+```python
+from plone import api
+
+# Get all add-ons
+addons = api.addon.get_addons()
+
+# Get only installed add-ons
+installed = api.addon.get_addons(limit="installed")
+
+# Get only upgradable add-ons
+upgradable = api.addon.get_addons(limit="upgradable")
+
+# Get only broken add-ons
+broken = api.addon.get_addons(limit="broken")
+```
+
+(addons-get-addon-ids)=
+
+## Get add-on IDs
+
+To get the IDs of all the add-ons present in the current Plone site, use the {func}`api.addon.get_addon_ids` function.
+The function accepts an optional `limit` parameter to filter the returned add-ons, exactly the same as the {func}`api.addon.get_addons` function.
+`limit` may be one of the following strings.
+
+`available`
+:   Products that are not installed, but could be.
+
+`broken`
+:   Uninstallable products with broken dependencies.
+
+`installed`
+:   Only products that are installed and not hidden.
+
+`non_installable`
+:   Non-installable products.
+
+`upgradable`
+:   Only products with upgrades.
+
+The following example demonstrates usage of the {func}`api.addon.get_addon_ids` function.
+
+```python
+# Get IDs of installed add-ons
+addon_ids = api.addon.get_addon_ids(limit="installed")
+```
+
+## Get add-on information
+
+To get information about a specific add-on, use the {func}`api.addon.get` function, passing in the name of the add-on as a string.
+
+```python
+from plone import api
+
+addon = api.addon.get("plone.session")
+print(addon.id)           # ID of the add-on
+print(addon.version)      # Version string
+print(addon.title)        # Display title
+print(addon.description)  # Description
+print(addon.flags)        # List of flags like ["installed", "upgradable"]
+```
+
+## Install and uninstall add-ons
+
+To install an add-on, use the {func}`api.addon.install` function, passing in the name of the add-on as a string, as shown in the following example.
+
+```python
+from plone import api
+
+success = api.addon.install("plone.session")
+```
+
+This function returns a `false` boolean value in the following cases.
+- The installation fails due to an error.
+- The add-on is already installed.
+- The add-on is not found among the available add-ons.
+
+
+To uninstall an add-on, use the {func}`api.addon.uninstall` function, passing in the name of the add-on as a string, as shown in the following example.
+
+
+```python
+from plone import api
+
+success = api.addon.uninstall("plone.session")
+```
+
+This function returns a `false` boolean value in the following cases.
+- The removal of add-on fails due to an error.
+- The add-on is not installed.
+
+## Get add-on version
+
+To get the version of an add-on, use the {func}`api.addon.get_version` function, passing in the name of the add-on as a string, as shown in the following example.
+
+```python
+from plone import api
+
+version = api.addon.get_version("plone.session")
+```
+
+Note that this returns the version of the Python package installed from _PyPI_, not the version of the add-on's _GenericSetup_ profile.
+
+(addons-exceptions)=
+
+## Exceptions
+
+The {exc}`~plone.api.exc.InvalidParameterError` exception may be raised in the following cases.
+
+- When using the {func}`api.addon.get` function, trying to get information about a non-existent add-on.
+- When using either function {func}`api.addon.get_addons` or {func}`api.addon.get_addon_ids`, using an invalid `limit` parameter value.

plone_api-2.5.0/src/plone/api/tests/test_addon.py

@@ -0,0 +1,106 @@
+"""Tests for plone.api.addon methods."""
+
+from plone import api
+from plone.api.addon import AddonInformation
+from plone.api.tests.base import INTEGRATION_TESTING
+
+import unittest
+
+
+ADDON = "plone.session"
+
+
+class TestAPIAddonGetAddons(unittest.TestCase):
+    """TestCase for plone.api.addon.get_addons."""
+
+    layer = INTEGRATION_TESTING
+
+    def setUp(self):
+        """Set up TestCase."""
+        self.portal = self.layer["portal"]
+        # Install plone.app.multilingual
+        api.addon.install(ADDON)
+
+    def test_api_get_addons(self):
+        """Test api.addon.get_addons without any filter."""
+        result = api.addon.get_addons()
+        self.assertIsInstance(result, list)
+        addon_ids = [addon.id for addon in result]
+        self.assertIn(ADDON, addon_ids)
+
+    def test_api_get_addons_limit_broken(self):
+        """Test api.addon.get_addons filtering for broken add-ons."""
+        result = api.addon.get_addons(limit="broken")
+        self.assertEqual(len(result), 0)
+
+    def test_api_get_addons_limit_non_installable(self):
+        """Test api.addon.get_addons filtering for non_installable add-ons."""
+        result = api.addon.get_addons(limit="non_installable")
+        self.assertNotEqual(len(result), 0)
+        addon_ids = [addon.id for addon in result]
+        self.assertIn("plone.app.dexterity", addon_ids)
+
+    def test_api_get_addons_limit_installed(self):
+        """Test api.addon.get_addons filtering for installed add-ons."""
+        result = api.addon.get_addons(limit="installed")
+        self.assertEqual(len(result), 2)
+        addon_ids = [addon.id for addon in result]
+        self.assertIn(ADDON, addon_ids)
+
+    def test_api_get_addons_limit_upgradable(self):
+        """Test api.addon.get_addons filtering for add-ons with upgradable."""
+        result = api.addon.get_addons(limit="upgradable")
+        self.assertEqual(len(result), 0)
+
+    def test_api_get_addons_limit_invalid(self):
+        """Test api.addon.get_addons filtering with an invalid parameter."""
+        with self.assertRaises(api.exc.InvalidParameterError) as cm:
+            api.addon.get_addons(limit="foobar")
+        self.assertIn("Parameter limit='foobar' is not valid.", str(cm.exception))
+
+    def test_api_get_addon_ids(self):
+        """Test api.addon.get_addon_ids."""
+        result = api.addon.get_addon_ids(limit="installed")
+        self.assertEqual(len(result), 2)
+        self.assertIn(ADDON, result)
+
+
+class TestAPIAddon(unittest.TestCase):
+    """TestCase for plone.api.addon."""
+
+    layer = INTEGRATION_TESTING
+
+    def setUp(self):
+        """Set up TestCase."""
+        self.portal = self.layer["portal"]
+
+    def test_api_install(self):
+        """Test api.addon.install."""
+        result = api.addon.install(ADDON)
+        self.assertTrue(result)
+
+    def test_api_uninstall(self):
+        """Test api.addon.uninstall."""
+        # First install the add-on
+        api.addon.install(ADDON)
+        # Then uninstall the add-on
+        result = api.addon.uninstall(ADDON)
+        self.assertTrue(result)
+
+    def test_api_uninstall_unavailable(self):
+        """Test api.addon.uninstall unavailable add-on."""
+        result = api.addon.uninstall("Foobar")
+        self.assertFalse(result)
+
+    def test_api_get(self):
+        """Test api.addon.get."""
+        result = api.addon.get(ADDON)
+        self.assertIsInstance(result, AddonInformation)
+        self.assertEqual(result.id, ADDON)
+        self.assertTrue(result.valid)
+        self.assertEqual(result.description, "Optional plone.session refresh support.")
+        self.assertEqual(result.profile_type, "default")
+        self.assertIsInstance(result.version, str)
+        self.assertIsInstance(result.install_profile, dict)
+        self.assertIsInstance(result.uninstall_profile, dict)
+        self.assertIsInstance(result.upgrade_info, dict)

{plone_api-2.4.0 → plone_api-2.5.0}/src/plone.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: plone.api
-Version: 2.4.0
+Version: 2.5.0
 Summary: A Plone API.
 Home-page: https://github.com/plone/plone.api
 Author: Plone Foundation
@@ -127,6 +127,20 @@ Continuous Integration
 
 <!-- towncrier release notes start -->
 
+## 2.5.0 (2025-03-25)
+
+
+### New features:
+
+- Implement `plone.api.addon` module. @ericof, @ujsquared, @stevepiercy #505
+
+## 2.4.1 (2025-03-17)
+
+
+### Bug fixes:
+
+- Attempt to generate a random temporary id for a content type up to 100 times, else continue to raise a `zExceptions.BadRequest` error. @rohnsha0 #445
+
 ## 2.4.0 (2025-03-14)
 
 

{plone_api-2.4.0 → plone_api-2.5.0}/src/plone.api.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ setup.cfg
 setup.py
 tox.ini
 docs/about.md
+docs/addon.md
 docs/content.md
 docs/contribute.md
 docs/env.md
@@ -25,6 +26,7 @@ src/plone.api.egg-info/not-zip-safe
 src/plone.api.egg-info/requires.txt
 src/plone.api.egg-info/top_level.txt
 src/plone/api/__init__.py
+src/plone/api/addon.py
 src/plone/api/configure.zcml
 src/plone/api/content.py
 src/plone/api/env.py
@@ -43,6 +45,7 @@ src/plone/api/tests/Dexterity_Folder.xml
 src/plone/api/tests/Dexterity_Item.xml
 src/plone/api/tests/__init__.py
 src/plone/api/tests/base.py
+src/plone/api/tests/test_addon.py
 src/plone/api/tests/test_content.py
 src/plone/api/tests/test_doctests.py
 src/plone/api/tests/test_env.py
@@ -52,6 +55,7 @@ src/plone/api/tests/test_relation.py
 src/plone/api/tests/test_user.py
 src/plone/api/tests/test_validation.py
 src/plone/api/tests/doctests/about.md
+src/plone/api/tests/doctests/addon.md
 src/plone/api/tests/doctests/content.md
 src/plone/api/tests/doctests/contribute.md
 src/plone/api/tests/doctests/env.md

{plone_api-2.4.0 → plone_api-2.5.0}/tox.ini

@@ -107,7 +107,7 @@ commands =
 description = run the distribution tests
 use_develop = true
 skip_install = false
-constrain_package_deps = true
+constrain_package_deps = True
 set_env =
     ROBOT_BROWSER=headlesschrome
 
@@ -153,7 +153,7 @@ extras =
 description = get a test coverage report
 use_develop = true
 skip_install = false
-constrain_package_deps = true
+constrain_package_deps = True
 set_env =
     ROBOT_BROWSER=headlesschrome
 
@@ -201,7 +201,7 @@ use_develop = true
 skip_install = false
 # Here we must always constrain the package deps to what is already installed,
 # otherwise we simply get the latest from PyPI, which may not work.
-constrain_package_deps = true
+constrain_package_deps = True
 set_env =
 
 ##
@@ -259,6 +259,7 @@ allowlist_externals =
 # See [testenv:docs] for classic documentation
 basepython = python3.11
 skip_install = False
+constrain_package_deps = True
 package = editable
 allowlist_externals =
     mkdir
@@ -275,6 +276,7 @@ commands =
 # Build docs on Read the Docs to preview pull requests using plone-sphinx-theme
 basepython = python3.11
 skip_install = False
+constrain_package_deps = True
 extras =
     tests
 deps =
@@ -306,6 +308,7 @@ whitelist_externals =
 [testenv:linkcheck]
 basepython = python3.11
 skip_install = False
+constrain_package_deps = True
 package = editable
 allowlist_externals =
     mkdir
@@ -321,7 +324,7 @@ commands =
 [testenv:livehtml]
 basepython = python3.11
 skip_install = False
-constrain_package_deps = true
+constrain_package_deps = True
 package = editable
 allowlist_externals =
     mkdir
@@ -329,7 +332,6 @@ extras =
     {[testenv:plone6docs]extras}
 deps =
     {[testenv:plone6docs]deps}
-    -c https://dist.plone.org/release/6.0-dev/constraints.txt
 commands =
     python -VV
     mkdir -p {toxinidir}/_build/plone6docs