python-pptx2 2.14.0__py3-none-any.whl → 2.16.0__py3-none-any.whl

pptx2/__init__.py

@@ -35,6 +35,7 @@ from pptx2.opc.constants import CONTENT_TYPE as CT
 from pptx2.opc.package import PartFactory
 from pptx2.parts.chart import ChartPart
 from pptx2.parts.coreprops import CorePropertiesPart
+from pptx2.parts.customprops import CustomPropertiesPart
 from pptx2.parts.diagram import (
     DiagramColorsPart,
     DiagramDataPart,
@@ -56,7 +57,7 @@ from pptx2.parts.slide import (
 if TYPE_CHECKING:
     from pptx2.opc.package import Part
 
-__version__ = "2.14.0"
+__version__ = "2.16.0"
 
 sys.modules["pptx2.exceptions"] = exceptions
 del sys
@@ -98,6 +99,7 @@ content_type_to_part_class_map: dict[str, type[Part]] = {
     CT.PML_TEMPLATE_MAIN: PresentationPart,
     CT.PML_SLIDESHOW_MAIN: PresentationPart,
     CT.OPC_CORE_PROPERTIES: CorePropertiesPart,
+    CT.OFC_CUSTOM_PROPERTIES: CustomPropertiesPart,
     CT.PML_NOTES_MASTER: NotesMasterPart,
     CT.PML_NOTES_SLIDE: NotesSlidePart,
     CT.PML_SLIDE: SlidePart,
@@ -136,6 +138,7 @@ PartFactory.part_type_for.update(content_type_to_part_class_map)
 del (
     ChartPart,
     CorePropertiesPart,
+    CustomPropertiesPart,
     DiagramColorsPart,
     DiagramDataPart,
     DiagramLayoutPart,

pptx2/_slide_importer.py

@@ -93,6 +93,37 @@ def import_slide(
     return importer.run()
 
 
+def next_layout_hierarchy_id(prs_part: PresentationPart) -> int:
+    """Return a fresh unique id for a `p:sldMasterId` / `p:sldLayoutId` entry.
+
+    These share one id space starting at 2147483648 (ST_SlideMasterId /
+    ST_SlideLayoutId minimum); duplicates across the presentation are a
+    repair trigger, so scan every master's layout-id list plus the
+    presentation's master-id list for the current maximum. Used both when
+    cloning masters (import_slide) and when adding or cloning slide layouts.
+    """
+    used = [2147483647]
+    prs_element = prs_part._element  # pyright: ignore[reportPrivateUsage]
+    used += [int(v) for v in prs_element.xpath("p:sldMasterIdLst/p:sldMasterId/@id")]
+    for dst_master_part in _iter_master_parts(prs_part):
+        used += [
+            int(v)
+            for v in dst_master_part._element.xpath(  # pyright: ignore[reportPrivateUsage]
+                "p:sldLayoutIdLst/p:sldLayoutId/@id"
+            )
+        ]
+    return max(used) + 1
+
+
+def _iter_master_parts(prs_part: PresentationPart):
+    """Yield each SlideMasterPart referenced from *prs_part*'s `p:sldMasterIdLst`."""
+    prs_element = prs_part._element  # pyright: ignore[reportPrivateUsage]
+    if prs_element.sldMasterIdLst is None:
+        return
+    for entry in prs_element.sldMasterIdLst.sldMasterId_lst:
+        yield prs_part.related_part(entry.rId)
+
+
 # ---------------------------------------------------------------------------
 # Internal implementation
 # ---------------------------------------------------------------------------
@@ -169,13 +200,9 @@ class _SlideImporter:
                 return dst_master_part
         return None
 
-    def _iter_dst_masters(self):  # type: ignore[return]
+    def _iter_dst_masters(self):
         """Yield each SlideMasterPart already in the destination presentation."""
-        prs_element = self._dst_prs_part._element  # pyright: ignore[reportPrivateUsage]
-        if prs_element.sldMasterIdLst is None:
-            return
-        for entry in prs_element.sldMasterIdLst.sldMasterId_lst:
-            yield self._dst_prs_part.related_part(entry.rId)
+        yield from _iter_master_parts(self._dst_prs_part)
 
     def _find_or_clone_layout_in_master(
         self, src_layout_part: SlideLayoutPart, dst_master_part: SlideMasterPart
@@ -325,22 +352,9 @@ class _SlideImporter:
     def _next_hierarchy_id(self) -> int:
         """Return a fresh unique id for a `p:sldMasterId` / `p:sldLayoutId` entry.
 
-        These share one id space starting at 2147483648 (ST_SlideMasterId /
-        ST_SlideLayoutId minimum); duplicates across the presentation are a
-        repair trigger, so scan every master's layout-id list plus the
-        presentation's master-id list for the current maximum.
+        See :func:`next_layout_hierarchy_id`.
         """
-        used = [2147483647]
-        prs_element = self._dst_prs_part._element  # pyright: ignore[reportPrivateUsage]
-        used += [int(v) for v in prs_element.xpath("p:sldMasterIdLst/p:sldMasterId/@id")]
-        for dst_master_part in self._iter_dst_masters():
-            used += [
-                int(v)
-                for v in dst_master_part._element.xpath(  # pyright: ignore[reportPrivateUsage]
-                    "p:sldLayoutIdLst/p:sldLayoutId/@id"
-                )
-            ]
-        return max(used) + 1
+        return next_layout_hierarchy_id(self._dst_prs_part)
 
     # ------------------------------------------------------------------
     # Slide copy

pptx2/api.py

@@ -18,12 +18,14 @@ if TYPE_CHECKING:
     from pptx2.parts.presentation import PresentationPart
 
 
-def Presentation(pptx: str | IO[bytes] | None = None) -> presentation.Presentation:
+def Presentation(
+    pptx: str | os.PathLike[str] | IO[bytes] | None = None,
+) -> presentation.Presentation:
     """
     Return a |Presentation| object loaded from *pptx*, where *pptx* can be
-    either a path to a ``.pptx`` file (a string) or a file-like object. If
-    *pptx* is missing or ``None``, the built-in default presentation
-    "template" is loaded.
+    either a path to a ``.pptx`` file (a string or ``pathlib.Path``) or a
+    file-like object. If *pptx* is missing or ``None``, the built-in default
+    presentation "template" is loaded.
     """
     if pptx is None:
         pptx = _default_pptx_path()
@@ -45,5 +47,9 @@ def _default_pptx_path() -> str:
 
 def _is_pptx_package(prs_part: PresentationPart):
     """Return |True| if *prs_part* is a valid main document part, |False| otherwise."""
-    valid_content_types = (CT.PML_PRESENTATION_MAIN, CT.PML_PRES_MACRO_MAIN)
+    valid_content_types = (
+        CT.PML_PRESENTATION_MAIN,
+        CT.PML_PRES_MACRO_MAIN,
+        CT.PML_TEMPLATE_MAIN,
+    )
     return prs_part.content_type in valid_content_types

pptx2/audit.py

@@ -30,7 +30,7 @@ The audit is read-only — it never mutates the deck.
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Iterable
 
 if TYPE_CHECKING:
     from pptx2.api import Presentation
@@ -174,15 +174,27 @@ def audit(
     *,
     size_warn_bytes: int = 2_000_000,
     check_fonts: bool = True,
+    extra_safe_fonts: "Iterable[str] | None" = None,
 ) -> AuditReport:
     """Walk the deck and return an :class:`AuditReport` summary.
 
     Read-only — never mutates the presentation.  Each slide is linted
     in passing-defaults mode; per-slide overrides should be supplied
     via the slide-level ``slide.lint(...)`` API directly.
+
+    *extra_safe_fonts* names additional fonts to treat as safe for the
+    font-warning probe, on top of the common Windows/macOS/Office set
+    (matching is case-insensitive).  Use it where the rendering
+    environment genuinely ships the font — e.g. ``DejaVu Sans`` in a
+    sandbox whose font policy standardizes on it, or a corporate font
+    you embed in every deck.
     """
     from pptx2.shapes.picture import Picture
 
+    safe_fonts = _COMMON_FONTS
+    if extra_safe_fonts is not None:
+        safe_fonts = _COMMON_FONTS | frozenset(f.lower() for f in extra_safe_fonts)
+
     report = AuditReport()
     slides = list(prs.slides)
     report.total_slides = len(slides)
@@ -249,7 +261,7 @@ def audit(
                 for para in tf.paragraphs:
                     for run in para.runs:
                         name = run.font.name
-                        if name and name.lower() not in _COMMON_FONTS:
+                        if name and name.lower() not in safe_fonts:
                             report.font_warnings.append((idx, name))
 
         if content_shapes == 0:

pptx2/chart/data.py

@@ -12,6 +12,7 @@ from pptx2.chart.xlsx import (
     XyWorkbookWriter,
 )
 from pptx2.chart.xmlwriter import ChartXmlWriter
+from pptx2.oxml.simpletypes import ST_FirstSliceAng
 from pptx2.util import lazyproperty
 
 
@@ -268,6 +269,8 @@ class CategoryChartData(_BaseChartData):
     The corresponding X value is inferred by its position in the sequence.
     """
 
+    _first_slice_angle = 0
+
     def add_category(self, label):
         """
         Return a newly created |data.Category| object having *label* and
@@ -323,6 +326,20 @@ class CategoryChartData(_BaseChartData):
         """
         return self._workbook_writer.categories_ref
 
+    @property
+    def first_slice_angle(self):
+        """
+        Read/write int in range 0..359 specifying the angle in degrees of
+        the first slice for a doughnut chart created from this chart data,
+        clockwise from 12 o'clock. The default is 0, the PowerPoint default.
+        """
+        return self._first_slice_angle
+
+    @first_slice_angle.setter
+    def first_slice_angle(self, value):
+        ST_FirstSliceAng.validate(value)
+        self._first_slice_angle = int(value)
+
     def values_ref(self, series):
         """
         The Excel worksheet reference to the values for *series* (not

pptx2/chart/plot.py

@@ -220,6 +220,25 @@ class DoughnutPlot(_BasePlot):
         holeSize = self._element.get_or_add_holeSize()
         holeSize.val = value
 
+    @property
+    def first_slice_angle(self):
+        """
+        Read/write int in range 0..359 specifying the angle in degrees of
+        the first slice of this doughnut, clockwise from 12 o'clock. The
+        PowerPoint default for a new doughnut chart is 0, which is what this
+        property reports when no explicit ``<c:firstSliceAng>`` element is
+        present.
+        """
+        firstSliceAng = self._element.firstSliceAng
+        if firstSliceAng is None:
+            return 0
+        return firstSliceAng.val
+
+    @first_slice_angle.setter
+    def first_slice_angle(self, value):
+        firstSliceAng = self._element.get_or_add_firstSliceAng()
+        firstSliceAng.val = value
+
 
 class LinePlot(_BasePlot):
     """

pptx2/chart/xmlwriter.py

@@ -669,7 +669,7 @@ class _DoughnutChartXmlWriter(_BaseChartXmlWriter):
             '          <c:showBubbleSize val="0"/>\n'
             '          <c:showLeaderLines val="1"/>\n'
             "        </c:dLbls>\n"
-            '        <c:firstSliceAng val="0"/>\n'
+            '        <c:firstSliceAng val="{firstSliceAng}"/>\n'
             '        <c:holeSize val="50"/>\n'
             "      </c:doughnutChart>\n"
             "    </c:plotArea>\n"
@@ -693,7 +693,7 @@ class _DoughnutChartXmlWriter(_BaseChartXmlWriter):
             "    </a:p>\n"
             "  </c:txPr>\n"
             "</c:chartSpace>\n"
-        ).format(**{"ser_xml": self._ser_xml})
+        ).format(**{"ser_xml": self._ser_xml, "firstSliceAng": self._firstSliceAng})
 
     @property
     def _explosion_xml(self):
@@ -701,6 +701,15 @@ class _DoughnutChartXmlWriter(_BaseChartXmlWriter):
             return '          <c:explosion val="25"/>\n'
         return ""
 
+    @property
+    def _firstSliceAng(self):
+        """
+        The integer angle in degrees for the ``<c:firstSliceAng>`` element,
+        taken from the chart data object when it specifies one and 0
+        (the PowerPoint default) otherwise.
+        """
+        return getattr(self._chart_data, "first_slice_angle", 0)
+
     @property
     def _ser_xml(self):
         xml = ""

pptx2/enum/text.py

@@ -228,3 +228,75 @@ class PP_PARAGRAPH_ALIGNMENT(BaseXmlEnum):
 
 
 PP_ALIGN = PP_PARAGRAPH_ALIGNMENT
+
+
+class MSO_TEXT_FIELD_TYPE(BaseXmlEnum):
+    """Specifies the kind of value a text field (`a:fld`) displays.
+
+    Used with :meth:`.Paragraph.add_field` to add a run-like field element to a paragraph.
+    The field's displayed text (the actual slide number, the current date, ...) is computed by
+    PowerPoint when the slide is rendered; the `a:t` child element holds only the "cached"
+    placeholder text readers that do not compute fields will show.
+
+    Example::
+
+        from pptx2.enum.text import MSO_TEXT_FIELD_TYPE
+
+        paragraph.add_field(MSO_TEXT_FIELD_TYPE.SLIDE_NUMBER)
+
+    The XML tokens are the ST_TextFieldType values DrawingML defines ("slidenum", "datetime",
+    "datetime1" through "datetime13") plus "datetimeFigureOut", the token PowerPoint writes for
+    an automatically updated date.
+    """
+
+    SLIDE_NUMBER = (1, "slidenum", "The number of the slide the field appears on.")
+    """The number of the slide the field appears on."""
+
+    DATETIME = (2, "datetime", "The date and time in the containing document's default format.")
+    """The date and time in the containing document's default format."""
+
+    DATETIME_1 = (3, "datetime1", "Predefined date/time format 1 (locale-dependent rendering).")
+    """Predefined date/time format 1 (locale-dependent rendering)."""
+
+    DATETIME_2 = (4, "datetime2", "Predefined date/time format 2 (locale-dependent rendering).")
+    """Predefined date/time format 2 (locale-dependent rendering)."""
+
+    DATETIME_3 = (5, "datetime3", "Predefined date/time format 3 (locale-dependent rendering).")
+    """Predefined date/time format 3 (locale-dependent rendering)."""
+
+    DATETIME_4 = (6, "datetime4", "Predefined date/time format 4 (locale-dependent rendering).")
+    """Predefined date/time format 4 (locale-dependent rendering)."""
+
+    DATETIME_5 = (7, "datetime5", "Predefined date/time format 5 (locale-dependent rendering).")
+    """Predefined date/time format 5 (locale-dependent rendering)."""
+
+    DATETIME_6 = (8, "datetime6", "Predefined date/time format 6 (locale-dependent rendering).")
+    """Predefined date/time format 6 (locale-dependent rendering)."""
+
+    DATETIME_7 = (9, "datetime7", "Predefined date/time format 7 (locale-dependent rendering).")
+    """Predefined date/time format 7 (locale-dependent rendering)."""
+
+    DATETIME_8 = (10, "datetime8", "Predefined date/time format 8 (locale-dependent rendering).")
+    """Predefined date/time format 8 (locale-dependent rendering)."""
+
+    DATETIME_9 = (11, "datetime9", "Predefined date/time format 9 (locale-dependent rendering).")
+    """Predefined date/time format 9 (locale-dependent rendering)."""
+
+    DATETIME_10 = (12, "datetime10", "Predefined date/time format 10 (locale-dependent rendering).")
+    """Predefined date/time format 10 (locale-dependent rendering)."""
+
+    DATETIME_11 = (13, "datetime11", "Predefined date/time format 11 (locale-dependent rendering).")
+    """Predefined date/time format 11 (locale-dependent rendering)."""
+
+    DATETIME_12 = (14, "datetime12", "Predefined date/time format 12 (locale-dependent rendering).")
+    """Predefined date/time format 12 (locale-dependent rendering)."""
+
+    DATETIME_13 = (15, "datetime13", "Predefined date/time format 13 (locale-dependent rendering).")
+    """Predefined date/time format 13 (locale-dependent rendering)."""
+
+    DATETIME_FIGURE_OUT = (
+        16,
+        "datetimeFigureOut",
+        "The current date, in the format PowerPoint figures out automatically.",
+    )
+    """The current date, in the format PowerPoint figures out automatically."""

pptx2/opc/package.py

@@ -7,6 +7,7 @@ presentations to and from a .pptx file.
 from __future__ import annotations
 
 import collections
+import os
 from typing import IO, TYPE_CHECKING, DefaultDict, Iterator, Mapping, Set, cast
 
 from pptx2.opc.constants import RELATIONSHIP_TARGET_MODE as RTM
@@ -73,11 +74,11 @@ class OpcPackage(_RelatableMixin):
     file or file-like object containing a package (.pptx file).
     """
 
-    def __init__(self, pkg_file: str | IO[bytes]):
+    def __init__(self, pkg_file: str | os.PathLike[str] | IO[bytes]):
         self._pkg_file = pkg_file
 
     @classmethod
-    def open(cls, pkg_file: str | IO[bytes]) -> Self:
+    def open(cls, pkg_file: str | os.PathLike[str] | IO[bytes]) -> Self:
         """Return an |OpcPackage| instance loaded with the contents of `pkg_file`."""
         return cls(pkg_file)._load()
 
@@ -148,10 +149,10 @@ class OpcPackage(_RelatableMixin):
                 return PackURI(candidate_partname)
         raise Exception("ProgrammingError: ran out of candidate_partnames")  # pragma: no cover
 
-    def save(self, pkg_file: str | IO[bytes]) -> None:
+    def save(self, pkg_file: str | os.PathLike[str] | IO[bytes]) -> None:
         """Save this package to `pkg_file`.
 
-        `file` can be either a path to a file (a string) or a file-like object.
+        `file` can be either a path to a file (a string or `pathlib.Path`) or a file-like object.
         """
         PackageWriter.write(pkg_file, self._rels, tuple(self.iter_parts()))
 
@@ -170,13 +171,13 @@ class OpcPackage(_RelatableMixin):
 class _PackageLoader:
     """Function-object that loads a package from disk (or other store)."""
 
-    def __init__(self, pkg_file: str | IO[bytes], package: Package):
+    def __init__(self, pkg_file: str | os.PathLike[str] | IO[bytes], package: Package):
         self._pkg_file = pkg_file
         self._package = package
 
     @classmethod
     def load(
-        cls, pkg_file: str | IO[bytes], package: Package
+        cls, pkg_file: str | os.PathLike[str] | IO[bytes], package: Package
     ) -> tuple[CT_Relationships, dict[PackURI, Part]]:
         """Return (pkg_xml_rels, parts) pair resulting from loading `pkg_file`.
 
@@ -360,11 +361,11 @@ class Part(_RelatableMixin):
         # --- this must be public to allow the part graph to be traversed ---
         return self._rels
 
-    def _blob_from_file(self, file: str | IO[bytes]) -> bytes:
-        """Return bytes of `file`, which is either a str path or a file-like object."""
-        # --- a str `file` is assumed to be a path ---
-        if isinstance(file, str):
-            with open(file, "rb") as f:
+    def _blob_from_file(self, file: str | os.PathLike[str] | IO[bytes]) -> bytes:
+        """Return bytes of `file`, which is either a path or a file-like object."""
+        # --- a path-like `file` is assumed to be a path ---
+        if isinstance(file, (str, os.PathLike)):
+            with open(os.fspath(file), "rb") as f:
                 return f.read()
 
         # --- otherwise, assume `file` is a file-like object

pptx2/opc/serialized.py

@@ -26,7 +26,7 @@ class PackageReader(Container[bytes]):
     perhaps by unzipping a .pptx file.
     """
 
-    def __init__(self, pkg_file: str | IO[bytes]):
+    def __init__(self, pkg_file: str | os.PathLike[str] | IO[bytes]):
         self._pkg_file = pkg_file
 
     def __contains__(self, pack_uri: object) -> bool:
@@ -62,14 +62,22 @@ class PackageWriter:
     Its single API classmethod is :meth:`write`. This class is not intended to be instantiated.
     """
 
-    def __init__(self, pkg_file: str | IO[bytes], pkg_rels: _Relationships, parts: Sequence[Part]):
+    def __init__(
+        self,
+        pkg_file: str | os.PathLike[str] | IO[bytes],
+        pkg_rels: _Relationships,
+        parts: Sequence[Part],
+    ):
         self._pkg_file = pkg_file
         self._pkg_rels = pkg_rels
         self._parts = parts
 
     @classmethod
     def write(
-        cls, pkg_file: str | IO[bytes], pkg_rels: _Relationships, parts: Sequence[Part]
+        cls,
+        pkg_file: str | os.PathLike[str] | IO[bytes],
+        pkg_rels: _Relationships,
+        parts: Sequence[Part],
     ) -> None:
         """Write a physical package (.pptx file) to `pkg_file`.
 
@@ -127,21 +135,22 @@ class _PhysPkgReader(Container[PackURI]):
         )
 
     @classmethod
-    def factory(cls, pkg_file: str | IO[bytes]) -> _PhysPkgReader:
+    def factory(cls, pkg_file: str | os.PathLike[str] | IO[bytes]) -> _PhysPkgReader:
         """Return |_PhysPkgReader| subtype instance appropriage for `pkg_file`."""
-        # --- for pkg_file other than str, assume it's a stream and pass it to Zip
+        # --- for pkg_file other than a path, assume it's a stream and pass it to Zip
         # --- reader to sort out
-        if not isinstance(pkg_file, str):
+        if not isinstance(pkg_file, (str, os.PathLike)):
             return _ZipPkgReader(pkg_file)
 
         # --- otherwise we treat `pkg_file` as a path ---
-        if os.path.isdir(pkg_file):
-            return _DirPkgReader(pkg_file)
+        path = os.fspath(pkg_file)
+        if os.path.isdir(path):
+            return _DirPkgReader(path)
 
-        if zipfile.is_zipfile(pkg_file):
-            return _ZipPkgReader(pkg_file)
+        if zipfile.is_zipfile(path):
+            return _ZipPkgReader(path)
 
-        raise PackageNotFoundError("Package not found at '%s'" % pkg_file)
+        raise PackageNotFoundError("Package not found at '%s'" % path)
 
 
 class _DirPkgReader(_PhysPkgReader):
@@ -172,7 +181,7 @@ class _DirPkgReader(_PhysPkgReader):
 class _ZipPkgReader(_PhysPkgReader):
     """Implements |PhysPkgReader| interface for a zip-file OPC package."""
 
-    def __init__(self, pkg_file: str | IO[bytes]):
+    def __init__(self, pkg_file: str | os.PathLike[str] | IO[bytes]):
         self._pkg_file = pkg_file
 
     def __contains__(self, pack_uri: object) -> bool:
@@ -199,7 +208,7 @@ class _PhysPkgWriter:
     """Base class for physical package writer objects."""
 
     @classmethod
-    def factory(cls, pkg_file: str | IO[bytes]) -> _ZipPkgWriter:
+    def factory(cls, pkg_file: str | os.PathLike[str] | IO[bytes]) -> _ZipPkgWriter:
         """Return |_PhysPkgWriter| subtype instance appropriage for `pkg_file`.
 
         Currently the only subtype is `_ZipPkgWriter`, but a `_DirPkgWriter` could be implemented
@@ -217,7 +226,7 @@ class _PhysPkgWriter:
 class _ZipPkgWriter(_PhysPkgWriter):
     """Implements |PhysPkgWriter| interface for a zip-file (.pptx file) OPC package."""
 
-    def __init__(self, pkg_file: str | IO[bytes]):
+    def __init__(self, pkg_file: str | os.PathLike[str] | IO[bytes]):
         self._pkg_file = pkg_file
 
     def __enter__(self) -> _ZipPkgWriter:

pptx2/oxml/__init__.py

@@ -213,8 +213,10 @@ register_element_cls("c:xMode", CT_LayoutMode)
 
 
 from pptx2.oxml.coreprops import CT_CoreProperties  # noqa: E402
+from pptx2.oxml.customprops import CT_CustomProperties  # noqa: E402
 
 register_element_cls("cp:coreProperties", CT_CoreProperties)
+register_element_cls("custom:Properties", CT_CustomProperties)
 
 
 from pptx2.oxml.dml.color import (  # noqa: E402
@@ -324,6 +326,8 @@ register_element_cls("a:prstDash", CT_PresetLineDashProperties)
 
 
 from pptx2.oxml.presentation import (  # noqa: E402
+    CT_NotesMasterIdList,
+    CT_NotesMasterIdListEntry,
     CT_Presentation,
     CT_SlideId,
     CT_SlideIdList,
@@ -332,6 +336,8 @@ from pptx2.oxml.presentation import (  # noqa: E402
     CT_SlideSize,
 )
 
+register_element_cls("p:notesMasterId", CT_NotesMasterIdListEntry)
+register_element_cls("p:notesMasterIdLst", CT_NotesMasterIdList)
 register_element_cls("p:presentation", CT_Presentation)
 register_element_cls("p:sldId", CT_SlideId)
 register_element_cls("p:sldIdLst", CT_SlideIdList)

pptx2/oxml/chart/plot.py

@@ -6,6 +6,7 @@ from pptx2.oxml.chart.datalabel import CT_DLbls
 from pptx2.oxml.simpletypes import (
     ST_BarDir,
     ST_BubbleScale,
+    ST_FirstSliceAng,
     ST_GapAmount,
     ST_Grouping,
     ST_HoleSize,
@@ -241,10 +242,21 @@ class CT_DoughnutChart(BaseChartElement):
     varyColors = ZeroOrOne("c:varyColors", successors=_tag_seq[1:])
     ser = ZeroOrMore("c:ser", successors=_tag_seq[2:])
     dLbls = ZeroOrOne("c:dLbls", successors=_tag_seq[3:])
+    firstSliceAng = ZeroOrOne("c:firstSliceAng", successors=_tag_seq[4:])
     holeSize = ZeroOrOne("c:holeSize", successors=_tag_seq[5:])
     del _tag_seq
 
 
+class CT_FirstSliceAng(BaseOxmlElement):
+    """
+    ``<c:firstSliceAng>`` child of a ``<c:doughnutChart>`` element,
+    specifying the angle in degrees of the first slice, clockwise from 12
+    o'clock.
+    """
+
+    val = OptionalAttribute("val", ST_FirstSliceAng, default=0)
+
+
 class CT_GapAmount(BaseOxmlElement):
     """
     ``<c:gapWidth>`` child of ``<c:barChart>`` element, also used for other
@@ -362,4 +374,5 @@ class CT_ScatterChart(BaseChartElement):
 # -- avoid a circular import at package-initialization time.
 from pptx2.oxml import register_element_cls  # noqa: E402
 
+register_element_cls("c:firstSliceAng", CT_FirstSliceAng)
 register_element_cls("c:holeSize", CT_HoleSize)