langchain-micompress 0.1.0__tar.gz

langchain_micompress-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MiCompress (https://micompress.com)
+
+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_micompress-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: langchain-micompress
+Version: 0.1.0
+Summary: LangChain tools for MiCompress: compress images, PDFs, video, audio, Office documents and archives
+Author-email: MiCompress <support@micompress.com>
+License: MIT
+Project-URL: Homepage, https://micompress.com/mcp-server
+Project-URL: Issues, https://github.com/micompress/micompress-mcp/issues
+Keywords: langchain,tool,agent,compress,compression,image,pdf,micompress
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core<2,>=0.3
+Requires-Dist: pydantic>=2
+Dynamic: license-file
+
+# langchain-micompress
+
+LangChain tools for [MiCompress](https://micompress.com): let your agent compress
+**images, PDFs, video, audio, Office documents, EPUB books and archives**.
+
+```bash
+pip install langchain-micompress
+```
+
+## Usage
+
+```python
+from langchain_micompress import MiCompressCompressFile
+
+tool = MiCompressCompressFile()          # anonymous, or MiCompressCompressFile(api_key="mc_...")
+print(tool.invoke({"path": "report.pdf", "preset": "extreme"}))
+# Compressed report.pdf → report-min.pdf: 4.2MB → 610.3KB (86% smaller).
+```
+
+With an agent:
+
+```python
+from langchain_micompress import MiCompressToolkit
+
+tools = MiCompressToolkit().get_tools()   # micompress_compress_file, micompress_list_formats
+agent = create_agent(model, tools)        # any LangChain / LangGraph agent
+```
+
+| Tool | What it does |
+| --- | --- |
+| `micompress_compress_file` | Compress a local file and write the smaller copy (default: `<name>-min.<ext>`). Arguments: `path`, optional `output_path`, `preset` (`lossless`, `recommended`, `extreme`), `max_width` (images). |
+| `micompress_list_formats` | List the supported extensions by category. |
+
+## API key (optional)
+
+Without a key the tools work anonymously within per-format size limits. For larger files
+create a free key at [micompress.com/account](https://micompress.com/account) and set
+`MICOMPRESS_API_KEY`, or pass `api_key=`.
+
+## What is sent where
+
+The file is uploaded to micompress.com over HTTPS to be compressed. Uploaded originals are
+deleted within about 10 minutes and results within 24 hours —
+[privacy policy](https://micompress.com/privacy). Files reachable by URL can also be
+compressed with the hosted MCP server at `https://micompress.com/mcp`
+([docs](https://micompress.com/mcp-server)).
+
+## License
+
+MIT

langchain_micompress-0.1.0/README.md

@@ -0,0 +1,50 @@
+# langchain-micompress
+
+LangChain tools for [MiCompress](https://micompress.com): let your agent compress
+**images, PDFs, video, audio, Office documents, EPUB books and archives**.
+
+```bash
+pip install langchain-micompress
+```
+
+## Usage
+
+```python
+from langchain_micompress import MiCompressCompressFile
+
+tool = MiCompressCompressFile()          # anonymous, or MiCompressCompressFile(api_key="mc_...")
+print(tool.invoke({"path": "report.pdf", "preset": "extreme"}))
+# Compressed report.pdf → report-min.pdf: 4.2MB → 610.3KB (86% smaller).
+```
+
+With an agent:
+
+```python
+from langchain_micompress import MiCompressToolkit
+
+tools = MiCompressToolkit().get_tools()   # micompress_compress_file, micompress_list_formats
+agent = create_agent(model, tools)        # any LangChain / LangGraph agent
+```
+
+| Tool | What it does |
+| --- | --- |
+| `micompress_compress_file` | Compress a local file and write the smaller copy (default: `<name>-min.<ext>`). Arguments: `path`, optional `output_path`, `preset` (`lossless`, `recommended`, `extreme`), `max_width` (images). |
+| `micompress_list_formats` | List the supported extensions by category. |
+
+## API key (optional)
+
+Without a key the tools work anonymously within per-format size limits. For larger files
+create a free key at [micompress.com/account](https://micompress.com/account) and set
+`MICOMPRESS_API_KEY`, or pass `api_key=`.
+
+## What is sent where
+
+The file is uploaded to micompress.com over HTTPS to be compressed. Uploaded originals are
+deleted within about 10 minutes and results within 24 hours —
+[privacy policy](https://micompress.com/privacy). Files reachable by URL can also be
+compressed with the hosted MCP server at `https://micompress.com/mcp`
+([docs](https://micompress.com/mcp-server)).
+
+## License
+
+MIT

langchain_micompress-0.1.0/langchain_micompress/__init__.py

@@ -0,0 +1,14 @@
+"""LangChain integration for MiCompress (https://micompress.com)."""
+
+from ._version import __version__
+from .client import MiCompressClient, MiCompressError
+from .tools import MiCompressCompressFile, MiCompressListFormats, MiCompressToolkit
+
+__all__ = [
+    "MiCompressClient",
+    "MiCompressError",
+    "MiCompressCompressFile",
+    "MiCompressListFormats",
+    "MiCompressToolkit",
+    "__version__",
+]

langchain_micompress-0.1.0/langchain_micompress/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

langchain_micompress-0.1.0/langchain_micompress/client.py

@@ -0,0 +1,141 @@
+"""Minimal stdlib client for the MiCompress compression API.
+
+Kept separate from the ``micompress`` CLI package on purpose: the server tells
+integrations apart by ``X-MiCompress-Client``, and this one reports itself as
+``langchain`` so its usage is measurable on its own.
+"""
+
+import json
+import os
+import urllib.error
+import urllib.request
+import uuid
+
+from ._version import __version__
+
+DEFAULT_BASE = "https://micompress.com"
+USER_AGENT = "micompress-langchain/%s (+https://micompress.com)" % __version__
+CLIENT_ID = "langchain/%s" % __version__
+ACCOUNT_URL = DEFAULT_BASE + "/account"
+PRESETS = ("lossless", "recommended", "extreme")
+
+
+class MiCompressError(Exception):
+    """A compression request failed. ``code`` is the API's machine-readable code, if any."""
+
+    def __init__(self, message, code=None):
+        super().__init__(message)
+        self.code = code
+
+
+def _ext(filename):
+    base = os.path.basename(filename).lower()
+    return base.rsplit(".", 1)[1] if "." in base else ""
+
+
+class MiCompressClient:
+    """Compress local files through https://micompress.com.
+
+    ``api_key`` is optional (personal ``mc_...`` key from micompress.com/account);
+    without it the API works anonymously within per-format size limits.
+    It falls back to the ``MICOMPRESS_API_KEY`` environment variable.
+    """
+
+    def __init__(self, api_key=None, base_url=DEFAULT_BASE, timeout=300):
+        self.api_key = api_key if api_key is not None else os.environ.get("MICOMPRESS_API_KEY") or None
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._formats = None
+
+    def _headers(self, extra=None):
+        headers = {"User-Agent": USER_AGENT, "X-MiCompress-Client": CLIENT_ID, "Accept": "application/json"}
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        if extra:
+            headers.update(extra)
+        return headers
+
+    def _request(self, url, data=None, headers=None, method="GET"):
+        req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as e:
+            raw = e.read().decode("utf-8", "replace")
+            try:
+                payload = json.loads(raw)
+            except ValueError:
+                raise MiCompressError("HTTP %s from %s" % (e.code, url), "HTTP_%s" % e.code)
+            code = payload.get("code")
+            message = payload.get("error") or "HTTP %s" % e.code
+            if code == "LOGIN_REQUIRED":
+                message = ("The file is over the anonymous size limit. Use a free API key from %s "
+                           "(MICOMPRESS_API_KEY) for larger files." % ACCOUNT_URL)
+            raise MiCompressError(message, code or "API_ERROR")
+        except urllib.error.URLError as e:
+            raise MiCompressError("Network error: %s" % e.reason, "NETWORK")
+
+    def formats(self):
+        """Supported extensions → {group, endpoint, maxBytes} for this caller (cached)."""
+        if self._formats is None:
+            raw = self._request(self.base_url + "/api/v1/capabilities", headers=self._headers())
+            self._formats = json.loads(raw.decode("utf-8"))["formats"]
+        return self._formats
+
+    def compress(self, input_path, output_path=None, preset=None, max_width=None):
+        """Compress ``input_path`` and write the result. Returns a summary dict.
+
+        ``output_path`` defaults to the input path with a ``-min`` suffix.
+        """
+        if preset and preset not in PRESETS:
+            raise MiCompressError("preset must be one of %s" % ", ".join(PRESETS), "BAD_PRESET")
+        if not os.path.isfile(input_path):
+            raise MiCompressError("File not found: %s" % input_path, "ENOENT")
+
+        filename = os.path.basename(input_path)
+        info = self.formats().get(_ext(filename))
+        if not info:
+            raise MiCompressError(
+                'Unsupported file type ".%s". Supported: %s'
+                % (_ext(filename) or "?", ", ".join(sorted(self.formats()))), "UNSUPPORTED")
+
+        fields = {"preset": preset or "recommended"}
+        if max_width:
+            fields["maxWidth"] = str(int(max_width))
+        boundary = uuid.uuid4().hex
+        body = bytearray()
+        for name, value in fields.items():
+            body += ("--%s\r\nContent-Disposition: form-data; name=\"%s\"\r\n\r\n%s\r\n"
+                     % (boundary, name, value)).encode("utf-8")
+        body += ("--%s\r\nContent-Disposition: form-data; name=\"file\"; filename=\"%s\"\r\n"
+                 "Content-Type: application/octet-stream\r\n\r\n"
+                 % (boundary, filename.replace('"', "_"))).encode("utf-8")
+        with open(input_path, "rb") as fh:
+            body += fh.read()
+        body += ("\r\n--%s--\r\n" % boundary).encode("utf-8")
+
+        raw = self._request(self.base_url + info["endpoint"], data=bytes(body), method="POST",
+                            headers=self._headers({"Content-Type": "multipart/form-data; boundary=%s" % boundary}))
+        payload = json.loads(raw.decode("utf-8"))
+        if not payload.get("success"):
+            raise MiCompressError(payload.get("error") or "Compression failed", payload.get("code"))
+
+        data = self._request(self.base_url + payload["downloadUrl"], headers={"User-Agent": USER_AGENT})
+        if not output_path:
+            stem, dot_ext = os.path.splitext(input_path)
+            # The server may change the extension (e.g. a PNG that is really a JPEG).
+            served_ext = os.path.splitext(payload["downloadUrl"])[1] or dot_ext
+            output_path = stem + "-min" + served_ext
+        parent = os.path.dirname(os.path.abspath(output_path))
+        os.makedirs(parent, exist_ok=True)
+        with open(output_path, "wb") as fh:
+            fh.write(data)
+
+        return {
+            "output_path": output_path,
+            "input_size": payload.get("inputSize"),
+            "output_size": payload.get("outputSize"),
+            "saved_percent": payload.get("savedPercent"),
+            "format": payload.get("format"),
+            "note": payload.get("note"),
+        }

langchain_micompress-0.1.0/langchain_micompress/tools.py

@@ -0,0 +1,113 @@
+"""LangChain tools for MiCompress."""
+
+from typing import Literal, Optional, Type
+
+from langchain_core.tools import BaseTool, ToolException
+from pydantic import BaseModel, Field, PrivateAttr
+
+from .client import MiCompressClient, MiCompressError
+
+
+def _human(n):
+    if n is None:
+        return "?"
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024 or unit == "GB":
+            return ("%.1f%s" % (n, unit)) if unit != "B" else "%d%s" % (n, unit)
+        n /= 1024.0
+
+
+class CompressFileInput(BaseModel):
+    path: str = Field(description="Path of the local file to compress.")
+    output_path: Optional[str] = Field(
+        default=None,
+        description='Where to write the result. Defaults to the input path with a "-min" suffix.')
+    preset: Optional[Literal["lossless", "recommended", "extreme"]] = Field(
+        default=None,
+        description="lossless keeps quality identical; recommended (default) balances size and quality; "
+                    "extreme gives the smallest file.")
+    max_width: Optional[int] = Field(default=None, description="Images only: resize down to this width in pixels.")
+
+
+class MiCompressCompressFile(BaseTool):
+    """Compress a local image, PDF, video, audio file, Office document or archive.
+
+    The file is uploaded to https://micompress.com over HTTPS and the smaller copy is
+    written back to disk. Set ``MICOMPRESS_API_KEY`` (or pass ``api_key``) for larger files.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_micompress import MiCompressCompressFile
+            tool = MiCompressCompressFile()
+            tool.invoke({"path": "report.pdf", "preset": "extreme"})
+    """
+
+    name: str = "micompress_compress_file"
+    description: str = (
+        "Compress a local file (images such as JPG, PNG, WebP, GIF, HEIC or RAW; PDF; video; audio; "
+        "Word, Excel, PowerPoint; EPUB; ZIP/7Z/RAR) and write the smaller copy to disk. "
+        "Returns the output path and the size before and after."
+    )
+    args_schema: Type[BaseModel] = CompressFileInput
+    handle_tool_error: bool = True
+
+    api_key: Optional[str] = None
+    base_url: str = "https://micompress.com"
+    _client: MiCompressClient = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._client = MiCompressClient(api_key=self.api_key, base_url=self.base_url)
+
+    def _run(self, path: str, output_path: Optional[str] = None, preset: Optional[str] = None,
+             max_width: Optional[int] = None, run_manager=None) -> str:
+        try:
+            r = self._client.compress(path, output_path=output_path, preset=preset, max_width=max_width)
+        except MiCompressError as e:
+            raise ToolException(str(e))
+        text = "Compressed %s → %s: %s → %s (%s%% smaller)." % (
+            path, r["output_path"], _human(r["input_size"]), _human(r["output_size"]), r["saved_percent"])
+        if r.get("note"):
+            text += " Note: %s" % r["note"]
+        return text
+
+
+class MiCompressListFormats(BaseTool):
+    """List the file extensions MiCompress can compress, grouped by category."""
+
+    name: str = "micompress_list_formats"
+    description: str = "List the file extensions that micompress_compress_file accepts, grouped by category."
+    handle_tool_error: bool = True
+
+    api_key: Optional[str] = None
+    base_url: str = "https://micompress.com"
+    _client: MiCompressClient = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._client = MiCompressClient(api_key=self.api_key, base_url=self.base_url)
+
+    def _run(self, run_manager=None) -> str:
+        try:
+            formats = self._client.formats()
+        except MiCompressError as e:
+            raise ToolException(str(e))
+        groups = {}
+        for ext, info in formats.items():
+            groups.setdefault(info["group"], []).append(ext)
+        return "\n".join("%s: %s" % (g, ", ".join(sorted(exts))) for g, exts in sorted(groups.items()))
+
+
+class MiCompressToolkit:
+    """Convenience wrapper returning both MiCompress tools."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: str = "https://micompress.com"):
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def get_tools(self):
+        return [
+            MiCompressCompressFile(api_key=self.api_key, base_url=self.base_url),
+            MiCompressListFormats(api_key=self.api_key, base_url=self.base_url),
+        ]

langchain_micompress-0.1.0/langchain_micompress.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: langchain-micompress
+Version: 0.1.0
+Summary: LangChain tools for MiCompress: compress images, PDFs, video, audio, Office documents and archives
+Author-email: MiCompress <support@micompress.com>
+License: MIT
+Project-URL: Homepage, https://micompress.com/mcp-server
+Project-URL: Issues, https://github.com/micompress/micompress-mcp/issues
+Keywords: langchain,tool,agent,compress,compression,image,pdf,micompress
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core<2,>=0.3
+Requires-Dist: pydantic>=2
+Dynamic: license-file
+
+# langchain-micompress
+
+LangChain tools for [MiCompress](https://micompress.com): let your agent compress
+**images, PDFs, video, audio, Office documents, EPUB books and archives**.
+
+```bash
+pip install langchain-micompress
+```
+
+## Usage
+
+```python
+from langchain_micompress import MiCompressCompressFile
+
+tool = MiCompressCompressFile()          # anonymous, or MiCompressCompressFile(api_key="mc_...")
+print(tool.invoke({"path": "report.pdf", "preset": "extreme"}))
+# Compressed report.pdf → report-min.pdf: 4.2MB → 610.3KB (86% smaller).
+```
+
+With an agent:
+
+```python
+from langchain_micompress import MiCompressToolkit
+
+tools = MiCompressToolkit().get_tools()   # micompress_compress_file, micompress_list_formats
+agent = create_agent(model, tools)        # any LangChain / LangGraph agent
+```
+
+| Tool | What it does |
+| --- | --- |
+| `micompress_compress_file` | Compress a local file and write the smaller copy (default: `<name>-min.<ext>`). Arguments: `path`, optional `output_path`, `preset` (`lossless`, `recommended`, `extreme`), `max_width` (images). |
+| `micompress_list_formats` | List the supported extensions by category. |
+
+## API key (optional)
+
+Without a key the tools work anonymously within per-format size limits. For larger files
+create a free key at [micompress.com/account](https://micompress.com/account) and set
+`MICOMPRESS_API_KEY`, or pass `api_key=`.
+
+## What is sent where
+
+The file is uploaded to micompress.com over HTTPS to be compressed. Uploaded originals are
+deleted within about 10 minutes and results within 24 hours —
+[privacy policy](https://micompress.com/privacy). Files reachable by URL can also be
+compressed with the hosted MCP server at `https://micompress.com/mcp`
+([docs](https://micompress.com/mcp-server)).
+
+## License
+
+MIT

langchain_micompress-0.1.0/langchain_micompress.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_micompress/__init__.py
+langchain_micompress/_version.py
+langchain_micompress/client.py
+langchain_micompress/tools.py
+langchain_micompress.egg-info/PKG-INFO
+langchain_micompress.egg-info/SOURCES.txt
+langchain_micompress.egg-info/dependency_links.txt
+langchain_micompress.egg-info/requires.txt
+langchain_micompress.egg-info/top_level.txt
+tests/test_live.py

langchain_micompress-0.1.0/langchain_micompress.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_micompress-0.1.0/langchain_micompress.egg-info/requires.txt

@@ -0,0 +1,2 @@
+langchain-core<2,>=0.3
+pydantic>=2

langchain_micompress-0.1.0/langchain_micompress.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_micompress

langchain_micompress-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-micompress"
+dynamic = ["version"]
+description = "LangChain tools for MiCompress: compress images, PDFs, video, audio, Office documents and archives"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "MiCompress", email = "support@micompress.com" }]
+keywords = ["langchain", "tool", "agent", "compress", "compression", "image", "pdf", "micompress"]
+dependencies = ["langchain-core>=0.3,<2", "pydantic>=2"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Graphics :: Graphics Conversion",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://micompress.com/mcp-server"
+Issues = "https://github.com/micompress/micompress-mcp/issues"
+
+[tool.setuptools]
+packages = ["langchain_micompress"]
+
+[tool.setuptools.dynamic]
+version = { attr = "langchain_micompress._version.__version__" }

langchain_micompress-0.1.0/setup.cfg

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

langchain_micompress-0.1.0/tests/test_live.py

@@ -0,0 +1,33 @@
+"""Live end-to-end test against micompress.com (needs network)."""
+
+import os
+import tempfile
+import urllib.request
+
+from langchain_micompress import MiCompressCompressFile, MiCompressListFormats, MiCompressToolkit
+
+SAMPLE = "https://micompress.com/samples/photo.jpg"
+
+
+def test_compress_and_list():
+    with tempfile.TemporaryDirectory() as d:
+        src = os.path.join(d, "photo.jpg")
+        req = urllib.request.Request(SAMPLE, headers={"User-Agent": "micompress-langchain-test"})
+        with urllib.request.urlopen(req) as r, open(src, "wb") as fh:
+            fh.write(r.read())
+        out = MiCompressCompressFile().invoke({"path": src})
+        assert "smaller" in out, out
+        assert os.path.exists(os.path.join(d, "photo-min.jpg"))
+        assert os.path.getsize(os.path.join(d, "photo-min.jpg")) < os.path.getsize(src)
+
+        err = MiCompressCompressFile().invoke({"path": os.path.join(d, "nope.xyz")})
+        assert "not found" in err.lower(), err
+
+    formats = MiCompressListFormats().invoke({})
+    assert "image:" in formats and "pdf" in formats, formats
+    assert len(MiCompressToolkit().get_tools()) == 2
+
+
+if __name__ == "__main__":
+    test_compress_and_list()
+    print("ok")