poma 0.0.0__py3-none-any.whl

poma/integrations/llamaindex_poma.py

@@ -0,0 +1,361 @@
+# ---------------------------------------------------------------------
+#  POMA integration for LlamaIndex
+# ---------------------------------------------------------------------
+
+import os
+import hashlib
+from typing import Any
+from pathlib import Path
+from collections import defaultdict
+from collections.abc import Sequence, Iterable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from llama_index.core.readers.base import BaseReader
+from llama_index.core.node_parser import NodeParser
+from llama_index.core.retrievers import BaseRetriever
+from llama_index.core.schema import (
+    Document,
+    NodeWithScore,
+    TextNode,
+    BaseNode,
+    QueryBundle,
+)
+from pydantic import PrivateAttr
+
+from poma import Poma
+from poma.client import ALLOWED_FILE_EXTENSIONS
+from poma.retrieval import _cheatsheets_from_chunks
+from poma.exceptions import InvalidInputError
+
+__all__ = ["PomaFileReader", "PomaChunksetNodeParser", "PomaCheatsheetRetrieverLI"]
+
+
+# ------------------------------------------------------------------ #
+#  Load from Path → LI Documents                                     #
+# ------------------------------------------------------------------ #
+
+
+class PomaFileReader(BaseReader):
+
+    def load_data(self, input_path: str | Path) -> list[Document]:
+        """
+        Load files from the input path (file or directory) into LlamaIndex Documents.
+        Only files with allowed extensions are processed; others are skipped.
+        """
+        path = Path(input_path).expanduser().resolve()
+        if not path.exists():
+            raise FileNotFoundError(f"No such path: {path}")
+
+        documents: list[Document] = []
+        skipped: int = 0
+
+        def _process_file(file_path: Path):
+            nonlocal skipped, documents
+            if not file_path.is_file():
+                return
+            file_extension = file_path.suffix.lower()
+            if not file_extension or file_extension not in ALLOWED_FILE_EXTENSIONS:
+                skipped += 1
+                return
+            file_bytes = file_path.read_bytes()
+            file_hash = hashlib.md5(file_bytes).hexdigest()
+            if file_extension == ".pdf":
+                # LlamaIndex requires `text` to be str.
+                # Actual file processing happens downstream in the node parser.
+                text_payload: str = ""
+            else:
+                try:
+                    text_payload = file_bytes.decode("utf-8")
+                except UnicodeDecodeError:
+                    skipped += 1
+                    return
+            documents.append(
+                Document(
+                    text=text_payload,
+                    metadata={
+                        "source_path": str(file_path),
+                        "doc_id": f"{file_hash}",
+                    },
+                )
+            )
+
+        if path.is_file():
+            _process_file(path)
+        elif path.is_dir():
+            for path_in_dir in sorted(path.rglob("*")):
+                _process_file(path_in_dir)
+        else:
+            raise FileNotFoundError(f"Unsupported path type (not file/dir): {path}")
+
+        allowed = ", ".join(sorted(ALLOWED_FILE_EXTENSIONS))
+        if not documents:
+            raise InvalidInputError(f"No supported files found. Allowed: {allowed}")
+        if skipped > 0:
+            print(
+                f"Skipped {skipped} file(s) due to unsupported or unreadable type. Allowed: {allowed}"
+            )
+        return documents
+
+
+# ------------------------------------------------------------------ #
+#  Generate Chunksets                                                #
+# ------------------------------------------------------------------ #
+
+
+class PomaChunksetNodeParser(NodeParser):
+    # """Calls **POMA API** for each document, choosing text vs file ingestion as needed."""
+
+    _client: Poma = PrivateAttr()
+
+    def __init__(self, *, client: Poma):
+        """Initialize with Poma client instance."""
+        super().__init__()
+        self._client = client
+
+    def _parse_nodes(
+        self, nodes: Sequence[BaseNode], show_progress: bool = False, **kwargs: Any
+    ) -> list[BaseNode]:
+        """Not implemented, use _get_nodes_from_documents()."""
+        raise NotImplementedError("Not implemented, use _get_nodes_from_documents().")
+
+    def _get_nodes_from_documents(
+        self, documents: Sequence[Document], show_progress: bool = False
+    ) -> list[BaseNode]:
+        """
+        Convert LlamaIndex Documents into chunkset Nodes via POMA API.
+        Each output Node represents a chunkset, with associated chunks in metadata.
+        """
+
+        documents = list(documents)
+        if not documents:
+            raise InvalidInputError("No documents provided to process.")
+
+        total_docs = len(documents)
+        chunked_nodes: list[BaseNode] = []
+        failed_paths: list[str] = []
+
+        def _safe_int(value: object) -> int | None:
+            if isinstance(value, bool):
+                return None
+            if isinstance(value, int):
+                return value
+            if isinstance(value, str):
+                try:
+                    return int(value.strip())
+                except Exception:
+                    return None
+            try:
+                return int(value)  # type: ignore[arg-type]
+            except Exception:
+                return None
+
+        def _doc_id_and_src(doc: Document) -> tuple[str, str]:
+            src_path = doc.metadata.get("source_path", "in-memory-text")
+            doc_id = doc.metadata.get("doc_id") or Path(src_path).stem or "unknown-doc"
+            return doc_id, src_path
+
+        def _process_one(
+            poma_doc: Document, doc_idx: int, total_docs: int
+        ) -> tuple[list[BaseNode], str | None]:
+            """Process a single document via POMA API, return chunkset nodes or failed source path."""
+            try:
+                doc_id, src_path = _doc_id_and_src(poma_doc)
+                path_obj: Path | None = None
+                if src_path and src_path.strip() and isinstance(src_path, str):
+                    try:
+                        path = Path(src_path).expanduser().resolve()
+                        if path.exists():
+                            path_obj = path
+                    except Exception:
+                        path_obj = None
+                if not path_obj:
+                    raise InvalidInputError(
+                        "No valid source_path found in document metadata."
+                    )
+                start_result = self._client.start_chunk_file(path_obj, base_url=None)
+                job_id = start_result.get("job_id")
+                if not job_id:
+                    raise RuntimeError("Failed to receive job ID from server.")
+                if show_progress:
+                    print(
+                        f"[{doc_idx}/{total_docs}] ⏳ Job {job_id} started for: {src_path}. Polling for results..."
+                    )
+                result = self._client.get_chunk_result(
+                    str(job_id), show_progress=show_progress
+                )
+                chunks: list[dict] = result.get("chunks", [])
+                chunksets: list[dict] = result.get("chunksets", [])
+            except Exception as exception:
+                print(
+                    f"[{doc_idx}/{total_docs}] ❌ Exception chunking document: {exception}"
+                )
+                src_path = poma_doc.metadata.get("source_path", "in-memory-text")
+                return [], src_path
+
+            file_nodes: list[BaseNode] = []
+            try:
+                chunks_by_index: dict[int, dict] = {}
+                for chunk in chunks:
+                    idx = _safe_int(chunk.get("chunk_index"))
+                    if idx is not None:
+                        chunks_by_index[idx] = chunk
+                for cs in chunksets:
+                    chunkset_index = cs.get("chunkset_index")
+                    chunks_indices = cs.get("chunks", []) or []
+                    normalized_indices: list[int] = []
+                    for chunk_index in chunks_indices:
+                        idx = _safe_int(chunk_index)
+                        if idx is not None:
+                            normalized_indices.append(idx)
+                    relevant_chunks = [
+                        chunks_by_index[idx]
+                        for idx in normalized_indices
+                        if idx in chunks_by_index
+                    ]
+                    text_node = TextNode(
+                        text=cs.get("contents", ""),
+                        metadata={
+                            "doc_id": doc_id,
+                            "chunkset_index": chunkset_index,
+                            "chunks": relevant_chunks,
+                            "chunkset": cs,
+                            "source_path": src_path,
+                        },
+                    )
+                    # Keep embeddings clean – just embed content, not metadata
+                    text_node.excluded_embed_metadata_keys = list(
+                        text_node.metadata.keys()
+                    )
+                    file_nodes.append(text_node)
+            except Exception as exception:
+                print(
+                    f"[{doc_idx}/{total_docs}] ❌ Exception processing chunking result: {exception}"
+                )
+                src_path = poma_doc.metadata.get("source_path", "in-memory-text")
+                return [], src_path
+            return file_nodes, None
+
+        # parallel processing of documents
+        cores = os.cpu_count() or 1
+        group_size = 5 if cores >= 5 else cores
+        for start in range(0, total_docs, group_size):
+            batch = list(
+                enumerate(documents[start : start + group_size], start=start + 1)
+            )
+            with ThreadPoolExecutor(max_workers=group_size) as executor:
+                futures = {
+                    executor.submit(_process_one, doc, idx, total_docs): (idx, doc)
+                    for idx, doc in batch
+                }
+                for future in as_completed(futures):
+                    idx, doc = futures[future]
+                    try:
+                        node_chunks, failed_src = future.result()
+                        if failed_src is None:
+                            chunked_nodes.extend(node_chunks)
+                            if show_progress:
+                                src_path = doc.metadata.get(
+                                    "source_path", "in-memory-text"
+                                )
+                                print(
+                                    f"[{idx}/{total_docs}] ✅ Done: {src_path} (+{len(node_chunks)} node-chunks)"
+                                )
+                        else:
+                            failed_paths.append(failed_src)
+                            if show_progress:
+                                print(f"[{idx}/{total_docs}] ❌ Failed: {failed_src}")
+                    except Exception as error:
+                        failed_paths.append(
+                            doc.metadata.get("source_path", "in-memory-text")
+                        )
+                        if show_progress:
+                            print(
+                                f"[{idx}/{total_docs}] ❌ Failed with unexpected error: {error}"
+                            )
+
+        if failed_paths:
+            print("The following files failed to process:")
+            for path in failed_paths:
+                print(f" - {path}")
+
+        if not chunked_nodes:
+            raise InvalidInputError("No documents could be split successfully.")
+
+        return chunked_nodes
+
+
+# ----------------------------------------------------------------
+# Cheatsheet Retriever
+# ----------------------------------------------------------------
+
+
+class PomaCheatsheetRetrieverLI(BaseRetriever):
+
+    def __init__(self, base: BaseRetriever):
+        """Wrap an existing LlamaIndex retriever. Keep its callback/verbosity."""
+        if not isinstance(base, BaseRetriever):
+            raise ValueError("base must be an instance of BaseRetriever.")
+        super().__init__(
+            callback_manager=getattr(base, "callback_manager", None),
+            verbose=getattr(base, "_verbose", False),
+        )
+        self._base = base
+
+    def _retrieve(self, query_bundle: QueryBundle) -> list[NodeWithScore]:
+        """Retrieve chunkset nodes and generate cheatsheets for the given query."""
+        nodes = self._base.retrieve(query_bundle)
+        if not nodes:
+            return []
+        grouped: dict[str, list[NodeWithScore]] = defaultdict(list)
+        best_score: dict[str, float] = defaultdict(float)
+        for node in nodes:
+            doc_id = node.metadata["doc_id"]
+            grouped[doc_id].append(node)
+            best_score[doc_id] = max(best_score[doc_id], node.score or 1.0)
+        cheatsheet_nodes: list[NodeWithScore] = []
+        for doc_id, chunked_nodes in grouped.items():
+            cheatsheet = self._create_cheatsheet_llamaindex(chunked_nodes)
+            cheatsheet_node = TextNode(text=cheatsheet, metadata={"doc_id": doc_id})
+            cheatsheet_nodes.append(
+                NodeWithScore(node=cheatsheet_node, score=best_score[doc_id])
+            )
+        return cheatsheet_nodes
+
+    def as_query_engine(self, **kwargs):
+        """Wrap as a LlamaIndex RetrieverQueryEngine."""
+        from llama_index.core.query_engine import RetrieverQueryEngine
+
+        return RetrieverQueryEngine(self, **kwargs)
+
+    def _create_cheatsheet_llamaindex(self, chunked_nodes: list[NodeWithScore]) -> str:
+        """Generate a single deduplicated cheatsheet from chunked nodes."""
+        all_chunks = []
+        seen = set()
+        for node in chunked_nodes:
+            doc_id = node.metadata.get("doc_id", "unknown_doc")
+            chunks = node.metadata.get("chunks", [])
+            if not chunks:
+                continue
+            for chunk in chunks:
+                if not isinstance(chunk, dict):
+                    continue
+                chunk_index = chunk.get("chunk_index")
+                if chunk_index is None or chunk_index in seen:
+                    continue
+                seen.add(chunk_index)
+                chunk["tag"] = doc_id
+                all_chunks.append(chunk)
+        sorted_chunks = sorted(
+            all_chunks, key=lambda chunk: (chunk["tag"], chunk["chunk_index"])
+        )
+        cheatsheets = _cheatsheets_from_chunks(sorted_chunks)
+        if (
+            not cheatsheets
+            or not isinstance(cheatsheets, list)
+            or len(cheatsheets) == 0
+            or "content" not in cheatsheets[0]
+        ):
+            raise Exception(
+                "Unknown error; cheatsheet could not be created from input chunks."
+            )
+        return cheatsheets[0]["content"]

