Make a query for tabular (XLSX and CSV) (#14)

- [NOTICKET] add software to gitignore (d43ecb180036339cf287e93f1d9116bd6eff9b9d)
- [NOTICKET] add pyarrow (e50eadc82e160012e3319267f5bfe084cd9034d4)
- [KM-515][document] Make Query for Tabular Type (XLSX & CSV) (695ca0a154a68077c51499ed83b7507b988be065)
- [KM-455][document] decided methods retrieval for document (8c9cc79223eb1d96c8622d129219a83a4ba2500b)


Co-authored-by: Sofhia Az-Zahra <sofhiaazzhr@users.noreply.huggingface.co>

.gitignore

@@ -39,4 +39,7 @@ playground_create_user.py
 API_CONTRACT.md
 context_engineering/
 sample_file/
-test_tesseract.py
+test_tesseract.py
+
+# Windows binaries — installed via apt in Docker instead
+software/

pyproject.toml

@@ -90,6 +90,7 @@ dependencies = [
     "pdf2image>=1.17.0",
     "pytesseract>=0.3.13",
     "pypdf2>=3.0.1",
+    "pyarrow>=24.0.0",
 ]
 
 [project.optional-dependencies]

src/query/executors/tabular.py

@@ -1,39 +1,311 @@
 """Executor for tabular document sources (source_type="document", file_type csv/xlsx).
 
 Flow:
-  1. Group RetrievalResult chunks by document_id.
-  2. For each document: download bytes from Azure Blob -> read with pandas.
-  3. Filter DataFrame to relevant columns identified by retrieval.
-  4. Return QueryResult per document.
+  1. Group RetrievalResult chunks by (document_id, sheet_name).
+  2. Per group: download Parquet from Azure Blob → pandas DataFrame.
+  3. Build schema context from DataFrame columns + sample values.
+  4. LLM decides operation (groupby_sum, filter, top_n, etc.) via structured output.
+  5. Pandas runs the operation; retry up to 3x on error with feedback to LLM.
+  6. Fallback to raw rows if all retries fail.
+  7. Return QueryResult per group.
 """
+import asyncio
+from typing import Literal, TypedDict
 
+import pandas as pd
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import AzureChatOpenAI
+from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from src.config.settings import settings
+from src.knowledge.parquet_service import download_parquet
 from src.middlewares.logging import get_logger
 from src.query.base import BaseExecutor, QueryResult
 from src.rag.base import RetrievalResult
 
 logger = get_logger("tabular_executor")
 
+
+class _GroupInfo(TypedDict):
+    columns: list[str]
+    filename: str
+    file_type: str
+
+
 _TABULAR_FILE_TYPES = ("csv", "xlsx")
+_MAX_RETRIES = 3
+
+_SYSTEM_PROMPT = """\
+You are a data analyst. Given a DataFrame schema and a user question, \
+decide which pandas operation to perform.
+
+IMPORTANT rules:
+- Use ONLY the exact column names as written in the schema below. Never translate or rename them.
+- For top_n: always set value_col to the column to sort by. Do NOT use sort_col for top_n.
+- For sort: use sort_col for the column to sort by.
+- For filter with comparison (>, <, >=, <=, !=): set filter_operator accordingly (gt, lt, gte, lte, ne). Default is eq (==).
+- For multi-condition filters (AND logic), use the filters field as a list of {{"col", "value", "op"}} dicts instead of filter_col/filter_value.
+  Example: status=SUCCESS AND amount_paid>200000 → filters=[{{"col":"status","value":"SUCCESS","op":"eq"}},{{"col":"amount_paid","value":"200000","op":"gt"}}]
+- IMPORTANT: When the question uses "or" / "atau" between values of the same column, you MUST use or_filters (NOT filters).
+  or_filters applies OR logic: rows matching ANY condition are kept.
+  filters applies AND logic: rows must match ALL conditions.
+  Example: "(status FAILED or REVERSED) AND payment_channel=Tokopedia" →
+    or_filters=[{{"col":"status","value":"FAILED","op":"eq"}},{{"col":"status","value":"REVERSED","op":"eq"}}]
+    filters=[{{"col":"payment_channel","value":"Tokopedia","op":"eq"}}]
+- For groupby with a pre-filter (e.g. count SUCCESS per channel): use filters or or_filters to narrow rows first, then use groupby_count/groupby_sum/groupby_avg on the filtered data by setting both filters and group_col.
+
+Schema:
+{schema}
+
+{error_section}"""
+
+
+class TabularOperation(BaseModel):
+    operation: Literal[
+        "filter", "groupby_sum", "groupby_avg", "groupby_count",
+        "top_n", "sort", "aggregate", "raw"
+    ]
+    group_col: str | None = None       # for groupby_*
+    value_col: str | None = None       # for groupby_*, top_n, aggregate
+    filter_col: str | None = None      # for single filter
+    filter_value: str | None = None    # for single filter
+    filter_operator: Literal["eq", "ne", "gt", "gte", "lt", "lte"] = "eq"  # for single filter
+    filters: list[dict] | None = None     # for multi-condition AND: [{"col": ..., "value": ..., "op": ...}]
+    or_filters: list[dict] | None = None  # for OR conditions, applied before AND filters
+    sort_col: str | None = None        # for sort
+    ascending: bool = True             # for sort
+    n: int | None = None               # for top_n
+    agg_func: Literal["sum", "avg", "min", "max", "count"] | None = None  # for aggregate
+    reasoning: str
+
+
+def _get_filter_mask(df: pd.DataFrame, col: str, value: str, operator: str) -> pd.Series:
+    numeric = pd.to_numeric(df[col], errors="coerce")
+    if operator == "eq":
+        return df[col].astype(str) == str(value)
+    elif operator == "ne":
+        return df[col].astype(str) != str(value)
+    elif operator == "gt":
+        return numeric > float(value)
+    elif operator == "gte":
+        return numeric >= float(value)
+    elif operator == "lt":
+        return numeric < float(value)
+    elif operator == "lte":
+        return numeric <= float(value)
+    raise ValueError(f"Unknown operator: {operator}")
+
+
+def _apply_single_filter(df: pd.DataFrame, col: str, value: str, operator: str) -> pd.DataFrame:
+    numeric = pd.to_numeric(df[col], errors="coerce")
+    if operator == "eq":
+        return df[df[col].astype(str) == str(value)]
+    elif operator == "ne":
+        return df[df[col].astype(str) != str(value)]
+    elif operator == "gt":
+        return df[numeric > float(value)]
+    elif operator == "gte":
+        return df[numeric >= float(value)]
+    elif operator == "lt":
+        return df[numeric < float(value)]
+    elif operator == "lte":
+        return df[numeric <= float(value)]
+    raise ValueError(f"Unknown operator: {operator}")
+
+
+def _build_schema_context(df: pd.DataFrame) -> str:
+    lines = []
+    for col in df.columns:
+        sample = df[col].dropna().head(3).tolist()
+        lines.append(f"- {col} ({df[col].dtype}): sample values: {sample}")
+    return "\n".join(lines)
+
+
+def _apply_operation(df: pd.DataFrame, op: TabularOperation, limit: int) -> pd.DataFrame:
+    if op.operation == "groupby_sum":
+        if not op.group_col or not op.value_col:
+            raise ValueError(f"groupby_sum requires group_col and value_col, got {op}")
+        return df.groupby(op.group_col)[op.value_col].sum().reset_index().nlargest(limit, op.value_col)
+    elif op.operation == "groupby_avg":
+        if not op.group_col or not op.value_col:
+            raise ValueError(f"groupby_avg requires group_col and value_col, got {op}")
+        return df.groupby(op.group_col)[op.value_col].mean().reset_index().nlargest(limit, op.value_col)
+    elif op.operation == "groupby_count":
+        if not op.group_col:
+            raise ValueError(f"groupby_count requires group_col, got {op}")
+        df_filtered = df.copy()
+        if op.or_filters:
+            or_mask = pd.Series([False] * len(df_filtered), index=df_filtered.index)
+            for f in op.or_filters:
+                or_mask = or_mask | _get_filter_mask(df_filtered, f["col"], f["value"], f.get("op", "eq"))
+            df_filtered = df_filtered[or_mask]
+        if op.filters:
+            for f in op.filters:
+                df_filtered = _apply_single_filter(df_filtered, f["col"], f["value"], f.get("op", "eq"))
+        elif op.filter_col and op.filter_value is not None:
+            df_filtered = _apply_single_filter(df_filtered, op.filter_col, op.filter_value, op.filter_operator)
+        return df_filtered.groupby(op.group_col).size().reset_index(name="count").nlargest(limit, "count")
+    elif op.operation == "filter":
+        result = df.copy()
+        if op.or_filters:
+            or_mask = pd.Series([False] * len(result), index=result.index)
+            for f in op.or_filters:
+                or_mask = or_mask | _get_filter_mask(result, f["col"], f["value"], f.get("op", "eq"))
+            result = result[or_mask]
+        if op.filters:
+            for f in op.filters:
+                result = _apply_single_filter(result, f["col"], f["value"], f.get("op", "eq"))
+        elif op.filter_col and op.filter_value is not None and not op.or_filters:
+            result = _apply_single_filter(result, op.filter_col, op.filter_value, op.filter_operator)
+        elif not op.or_filters and not op.filters and (not op.filter_col or op.filter_value is None):
+            raise ValueError(f"filter requires filter_col/filter_value or filters or or_filters, got {op}")
+        return result.head(limit)
+    elif op.operation == "top_n":
+        col = op.value_col or op.sort_col
+        if not col:
+            raise ValueError(f"top_n requires value_col, got {op}")
+        n = op.n or limit
+        return df.nlargest(n, col)
+    elif op.operation == "sort":
+        if not op.sort_col:
+            raise ValueError(f"sort requires sort_col, got {op}")
+        return df.sort_values(op.sort_col, ascending=op.ascending).head(limit)
+    elif op.operation == "aggregate":
+        if not op.value_col or not op.agg_func:
+            raise ValueError(f"aggregate requires value_col and agg_func, got {op}")
+        funcs = {"sum": "sum", "avg": "mean", "min": "min", "max": "max", "count": "count"}
+        value = getattr(df[op.value_col], funcs[op.agg_func])()
+        return pd.DataFrame([{op.value_col: value, "operation": op.agg_func}])
+    else:  # "raw"
+        return df.head(limit)
 
 
 class TabularExecutor(BaseExecutor):
+    def __init__(self) -> None:
+        self._llm = AzureChatOpenAI(
+            azure_deployment=settings.azureai_deployment_name_4o,
+            openai_api_version=settings.azureai_api_version_4o,
+            azure_endpoint=settings.azureai_endpoint_url_4o,
+            api_key=settings.azureai_api_key_4o,
+            temperature=0,
+        )
+        self._prompt = ChatPromptTemplate.from_messages([
+            ("system", _SYSTEM_PROMPT),
+            ("human", "{question}"),
+        ])
+        self._chain = self._prompt | self._llm.with_structured_output(TabularOperation)
+
     async def execute(
         self,
         results: list[RetrievalResult],
         user_id: str,
-        db: AsyncSession,
+        _db: AsyncSession,
+        question: str,
         limit: int = 100,
     ) -> list[QueryResult]:
-        # TODO: implement
-        # 1. filter results where source_type == "document" and file_type in _TABULAR_FILE_TYPES
-        # 2. group by document_id -> list of column_names
-        # 3. per group: look up Document by document_id -> get blob_name
-        # 4. blob_storage.download_file(blob_name) -> pd.read_csv / pd.read_excel
-        # 5. df[relevant_columns].head(limit) -> rows as list[dict]
-        # 6. return QueryResult per document
-        raise NotImplementedError
+        tabular = [
+            r for r in results
+            if r.metadata.get("data", {}).get("file_type") in _TABULAR_FILE_TYPES
+        ]
+
+        if not tabular:
+            return []
+
+        # Group by (document_id, sheet_name) → collect relevant column names
+        groups: dict[tuple[str, str | None], _GroupInfo] = {}
+        for r in tabular:
+            data = r.metadata.get("data", {})
+            doc_id = data.get("document_id")
+            if not doc_id:
+                continue
+            sheet_name = data.get("sheet_name")  # None for CSV
+            col_name = data.get("column_name")
+            filename = data.get("filename", "")
+            file_type = data.get("file_type", "")
+
+            key = (doc_id, sheet_name)
+            if key not in groups:
+                groups[key] = {
+                    "columns": [],
+                    "filename": filename,
+                    "file_type": file_type,
+                }
+            if col_name and col_name not in groups[key]["columns"]:
+                groups[key]["columns"].append(col_name)
+
+        async def _process_group(
+            doc_id: str, sheet_name: str | None, info: _GroupInfo
+        ) -> QueryResult | None:
+            try:
+                df = await download_parquet(user_id, doc_id, sheet_name)
+                df_result = await self._query_with_agent(df, question, limit)
+
+                table_label = info["filename"]
+                if sheet_name:
+                    table_label += f" / sheet: {sheet_name}"
+
+                logger.info(
+                    "tabular query complete",
+                    document_id=doc_id,
+                    sheet=sheet_name,
+                    file_type=info["file_type"],
+                    rows=len(df_result),
+                    columns=len(df_result.columns),
+                )
+                return QueryResult(
+                    source_type="document",
+                    source_id=doc_id,
+                    table_or_file=table_label,
+                    columns=list(df_result.columns),
+                    rows=df_result.to_dict(orient="records"),
+                    row_count=len(df_result),
+                )
+            except Exception as e:
+                logger.error(
+                    "tabular query failed",
+                    document_id=doc_id,
+                    sheet=sheet_name,
+                    error=str(e),
+                )
+                return None
+
+        gathered = await asyncio.gather(*[
+            _process_group(doc_id, sheet_name, info)
+            for (doc_id, sheet_name), info in groups.items()
+        ])
+        return [r for r in gathered if r is not None]
+
+    async def _query_with_agent(
+        self, df: pd.DataFrame, question: str, limit: int
+    ) -> pd.DataFrame:
+        schema_ctx = _build_schema_context(df)
+        prev_error = ""
+
+        for attempt in range(_MAX_RETRIES):
+            error_section = (
+                f"Previous attempt failed: {prev_error}\nFix the issue."
+                if prev_error else ""
+            )
+            try:
+                op: TabularOperation = await self._chain.ainvoke({
+                    "schema": schema_ctx,
+                    "error_section": error_section,
+                    "question": question,
+                })
+                logger.info(
+                    "tabular operation decided",
+                    operation=op.operation,
+                    reasoning=op.reasoning,
+                )
+                return _apply_operation(df, op, limit)
+            except Exception as e:
+                prev_error = str(e)
+                logger.warning("tabular agent error", attempt=attempt + 1, error=prev_error)
+
+        # Fallback: return raw rows
+        logger.warning("tabular agent failed after retries, returning raw rows")
+        return df.head(limit)
 
 
 tabular_executor = TabularExecutor()

src/rag/retrievers/document.py

@@ -1,32 +1,154 @@
-"""Document retriever — handles PDF, DOCX, TXT chunks (source_type="document", non-tabular).
+"""Document retriever — handles PDF, DOCX, TXT chunks (source_type="document", non-tabular)."""
 
-TEAMMATE: implement retrieve() below.
-Strategy: MMR (amax_marginal_relevance_search) + score threshold to avoid returning
-near-identical chunks from the same PDF page.
-Filter: source_type="document" AND data->>'file_type' NOT IN ('csv', 'xlsx')
-"""
+from langchain_postgres import PGVector
+from langchain_postgres.vectorstores import DistanceStrategy
+from langchain_openai import AzureOpenAIEmbeddings
+from sqlalchemy import text
 
+from src.config.settings import settings
+from src.db.postgres.connection import _pgvector_engine
 from src.db.postgres.vector_store import get_vector_store
 from src.middlewares.logging import get_logger
 from src.rag.base import BaseRetriever, RetrievalResult
 
 logger = get_logger("document_retriever")
 
-_SCORE_THRESHOLD = 0.45  # discard chunks with cosine distance above this
+# Change this one line to switch retrieval method
+# Options: "mmr" | "cosine" | "euclidean" | "inner_product" | "manhattan"
+_RETRIEVAL_METHOD = "mmr"
+
+_TABULAR_TYPES = {"csv", "xlsx"}
+_FETCH_K = 20
+_LAMBDA_MULT = 0.5
+_COLLECTION_NAME = "document_embeddings"
+
+_embeddings = AzureOpenAIEmbeddings(
+    azure_deployment=settings.azureai_deployment_name_embedding,
+    openai_api_version=settings.azureai_api_version_embedding,
+    azure_endpoint=settings.azureai_endpoint_url_embedding,
+    api_key=settings.azureai_api_key_embedding,
+)
+
+_euclidean_store = PGVector(
+    embeddings=_embeddings,
+    connection=_pgvector_engine,
+    collection_name=_COLLECTION_NAME,
+    distance_strategy=DistanceStrategy.EUCLIDEAN,
+    use_jsonb=True,
+    async_mode=True,
+    create_extension=False,
+)
+
+_ip_store = PGVector(
+    embeddings=_embeddings,
+    connection=_pgvector_engine,
+    collection_name=_COLLECTION_NAME,
+    distance_strategy=DistanceStrategy.MAX_INNER_PRODUCT,
+    use_jsonb=True,
+    async_mode=True,
+    create_extension=False,
+)
+
+_MANHATTAN_SQL = text("""
+    SELECT
+        lpe.document,
+        lpe.cmetadata,
+        lpe.embedding <+> CAST(:embedding AS vector) AS distance
+    FROM langchain_pg_embedding lpe
+    JOIN langchain_pg_collection lpc ON lpe.collection_id = lpc.uuid
+    WHERE lpc.name = :collection
+      AND lpe.cmetadata->>'user_id' = :user_id
+      AND lpe.cmetadata->>'source_type' = 'document'
+    ORDER BY distance ASC
+    LIMIT :k
+""")
 
 
 class DocumentRetriever(BaseRetriever):
-    def __init__(self):
+    def __init__(self) -> None:
         self.vector_store = get_vector_store()
 
     async def retrieve(
         self, query: str, user_id: str, k: int = 5
     ) -> list[RetrievalResult]:
-        # TODO (teammate): implement MMR retrieval for prose documents
-        # Filter: {"user_id": user_id, "source_type": "document"}
-        # then post-filter to exclude file_type in ("csv", "xlsx")
-        logger.info("document retriever not yet implemented — returning empty")
-        return []
+        filter_ = {"user_id": user_id, "source_type": "document"}
+        fetch_k = k + len(_TABULAR_TYPES)
+
+        if _RETRIEVAL_METHOD == "manhattan":
+            return await self._retrieve_manhattan(query, user_id, k, fetch_k)
+
+        if _RETRIEVAL_METHOD == "mmr":
+            docs = await self.vector_store.amax_marginal_relevance_search(
+                query=query,
+                k=fetch_k,
+                fetch_k=_FETCH_K,
+                lambda_mult=_LAMBDA_MULT,
+                filter=filter_,
+            )
+            cosine = await self.vector_store.asimilarity_search_with_score(
+                query=query, k=fetch_k, filter=filter_,
+            )
+            score_map = {doc.page_content: score for doc, score in cosine}
+            docs_with_scores = [(doc, score_map.get(doc.page_content, 0.0)) for doc in docs]
+        elif _RETRIEVAL_METHOD == "euclidean":
+            docs_with_scores = await _euclidean_store.asimilarity_search_with_score(
+                query=query, k=fetch_k, filter=filter_,
+            )
+        elif _RETRIEVAL_METHOD == "inner_product":
+            docs_with_scores = await _ip_store.asimilarity_search_with_score(
+                query=query, k=fetch_k, filter=filter_,
+            )
+        else:  # cosine
+            docs_with_scores = await self.vector_store.asimilarity_search_with_score(
+                query=query, k=fetch_k, filter=filter_,
+            )
+
+        results = []
+        for doc, score in docs_with_scores:
+            file_type = doc.metadata.get("data", {}).get("file_type", "")
+            if file_type not in _TABULAR_TYPES:
+                results.append(RetrievalResult(
+                    content=doc.page_content,
+                    metadata=doc.metadata,
+                    score=score,
+                    source_type="document",
+                ))
+            if len(results) == k:
+                break
+
+        logger.info("retrieved chunks", method=_RETRIEVAL_METHOD, count=len(results))
+        return results
+
+    async def _retrieve_manhattan(
+        self, query: str, user_id: str, k: int, fetch_k: int
+    ) -> list[RetrievalResult]:
+        query_vector = await _embeddings.aembed_query(query)
+        vector_str = "[" + ",".join(str(v) for v in query_vector) + "]"
+
+        async with _pgvector_engine.connect() as conn:
+            result = await conn.execute(_MANHATTAN_SQL, {
+                "embedding": vector_str,
+                "collection": _COLLECTION_NAME,
+                "user_id": user_id,
+                "k": fetch_k,
+            })
+            rows = result.fetchall()
+
+        results = []
+        for row in rows:
+            file_type = row.cmetadata.get("data", {}).get("file_type", "")
+            if file_type not in _TABULAR_TYPES:
+                results.append(RetrievalResult(
+                    content=row.document,
+                    metadata=row.cmetadata,
+                    score=float(row.distance),
+                    source_type="document",
+                ))
+            if len(results) == k:
+                break
+
+        logger.info("retrieved chunks", method="manhattan", count=len(results))
+        return results
 
 
 document_retriever = DocumentRetriever()

uv.lock

@@ -47,6 +47,7 @@ dependencies = [
     { name = "prometheus-client" },
     { name = "psycopg", extra = ["binary", "pool"] },
     { name = "psycopg2" },
+    { name = "pyarrow" },
     { name = "pydantic" },
     { name = "pydantic-settings" },
     { name = "pymongo" },
@@ -127,6 +128,7 @@ requires-dist = [
     { name = "prometheus-client", specifier = "==0.21.1" },
     { name = "psycopg", extras = ["binary", "pool"], specifier = "==3.2.3" },
     { name = "psycopg2", specifier = ">=2.9.11" },
+    { name = "pyarrow", specifier = ">=24.0.0" },
     { name = "pydantic", specifier = "==2.10.3" },
     { name = "pydantic-settings", specifier = "==2.7.0" },
     { name = "pymongo", specifier = ">=4.14.0" },
@@ -2400,6 +2402,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b5/bf/635fbe5dd10ed200afbbfbe98f8602829252ca1cce81cc48fb25ed8dadc0/psycopg2-2.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:e03e4a6dbe87ff81540b434f2e5dc2bddad10296db5eea7bdc995bf5f4162938", size = 2713969, upload-time = "2025-10-10T11:10:15.946Z" },
 ]
 
+[[package]]
+name = "pyarrow"
+version = "24.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" },
+]
+
 [[package]]
 name = "pyasn1"
 version = "0.6.3"