bankstatementparser-mcp 0.0.10__py3-none-any.whl

bankstatementparser_mcp/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (C) 2023-2026 Bank Statement Parser. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MCP server exposing the bankstatementparser library as agent tools.
+
+Install with ``pip install bankstatementparser-mcp`` and run
+``bankstatementparser-mcp`` (stdio transport).
+"""
+
+__version__ = "0.0.10"

bankstatementparser_mcp/server.py

@@ -0,0 +1,334 @@
+# Copyright (C) 2023-2026 Bank Statement Parser. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""BankStatementParser MCP server (stdio transport).
+
+Tools, the resource, and the prompt are thin adapters over the
+bankstatementparser parser core. The tools take **inline content**
+(the raw text of a statement) plus a filename hint, because an MCP
+client does not share the server's filesystem. Each call materialises
+the content in a private temporary file, runs the same
+``create_parser`` pipeline the CLI uses, and returns plain
+JSON-serialisable data.
+
+Run it with::
+
+    bankstatementparser-mcp
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from bankstatementparser.additional_parsers import (
+    create_parser,
+    detect_statement_format,
+)
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("bankstatementparser")
+
+_FORMAT_SUFFIX: dict[str, str] = {
+    "camt": ".xml",
+    "pain001": ".xml",
+    "csv": ".csv",
+    "ofx": ".ofx",
+    "qfx": ".qfx",
+    "mt940": ".mt940",
+}
+
+
+def _require_format(format_name: str) -> None:
+    """Reject an unsupported statement format.
+
+    Args:
+        format_name: The statement format to check.
+
+    Raises:
+        ValueError: If the format is not supported.
+    """
+    if format_name not in _FORMAT_SUFFIX:
+        supported = ", ".join(_FORMAT_SUFFIX)
+        raise ValueError(
+            f"Unsupported format '{format_name}'. Supported: {supported}"
+        )
+
+
+def _suffix_for(filename: str | None, format_name: str | None) -> str:
+    """Choose the temp-file suffix for an inline payload.
+
+    Args:
+        filename: Optional original filename whose extension is reused
+            when it is one the parser accepts.
+        format_name: Optional explicit format, used when no usable
+            filename extension is available.
+
+    Returns:
+        A file suffix (including the leading dot) for the temp file.
+
+    Raises:
+        ValueError: If neither a usable extension nor a supported
+            format is provided.
+    """
+    if filename:
+        suffix = Path(filename).suffix.lower()
+        if suffix in set(_FORMAT_SUFFIX.values()) | {".sta"}:
+            return suffix
+    if format_name:
+        _require_format(format_name)
+        return _FORMAT_SUFFIX[format_name]
+    raise ValueError(
+        "Provide a 'filename' with a supported extension "
+        "(.xml/.csv/.ofx/.qfx/.mt940/.sta) or an explicit 'format'."
+    )
+
+
+@contextmanager
+def _materialise(content: str, suffix: str) -> Iterator[Path]:
+    """Write inline content to a private temp file for one call.
+
+    A closed-then-reopened temp file (via :func:`tempfile.mkstemp`) is
+    used rather than an open ``NamedTemporaryFile`` so the file-based
+    parsers can reopen the path by name.
+
+    Args:
+        content: The raw statement text supplied by the client.
+        suffix: The file suffix to give the temp file.
+
+    Yields:
+        The path to the temporary file (removed on exit).
+    """
+    fd, name = tempfile.mkstemp(suffix=suffix)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(content)
+        yield Path(name)
+    finally:
+        os.unlink(name)
+
+
+def _summary_to_jsonable(summary: dict[str, Any]) -> dict[str, Any]:
+    """Coerce a summary record to JSON-serialisable primitives.
+
+    Args:
+        summary: The raw summary record from a parser.
+
+    Returns:
+        The same mapping with non-primitive values stringified.
+    """
+    jsonable: dict[str, Any] = {}
+    for key, value in summary.items():
+        if value is None or isinstance(value, str | int | bool):
+            jsonable[key] = value
+        else:
+            jsonable[key] = str(value)
+    return jsonable
+
+
+@mcp.tool()
+def list_supported_formats() -> list[str]:
+    """List every bank statement format the parser can read.
+
+    Returns:
+        The supported format identifiers.
+    """
+    return list(_FORMAT_SUFFIX)
+
+
+@mcp.tool()
+def detect_format(content: str, filename: str = "statement.xml") -> str:
+    """Detect which statement format a payload is.
+
+    Args:
+        content: The raw statement text.
+        filename: Original filename; its extension is the primary hint.
+
+    Returns:
+        The detected format identifier.
+
+    Raises:
+        ValueError: If the format cannot be detected.
+    """
+    suffix = _suffix_for(filename, None)
+    with _materialise(content, suffix) as path:
+        return detect_statement_format(path)
+
+
+@mcp.tool()
+def parse_statement(
+    content: str,
+    filename: str = "statement.xml",
+    format: str | None = None,
+    limit: int | None = None,
+) -> dict[str, Any]:
+    """Parse a statement into structured transactions and a summary.
+
+    Args:
+        content: The raw statement text.
+        filename: Original filename; its extension selects the format
+            when ``format`` is omitted.
+        format: Explicit format override.
+        limit: Optional cap on returned transaction rows.
+
+    Returns:
+        A dict with the resolved ``format``, ``columns``, full
+        ``transaction_count``, the (possibly truncated) ``transactions``
+        as row dicts, and the statement ``summary``.
+
+    Raises:
+        ValueError: If the format is unsupported or cannot be detected.
+    """
+    if format is not None:
+        _require_format(format)
+    suffix = _suffix_for(filename, format)
+    with _materialise(content, suffix) as path:
+        parser = create_parser(path, format)
+        frame = parser.parse()
+        summary = _summary_to_jsonable(dict(parser.get_summary()))
+        records = frame.to_dict("records")
+        total = len(records)
+        if limit is not None:
+            records = records[:limit]
+        return {
+            "format": format or detect_statement_format(path),
+            "columns": list(frame.columns),
+            "transaction_count": total,
+            "transactions": [
+                {k: (v if v is None else str(v)) for k, v in row.items()}
+                for row in records
+            ],
+            "summary": summary,
+        }
+
+
+@mcp.tool()
+def validate_statement(
+    content: str,
+    filename: str = "statement.xml",
+    format: str | None = None,
+) -> dict[str, Any]:
+    """Check whether a statement parses cleanly (a dry run).
+
+    Args:
+        content: The raw statement text.
+        filename: Original filename; its extension selects the format.
+        format: Explicit format override.
+
+    Returns:
+        A dict with ``is_valid``, the resolved ``format``, the
+        ``transaction_count`` on success, and an ``error`` on failure.
+    """
+    if format is not None:
+        _require_format(format)
+    try:
+        suffix = _suffix_for(filename, format)
+        with _materialise(content, suffix) as path:
+            resolved = format or detect_statement_format(path)
+            parser = create_parser(path, format)
+            frame = parser.parse()
+        return {
+            "is_valid": True,
+            "format": resolved,
+            "transaction_count": len(frame),
+            "error": None,
+        }
+    except Exception as exc:
+        return {
+            "is_valid": False,
+            "format": format,
+            "transaction_count": 0,
+            "error": str(exc),
+        }
+
+
+@mcp.tool()
+def summarize_statement(
+    content: str,
+    filename: str = "statement.xml",
+    format: str | None = None,
+) -> dict[str, Any]:
+    """Return only the statement summary (no per-transaction rows).
+
+    Args:
+        content: The raw statement text.
+        filename: Original filename; its extension selects the format.
+        format: Explicit format override.
+
+    Returns:
+        The summary record with Decimal values stringified.
+
+    Raises:
+        ValueError: If the format is unsupported or cannot be detected.
+    """
+    if format is not None:
+        _require_format(format)
+    suffix = _suffix_for(filename, format)
+    with _materialise(content, suffix) as path:
+        parser = create_parser(path, format)
+        return _summary_to_jsonable(dict(parser.get_summary()))
+
+
+@mcp.resource("bankstatementparser://formats")
+def formats_resource() -> str:
+    """Describe each supported statement format and its file extensions.
+
+    Returns:
+        A human-readable catalogue of the supported formats.
+    """
+    lines = [
+        "BankStatementParser supported input formats:",
+        "",
+        "- camt    : ISO 20022 CAMT.053 statements (.xml)",
+        "- pain001 : ISO 20022 pain.001 credit-transfer (.xml)",
+        "- csv     : delimited statement exports (.csv)",
+        "- ofx     : Open Financial Exchange (.ofx)",
+        "- qfx     : Quicken Financial Exchange (.qfx)",
+        "- mt940   : SWIFT MT940 statement messages (.mt940, .sta)",
+    ]
+    return "\n".join(lines)
+
+
+@mcp.prompt()
+def analyze_statement(filename: str = "statement.xml") -> str:
+    """Guided prompt for reading and reconciling a bank statement.
+
+    Args:
+        filename: The statement filename being analysed.
+
+    Returns:
+        A prompt string instructing the model how to proceed.
+    """
+    return (
+        f"Help me analyse the bank statement '{filename}'. First call "
+        "detect_format with its content to confirm the format, then "
+        "validate_statement to make sure it parses, then parse_statement "
+        "to read the transactions and summarize_statement for the "
+        "opening/closing balances. Reconcile the transaction total "
+        "against the balances and flag anything that looks off."
+    )
+
+
+def main() -> None:  # pragma: no cover - process entry point
+    """Run the BankStatementParser MCP server over stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bankstatementparser_mcp-0.0.10.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.4
+Name: bankstatementparser-mcp
+Version: 0.0.10
+Summary: Model Context Protocol (MCP) server exposing the bankstatementparser bank statement parsing library as agent tools.
+License: Apache-2.0
+License-File: LICENSE
+Author: Sebastien Rousseau
+Author-email: sebastian.rousseau@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: bankstatementparser (>=0.0.9)
+Requires-Dist: mcp (>=1.2)
+Project-URL: Homepage, https://bankstatementparser.com
+Project-URL: Repository, https://github.com/sebastienrousseau/bankstatementparser-mcp
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+
+<p align="center">
+  <img
+    src="https://cloudcdn.pro/bankstatementparser/v1/logos/bankstatementparser.svg"
+    alt="bankstatementparser-mcp logo"
+    width="120"
+    height="120"
+  />
+</p>
+
+<h1 align="center">bankstatementparser-mcp</h1>
+
+<p align="center">
+  <b>Model Context Protocol server exposing the bankstatementparser library as first-class agent tools for reading bank statements.</b>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/bankstatementparser-mcp/"><img src="https://img.shields.io/pypi/v/bankstatementparser-mcp?style=for-the-badge" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/bankstatementparser-mcp/"><img src="https://img.shields.io/pypi/pyversions/bankstatementparser-mcp.svg?style=for-the-badge" alt="Python versions" /></a>
+  <a href="https://pypi.org/project/bankstatementparser-mcp/"><img src="https://img.shields.io/pypi/dm/bankstatementparser-mcp.svg?style=for-the-badge" alt="PyPI downloads" /></a>
+  <a href="https://github.com/sebastienrousseau/bankstatementparser-mcp/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/sebastienrousseau/bankstatementparser-mcp/ci.yml?branch=main&label=Tests&style=for-the-badge" alt="Tests" /></a>
+  <a href="https://github.com/sebastienrousseau/bankstatementparser-mcp/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/sebastienrousseau/bankstatementparser-mcp/ci.yml?branch=main&label=Coverage&style=for-the-badge" alt="Coverage" /></a>
+  <a href="#license"><img src="https://img.shields.io/pypi/l/bankstatementparser-mcp?style=for-the-badge" alt="License" /></a>
+  <a href="https://glama.ai/mcp/servers/sebastienrousseau/bankstatementparser-mcp"><img src="https://glama.ai/mcp/servers/sebastienrousseau/bankstatementparser-mcp/badges/score.svg" alt="Glama MCP server score" /></a>
+</p>
+
+---
+
+## Contents
+
+**Getting started**
+
+- [What is bankstatementparser-mcp?](#what-is-bankstatementparser-mcp) — the problem it solves
+- [Install](#install) — PyPI, virtualenv, Docker
+- [Quick start](#quick-start) — register with Claude Desktop in 30 seconds
+
+**Library reference**
+
+- [Tools](#tools) — the five tools, one resource, one prompt
+- [Using the tools](#using-the-tools) — call them in-process from Python
+
+**Operational**
+
+- [When not to use bankstatementparser-mcp](#when-not-to-use-bankstatementparser-mcp) — honest boundaries
+- [Development](#development) — gates, make targets
+- [Security](#security) — sandboxing posture
+- [Documentation](#documentation) — examples, guides
+- [Contributing](#contributing) — how to get changes in
+- [License](#license) — Apache-2.0
+
+---
+
+## What is bankstatementparser-mcp?
+
+The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) is
+an open standard that lets AI agents discover and call external tools in
+a uniform way. **bankstatementparser-mcp** is the MCP server that turns the
+[`bankstatementparser`](https://github.com/sebastienrousseau/bankstatementparser)
+library into first-class agent tools — so an assistant can read,
+validate, and summarise **bank statements** in formats such as ISO 20022
+CAMT.053, SWIFT MT940, OFX/QFX, and CSV directly from a conversation.
+
+Every tool is a thin wrapper over the `bankstatementparser` parser core
+(`create_parser`, `detect_statement_format`), so the results behave
+identically to the CLI. Because an MCP client does not share the
+server's filesystem, the tools take **inline statement content** (plus a
+filename hint) and materialise it in a private temporary file for the
+duration of a single call. Tools return JSON-serialisable data.
+
+| Concern | How bankstatementparser-mcp handles it |
+| :--- | :--- |
+| Transport | stdio (FastMCP default); zero config beyond the client manifest |
+| Input model | Inline content + filename hint; no shared filesystem required |
+| Format fidelity | Tools delegate to `bankstatementparser`'s `create_parser` pipeline |
+| Format detection | `detect_format` mirrors the library's `detect_statement_format` |
+| Validation | `validate_statement` is a dry run that returns structured results |
+| Isolation | Each call writes to a private temp file that is deleted on exit |
+
+---
+
+## Install
+
+| Channel | Command | Notes |
+| :--- | :--- | :--- |
+| PyPI | `pip install bankstatementparser-mcp` | Pulls in `bankstatementparser >= 0.0.9` + MCP SDK |
+| Source | `git clone https://github.com/sebastienrousseau/bankstatementparser-mcp && cd bankstatementparser-mcp && poetry install` | For development |
+| Docker (GHCR) | `docker pull ghcr.io/sebastienrousseau/bankstatementparser-mcp:latest` | Multi-arch (linux/amd64, linux/arm64); runs `bankstatementparser-mcp` over stdio |
+
+Requires Python 3.10 or later. Works on macOS, Linux, and Windows.
+
+<details>
+<summary>Using an isolated virtual environment (recommended)</summary>
+
+```sh
+python -m venv venv
+source venv/bin/activate        # macOS/Linux
+venv\Scripts\activate           # Windows
+python -m pip install -U bankstatementparser-mcp
+```
+
+</details>
+
+---
+
+## Quick start
+
+Register the server with any MCP client (Claude Desktop shown):
+
+```json
+{
+  "mcpServers": {
+    "bankstatementparser": { "command": "bankstatementparser-mcp" }
+  }
+}
+```
+
+That's it. Restart the client and the tools are available to the agent.
+
+The server speaks JSON-RPC over stdin/stdout — it is meant to be
+launched by an MCP client, not used interactively.
+
+---
+
+## Tools
+
+All tools delegate to the `bankstatementparser` parser core, so they
+behave identically to the library.
+
+| Tool | Purpose |
+| :--- | :--- |
+| `list_supported_formats` | List every bank statement format the parser can read |
+| `detect_format` | Detect which statement format an inline payload is |
+| `parse_statement` | Parse a statement into structured transactions plus a summary |
+| `validate_statement` | Dry-run check whether a statement parses cleanly |
+| `summarize_statement` | Return only the statement summary (no per-transaction rows) |
+
+Plus one resource and one prompt:
+
+| Kind | Name | Purpose |
+| :--- | :--- | :--- |
+| Resource | `bankstatementparser://formats` | Read-only catalogue of supported formats and their file extensions |
+| Prompt | `analyze_statement` | Guided multi-step prompt that walks an agent through reading and reconciling a statement |
+
+Supported formats: `camt` (ISO 20022 CAMT.053, `.xml`), `pain001`
+(ISO 20022 pain.001, `.xml`), `csv` (`.csv`), `ofx` (`.ofx`), `qfx`
+(`.qfx`), and `mt940` (SWIFT MT940, `.mt940` / `.sta`).
+
+---
+
+## Using the tools
+
+The tools are plain functions on the `bankstatementparser_mcp.server`
+module, so you can call them in-process:
+
+```python
+from bankstatementparser_mcp.server import (
+    detect_format,
+    parse_statement,
+    summarize_statement,
+)
+
+csv = (
+    "date,description,amount,currency,balance\n"
+    "2023-01-02,Salary,500.00,EUR,1500.00\n"
+    "2023-01-03,Groceries,-40.50,EUR,1459.50\n"
+)
+
+# 1. Detect the format from the filename hint + content.
+print(detect_format(csv, "statement.csv"))
+# -> csv
+
+# 2. Parse the statement into structured rows + a summary.
+parsed = parse_statement(csv, "statement.csv")
+print(parsed["transaction_count"], parsed["columns"])
+
+# 3. Read just the opening/closing balances.
+print(summarize_statement(csv, "statement.csv"))
+```
+
+The resource and prompt are plain functions too: `formats_resource`
+backs `bankstatementparser://formats`, and `analyze_statement` returns
+the guided multi-step prompt.
+
+```python
+from bankstatementparser_mcp.server import (
+    analyze_statement,
+    formats_resource,
+)
+
+print(formats_resource())          # the supported-formats catalogue
+print(analyze_statement("statement.csv"))  # the guided analysis prompt
+```
+
+See the [`examples/`](examples/) folder for runnable walkthroughs,
+including [`04_resource_and_prompt.py`](examples/04_resource_and_prompt.py).
+
+---
+
+## When not to use bankstatementparser-mcp
+
+- **You're not driving an MCP-aware agent.** Use the
+  [`bankstatementparser`](https://pypi.org/project/bankstatementparser/)
+  CLI or library directly — it exposes the same surface with less
+  indirection.
+- **You need to parse files already on disk in bulk.** The library's
+  CLI reads paths directly and avoids the inline-content round-trip the
+  MCP tools use.
+
+---
+
+## Development
+
+`bankstatementparser-mcp` uses [Poetry](https://python-poetry.org/) and
+[mise](https://mise.jdx.dev/).
+
+```bash
+git clone https://github.com/sebastienrousseau/bankstatementparser-mcp.git
+cd bankstatementparser-mcp
+mise install
+poetry install
+```
+
+A `Makefile` orchestrates the quality gates (kept in lockstep with CI):
+
+| Target | What it runs |
+| :--- | :--- |
+| `make check` | All gates (REQUIRED before commit) |
+| `make test` | `pytest --cov=bankstatementparser_mcp --cov-branch --cov-fail-under=100` |
+| `make lint` | `ruff check` + `black --check` |
+| `make type-check` | `mypy --strict` |
+| `make docs` | `interrogate --fail-under=100` (docstring coverage) |
+
+Current state (v0.0.10): **100% line + branch coverage** against a 100%
+enforced floor, mypy `--strict` clean, interrogate 100%.
+
+---
+
+## Security
+
+- **No persistent filesystem writes from tools.** Each call writes the
+  inline content to a private temporary file that is deleted as soon as
+  the call returns.
+- **Validation failures** from `validate_statement` are returned as
+  structured `{"is_valid": false, "error": ...}` payloads — never as
+  stack traces.
+- **Dependencies** are pinned via `poetry.lock` and audited by
+  `pip-audit` and Bandit in CI.
+
+To report a vulnerability, please use
+[GitHub private vulnerability reporting](https://github.com/sebastienrousseau/bankstatementparser-mcp/security)
+rather than a public issue.
+
+---
+
+## Documentation
+
+- **Runnable examples:** [`examples/`](https://github.com/sebastienrousseau/bankstatementparser-mcp/tree/main/examples)
+- **Release history:** [CHANGELOG.md](https://github.com/sebastienrousseau/bankstatementparser-mcp/blob/main/CHANGELOG.md)
+- **MCP specification:** [modelcontextprotocol.io](https://modelcontextprotocol.io)
+
+---
+
+## Contributing
+
+Contributions are welcome — see the
+[contributing instructions](https://github.com/sebastienrousseau/bankstatementparser-mcp/blob/main/CONTRIBUTING.md).
+Thanks to all the
+[contributors](https://github.com/sebastienrousseau/bankstatementparser-mcp/graphs/contributors)
+who have helped build `bankstatementparser-mcp`.
+
+---
+
+## License
+
+Licensed under the [Apache License, Version 2.0](https://opensource.org/license/apache-2-0/).
+Any contribution submitted for inclusion shall be licensed as above,
+without additional terms.
+
+---
+
+<p align="center">
+  <a href="https://bankstatementparser.com">bankstatementparser.com</a> ·
+  <a href="https://pypi.org/project/bankstatementparser-mcp/">PyPI</a> ·
+  <a href="https://github.com/sebastienrousseau/bankstatementparser-mcp">GitHub</a>
+</p>
+

bankstatementparser_mcp-0.0.10.dist-info/RECORD

@@ -0,0 +1,7 @@
+bankstatementparser_mcp/__init__.py,sha256=xo5GNbytX1OmD6GrWqDAL3sefGXjA9EQ5DDYR4vtQdQ,823
+bankstatementparser_mcp/server.py,sha256=VJZ0kS_YM1LGgswe42ZMoEnFlrYcQyZhuwEn_2GRloI,10317
+bankstatementparser_mcp-0.0.10.dist-info/METADATA,sha256=MAXursIJ_Xtf5z1mK1OrUDqhAEBC1quGlMcsE-n8n4k,11860
+bankstatementparser_mcp-0.0.10.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+bankstatementparser_mcp-0.0.10.dist-info/entry_points.txt,sha256=0fMgDHFjvHlg3k_otbSQKvpyNm0jFtklb_J6B29BDLE,79
+bankstatementparser_mcp-0.0.10.dist-info/licenses/LICENSE,sha256=BhsQ65IVGLlScIgEHcMm2leCnoRbQqwPcLd7N2c8Gt0,10244
+bankstatementparser_mcp-0.0.10.dist-info/RECORD,,

bankstatementparser_mcp-0.0.10.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

bankstatementparser_mcp-0.0.10.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bankstatementparser-mcp=bankstatementparser_mcp.server:main
+

bankstatementparser_mcp-0.0.10.dist-info/licenses/LICENSE

@@ -0,0 +1,189 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work.
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to the Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by the Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding any notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2023-2026 Sebastien Rousseau
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.