plone.exportimport 2.0.2__tar.gz → 2.2.0__tar.gz

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/CHANGES.md

@@ -9,6 +9,39 @@
 
 <!-- towncrier release notes start -->
 
+## 2.2.0 (2026-10-01)
+
+
+### New features
+
+- Add `--path` and `--paths` options to `plone-exporter` to export only parts of a site. Relations, translations, discussions, portlets and redirects are limited to the exported content @ericof #86
+
+
+### Bug fixes
+
+- Do not fail exporting content whose ``language`` is ``None``. Such an item serializes to ``"language": null``, and ``fix_language`` raised ``AttributeError: 'NoneType' object has no attribute 'get'``. It is now treated like a missing language and gets the default-language placeholder, which the importer resolves. @kunalKumar-13 #95
+- Fixed export and import of grid blocks whose images have no ``image_scales`` information. @ericof #109
+- Fixed ``plone-exporter`` silently skipping fields protected by a read permission not granted to the ``Manager`` role, such as behavior fields on the Plone Site root. Both command line tools now run with the site hook set and without overriding the roles of the system user. @ericof #110
+- Do not silently drop file and image fields on import when a blob's file name has another Unicode normalization form on disk. Blob files are now exported under a normalized file name (NFC, without path separators or characters invalid on Windows), the import also finds the NFC form of a recorded blob path, and items that could not be fully deserialized are listed as imported with errors, making `plone-importer` exit with status 1 @ericof #114
+
+
+### Internal
+
+- Declared ``plone.autoform``, ``plone.behavior``, ``plone.supermodel`` and ``Products.GenericSetup`` as dependencies. @ericof 
+
+
+### Tests
+
+- Fix intermittent failure of the services export/import roundtrip test, which compared ZIP archives including file timestamps @ericof 
+- Fixed test isolation with pytest-plone 1.1.0 by keeping importers and fixtures from committing transactions during tests. @ericof 
+
+## 2.1.0 (2026-09-10)
+
+
+### New features
+
+- Make it easy to customize which content gets exported @gforcada #86
+
 ## 2.0.2 (2026-08-21)
 
 

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plone.exportimport
-Version: 2.0.2
+Version: 2.2.0
 Summary: Plone content export / import support
 Home-page: https://plone.org
 Author: Plone Foundation
@@ -17,7 +17,6 @@ Classifier: Framework :: Plone
 Classifier: Framework :: Plone :: 6.2
 Classifier: Framework :: Plone :: Core
 Classifier: Framework :: Zope :: 5
-Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
@@ -35,14 +34,18 @@ Requires-Dist: plone.app.dexterity
 Requires-Dist: plone.app.redirector
 Requires-Dist: plone.app.textfield
 Requires-Dist: plone.app.users
+Requires-Dist: plone.autoform
 Requires-Dist: plone.base
+Requires-Dist: plone.behavior
 Requires-Dist: plone.dexterity
 Requires-Dist: plone.namedfile
 Requires-Dist: plone.restapi
+Requires-Dist: plone.supermodel
 Requires-Dist: plone.uuid
 Requires-Dist: Products.CMFEditions
 Requires-Dist: Products.CMFPlone
 Requires-Dist: Products.DCWorkflow
+Requires-Dist: Products.GenericSetup
 Requires-Dist: Products.PlonePAS
 Requires-Dist: Products.PortalTransforms
 Requires-Dist: z3c.relationfield
@@ -241,6 +244,39 @@ The project is licensed under the GPLv2.
 
 <!-- towncrier release notes start -->
 