poma/retrieval.py

@@ -0,0 +1,176 @@
+# retrieval.py
+from collections import defaultdict
+from itertools import chain
+from typing import Any
+
+
+def generate_cheatsheets(
+    relevant_chunksets: list[dict[str, Any]], all_chunks: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    chunk_ids = [cs["chunks"] for cs in relevant_chunksets if "chunks" in cs]
+    chunk_ids = list(chain.from_iterable(chunk_ids))  # flatten the list
+    relevant_chunks = _get_relevant_chunks_for_ids(chunk_ids, all_chunks)
+    sorted_chunks = sorted(
+        relevant_chunks, key=lambda chunk: (chunk["tag"], chunk["chunk_index"])
+    )
+    return _cheatsheets_from_chunks(sorted_chunks)
+
+
+def generate_single_cheatsheet(
+    relevant_chunksets: list[dict[str, Any]], all_chunks: list[dict[str, Any]]
+) -> str:
+
+    def prepare_single_doc_chunks(
+        chunk_dicts: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        # Make sure there are no duplicate chunk_index values
+        check_dict = defaultdict(set)
+        has_duplicates = any(
+            chunk["chunk_index"] in check_dict[chunk["tag"]]
+            or check_dict[chunk["tag"]].add(chunk["chunk_index"])
+            for chunk in chunk_dicts
+        )
+        if has_duplicates:
+            raise ValueError(
+                "Duplicate chunk indices found in single document mode. "
+                "Each chunk must have a unique index."
+            )
+        # Use a fixed tag for chunks from single documents
+        for chunk_dict in chunk_dicts:
+            chunk_dict["tag"] = "single_doc"
+        return chunk_dicts
+
+    chunk_ids = [cs["chunks"] for cs in relevant_chunksets if "chunks" in cs]
+    chunk_ids = list(chain.from_iterable(chunk_ids))  # flatten the list
+    relevant_chunks = _get_relevant_chunks_for_ids(chunk_ids, all_chunks)
+    relevant_chunks = prepare_single_doc_chunks(relevant_chunks)
+    sorted_chunks = sorted(
+        relevant_chunks, key=lambda chunk: (chunk["tag"], chunk["chunk_index"])
+    )
+    cheatsheets = _cheatsheets_from_chunks(sorted_chunks)
+    if (
+        not cheatsheets
+        or not isinstance(cheatsheets, list)
+        or len(cheatsheets) == 0
+        or "content" not in cheatsheets[0]
+    ):
+        raise Exception(
+            "Unknown error; cheatsheet could not be created from input chunks."
+        )
+    return cheatsheets[0]["content"]
+
+
+def _get_relevant_chunks_for_ids(
+    chunk_ids: list[int],
+    chunks: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    chunk_indices_of_retrieved_chunksets = chunk_ids
+    all_chunks_of_doc = chunks
+
+    # Build helpers
+    sorted_chunks = sorted(all_chunks_of_doc, key=lambda c: c["chunk_index"])
+    index_to_chunk = {c["chunk_index"]: c for c in sorted_chunks}
+    index_to_depth = {c["chunk_index"]: c["depth"] for c in sorted_chunks}
+
+    # Find relatively deepest indices in the retrieval
+    candidate_indices = set(chunk_indices_of_retrieved_chunksets)
+
+    def is_ancestor(idx1, idx2):
+        """True if idx1 is an ancestor of idx2."""
+        # idx1 must be before idx2 and have smaller depth
+        if idx1 >= idx2:
+            return False
+        depth1 = index_to_depth[idx1]
+        depth2 = index_to_depth[idx2]
+        if depth1 >= depth2:
+            return False
+        # scan from idx1+1 up to idx2, making sure all are deeper than depth1 until idx2
+        for i in range(idx1 + 1, idx2 + 1):
+            depth = index_to_depth[sorted_chunks[i]["chunk_index"]]
+            if depth <= depth1 and sorted_chunks[i]["chunk_index"] != idx2:
+                return False
+        return True
+
+    # Exclude any index that is an ancestor of another in the set
+    relatively_deepest = set(candidate_indices)
+    for idx1 in candidate_indices:
+        for idx2 in candidate_indices:
+            if idx1 != idx2 and is_ancestor(idx1, idx2):
+                relatively_deepest.discard(idx1)
+                break
+
+    # Standard subtree/parent finding routines
+    def get_child_indices(chunk_index: int) -> list[int]:
+        base_depth = index_to_depth[chunk_index]
+        children = []
+        for i in range(chunk_index + 1, len(sorted_chunks)):
+            idx = sorted_chunks[i]["chunk_index"]
+            depth = sorted_chunks[i]["depth"]
+            if depth <= base_depth:
+                break
+            children.append(idx)
+        return children
+
+    def get_parent_indices(chunk_index: int) -> list[int]:
+        parents = []
+        current_depth = index_to_depth[chunk_index]
+        for i in range(chunk_index - 1, -1, -1):
+            idx = sorted_chunks[i]["chunk_index"]
+            depth = sorted_chunks[i]["depth"]
+            if depth < current_depth:
+                parents.append(idx)
+                current_depth = depth
+        return parents[::-1]  # root -> leaf order
+
+    # Collect all relevant indices
+    all_indices = set(
+        chunk_indices_of_retrieved_chunksets
+    )  # always include all search hits
+    for idx in relatively_deepest:
+        all_indices.update(get_child_indices(idx))
+
+    # Parents for all found nodes
+    for idx in list(all_indices):
+        all_indices.update(get_parent_indices(idx))
+
+    # Return in doc order
+    return [index_to_chunk[i] for i in sorted(all_indices)]
+
+
+def _cheatsheets_from_chunks(
+    content_chunks: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    cheatsheets: list[dict] = []
+
+    compressed_data = {}
+    for chunk in content_chunks:
+        if chunk["tag"] not in compressed_data:
+            # If there is data stored for a previous tag, save it to the cheatsheets list
+            if compressed_data:
+                for key, value in compressed_data.items():
+                    cheatsheets.append({"tag": key, "content": value["content"]})
+            # Clear the compressed_data for the current tag
+            compressed_data.clear()
+            # Start a new entry for the current tag
+            compressed_data[chunk["tag"]] = {
+                "content": chunk["content"],
+                "last_chunk": chunk["chunk_index"],
+            }
+        else:
+            # Check if chunks are consecutive
+            if (
+                chunk["chunk_index"]
+                == int(compressed_data[chunk["tag"]]["last_chunk"]) + 1
+            ):
+                compressed_data[chunk["tag"]]["content"] += "\n" + chunk["content"]
+            else:
+                compressed_data[chunk["tag"]]["content"] += "\n[…]\n" + chunk["content"]
+            # Update the last chunk index
+            compressed_data[chunk["tag"]]["last_chunk"] = chunk["chunk_index"]
+
+    # Save the last processed entry to the cheatsheets list
+    if compressed_data:
+        for key, value in compressed_data.items():
+            cheatsheets.append({"tag": key, "content": value["content"]})
+
+    return cheatsheets

poma-0.0.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: poma
+Version: 0.0.0
+Summary: Official Python SDK for the Poma document-processing API
+Author-email: "POMA AI GmbH, Berlin" <sdk@poma-ai.com>
+License-Expression: MPL-2.0
+Keywords: chunking,structure,rag,poma,documents,ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx==0.28.1
+Requires-Dist: pydantic==2.11.7
+Provides-Extra: integrations
+Requires-Dist: langchain==0.3.27; extra == "integrations"
+Requires-Dist: langchain-text-splitters==0.3.9; extra == "integrations"
+Requires-Dist: llama-index==0.13.0; extra == "integrations"
+Provides-Extra: integration-examples
+Requires-Dist: langchain==0.3.27; extra == "integration-examples"
+Requires-Dist: langchain-text-splitters==0.3.9; extra == "integration-examples"
+Requires-Dist: llama-index==0.13.0; extra == "integration-examples"
+Requires-Dist: llama-index-vector-stores-faiss==0.5.0; extra == "integration-examples"
+Requires-Dist: faiss-cpu==1.10.0; extra == "integration-examples"
+Requires-Dist: langchain_openai==0.3.28; extra == "integration-examples"
+Requires-Dist: langchain_community==0.3.27; extra == "integration-examples"
+Requires-Dist: llama-index-embeddings-langchain==0.4.0; extra == "integration-examples"
+Requires-Dist: dotenv; extra == "integration-examples"
+Dynamic: license-file
+
+![POMA AI Logo](https://raw.githubusercontent.com/poma-ai/.github/main/assets/POMA_AI_Logo_Pink.svg)
+# 📚 POMA: Preserving Optimal Markdown Architecture
+
+## 🚀Quick-Start Guide
+
+### Installation
+
+Requires Python 3.10+. Install the core packages:
+```bash
+pip install poma
+```
+
+For integrations into LangChain and LlamaIndex:
+```bash
+pip install poma[integrations]
+# Or LangChain/LlamaIndex including example extras:
+pip install poma[integration-examples]
+```
+
+
+- You may also want: `pip install python-dotenv` to load API keys from a .env file.
+- API keys required (POMA_API_KEY) for the POMA AI client via environment variables.
+- **To request a POMA_API_KEY, please contact us at api@poma-ai.com**
+
+
+### Example Implementations — all examples, integrations, and additional information can be found in our GitHub repository: [poma-ai/poma](https://github.com/poma-ai/)
+
+We provide four example implementations to help you get started with POMA AI:
+- example.py — A standalone implementation for documents, showing the basic POMA AI workflow with simple keyword-based retrieval
+- example_langchain.py — Integration with LangChain, demonstrating how easy it is to use POMA AI with LangChain
+- example_llamaindex.py — Integration with LlamaIndex, showing how simple it is to use POMA AI with LlamaIndex
+
+*Note: The integration examples use OpenAI embeddings. Make sure to set your OPENAI_API_KEY environment variable, or replace the embeddings with your preferred ones.*
+
+
+All examples follow the same two-phase process (ingest → retrieve) but demonstrate different integration options for your RAG pipeline.
+
+! Please do NOT send any sensitive and/or personal information to POMA AI endpoints without having a signed contract & DPA !

poma-0.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+poma/__init__.py,sha256=SARVBTJw2pkIXR2_OYMPYjB7W335er_2-9j4yhzVTZI,266
+poma/client.py,sha256=HOlNVfSPYzq1RjLVUtIqbObH5QSLRbi7KnbCnBjpUh4,14201
+poma/exceptions.py,sha256=5d8SdIIRFotKUJJAy9mct2q44oEmAsR15OVEmkLDfkQ,518
+poma/retrieval.py,sha256=bm68_1QscJXa76sxVuAkcwdeGsvEZaQkrY3-3uUxrIg,6730
+poma/integrations/__init__.py,sha256=xrrJluggTLtrKs4jLOZUWkFENqWSHSnhCqYQYY51kq0,405
+poma/integrations/langchain_poma.py,sha256=IL3pWWGCEK_O0JagpnKPFRwKclyNTwPcaTTdKJkYfYY,14608
+poma/integrations/llamaindex_poma.py,sha256=n3M71QXGVA2RTsUC24ZTt__VHEgsTbIW9BVwEn1Xxbg,14868
+poma-0.0.0.dist-info/licenses/LICENSE,sha256=YRzZ4sQOWV3ut0G4LHZJ2hT90shzZufGlXoIx4LWFEo,15254
+poma-0.0.0.dist-info/METADATA,sha256=JRBqFlkSlEQQEkotQmR02vRniUWeFlkKQ2bjdTGr7ZU,3079
+poma-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+poma-0.0.0.dist-info/top_level.txt,sha256=f_3c5Y6SojNnH0iiiE898fIKF6R2LqWyAw-BGi-72YI,5
+poma-0.0.0.dist-info/RECORD,,

poma-0.0.0.dist-info/WHEEL

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