langchain-xparse 1.0.0__tar.gz

langchain_xparse-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wangxuetong123456
+
+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.

langchain_xparse-1.0.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: langchain-xparse
+Version: 1.0.0
+Summary: LangChain integration with xParse Pipeline API for document parsing, chunking and embedding
+Author-email: intsig-textin <wangxuetongxztx@163.com>
+Maintainer-email: intsig-textin <wangxuetongxztx@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/intsig-textin/langchain-xparse
+Project-URL: Source, https://github.com/intsig-textin/langchain-xparse
+Project-URL: Documentation, https://docs.textin.com/pipeline/overview
+Project-URL: Bug Tracker, https://github.com/intsig-textin/langchain-xparse/issues
+Keywords: langchain,xparse,document-loader,textin,parsing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: python-dotenv>=1.0; extra == "dev"
+Dynamic: license-file
+
+# langchain-xparse
+
+LangChain integration with [xParse Pipeline API](https://docs.textin.com/pipeline/overview) for document parsing, chunking and embedding. Supports parse / chunk / embed stages only (extract is not supported in this loader).
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install langchain-xparse
+```
+
+Local editable install:
+
+```bash
+pip install -e .
+```
+
+## Configuration
+
+Set your TextIn credentials (from [Textin Workspace](https://www.textin.com/console/dashboard/setting) ):
+
+```bash
+export XPARSE_APP_ID="your-app-id"
+export XPARSE_SECRET_CODE="your-secret-code"
+```
+
+Or pass them when creating the loader:
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    app_id="your-app-id",
+    secret_code="your-secret-code",
+)
+```
+
+## Usage
+
+### Basic (parse only)
+
+```python
+from langchain_xparse import XParseLoader
+
+loader = XParseLoader(file_path="example.pdf")
+docs = loader.load()
+print(docs[0].page_content[:200])
+print(docs[0].metadata)  # source, category, element_id, filename, page_number, ...
+```
+
+### Lazy load
+
+```python
+for doc in loader.lazy_load():
+    # process(doc)
+```
+
+### Async
+
+```python
+async for doc in loader.alazy_load():
+    # process(doc)
+```
+
+### Convenience params (parse + chunk, or parse + chunk + embed)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="by_title",
+    chunk_max_characters=500,
+    chunk_overlap=50,
+)
+# Or with embed:
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="basic",
+    chunk_max_characters=1000,
+    embed_provider="qwen",
+    embed_model_name="text-embedding-v4",
+)
+docs = loader.load()
+```
+
+### Custom stages (advanced)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    stages=[
+        {"type": "parse", "config": {"provider": "textin"}},
+        {"type": "chunk", "config": {"strategy": "by_page", "max_characters": 800}},
+    ],
+)
+```
+
+### Multiple files
+
+```python
+loader = XParseLoader(file_path=["a.pdf", "b.pdf"])
+for doc in loader.lazy_load():
+    print(doc.metadata.get("source"), doc.page_content[:50])
+```
+
+### File-like object
+
+When passing a file-like object instead of a path, you must set `metadata_filename`:
+
+```python
+with open("doc.pdf", "rb") as f:
+    loader = XParseLoader(file=f, metadata_filename="doc.pdf")
+    docs = loader.load()
+```
+
+## References
+
+- [xParse overview](https://docs.textin.com/pipeline/overview)
+- [Pipeline API](https://docs.textin.com/api-reference/endpoint/pipeline)

langchain_xparse-1.0.0/README.md

@@ -0,0 +1,120 @@
+# langchain-xparse
+
+LangChain integration with [xParse Pipeline API](https://docs.textin.com/pipeline/overview) for document parsing, chunking and embedding. Supports parse / chunk / embed stages only (extract is not supported in this loader).
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install langchain-xparse
+```
+
+Local editable install:
+
+```bash
+pip install -e .
+```
+
+## Configuration
+
+Set your TextIn credentials (from [Textin Workspace](https://www.textin.com/console/dashboard/setting) ):
+
+```bash
+export XPARSE_APP_ID="your-app-id"
+export XPARSE_SECRET_CODE="your-secret-code"
+```
+
+Or pass them when creating the loader:
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    app_id="your-app-id",
+    secret_code="your-secret-code",
+)
+```
+
+## Usage
+
+### Basic (parse only)
+
+```python
+from langchain_xparse import XParseLoader
+
+loader = XParseLoader(file_path="example.pdf")
+docs = loader.load()
+print(docs[0].page_content[:200])
+print(docs[0].metadata)  # source, category, element_id, filename, page_number, ...
+```
+
+### Lazy load
+
+```python
+for doc in loader.lazy_load():
+    # process(doc)
+```
+
+### Async
+
+```python
+async for doc in loader.alazy_load():
+    # process(doc)
+```
+
+### Convenience params (parse + chunk, or parse + chunk + embed)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="by_title",
+    chunk_max_characters=500,
+    chunk_overlap=50,
+)
+# Or with embed:
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="basic",
+    chunk_max_characters=1000,
+    embed_provider="qwen",
+    embed_model_name="text-embedding-v4",
+)
+docs = loader.load()
+```
+
+### Custom stages (advanced)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    stages=[
+        {"type": "parse", "config": {"provider": "textin"}},
+        {"type": "chunk", "config": {"strategy": "by_page", "max_characters": 800}},
+    ],
+)
+```
+
+### Multiple files
+
+```python
+loader = XParseLoader(file_path=["a.pdf", "b.pdf"])
+for doc in loader.lazy_load():
+    print(doc.metadata.get("source"), doc.page_content[:50])
+```
+
+### File-like object
+
+When passing a file-like object instead of a path, you must set `metadata_filename`:
+
+```python
+with open("doc.pdf", "rb") as f:
+    loader = XParseLoader(file=f, metadata_filename="doc.pdf")
+    docs = loader.load()
+```
+
+## References
+
+- [xParse overview](https://docs.textin.com/pipeline/overview)
+- [Pipeline API](https://docs.textin.com/api-reference/endpoint/pipeline)

langchain_xparse-1.0.0/langchain_xparse/__init__.py

@@ -0,0 +1,20 @@
+"""LangChain integration with xParse Pipeline API."""
+
+from importlib import metadata
+
+from langchain_xparse.client import XParseAPIError
+from langchain_xparse.document_loaders import XParseLoader
+
+try:
+    __version__ = metadata.version("langchain-xparse")
+except metadata.PackageNotFoundError:
+    try:
+        __version__ = metadata.version(__package__ or "langchain_xparse")
+    except metadata.PackageNotFoundError:
+        __version__ = ""
+
+__all__ = [
+    "XParseAPIError",
+    "XParseLoader",
+    "__version__",
+]

langchain_xparse-1.0.0/langchain_xparse/client.py

@@ -0,0 +1,92 @@
+"""xParse Pipeline API client: auth, request/response handling, sync and async."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+DEFAULT_BASE_URL = "https://api.textin.com"
+PIPELINE_PATH = "/api/xparse/pipeline"
+DEFAULT_STAGES = [{"type": "parse", "config": {"provider": "textin"}}]
+
+
+class XParseAPIError(Exception):
+    """Raised when the Pipeline API returns code != 200."""
+
+    def __init__(self, code: int, message: str, *args: Any, **kwargs: Any) -> None:
+        self.code = code
+        self.message = message
+        super().__init__(code, message, *args, **kwargs)
+
+
+class PipelineClient:
+    """Client for xParse Pipeline API (sync and async)."""
+
+    def __init__(
+        self,
+        app_id: str,
+        secret_code: str,
+        base_url: str = DEFAULT_BASE_URL,
+    ) -> None:
+        self.app_id = app_id
+        self.secret_code = secret_code
+        self.base_url = base_url.rstrip("/")
+        self._headers = {
+            "x-ti-app-id": app_id,
+            "x-ti-secret-code": secret_code,
+        }
+
+    def _url(self) -> str:
+        return f"{self.base_url}{PIPELINE_PATH}"
+
+    def _parse_response(self, response: httpx.Response) -> list[dict[str, Any]]:
+        try:
+            data = response.json()
+        except Exception as e:
+            raise XParseAPIError(
+                response.status_code,
+                f"Invalid JSON response: {e}",
+            ) from e
+        code = data.get("code", response.status_code)
+        msg = data.get("message", "")
+        if code != 200:
+            raise XParseAPIError(code, msg or f"HTTP {response.status_code}")
+        # API may return elements at top level or nested in 'data' field
+        elements = data.get("elements")
+        if elements is None and "data" in data and isinstance(data["data"], dict):
+            elements = data["data"].get("elements")
+        return elements or []
+
+    def run_pipeline(
+        self,
+        file_content: bytes,
+        filename: str,
+        stages: list[dict[str, Any]] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Execute the pipeline (sync). Returns list of elements."""
+        stages = stages or DEFAULT_STAGES
+        url = self._url()
+        files = {"file": (filename, file_content)}
+        data = {"stages": json.dumps(stages)}
+        with httpx.Client(timeout=120.0) as client:
+            resp = client.post(url, headers=self._headers, files=files, data=data)
+        resp.raise_for_status()
+        return self._parse_response(resp)
+
+    async def arun_pipeline(
+        self,
+        file_content: bytes,
+        filename: str,
+        stages: list[dict[str, Any]] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Execute the pipeline (async). Returns list of elements."""
+        stages = stages or DEFAULT_STAGES
+        url = self._url()
+        files = {"file": (filename, file_content)}
+        data = {"stages": json.dumps(stages)}
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            resp = await client.post(url, headers=self._headers, files=files, data=data)
+        resp.raise_for_status()
+        return self._parse_response(resp)

langchain_xparse-1.0.0/langchain_xparse/document_loaders.py

@@ -0,0 +1,274 @@
+"""xParse Pipeline document loader: XParseLoader and _SingleDocumentLoader."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, AsyncIterator, Callable, Iterator
+
+from langchain_core.document_loaders.base import BaseLoader
+from langchain_core.documents import Document
+
+from langchain_xparse.client import DEFAULT_STAGES, PipelineClient
+
+
+def _build_stages(
+    *,
+    parse_provider: str = "textin",
+    chunk_strategy: str | None = None,
+    chunk_max_characters: int | None = None,
+    chunk_overlap: int | None = None,
+    chunk_include_orig_elements: bool = False,
+    chunk_new_after_n_chars: int | None = None,
+    embed_provider: str | None = None,
+    embed_model_name: str | None = None,
+    **kwargs: Any,
+) -> list[dict[str, Any]]:
+    """Build Pipeline stages from convenience parameters (parse/chunk/embed only)."""
+    stages: list[dict[str, Any]] = [
+        {"type": "parse", "config": {"provider": parse_provider}}
+    ]
+    if chunk_strategy is not None:
+        chunk_config: dict[str, Any] = {"strategy": chunk_strategy}
+        if chunk_max_characters is not None:
+            chunk_config["max_characters"] = chunk_max_characters
+        if chunk_overlap is not None:
+            chunk_config["overlap"] = chunk_overlap
+        if chunk_include_orig_elements:
+            chunk_config["include_orig_elements"] = True
+        if chunk_new_after_n_chars is not None:
+            chunk_config["new_after_n_chars"] = chunk_new_after_n_chars
+        stages.append({"type": "chunk", "config": chunk_config})
+    if embed_provider is not None and embed_model_name is not None:
+        stages.append(
+            {
+                "type": "embed",
+                "config": {
+                    "provider": embed_provider,
+                    "model_name": embed_model_name,
+                },
+            }
+        )
+    return stages
+
+
+class _SingleDocumentLoader(BaseLoader):
+    """Loads a single file via xParse Pipeline API into LangChain Documents."""
+
+    def __init__(
+        self,
+        *,
+        client: PipelineClient,
+        file_path: str | Path | None = None,
+        file: Any = None,
+        stages: list[dict[str, Any]],
+        post_processors: list[Callable[[str], str]] | None = None,
+        metadata_filename: str | None = None,
+    ) -> None:
+        self.client = client
+        self.file_path = str(file_path) if isinstance(file_path, Path) else file_path
+        self.file = file
+        self.stages = stages
+        self.post_processors = post_processors or []
+        self.metadata_filename = metadata_filename
+
+    def _file_content(self) -> bytes:
+        if self.file is not None:
+            return self.file.read()
+        if self.file_path:
+            with open(self.file_path, "rb") as f:
+                return f.read()
+        raise ValueError("file or file_path must be defined.")
+
+    def _filename(self) -> str:
+        if self.file_path:
+            return Path(self.file_path).name
+        if self.metadata_filename:
+            return self.metadata_filename
+        return "unknown"
+
+    def _source(self) -> str:
+        return self.file_path or self.metadata_filename or ""
+
+    def _element_to_document(self, element: dict[str, Any]) -> Document:
+        text = element.get("text") or ""
+        for fn in self.post_processors:
+            text = fn(text)
+        meta: dict[str, Any] = {
+            "source": self._source(),
+            "category": element.get("type"),
+            "element_id": element.get("element_id"),
+        }
+        if element.get("metadata"):
+            meta.update(element["metadata"])
+        if element.get("embeddings") is not None:
+            meta["embeddings"] = element["embeddings"]
+        return Document(page_content=text, metadata=meta)
+
+    def lazy_load(self) -> Iterator[Document]:
+        content = self._file_content()
+        filename = self._filename()
+        elements = self.client.run_pipeline(content, filename, self.stages)
+        for el in elements:
+            yield self._element_to_document(el)
+
+    async def alazy_load(self) -> AsyncIterator[Document]:
+        content = self._file_content()
+        filename = self._filename()
+        elements = await self.client.arun_pipeline(content, filename, self.stages)
+        for el in elements:
+            yield self._element_to_document(el)
+
+
+class XParseLoader(BaseLoader):
+    """Load documents via xParse Pipeline API (parse/chunk/embed; no extract).
+
+    Setup:
+        Set environment variables or pass credentials:
+
+        ```bash
+        export XPARSE_APP_ID="your-app-id"
+        export XPARSE_SECRET_CODE="your-secret-code"
+        ```
+
+    Example:
+        ```python
+        from langchain_xparse import XParseLoader
+
+        loader = XParseLoader(file_path="example.pdf")
+        docs = loader.load()
+
+        # With convenience params (parse + chunk):
+        loader = XParseLoader(
+            file_path="doc.pdf",
+            parse_provider="textin",
+            chunk_strategy="by_title",
+            chunk_max_characters=500,
+        )
+        for doc in loader.lazy_load():
+            print(doc.page_content[:100], doc.metadata)
+        ```
+    """
+
+    def __init__(
+        self,
+        file_path: str | Path | list[str] | list[Path] | None = None,
+        *,
+        file: Any = None,
+        app_id: str | None = None,
+        secret_code: str | None = None,
+        base_url: str | None = None,
+        stages: list[dict[str, Any]] | None = None,
+        post_processors: list[Callable[[str], str]] | None = None,
+        metadata_filename: str | None = None,
+        parse_provider: str = "textin",
+        chunk_strategy: str | None = None,
+        chunk_max_characters: int | None = None,
+        chunk_overlap: int | None = None,
+        chunk_include_orig_elements: bool = False,
+        chunk_new_after_n_chars: int | None = None,
+        embed_provider: str | None = None,
+        embed_model_name: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if file_path is not None and file is not None:
+            raise ValueError("file_path and file cannot be defined simultaneously.")
+        if file is not None and metadata_filename is None:
+            raise ValueError(
+                "When using file (file-like), metadata_filename must be specified."
+            )
+
+        self._app_id = app_id or os.getenv("XPARSE_APP_ID") or ""
+        self._secret_code = secret_code or os.getenv("XPARSE_SECRET_CODE") or ""
+        self._base_url = base_url or "https://api.textin.com"
+        self.file_path = file_path
+        self.file = file
+        self.post_processors = post_processors or []
+        self.metadata_filename = metadata_filename
+
+        if stages is not None:
+            self._stages = stages
+        else:
+            self._stages = _build_stages(
+                parse_provider=parse_provider,
+                chunk_strategy=chunk_strategy,
+                chunk_max_characters=chunk_max_characters,
+                chunk_overlap=chunk_overlap,
+                chunk_include_orig_elements=chunk_include_orig_elements,
+                chunk_new_after_n_chars=chunk_new_after_n_chars,
+                embed_provider=embed_provider,
+                embed_model_name=embed_model_name,
+                **kwargs,
+            )
+
+        self._client = PipelineClient(
+            app_id=self._app_id,
+            secret_code=self._secret_code,
+            base_url=self._base_url,
+        )
+
+    def _load_one(
+        self,
+        f_path: str | Path | None = None,
+        f: Any = None,
+        meta_filename: str | None = None,
+    ) -> Iterator[Document]:
+        single = _SingleDocumentLoader(
+            client=self._client,
+            file_path=str(f_path) if f_path is not None else None,
+            file=f,
+            stages=self._stages,
+            post_processors=self.post_processors,
+            metadata_filename=meta_filename,
+        )
+        yield from single.lazy_load()
+
+    async def _aload_one(
+        self,
+        f_path: str | Path | None = None,
+        f: Any = None,
+        meta_filename: str | None = None,
+    ) -> AsyncIterator[Document]:
+        single = _SingleDocumentLoader(
+            client=self._client,
+            file_path=str(f_path) if f_path is not None else None,
+            file=f,
+            stages=self._stages,
+            post_processors=self.post_processors,
+            metadata_filename=meta_filename,
+        )
+        async for doc in single.alazy_load():
+            yield doc
+
+    def lazy_load(self) -> Iterator[Document]:
+        if isinstance(self.file, list):
+            for f in self.file:
+                yield from self._load_one(f=f, meta_filename=self.metadata_filename)
+            return
+        if isinstance(self.file_path, list):
+            for p in self.file_path:
+                yield from self._load_one(f_path=p)
+            return
+        yield from self._load_one(
+            f_path=self.file_path,
+            f=self.file,
+            meta_filename=self.metadata_filename,
+        )
+
+    async def alazy_load(self) -> AsyncIterator[Document]:
+        if isinstance(self.file, list):
+            for f in self.file:
+                async for doc in self._aload_one(f=f, meta_filename=self.metadata_filename):
+                    yield doc
+            return
+        if isinstance(self.file_path, list):
+            for p in self.file_path:
+                async for doc in self._aload_one(f_path=p):
+                    yield doc
+            return
+        async for doc in self._aload_one(
+            f_path=self.file_path,
+            f=self.file,
+            meta_filename=self.metadata_filename,
+        ):
+            yield doc

langchain_xparse-1.0.0/langchain_xparse.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: langchain-xparse
+Version: 1.0.0
+Summary: LangChain integration with xParse Pipeline API for document parsing, chunking and embedding
+Author-email: intsig-textin <wangxuetongxztx@163.com>
+Maintainer-email: intsig-textin <wangxuetongxztx@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/intsig-textin/langchain-xparse
+Project-URL: Source, https://github.com/intsig-textin/langchain-xparse
+Project-URL: Documentation, https://docs.textin.com/pipeline/overview
+Project-URL: Bug Tracker, https://github.com/intsig-textin/langchain-xparse/issues
+Keywords: langchain,xparse,document-loader,textin,parsing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: python-dotenv>=1.0; extra == "dev"
+Dynamic: license-file
+
+# langchain-xparse
+
+LangChain integration with [xParse Pipeline API](https://docs.textin.com/pipeline/overview) for document parsing, chunking and embedding. Supports parse / chunk / embed stages only (extract is not supported in this loader).
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install langchain-xparse
+```
+
+Local editable install:
+
+```bash
+pip install -e .
+```
+
+## Configuration
+
+Set your TextIn credentials (from [Textin Workspace](https://www.textin.com/console/dashboard/setting) ):
+
+```bash
+export XPARSE_APP_ID="your-app-id"
+export XPARSE_SECRET_CODE="your-secret-code"
+```
+
+Or pass them when creating the loader:
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    app_id="your-app-id",
+    secret_code="your-secret-code",
+)
+```
+
+## Usage
+
+### Basic (parse only)
+
+```python
+from langchain_xparse import XParseLoader
+
+loader = XParseLoader(file_path="example.pdf")
+docs = loader.load()
+print(docs[0].page_content[:200])
+print(docs[0].metadata)  # source, category, element_id, filename, page_number, ...
+```
+
+### Lazy load
+
+```python
+for doc in loader.lazy_load():
+    # process(doc)
+```
+
+### Async
+
+```python
+async for doc in loader.alazy_load():
+    # process(doc)
+```
+
+### Convenience params (parse + chunk, or parse + chunk + embed)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="by_title",
+    chunk_max_characters=500,
+    chunk_overlap=50,
+)
+# Or with embed:
+loader = XParseLoader(
+    file_path="doc.pdf",
+    parse_provider="textin",
+    chunk_strategy="basic",
+    chunk_max_characters=1000,
+    embed_provider="qwen",
+    embed_model_name="text-embedding-v4",
+)
+docs = loader.load()
+```
+
+### Custom stages (advanced)
+
+```python
+loader = XParseLoader(
+    file_path="doc.pdf",
+    stages=[
+        {"type": "parse", "config": {"provider": "textin"}},
+        {"type": "chunk", "config": {"strategy": "by_page", "max_characters": 800}},
+    ],
+)
+```
+
+### Multiple files
+
+```python
+loader = XParseLoader(file_path=["a.pdf", "b.pdf"])
+for doc in loader.lazy_load():
+    print(doc.metadata.get("source"), doc.page_content[:50])
+```
+
+### File-like object
+
+When passing a file-like object instead of a path, you must set `metadata_filename`:
+
+```python
+with open("doc.pdf", "rb") as f:
+    loader = XParseLoader(file=f, metadata_filename="doc.pdf")
+    docs = loader.load()
+```
+
+## References
+
+- [xParse overview](https://docs.textin.com/pipeline/overview)
+- [Pipeline API](https://docs.textin.com/api-reference/endpoint/pipeline)

langchain_xparse-1.0.0/langchain_xparse.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_xparse/__init__.py
+langchain_xparse/client.py
+langchain_xparse/document_loaders.py
+langchain_xparse/py.typed
+langchain_xparse.egg-info/PKG-INFO
+langchain_xparse.egg-info/SOURCES.txt
+langchain_xparse.egg-info/dependency_links.txt
+langchain_xparse.egg-info/requires.txt
+langchain_xparse.egg-info/top_level.txt

langchain_xparse-1.0.0/langchain_xparse.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_xparse-1.0.0/langchain_xparse.egg-info/requires.txt

@@ -0,0 +1,7 @@
+langchain-core>=1.0
+httpx>=0.24
+
+[dev]
+pytest>=7
+pytest-asyncio>=0.21
+python-dotenv>=1.0

langchain_xparse-1.0.0/langchain_xparse.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_xparse

langchain_xparse-1.0.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-xparse"
+version = "1.0.0"
+description = "LangChain integration with xParse Pipeline API for document parsing, chunking and embedding"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "intsig-textin", email = "wangxuetongxztx@163.com"}
+]
+maintainers = [
+    {name = "intsig-textin", email = "wangxuetongxztx@163.com"}
+]
+keywords = ["langchain", "xparse", "document-loader", "textin", "parsing"]
+dependencies = [
+    "langchain-core>=1.0",
+    "httpx>=0.24",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+    "pytest-asyncio>=0.21",
+    "python-dotenv>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/intsig-textin/langchain-xparse"
+Source = "https://github.com/intsig-textin/langchain-xparse"
+Documentation = "https://docs.textin.com/pipeline/overview"
+"Bug Tracker" = "https://github.com/intsig-textin/langchain-xparse/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["langchain_xparse*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+markers = [
+    "integration: marks tests as integration (require XPARSE_APP_ID, XPARSE_SECRET_CODE)",
+]

langchain_xparse-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+