+## 2.2.0 (2026-10-01)
+
+
+### New features
+
+- Add `--path` and `--paths` options to `plone-exporter` to export only parts of a site. Relations, translations, discussions, portlets and redirects are limited to the exported content @ericof #86
+
+
+### Bug fixes
+
+- Do not fail exporting content whose ``language`` is ``None``. Such an item serializes to ``"language": null``, and ``fix_language`` raised ``AttributeError: 'NoneType' object has no attribute 'get'``. It is now treated like a missing language and gets the default-language placeholder, which the importer resolves. @kunalKumar-13 #95
+- Fixed export and import of grid blocks whose images have no ``image_scales`` information. @ericof #109
+- Fixed ``plone-exporter`` silently skipping fields protected by a read permission not granted to the ``Manager`` role, such as behavior fields on the Plone Site root. Both command line tools now run with the site hook set and without overriding the roles of the system user. @ericof #110
+- Do not silently drop file and image fields on import when a blob's file name has another Unicode normalization form on disk. Blob files are now exported under a normalized file name (NFC, without path separators or characters invalid on Windows), the import also finds the NFC form of a recorded blob path, and items that could not be fully deserialized are listed as imported with errors, making `plone-importer` exit with status 1 @ericof #114
+
+
+### Internal
+
+- Declared ``plone.autoform``, ``plone.behavior``, ``plone.supermodel`` and ``Products.GenericSetup`` as dependencies. @ericof 
+
+
+### Tests
+
+- Fix intermittent failure of the services export/import roundtrip test, which compared ZIP archives including file timestamps @ericof 
+- Fixed test isolation with pytest-plone 1.1.0 by keeping importers and fixtures from committing transactions during tests. @ericof 
+
+## 2.1.0 (2026-09-10)
+
+
+### New features
+
+- Make it easy to customize which content gets exported @gforcada #86
+
 ## 2.0.2 (2026-08-21)
 
 

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/setup.py

