python-pages 0.1.0__py3-none-any.whl

pages/text.py

@@ -0,0 +1,294 @@
+"""Schema-aware helpers for TSWP storage and character styles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .iwa import ArchiveSegment, MessageInfo
+from .protobuf import Message, encode_varint, read_varint
+
+TYPE_STORAGE = 2001
+TYPE_CHARACTER_STYLE = 2021
+TYPE_PARAGRAPH_STYLE = 2022
+
+STORAGE_TEXT = 3
+STORAGE_TABLE_PARA_STYLE = 5
+STORAGE_TABLE_CHAR_STYLE = 8
+STYLE_SUPER = 1
+STYLE_CHAR_PROPERTIES = 11
+CHAR_BOLD = 1
+CHAR_FONT_NAME = 5
+DEFAULT_BOLD_FONT_NAME = "PUDReiminPr6N-Bold"
+
+INDEXED_STORAGE_TABLES = (
+    5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 28
+)
+OVERLAPPING_STORAGE_TABLES = (25, 26)
+
+
+@dataclass(frozen=True)
+class AttributeRun:
+    character_index: int
+    object_id: int | None
+
+
+@dataclass
+class LocatedObject:
+    filename: str
+    segment: ArchiveSegment
+    info: MessageInfo
+    message: Message
+
+
+def parse_reference(data: bytes) -> int | None:
+    message = Message.parse(data)
+    field = message.one(1)
+    return int(field.value) if field is not None else None
+
+
+def make_reference(identifier: int) -> bytes:
+    message = Message()
+    message.add_varint(1, identifier)
+    return message.encode()
+
+
+def parse_attribute_table(data: bytes) -> list[AttributeRun]:
+    table = Message.parse(data)
+    result: list[AttributeRun] = []
+    for raw_entry in table.get(1):
+        entry = Message.parse(bytes(raw_entry.value))
+        index = entry.one(1)
+        if index is None:
+            raise ValueError("ObjectAttributeTable entry lacks character_index")
+        obj = entry.one(2)
+        result.append(AttributeRun(int(index.value), parse_reference(bytes(obj.value)) if obj else None))
+    return sorted(result, key=lambda item: item.character_index)
+
+
+def encode_attribute_table(runs: list[AttributeRun]) -> bytes:
+    table = Message()
+    for run in sorted(runs, key=lambda item: item.character_index):
+        entry = Message()
+        entry.add_varint(1, run.character_index)
+        if run.object_id is not None:
+            entry.add_bytes(2, make_reference(run.object_id))
+        table.add_bytes(1, entry.encode())
+    return table.encode()
+
+
+def style_at(runs: list[AttributeRun], index: int) -> int | None:
+    current = None
+    for run in runs:
+        if run.character_index > index:
+            break
+        current = run.object_id
+    return current
+
+
+def replace_style_range(
+    runs: list[AttributeRun],
+    start: int,
+    end: int,
+    style_id: int | None,
+    *,
+    compact: bool = True,
+) -> list[AttributeRun]:
+    if start < 0 or end <= start:
+        raise ValueError("range must be non-empty and non-negative")
+    restore = style_at(runs, end)
+    result = [run for run in runs if not (start <= run.character_index < end)]
+    result = [run for run in result if run.character_index not in (start, end)]
+    result.extend([AttributeRun(start, style_id), AttributeRun(end, restore)])
+    result.sort(key=lambda item: item.character_index)
+    if not compact:
+        # Paragraph tables use explicit entries as paragraph boundaries, including
+        # adjacent entries with the same effective style. They must survive a
+        # style edit even though they are redundant for style lookup alone.
+        return result
+    # Adjacent entries with the same effective style are redundant.
+    compact: list[AttributeRun] = []
+    for run in result:
+        if compact and compact[-1].object_id == run.object_id:
+            continue
+        compact.append(run)
+    return compact
+
+
+def utf16_length(text: str) -> int:
+    return len(text.encode("utf-16-le")) // 2
+
+
+def rewrite_indexed_table(
+    data: bytes, start: int, end: int, replacement_length: int
+) -> bytes:
+    """Rewrite a character-indexed attribute table after one text replacement."""
+    delta = replacement_length - (end - start)
+    table = Message.parse(data)
+    rewritten = []
+    for raw in table.fields:
+        if raw.number != 1 or raw.wire_type != 2:
+            rewritten.append(raw)
+            continue
+        entry = Message.parse(bytes(raw.value))
+        index = entry.one(1)
+        if index is None or index.wire_type != 0:
+            raise ValueError("attribute-table entry lacks a varint character_index")
+        value = int(index.value)
+        if start < value < end:
+            continue
+        if value >= end:
+            index.set_varint(value + delta)
+            raw.set_bytes(entry.encode())
+        rewritten.append(raw)
+    # A deletion can move the restore boundary at ``end`` onto an existing
+    # boundary at ``start``. Pages rejects a paragraph-style table containing
+    # duplicate offsets, so retain the later entry (the style after the
+    # deleted range) for every indexed attribute table.
+    seen_indices: set[int] = set()
+    deduplicated_reversed = []
+    for raw in reversed(rewritten):
+        if raw.number != 1 or raw.wire_type != 2:
+            deduplicated_reversed.append(raw)
+            continue
+        entry = Message.parse(bytes(raw.value))
+        index = entry.one(1)
+        if index is None or index.wire_type != 0:
+            deduplicated_reversed.append(raw)
+            continue
+        value = int(index.value)
+        if value in seen_indices:
+            continue
+        seen_indices.add(value)
+        deduplicated_reversed.append(raw)
+    table.fields = list(reversed(deduplicated_reversed))
+    return table.encode()
+
+
+def rewrite_overlapping_table(
+    data: bytes, start: int, end: int, replacement_length: int
+) -> bytes:
+    """Rewrite TSP.Range entries in an OverlappingFieldAttributeTable."""
+    delta = replacement_length - (end - start)
+
+    def left_position(value: int) -> int:
+        if value <= start:
+            return value
+        if value >= end:
+            return value + delta
+        return start
+
+    def right_position(value: int) -> int:
+        if value <= start:
+            return value
+        if value >= end:
+            return value + delta
+        return start + replacement_length
+
+    table = Message.parse(data)
+    for raw in table.get(1):
+        entry = Message.parse(bytes(raw.value))
+        range_field = entry.one(1)
+        if range_field is None:
+            raise ValueError("overlapping attribute entry lacks TSP.Range")
+        range_message = Message.parse(bytes(range_field.value))
+        location = range_message.one(1)
+        length = range_message.one(2)
+        if location is None or length is None:
+            raise ValueError("TSP.Range lacks location or length")
+        old_start = int(location.value)
+        old_end = old_start + int(length.value)
+        new_start = left_position(old_start)
+        new_end = max(new_start, right_position(old_end))
+        location.set_varint(new_start)
+        length.set_varint(new_end - new_start)
+        range_field.set_bytes(range_message.encode())
+        raw.set_bytes(entry.encode())
+    return table.encode()
+
+
+def replace_storage_text(
+    storage: LocatedObject, start: int, end: int, value: str
+) -> int:
+    """Replace a UTF-16 range and propagate offsets through all storage tables."""
+    if not isinstance(value, str):
+        raise TypeError("replacement text must be a string")
+    text = "".join(bytes(field.value).decode("utf-8") for field in storage.message.get(3))
+    total = utf16_length(text)
+    if start < 0 or end < start or end > total:
+        raise ValueError("replacement range must be ordered and within storage text")
+    if start == end and not value:
+        return 0
+    start_cp = utf16_to_codepoint(text, start)
+    end_cp = utf16_to_codepoint(text, end)
+    updated_text = text[:start_cp] + value + text[end_cp:]
+    replacement_length = utf16_length(value)
+
+    text_fields = storage.message.get(3)
+    if text_fields:
+        text_fields[0].set_bytes(updated_text.encode("utf-8"))
+        storage.message.fields = [
+            field
+            for field in storage.message.fields
+            if field.number != 3 or field is text_fields[0]
+        ]
+    else:
+        storage.message.add_bytes(3, updated_text.encode("utf-8"))
+
+    for number in INDEXED_STORAGE_TABLES:
+        field = storage.message.one(number)
+        if field is not None:
+            field.set_bytes(
+                rewrite_indexed_table(bytes(field.value), start, end, replacement_length)
+            )
+    for number in OVERLAPPING_STORAGE_TABLES:
+        field = storage.message.one(number)
+        if field is not None:
+            field.set_bytes(
+                rewrite_overlapping_table(bytes(field.value), start, end, replacement_length)
+            )
+    return replacement_length - (end - start)
+
+
+def unpack_packed_varints(data: bytes) -> list[int]:
+    values: list[int] = []
+    pos = 0
+    while pos < len(data):
+        value, pos = read_varint(data, pos)
+        values.append(value)
+    return values
+
+
+def add_object_reference(info: MessageInfo, identifier: int) -> None:
+    fields = info.message.get(5)
+    if fields:
+        field = fields[0]
+        values = unpack_packed_varints(bytes(field.value))
+        if identifier not in values:
+            field.set_bytes(bytes(field.value) + encode_varint(identifier))
+            info.field.children = info.message
+            info.field.dirty = True
+    else:
+        info.message.add_bytes(5, encode_varint(identifier))
+        info.field.children = info.message
+        info.field.dirty = True
+
+
+def codepoint_to_utf16(text: str, index: int) -> int:
+    if index < 0 or index > len(text):
+        raise IndexError("text index out of bounds")
+    return len(text[:index].encode("utf-16-le")) // 2
+
+
+def utf16_to_codepoint(text: str, index: int) -> int:
+    if index < 0:
+        raise IndexError("UTF-16 index out of bounds")
+    units = 0
+    for position, character in enumerate(text):
+        if units == index:
+            return position
+        units += 2 if ord(character) > 0xFFFF else 1
+        if units > index:
+            raise ValueError("UTF-16 index splits a surrogate pair")
+    if units == index:
+        return len(text)
+    raise IndexError("UTF-16 index out of bounds")

python_pages-0.1.0.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: python-pages
+Version: 0.1.0
+Summary: A python-docx-inspired API for Apple Pages documents
+Author-email: Yuki Tamura <isoparametric@isoparametric.xyz>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/isoparametric/python-pages
+Project-URL: Issues, https://github.com/isoparametric/python-pages/issues
+Keywords: apple-pages,document,iwork,python-docx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Office Suites
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# python-pages
+
+`python-pages` is a Python library for reading and editing modern Apple Pages
+documents with an object model inspired by
+[`python-docx`](https://python-docx.readthedocs.io/). The distribution name is
+`python-pages`; the import name is `pages`:
+
+```python
+from pages import Document
+```
+
+The library edits `.pages` packages directly. It does not launch Pages, use
+AppleScript, or automate the GUI. Its runtime is dependency-free and consists
+of a ZIP container layer, a lossless protobuf-wire layer, an iWork Snappy/IWA
+layer, and a public document API.
+
+This project is alpha-quality. Keep the source document and inspect important
+outputs in Pages before using them in production.
+
+## Installation
+
+From a local checkout:
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install --upgrade pip
+python3 -m pip install -e .
+```
+
+The editable install provides both `import pages` and the `python-pages`
+command. To run without installing, prefix commands with `PYTHONPATH=src`.
+
+The project requires Python 3.11 or newer. There are no runtime dependencies.
+
+The requested `pages` import name is also used by an unrelated PyPI static-site
+generator. Install `python-pages` in a dedicated virtual environment and do not
+co-install that distribution; both projects would otherwise provide the same
+top-level import name.
+
+## Quick start
+
+```python
+from pages import (
+    Document,
+    Inches,
+    Pt,
+    RGBColor,
+    WD_ALIGN_PARAGRAPH,
+    WD_COLOR_INDEX,
+    WD_ORIENT,
+)
+
+document = Document("input.pages")
+
+paragraph = document.paragraphs[0]
+run = paragraph.runs[0]
+print(paragraph.text, run.text)
+
+# Character formatting uses python-docx-style tri-state values.
+run.bold = True
+run.italic = False
+run.underline = None
+run.font.name = "Helvetica-Bold"
+run.font.size = Pt(14)
+run.font.color.rgb = RGBColor(0x22, 0x66, 0xCC)
+run.font.strike = True
+run.font.subscript = False
+run.font.superscript = True
+
+# Pages stores the observed text background at paragraph granularity.
+paragraph.highlight_color = WD_COLOR_INDEX.YELLOW
+paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+paragraph.paragraph_format.line_spacing = Pt(24)
+paragraph.paragraph_format.space_before = Pt(12)
+paragraph.paragraph_format.left_indent = Inches(0.25)
+
+paragraph.add_run(" Appended text")
+document.add_paragraph("A new body paragraph")
+document.add_heading("A new heading", level=1)
+document.add_page_break()
+
+section = document.sections[0]
+section.orientation = WD_ORIENT.LANDSCAPE
+section.page_width, section.page_height = section.page_height, section.page_width
+section.left_margin = Inches(0.75)
+section.header.paragraphs[0].text = "Header text"
+
+document.save("output.pages")
+```
+
+`Document()` without a path starts with a bundled minimal Pages template.
+The template contains blank body text/previews and a neutral white placeholder
+for an otherwise unreachable image graph. The input path is never modified;
+changes are written only by `save()`.
+
+## API coverage
+
+The public API intentionally follows python-docx naming where Pages has a
+reasonable counterpart:
+
+| Area | python-pages support |
+|---|---|
+| Documents | `Document(path)`, `Document()`, `save()` |
+| Text | `paragraphs`, `Paragraph.text`, `runs`, `Run.text`, insertion and deletion |
+| Fonts | bold, italic, underline, strike, name, size, RGB color, subscript, superscript |
+| Paragraphs | alignment, line spacing, spacing before/after, indents, tab stops, named styles |
+| Sections | one Pages section with page size, margins, orientation, headers, and footers |
+| Tables | read rows/cells, edit materialized text cells, clone a blank table with `add_table()` |
+| Pictures | inspect/replace PNG images and clone an inline image with `add_picture()` |
+| Links and styles | inspect/edit existing hyperlinks; enumerate/apply named paragraph and character styles |
+| Properties | python-docx-shaped `core_properties` facade |
+| Comments | read comments, replies, authors, anchors, and edit existing comment text |
+
+Examples for additional object types:
+
+```python
+table = document.tables[0]
+print([[cell.text for cell in row.cells] for row in table.rows])
+table.cell(1, 1).text = "Updated cell"
+new_table = document.add_table(rows=3, cols=4)
+
+picture = document.inline_shapes[0]
+print(picture.filename, picture.width, picture.height)
+picture.replace("replacement.png", "replacement-256px-thumbnail.png")
+new_picture = document.add_picture("new-image.png", width=Inches(4))
+
+hyperlink = document.hyperlinks[0]
+hyperlink.text = "Project website"
+hyperlink.address = "https://example.com"
+
+for comment in document.comments:
+    print(comment.author, comment.anchor_text, comment.text)
+    print([reply.text for reply in comment.replies])
+```
+
+## Differences from python-docx
+
+`python-pages` is API-inspired, not a byte-format adapter for DOCX. Important
+differences follow from the Pages data model:
+
+- Pages page geometry is package-wide, so `Document.sections` contains one
+  section. Multiple DOCX sections and linked-to-previous behavior are not
+  emulated.
+- A Pages header or footer is exposed as its left, center, and right text
+  fragments rather than as a WordprocessingML story part.
+- The observed Pages text-background property belongs to an anonymous
+  paragraph style. `Run.font.highlight_color` is retained for call-shape
+  compatibility but reads or writes the run's entire containing paragraph.
+- `core_properties` values without a native Pages counterpart are stored in
+  `Metadata/PythonPagesCoreProperties.plist`. Documents written by the earlier
+  project name remain readable.
+- `add_table()` needs an existing Pages-authored table in the target document
+  as a structural template. It supports one tile of up to 256 rows and does
+  not implement cell merge or sparse-cell materialization.
+- `add_picture()` needs an existing Pages-authored image graph in the target
+  document. New and replacement media are PNG; automatic thumbnails support
+  non-interlaced 8-bit RGB/RGBA PNG.
+- Existing comments and replies can be read and edited, but creating a new
+  comment is intentionally disabled because Pages also writes collaboration
+  and view-state objects whose lifecycle is not yet established.
+- Existing hyperlinks can be edited. Creating a new hyperlink is not yet part
+  of the public API.
+- Pages formats are undocumented and can change between application versions.
+  The implementation preserves unknown protobuf fields where possible, but it
+  cannot guarantee support for every historical or future Pages variant.
+
+The detailed compatibility ledger and reverse-engineering evidence are in
+[REPORT.md](REPORT.md).
+
+## Command-line interface
+
+```sh
+python-pages inspect input.pages
+python-pages bold input.pages output.pages "unique body substring"
+```
+
+Without installation:
+
+```sh
+PYTHONPATH=src python3 -m pages.cli inspect input.pages
+```
+
+The `bold` helper expects an unambiguous substring unless `--occurrence` is
+provided. It converts Python string offsets to the UTF-16 offsets used by Pages.
+
+## Optional test fixtures are not distributed
+
+The test suite is self-contained and passes from a standalone checkout. Private
+`.pages` files used for Pages.app interoperability checks can contain
+copyrighted or sensitive content, so `samples/` and generated `output/`
+packages are excluded from Git and distributions.
+
+To enable the additional real-document tests, place a Pages-authored package at
+`samples/local_fixture.pages`. The tests activate automatically with
+`unittest.skipUnless` when the file is present. It must contain:
+
+- at least one inline PNG image;
+- at least one nonempty table;
+- at least one hyperlink; and
+- at least one comment with a reply.
+
+No particular headings, formatted runs, or document text are required by these
+optional tests. Use only content you are allowed to publish and do not commit
+the fixture.
+
+To enable the python-docx compatibility-ledger audit, place the upstream source
+tree at `ref/python-docx/`. Its tests must be under `ref/python-docx/tests/`;
+the ledger test also activates automatically when that directory is present.
+
+Run the suite with:
+
+```sh
+python3 -m unittest discover -s tests -v
+```
+
+Use the decoded-IWA audit tool for every write path:
+
+```sh
+PYTHONPATH=src python3 tools/diff_iwa.py before.pages after.pages
+unzip -t after.pages
+```
+
+## Architecture
+
+- Low level: `snappy.py`, `protobuf.py`, and `iwa.py` provide lossless wire
+  parsing and 64-KiB iWork frame handling.
+- Middle level: `pages.py`, `metadata.py`, `stylesheet.py`, `text.py`, and the
+  component-specific modules traverse and mutate Pages object graphs.
+- High level: `api.py` provides the python-docx-shaped object model exported by
+  `pages`.
+
+Synthesized styles are registered in the stylesheet, parent/child map,
+MessageInfo references, PackageMetadata UUID map, and cross-component reference
+map. Untouched ZIP members and IWA payloads are preserved byte-for-byte; changed
+members are re-encoded into valid Pages packages.
+
+## Project status
+
+The compatibility ledger accounts for all 59 python-docx test files and 662
+discovered behavior methods as migrated, partially migrated, or format-specific
+exclusions. When `ref/python-docx/` is present, the optional ledger test verifies
+that the upstream checkout contains behavior tests. The dependency-free test
+suite runs standalone; optional fixture and ledger tests activate automatically
+when their local inputs are present.
+
+`python-pages` is an independent project and is not affiliated with Apple or
+the python-docx project.

python_pages-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+pages/__init__.py,sha256=xPHPfQHrUBndczmlQ2uEQDz8zpVzuulvLgQ-CaQ9te8,1228
+pages/api.py,sha256=IywVwz4IC9LyBi6QRf-AkJTAWJ6SrpA7URCrJcdaUfE,61159
+pages/cli.py,sha256=Q-Vhkn9iIhcg6_OiZ0aRbWoj2OlQCxifeiqpC9x0-JM,1469
+pages/comments.py,sha256=3LS2UaFjDltdYwcgU8mQxcn3QUfCvtnypslSDGTfYFY,5688
+pages/components.py,sha256=gqRxa1GyFrzV60ETh69iBY8XREqvMITNCn5hwpz2ouc,15750
+pages/core_properties.py,sha256=y5CdAvS4mDytqifbumT2vWaG7bNj04JJS1wZo4smJ5I,4235
+pages/document.py,sha256=luDLACqJleXkwaSNywf-hwcUPxDHK1VZUhnM2kRMSIc,8113
+pages/hyperlinks.py,sha256=LCAMiiRz8-F2U6rrspQnXSazoCUwE0EyCEgBJtJUrLk,1788
+pages/iwa.py,sha256=yyx48EL74XT3oKSloVIqaSeIvBl2CeloE-jafZTCeyQ,3914
+pages/metadata.py,sha256=zQR3jRZTr40jZ4ZJL2Qbr9S4K2C8fZkuSkhCPwtUSiY,4409
+pages/pages.py,sha256=zIeYfX2FElvIJc30NvrqCdcj1uMyZevepqrCYsvCVd0,15350
+pages/pictures.py,sha256=0vr-sd9sTO14B953X4ah-guWF6TxtWrEZnlg0FbA56c,21499
+pages/protobuf.py,sha256=6o5Rf291a5KC6EMdMs-ChVho85r0R4kj8hljungR178,5276
+pages/snappy.py,sha256=6YW_uCSA4WMSe76SNHzxcIqDo5zzO6-5fme0ofvzKiE,4535
+pages/stylesheet.py,sha256=fiw8Gtr0h2jYHgrvolpTEKvORoHHUxGKokpmB2yGMCY,34932
+pages/tables.py,sha256=FoP7JDKuFEY8vh5X0qK7AXyeAcY0IFDf_sfdvxIujig,20731
+pages/text.py,sha256=qb_V1p3EfgBHbUBJqhaGsLiy-_Xff6Dk83f2scQg4vc,10043
+pages/data/default.pages,sha256=EZ9191Lg_aASO01lAVqQpruvhtc7XnJdKDJX6d_MuJw,50659
+python_pages-0.1.0.dist-info/licenses/LICENSE,sha256=i3ed-q3APi1nmfH2RM6ephX3mz7B2Uu5ztmA5-y1RQY,1068
+python_pages-0.1.0.dist-info/METADATA,sha256=8MiAMu_4KbGu8MR_6Bnd_enWSQUi6eXZptsf2MNem98,10473
+python_pages-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_pages-0.1.0.dist-info/entry_points.txt,sha256=Eqac5QpE5I_2F-kMjXKd0DnwOUVwAH77zM9zkjwL-H8,48
+python_pages-0.1.0.dist-info/top_level.txt,sha256=jfEHnE0lLOnMOMYDPpLhDOwJfWiGhHkfAXE7La4L7hw,6
+python_pages-0.1.0.dist-info/RECORD,,

python_pages-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_pages-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+python-pages = pages.cli:main

python_pages-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuki Tamura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_pages-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pages