python-pptx2 2.14.0__tar.gz → 2.16.0__tar.gz

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/HISTORY.rst

@@ -15,6 +15,126 @@ can sit beside both ``python-pptx`` (``pptx``) and ``power-pptx``
 .. _`scanny/python-pptx`: https://github.com/scanny/python-pptx
 
 
+2.16.0 (2026-08-30)
++++++++++++++++++++
+
+Added
+.....
+
+* ``audit(..., extra_safe_fonts=[...])`` — the font-warning probe now
+  accepts additional fonts to treat as safe (case-insensitive), on top
+  of the built-in common Windows/macOS/Office list. For rendering
+  environments that genuinely ship a font the built-in list doesn't
+  know — e.g. a Linux sandbox whose font policy standardizes on
+  ``DejaVu Sans`` — this keeps the audit signal instead of drowning it
+  in per-slide warnings.
+
+
+2.15.0 (2026-08-30)
++++++++++++++++++++
+
+Twelve ports from the upstream ``scanny/python-pptx`` pull-request
+backlog, triaged against this fork's existing surface: four correctness
+fixes (notes-master registration, ``.potx`` opening, MPO images,
+``PathLike`` inputs) and eight features (``add_paragraph(text=...)``,
+``get_by_name()`` on shape collections, doughnut first-slice angle,
+``Slides.remove()``, table row/column add & remove, custom document
+properties, slide-number/date fields, slide-layout authoring).
+
+Added
+.....
+
+* ``TextFrame.add_paragraph()`` accepts an optional ``text`` argument.
+  When given, the new paragraph carries that text as a single run
+  (``add_paragraph("Hello")`` is equivalent to ``add_paragraph()``
+  followed by setting ``.text``); when omitted, an empty paragraph is
+  added exactly as before (upstream feature by kckaiwei,
+  ``scanny/python-pptx#602``).
+* ``get_by_name(name, default=None)`` on shape collections
+  (``slide.shapes``, layout/master/notes shape trees, group shapes, and
+  placeholder collections via ``_BaseShapes``) — returns the first
+  shape whose ``name`` matches, or ``default`` when none does
+  (port of `scanny/python-pptx#798`_ by lthamm).
+
+.. _`scanny/python-pptx#798`: https://github.com/scanny/python-pptx/pull/798
+* ``DoughnutPlot.first_slice_angle`` — read/write angle in degrees
+  (0–359) of the first doughnut slice, mapped to the
+  ``<c:firstSliceAng>`` element. ``CategoryChartData.first_slice_angle``
+  bakes the angle into charts created with ``add_chart``; the plot
+  property also works on charts opened from a file.
+* ``prs.slides.remove(slide)`` — delete a slide from the presentation,
+  accepting either the |Slide| object or its integer slide id (upstream's
+  ``remove_slide`` signature). Purges ``p14:section`` membership and drops
+  the presentation→slide relationship so the slide part (and its notes
+  slide) fall out of the saved package. Raises ``ValueError`` for a slide
+  not in the collection. Removing the last slide yields a valid, empty
+  deck.
+* ``table.rows.add_row()`` / ``table.rows.remove(row_or_idx)`` and
+  ``table.columns.add_column(width=None)`` /
+  ``table.columns.remove(col_or_idx)`` — grow and shrink an existing
+  table. A new row/column copies the height/width and cell formatting
+  of the last row/column and arrives empty and unmerged; removal keeps
+  the one-``a:tc``-per-``a:gridCol`` invariant, resizes the graphic
+  frame, and raises ``ValueError`` rather than truncate a merged cell
+  spanning multiple rows/columns. Port of scanny/python-pptx#399 by
+  Ignisor.
+* ``prs.custom_properties`` — mapping-style read/write access to the
+  user-defined document properties in ``/docProps/custom.xml``.
+  ``get``/``set``/``delete`` with ``str``, ``int``, ``float``, and
+  ``bool`` values (stored as ``vt:lpstr``, ``vt:i4``, ``vt:r8``, and
+  ``vt:bool``); the part and its package-root relationship are created
+  lazily by the first assignment, and files that already carry a
+  custom-properties part open mapped to the new part class. Port of
+  ``scanny/python-pptx#342`` by stadlerism.
+* ``SlideLayouts.add_layout()`` appends a blank slide layout to a slide
+  master, named ``"Layout %s"`` by default (the ``%s`` is substituted with
+  the new master-to-layout relationship id). ``SlideLayouts.clone()``
+  deep-copies an existing layout of the same presentation — placeholders,
+  shapes, and referenced images included — under a non-colliding name, and
+  ``LayoutShapes.add_placeholder()`` adds a placeholder to a layout,
+  defaulting its idx to the matching master placeholder so inheritance and
+  ``slide.shapes.title`` keep working.
+
+
+Fixed
+.....
+
+* Creating a notes master (``prs.notes_master`` on a deck without one,
+  e.g. the default template) related the new part but never wrote the
+  matching ``p:notesMasterIdLst`` / ``p:notesMasterId`` entry into
+  ``presentation.xml``, so PowerPoint could flag the saved file for
+  repair. The id list is now registered on creation and reconciled on
+  access for decks saved by older versions (port of
+  scanny/python-pptx#1128 by robbybrodie).
+* ``@lazyproperty`` now caches a getter that legitimately returns
+  ``None``. The instance-cache hit test compared the cached value to
+  ``None``, so a ``None``-returning getter was silently re-evaluated on
+  every access, contradicting the decorator's documented evaluate-once
+  guarantee. The check is now key presence in the host object's
+  ``__dict__`` (upstream fix by Afonso Januário,
+  ``fix/lazyproperty-none-value-caching``).
+* MPO-encoded JPEG images (multi-picture object files common from
+  cameras, ``.mpo``) are accepted by ``add_picture()`` and
+  ``Image.from_file()`` instead of raising ``ValueError: unsupported
+  image format``. Pillow reports these as format ``MPO``; they are
+  mapped to the canonical ``jpg`` extension and ``image/jpeg``
+  content type (port of scanny/python-pptx#1075 by riparuk).
+* ``Presentation()`` now opens ``.potx`` template files. The main-document
+  part check only accepted the presentation and macro-enabled presentation
+  content types, so a template package raised ``ValueError``; the
+  ``presentationml.template.main+xml`` type is now accepted as well (port
+  of scanny/python-pptx#1071 by 9021007).
+* ``os.PathLike`` inputs (e.g. ``pathlib.Path``) are now accepted
+  wherever a file path was: ``Presentation()`` open and ``save()``,
+  ``Image.from_file()``, ``shapes.add_picture()``, and picture-placeholder
+  ``insert_picture()``. Previously a ``Path`` raised ``TypeError`` from
+  ``Image.from_file()`` and was misrouted as a stream by the package
+  reader. No behavior change for ``str`` or file-like inputs (port of
+  `scanny/python-pptx#1123`_ by AlexanderWillner).
+
+.. _`scanny/python-pptx#1123`: https://github.com/scanny/python-pptx/pull/1123
+
+
 2.14.0 (2026-08-26)
 +++++++++++++++++++
 
@@ -28,6 +148,12 @@ to concatenated digits (``7/10`` → ``710``). Slides now declare the
 Added
 .....
 
+* ``Paragraph.add_field()`` appends slide-number and date/time fields
+  (``a:fld``) to a paragraph, with the new ``MSO_TEXT_FIELD_TYPE``
+  enumeration covering the ``slidenum`` / ``datetime*`` tokens. Fields are
+  created with the schema-required braced GUID ``id`` and a cached-text
+  (``a:t``) placeholder PowerPoint replaces with the computed value at
+  render time; ``_Field`` exposes ``type``, ``text``, and ``font``.
 * **Bundled ``pptx2.mathml2omml``** — spec-compliant ``m:f`` / ``m:rad``
   / ``m:nary`` / ``m:sSub`` / matrices / accents. ``python-pptx2[math]``
   now only needs ``latex2mathml``.

{python_pptx2-2.14.0/src/python_pptx2.egg-info → python_pptx2-2.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-pptx2
-Version: 2.14.0
+Version: 2.16.0
 Summary: Create, read, and update PowerPoint 2007+ (.pptx) files. Fork of power-pptx / python-pptx, published as python-pptx2.
 Author: Matěj Štágl
 Author-email: stagl@wattlescript.org

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/features/steps/table.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from behave import given, then, when
-from helpers import test_pptx
+from helpers import saved_pptx_path, test_pptx
 
 from pptx2 import Presentation
 from pptx2.enum.text import MSO_ANCHOR  # noqa # pyright: ignore[reportUnusedImport]
@@ -16,6 +16,8 @@ from pptx2.util import Inches
 @given("a 2x2 Table object as table")
 def given_a_2x2_Table_object_as_table(context):
     prs = Presentation(test_pptx("shp-shapes"))
+    # ---prs is stashed so a later "I save the presentation" step can save it---
+    context.prs = prs
     context.table_ = prs.slides[0].shapes[3].table
 
 
@@ -152,6 +154,26 @@ def when_I_call_origin_cell_merge_other_cell(context):
     context.origin_cell.merge(context.other_cell)
 
 
+@when("I add a row to the table")
+def when_I_add_a_row_to_the_table(context):
+    context.table_.rows.add_row()
+
+
+@when("I add a column to the table")
+def when_I_add_a_column_to_the_table(context):
+    context.table_.columns.add_column()
+
+
+@when("I remove the second row of the table")
+def when_I_remove_the_second_row_of_the_table(context):
+    context.table_.rows.remove(1)
+
+
+@when("I remove the second column of the table")
+def when_I_remove_the_second_column_of_the_table(context):
+    context.table_.columns.remove(1)
+
+
 # then ====================================================
 
 
@@ -298,6 +320,24 @@ def then_table_rows_is_a_type_object(context, type_name):
     assert actual == expected, "table.rows is a %s object" % actual
 
 
+@then("the saved table has {int_lit} rows")
+@then("the saved table has {int_lit} row")
+def then_the_saved_table_has_n_rows(context, int_lit):
+    table = Presentation(saved_pptx_path).slides[0].shapes[3].table
+    actual = len(table.rows)
+    expected = int(int_lit)
+    assert actual == expected, "the saved table has %s rows" % actual
+
+
+@then("the saved table has {int_lit} columns")
+@then("the saved table has {int_lit} column")
+def then_the_saved_table_has_n_columns(context, int_lit):
+    table = Presentation(saved_pptx_path).slides[0].shapes[3].table
+    actual = len(table.columns)
+    expected = int(int_lit)
+    assert actual == expected, "the saved table has %s columns" % actual
+
+
 @then("table.vert_banding is {bool_lit}")
 def then_table_vert_banding_is_value(context, bool_lit):
     actual = context.table_.vert_banding

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/features/tbl-table.feature

@@ -58,3 +58,31 @@ Feature: Table properties and methods
      Given a 2x2 Table object as table
       When I assign table.vert_banding = True
       Then table.vert_banding is True
+
+
+  Scenario: Append table row
+     Given a 2x2 Table object as table
+      When I add a row to the table
+       And I save the presentation
+      Then the saved table has 3 rows
+
+
+  Scenario: Remove table row
+     Given a 2x2 Table object as table
+      When I remove the second row of the table
+       And I save the presentation
+      Then the saved table has 1 row
+
+
+  Scenario: Append table column
+     Given a 2x2 Table object as table
+      When I add a column to the table
+       And I save the presentation
+      Then the saved table has 3 columns
+
+
+  Scenario: Remove table column
+     Given a 2x2 Table object as table
+      When I remove the second column of the table
+       And I save the presentation
+      Then the saved table has 1 column

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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,

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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:

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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):
     """

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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 = ""

{python_pptx2-2.14.0 → python_pptx2-2.16.0}/src/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."""