@@ -8,7 +8,7 @@ long_description = f"""
 
 setup(
     name="plone.exportimport",
-    version="2.0.2",
+    version="2.2.0",
     description="Plone content export / import support",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -19,7 +19,6 @@ setup(
         "Framework :: Plone :: 6.2",
         "Framework :: Plone :: Core",
         "Framework :: Zope :: 5",
-        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
         "Operating System :: OS Independent",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3.10",
@@ -50,14 +49,18 @@ setup(
         "plone.app.redirector",
         "plone.app.textfield",
         "plone.app.users",
+        "plone.autoform",
         "plone.base",
+        "plone.behavior",
         "plone.dexterity",
         "plone.namedfile",
         "plone.restapi",
+        "plone.supermodel",
         "plone.uuid",
         "Products.CMFEditions",
         "Products.CMFPlone",
         "Products.DCWorkflow",
+        "Products.GenericSetup",
         "Products.PlonePAS",
         "Products.PortalTransforms",
         "z3c.relationfield",

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/cli/__init__.py

@@ -1,4 +1,3 @@
-from plone import api
 from plone.exportimport import logger as package_logger
 from plone.exportimport.exporters import get_exporter
 from plone.exportimport.importers import get_importer
@@ -13,19 +12,44 @@ CLI_SPEC = {
     "exporter": {
         "description": "Export Plone Site content",
         "options": {
-            "zopeconf": "Path to zope.conf",
-            "site": "Plone site ID or path to site to export the content from",
-            "path": "Path to export the content",
-            "--include-revisions": "Include revision history",
+            "zopeconf": {"help": "Path to zope.conf"},
+            "site": {
+                "help": "Plone site ID or path to site to export the content from"
+            },
+            "path": {"help": "Path to export the content"},
+            "--include-revisions": {
+                "action": "store_true",
+                "help": "Include revision history",
+            },
+            "--path": {
+                "action": "append",
+                "dest": "include_paths",
+                "metavar": "CONTENT_PATH",
+                "help": (
+                    "Export only this content, and everything inside it. "
+                    "Relative to the site root. Can be repeated"
+                ),
+            },
+            "--paths": {
+                "dest": "paths_file",
+                "metavar": "FILE",
+                "help": (
+                    "File with the content paths to export, one per line. "
+                    "Empty lines and lines starting with # are ignored"
+                ),
+            },
         },
     },
     "importer": {
         "description": "Import content into a Plone Site",
         "options": {
-            "zopeconf": "Path to zope.conf",
-            "site": "Plone site ID or path to site to import the content to",
-            "path": "Path to import the content from",
-            "--quiet": "Do not report items being imported",
+            "zopeconf": {"help": "Path to zope.conf"},
+            "site": {"help": "Plone site ID or path to site to import the content to"},
+            "path": {"help": "Path to import the content from"},
+            "--quiet": {
+                "action": "store_true",
+                "help": "Do not report items being imported",
+            },
         },
     },
 }
@@ -33,11 +57,8 @@ CLI_SPEC = {
 
 def _parse_args(description: str, options: dict, args: list):
     parser = argparse.ArgumentParser(description=description)
-    for key, help in options.items():
-        if key.startswith("-"):
-            parser.add_argument(key, action="store_true", help=help)
-        else:
-            parser.add_argument(key, help=help)
+    for key, kwargs in options.items():
+        parser.add_argument(key, **kwargs)
     namespace, _ = parser.parse_known_args(args[1:])
     return namespace
 
@@ -54,7 +75,10 @@ def exporter_cli(args=sys.argv):
         logger.error(f"{namespace.path} does not exist, please create it first.")
         sys.exit(1)
     site = cli_helpers.get_site(app, namespace.site, logger)
-    with api.env.adopt_roles(["Manager"]):
+    namespace.query = cli_helpers.get_export_query(
+        site, namespace.include_paths, namespace.paths_file, logger
+    )
+    with hooks.site(site):
         results = get_exporter(site).export_site(path, options=namespace)
     logger.info(f" Using path {path} to export content from Plone site at /{site.id}")
     for item in results[1:]:
@@ -75,9 +99,13 @@ def importer_cli(args=sys.argv):
     if not namespace.quiet:
         cli_helpers.setup_logger_console(package_logger)
     site = cli_helpers.get_site(app, namespace.site, logger)
-    with hooks.site(site), api.env.adopt_roles(["Manager"]):
+    with hooks.site(site):
         logger.info(f" Using path {path} to import content to Plone site at /{site.id}")
-        results = get_importer(site).import_site(path)
+        importer = get_importer(site)
+        results = importer.import_site(path)
         for item in results:
             logger.info(f" - {item}")
         transaction.commit()
+    if incomplete := importer.incomplete:
+        logger.error(f" {len(incomplete)} items were imported with errors")
+        sys.exit(1)

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/deserializers/blob.py

@@ -11,16 +11,29 @@ from zope.globalrequest import getRequest
 from zope.interface import implementer
 
 import codecs
+import unicodedata
 
 
 def load_blob(path: str) -> bytes:
-    """Load blob from fs and encode it as base64."""
+    """Load blob from fs and encode it as base64.
+
+    If no file exists at ``path``, the NFC form of ``path`` is tried as well:
+    exports may record the name in NFD while the file on disk is NFC (for
+    instance, after a commit with git's ``core.precomposeunicode``), and only
+    some filesystems treat both forms as the same name.
+
+    :param path: Blob path, relative to the content import directory.
+    :returns: Contents of the blob file.
+    :raises ValueError: If the blob file does not exist.
+    """
     request = getRequest()
     content_import_path = Path(request[settings.IMPORT_PATH_KEY])
-    path = content_import_path / path
-    if not path.exists():
-        raise ValueError(f"Blob not found at {path}")
-    data = path_utils.encode_file_contents(path)
+    blob_path = content_import_path / path
+    if not blob_path.exists():
+        blob_path = content_import_path / unicodedata.normalize("NFC", path)
+    if not blob_path.exists():
+        raise ValueError(f"Blob not found at {content_import_path / path}")
+    data = path_utils.encode_file_contents(blob_path)
     return codecs.decode(data, "base64")
 
 

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/base.py

@@ -14,10 +14,10 @@ import json
 class BaseExporter:
     name: str
     base_path: Path
-    errors: list = None
-    request: types.HTTPRequest = None
-    data_hooks: list[Callable] = None
-    obj_hooks: list[Callable] = None
+    errors: list
+    request: types.HTTPRequest
+    data_hooks: list[Callable] | None = None
+    obj_hooks: list[Callable] | None = None
     options: argparse.Namespace | None = None
 
     def __init__(
@@ -31,6 +31,18 @@ class BaseExporter:
     def get_option(self, name, default=None):
         return getattr(self.options, name, default)
 
+    def exported_content(self) -> dict[str, str] | None:
+        """Return the content selected for a partial export.
+
+        A partial export is requested by setting ``options.query``.
+        Exporters use this to keep only data related to the exported content.
+
+        :returns: Mapping of UID to physical path of the exported content, or
+            ``None`` when the whole site is exported.
+        """
+        query = self.get_option("query")
+        return utils.get_content_paths(query) if query else None
+
     @property
     def filepath(self) -> Path:
         """Filepath to be used during export."""
@@ -63,9 +75,10 @@ class BaseExporter:
     def export_data(
         self,
         base_path: Path,
-        data_hooks: list[Callable] = None,
-        obj_hooks: list[Callable] = None,
+        data_hooks: list[Callable] | None = None,
+        obj_hooks: list[Callable] | None = None,
         options: argparse.Namespace | None = None,
+        **kwargs: Any,
     ) -> list[Path]:
         """Write data to filesystem."""
         if not base_path.exists():

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/configure.zcml

@@ -15,6 +15,11 @@
       for="plone.base.interfaces.siteroot.IPloneSiteRoot"
       name="plone.exporter.content"
       />
+  <adapter
+      factory=".content.ObjectsExporter"
+      provides="plone.exportimport.interfaces.IObjectsExporter"
+      for="plone.base.interfaces.siteroot.IPloneSiteRoot"
+      />
   <adapter
       factory=".principals.PrincipalsExporter"
       provides="plone.exportimport.interfaces.INamedExporter"

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/content.py

@@ -12,26 +12,22 @@ from plone.exportimport import types
 from plone.exportimport.interfaces import IExportImportRequestMarker
 from plone.exportimport.utils import content as content_utils
 from plone.exportimport.utils import request_provides
+from typing import Any
+from zope.component import getAdapter
 from zope.interface import implementer
 
 import argparse
 
 
-@implementer(interfaces.INamedExporter)
-class ContentExporter(BaseExporter):
-    name: str = "content"
-    query: dict = None
-    filename_fmt: str = settings.EXPORT_CONTENT_FILEPATH
-    metadata: types.ExportImportMetadata = None
-    default_site_language: str = "en"
+class ObjectsExporter:
 
-    def all_objects(self) -> Generator:
+    def __init__(self, obj) -> None:
+        self.obj = obj
+
+    def get_objects(self, query, errors) -> Generator:
         """Return all objects to be serialized."""
-        query = self.query
         catalog = api.portal.get_tool("portal_catalog")
-        if "object_provides" not in query:
-            query["object_provides"] = "plone.dexterity.interfaces.IDexterityContent"
-        brains = catalog.unrestrictedSearchResults(**query)
+        brains = catalog.unrestrictedSearchResults(**content_utils.content_query(query))
         logger.info(f"Exporting {len(brains)}")
         for index, brain in enumerate(brains, start=1):
             try:
@@ -39,7 +35,7 @@ class ContentExporter(BaseExporter):
             except Exception:
                 brain_path = brain.getPath()
                 msg = f"Error getting object {brain_path} from brain"
-                self.errors.append({"path": brain_path, "message": msg})
+                errors.append({"path": brain_path, "message": msg})
                 logger.exception(msg, exc_info=True)
             else:
                 yield obj
@@ -47,6 +43,20 @@ class ContentExporter(BaseExporter):
             if not index % 100:
                 logger.info(f"Content Exporter: Handled {index} items...")
 
+
+@implementer(interfaces.INamedExporter)
+class ContentExporter(BaseExporter):
+    name: str = "content"
+    query: dict = None
+    filename_fmt: str = settings.EXPORT_CONTENT_FILEPATH
+    metadata: types.ExportImportMetadata = None
+    default_site_language: str = "en"
+
+    def all_objects(self) -> Generator:
+        """Return all objects to be serialized."""
+        adapter = getAdapter(self.site, interfaces.IObjectsExporter)
+        yield from adapter.get_objects(self.query, self.errors)
+
     def serialize(self, obj: DexterityContent) -> dict:
         """Serialize object."""
         obj_uid = content_utils.get_uid(obj)
@@ -142,19 +152,48 @@ class ContentExporter(BaseExporter):
             paths.insert(0, self.dump_metadata())
         return paths
 
+    def _prepare_query(
+        self, query: dict | None = None, options: argparse.Namespace | None = None
+    ) -> dict:
+        """Return the catalog query used to select the content to export.
+
+        An explicit ``query`` takes precedence over ``options.query``. When
+        neither is set, all content in the site is selected.
+
+        :param query: Explicit catalog query.
+        :param options: Export options, checked for a ``query`` attribute.
+        :returns: The catalog query to use.
+        """
+        query = query or getattr(options, "query", None)
+        return query if query else {"path": content_utils.get_obj_path(self.site)}
+
     def export_data(
         self,
         base_path: Path,
-        data_hooks: list[Callable] = None,
-        obj_hooks: list[Callable] = None,
-        query: dict | None = None,
+        data_hooks: list[Callable] | None = None,
+        obj_hooks: list[Callable] | None = None,
         options: argparse.Namespace | None = None,
+        query: dict | None = None,
+        **kwargs: Any,
     ) -> list[Path]:
+        """Export content to a ``content`` folder inside ``base_path``.
+
+        Arguments other than ``base_path`` should be passed by keyword, as
+        ``query`` comes after ``options`` in this signature.
+
+        :param base_path: Directory where the export is written.
+        :param data_hooks: Callables applied to the serialized data.
+        :param obj_hooks: Callables applied to each object before serialization.
+        :param options: Export options; ``options.query`` is used when no
+            ``query`` is passed.
+        :param query: Catalog query selecting the content to export. It takes
+            precedence over ``options.query``. Defaults to all content in the site.
+        :returns: Paths of the files written.
+        """
         # Content in a subpath of base_path
         base_path = base_path / self.name
-        query = query if query else {}
         site = self.site
-        self.query = query if query else {"path": content_utils.get_obj_path(site)}
+        self.query = self._prepare_query(query, options)
         metadata = types.ExportImportMetadata()
         self.metadata = metadata
         self.request[settings.EXPORT_CONTENT_METADATA_KEY] = metadata

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/discussions.py

@@ -24,7 +24,9 @@ class DiscussionsExporter(BaseExporter):
 
         from plone.exportimport.utils import discussions as utils
 
-        discussions = utils.get_discussions()
+        content = self.exported_content()
+        uids = set(content) if content is not None else None
+        discussions = utils.get_discussions(uids=uids)
         filepath = self._dump(discussions, self.filepath)
         logger.debug(
             f"- Discussions: Wrote {len(discussions)} discussions to {filepath}"

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/portlets.py

@@ -12,7 +12,9 @@ class PortletsExporter(BaseExporter):
 
     def dump(self) -> list[Path]:
         """Serialize object and dump it to disk."""
-        portlets = utils.get_portlets()
+        content = self.exported_content()
+        uids = set(content) if content is not None else None
+        portlets = utils.get_portlets(uids=uids)
         filepath = self._dump(portlets, self.filepath)
         logger.debug(f"- Portlets: Wrote {len(portlets)} portlets to {filepath}")
         return [filepath]

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/redirects.py

@@ -12,7 +12,9 @@ class RedirectsExporter(BaseExporter):
 
     def dump(self) -> list[Path]:
         """Serialize object and dump it to disk."""
-        redirects = utils.get_redirects()
+        content = self.exported_content()
+        paths = set(content.values()) if content is not None else None
+        redirects = utils.get_redirects(paths=paths)
         filepath = self._dump(redirects, self.filepath)
         logger.debug(f"- Redirects: Wrote {len(redirects)} redirects to {filepath}")
         return [filepath]

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/relations.py

@@ -12,7 +12,9 @@ class RelationsExporter(BaseExporter):
 
     def dump(self) -> list[Path]:
         """Serialize object and dump it to disk."""
-        relations = utils.get_relations()
+        content = self.exported_content()
+        uids = set(content) if content is not None else None
+        relations = utils.get_relations(uids=uids)
         filepath = self._dump(relations, self.filepath)
         logger.debug(f"- Relations: Wrote {len(relations)} relations to {filepath}")
         return [filepath]

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/exporters/translations.py

@@ -12,7 +12,9 @@ class TranslationsExporter(BaseExporter):
 
     def dump(self) -> list[Path]:
         """Serialize object and dump it to disk."""
-        translations = utils.get_translations()
+        content = self.exported_content()
+        uids = set(content) if content is not None else None
+        translations = utils.get_translations(uids=uids)
         filepath = self._dump(translations, self.filepath)
         logger.debug(
             f"- Translations: Wrote {len(translations)} translations to {filepath}"

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/importers/__init__.py

@@ -55,6 +55,14 @@ class Importer:
                 report.append(importer.import_data(path))
         return report
 
+    @property
+    def incomplete(self) -> dict[str, list[str]]:
+        """Items imported with errors, mapping each path to its failed fields."""
+        result: dict[str, list[str]] = {}
+        for importer in self.importers.values():
+            result.update(getattr(importer, "incomplete", {}))
+        return result
+
 
 def get_importer(site: PloneSite | None = None) -> Importer:
     """Get the importer."""

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/importers/content.py

@@ -13,11 +13,41 @@ from plone.exportimport.utils import request_provides
 import json
 
 
+def _failed_fields(exc: Exception) -> list[str]:
+    """Return the names of the fields reported in a deserialization error.
+
+    plone.restapi collects field errors and raises a single
+    :class:`zExceptions.BadRequest` whose first argument is a list of dicts,
+    each with an optional ``field`` key.
+
+    :param exc: Exception raised by the deserializer.
+    :returns: Sorted field names, or an empty list if the error does not
+        name any field.
+    """
+    errors = exc.args[0] if exc.args else None
+    if not isinstance(errors, list):
+        return []
+    fields = {
+        error["field"]
+        for error in errors
+        if isinstance(error, dict) and error.get("field")
+    }
+    return sorted(fields)
+
+
 class ContentImporter(BaseImporter):
     name: str = "content"
     metadata: types.ExportImportMetadata | None = None
     languages: types.PortalLanguages | None = None
-    dropped: set[str] = set()
+    dropped: set[str]
+    incomplete: dict[str, list[str]]
+
+    def __init__(self, site):
+        super().__init__(site)
+        # Items not created at all
+        self.dropped = set()
+        # Items created, but not fully deserialized: path -> failed fields
+        self.incomplete = {}
 
     def _cleanse_ordering(self, raw_data: dict[str, int]) -> dict[str, int]:
         """Prepare ordering data before deserialization.
@@ -60,6 +90,8 @@ class ContentImporter(BaseImporter):
             logger.error(
                 f"{config.logger_prefix} Error deserializing {obj}", exc_info=exc
             )
+            # The object exists, but some of its data was not applied
+            self.incomplete[data["@id"]] = _failed_fields(exc)
         return obj
 
     def construct(self, item: dict) -> DexterityContent | None:
@@ -210,6 +242,12 @@ class ContentImporter(BaseImporter):
             logger.warning("List of items dropped during import")
             for item_path in dropped:
                 logger.warning(f" - {item_path}")
+        # Report items that were created with missing data
+        if self.incomplete:
+            logger.error("List of items imported with errors")
+            for item_path, fields in sorted(self.incomplete.items()):
+                details = f" (fields: {', '.join(fields)})" if fields else ""
+                logger.error(f" - {item_path}{details}")
         return result
 
     def start(self):

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/interfaces.py

@@ -21,3 +21,7 @@ class INamedExporter(Interface):
 
 class INamedImporter(Interface):
     """Component to import content from a Plone Site."""
+
+
+class IObjectsExporter(Interface):
+    """Component to decide which objects are exported from a Plone Site."""

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/serializers/blob.py

@@ -78,6 +78,11 @@ def export_blob(
 
     Root path: settings.EXPORT_PATH_KEY
     File path: settings.EXPORT_CONTENT_BLOB_FILEPATH
+
+    The file name is normalized with
+    :func:`plone.exportimport.utils.path.normalize_filename`, so the path
+    written to disk, the returned path and the ``_blob_files_`` entry are the
+    same on every filesystem.
     """
     request = getRequest()
     # Metadata
@@ -85,7 +90,7 @@ def export_blob(
     uid = settings.SITE_ROOT_UID if content_utils.is_site_root(obj) else obj.UID()
     content_export_path = Path(request[settings.EXPORT_PATH_KEY])
     blob_path = settings.EXPORT_CONTENT_BLOB_FILEPATH.format(
-        UID=uid, fieldname=fieldname, filename=filename
+        UID=uid, fieldname=fieldname, filename=path_utils.normalize_filename(filename)
     )
     target_file = content_export_path / blob_path
     # Create target directory

{plone_exportimport-2.0.2 → plone_exportimport-2.2.0}/src/plone/exportimport/testing/__init__.py

@@ -10,14 +10,17 @@ class ExportImportLayer(PloneSandboxLayer):
 
     def setUpZope(self, app, configurationContext):
         import plone.exportimport
+        import plone.exportimport.testing
         import plone.volto
 
         self.loadZCML(package=plone.volto)
         self.loadZCML(package=plone.exportimport)
+        self.loadZCML(package=plone.exportimport.testing)
 
     def setUpPloneSite(self, portal):
         st = portal.portal_setup
         st.runAllImportStepsFromProfile("plone.volto:default")
+        st.runAllImportStepsFromProfile("plone.exportimport.testing:testing")
 
         # Enable plone.constraintypes behavior,
         # which is not enabled by default in plone.volto