image-migrate-picgo 0.1.0__tar.gz

image_migrate_picgo-0.1.0/LICENSE

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

image_migrate_picgo-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: image-migrate-picgo
+Version: 0.1.0
+Summary: Migrate images in one Markdown file through PicGo
+Keywords: markdown,picgo,image,migration
+Author: left0ver
+Author-email: left0ver <1614674987@qq.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: markdown-it-py>=4.0,<5
+Requires-Dist: typer>=0.21,<1
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="assets/logo.svg" alt="image-migrate-picgo logo" width="128">
+</p>
+
+<h1 align="center">image-migrate-picgo</h1>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.11%2B-blue?style=flat-square" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/PicGo-Server%20%7C%20CLI-blue?style=flat-square" alt="PicGo Server and CLI">
+  <img src="https://img.shields.io/badge/Images-Markdown%20%7C%20HTML-informational?style=flat-square" alt="Markdown and HTML images">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green?style=flat-square" alt="MIT License"></a>
+</p>
+
+<p align="center">
+  English | <a href="README.zh-CN.md">简体中文</a>
+</p>
+
+Move every image in a Markdown file to your image host with one command. `image-migrate-picgo` uploads the images through [PicGo](https://github.com/Molunerfinn/PicGo) and rewrites their links to the uploaded URLs.
+
+It is useful when you want to:
+
+- publish notes that reference local images,
+- move images from one image host to another,
+- replace inline Base64 (Data URL) images with regular links.
+
+## Features
+
+- **Every image source**: local files, HTTP/HTTPS URLs, and image Data URLs.
+- **Every image syntax**: inline Markdown images, reference-style images, and HTML `<img>` tags.
+- **Two upload methods**: PicGo Server (the PicGo desktop app) or PicGo CLI (`picgo` from npm).
+- **Safe rewriting**: code blocks, inline code, and ordinary links stay untouched. The file is written only after every upload succeeds.
+- **No duplicate uploads**: an image referenced several times is uploaded once.
+
+## Example
+
+Before:
+
+```markdown
+![Architecture](images/architecture.png "Overview")
+![Logo][logo]
+<img src="https://old-host.example.com/screenshot.png" width="600">
+
+[logo]: ./images/logo.png
+```
+
+After running `image-migrate-picgo notes.md`:
+
+```markdown
+![Architecture](<https://cdn.example.com/architecture.png> "Overview")
+![Logo](<https://cdn.example.com/logo.png>)
+<img src="https://cdn.example.com/screenshot.png" width="600">
+
+[logo]: ./images/logo.png
+```
+
+## Installation
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install image-migrate-picgo
+```
+
+You also need an image host configured in either PicGo Server or PicGo CLI (see [Upload methods](#upload-methods)).
+
+## Quick start
+
+1. Open the PicGo desktop app, configure an image host, and turn on **PicGo Server** in its settings.
+2. Migrate a file:
+
+   ```bash
+   image-migrate-picgo notes.md
+   ```
+
+> [!WARNING]
+> By default the Markdown file is **updated in place**. Commit or back it up first, or write the result to a new file with `--output`:
+>
+> ```bash
+> image-migrate-picgo notes.md --output notes.migrated.md
+> ```
+
+## Upload methods
+
+### PicGo Server (default)
+
+Uses the HTTP server built into the PicGo desktop app, at `http://127.0.0.1:36677/upload` by default.
+
+```bash
+# Custom address
+image-migrate-picgo notes.md --server-url http://127.0.0.1:36677/upload
+
+# Server protected by a secret
+image-migrate-picgo notes.md --server-secret <secret>
+```
+
+### PicGo CLI
+
+Uses the [PicGo core](https://github.com/PicGo/PicGo-Core) command line tool. No desktop app is needed, which suits servers and CI.
+
+```bash
+npm install picgo -g
+
+# Configure an uploader (an interactive wizard)
+image-migrate-picgo --configure
+
+# Upload through PicGo CLI
+image-migrate-picgo notes.md --method cli
+```
+
+The configuration is saved to `~/.picgo/config.json` by default. If the configuration file does not exist, `--method cli` starts the wizard automatically.
+
+## CLI options
+
+```text
+image-migrate-picgo [OPTIONS] [MARKDOWN]
+```
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `MARKDOWN` | Markdown file to migrate | — |
+| `-o`, `--output PATH` | Write the result to this file instead of updating `MARKDOWN` | Update in place |
+| `--method [server\|cli]` | Upload method | `server` |
+| `--server-url TEXT` | PicGo Server upload URL | `http://127.0.0.1:36677/upload` |
+| `--server-secret TEXT` | PicGo Server secret, sent as a Bearer token | — |
+| `--picgo-command PATH` | PicGo CLI executable | `picgo` on `PATH` |
+| `--picgo-config PATH` | PicGo CLI configuration file | `~/.picgo/config.json` |
+| `--configure` | Run the PicGo uploader wizard and exit | — |
+
+## Python API
+
+```python
+from image_migrate_picgo import CliUploader, ServerUploader, migrate_markdown
+
+result = migrate_markdown(
+    "notes.md",
+    ServerUploader(),  # or CliUploader()
+    output_path="notes.migrated.md",  # omit to update notes.md in place
+)
+
+print(result.output_path)  # where the result was written
+print(result.migrated_images)  # image references rewritten
+print(result.uploaded_images)  # unique images uploaded
+print(result.urls)  # uploaded URLs
+```
+
+## LICENSE
+
+This project is licensed under the [MIT License](LICENSE).

image_migrate_picgo-0.1.0/README.md

@@ -0,0 +1,148 @@
+<p align="center">
+  <img src="assets/logo.svg" alt="image-migrate-picgo logo" width="128">
+</p>
+
+<h1 align="center">image-migrate-picgo</h1>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.11%2B-blue?style=flat-square" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/PicGo-Server%20%7C%20CLI-blue?style=flat-square" alt="PicGo Server and CLI">
+  <img src="https://img.shields.io/badge/Images-Markdown%20%7C%20HTML-informational?style=flat-square" alt="Markdown and HTML images">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green?style=flat-square" alt="MIT License"></a>
+</p>
+
+<p align="center">
+  English | <a href="README.zh-CN.md">简体中文</a>
+</p>
+
+Move every image in a Markdown file to your image host with one command. `image-migrate-picgo` uploads the images through [PicGo](https://github.com/Molunerfinn/PicGo) and rewrites their links to the uploaded URLs.
+
+It is useful when you want to:
+
+- publish notes that reference local images,
+- move images from one image host to another,
+- replace inline Base64 (Data URL) images with regular links.
+
+## Features
+
+- **Every image source**: local files, HTTP/HTTPS URLs, and image Data URLs.
+- **Every image syntax**: inline Markdown images, reference-style images, and HTML `<img>` tags.
+- **Two upload methods**: PicGo Server (the PicGo desktop app) or PicGo CLI (`picgo` from npm).
+- **Safe rewriting**: code blocks, inline code, and ordinary links stay untouched. The file is written only after every upload succeeds.
+- **No duplicate uploads**: an image referenced several times is uploaded once.
+
+## Example
+
+Before:
+
+```markdown
+![Architecture](images/architecture.png "Overview")
+![Logo][logo]
+<img src="https://old-host.example.com/screenshot.png" width="600">
+
+[logo]: ./images/logo.png
+```
+
+After running `image-migrate-picgo notes.md`:
+
+```markdown
+![Architecture](<https://cdn.example.com/architecture.png> "Overview")
+![Logo](<https://cdn.example.com/logo.png>)
+<img src="https://cdn.example.com/screenshot.png" width="600">
+
+[logo]: ./images/logo.png
+```
+
+## Installation
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install image-migrate-picgo
+```
+
+You also need an image host configured in either PicGo Server or PicGo CLI (see [Upload methods](#upload-methods)).
+
+## Quick start
+
+1. Open the PicGo desktop app, configure an image host, and turn on **PicGo Server** in its settings.
+2. Migrate a file:
+
+   ```bash
+   image-migrate-picgo notes.md
+   ```
+
+> [!WARNING]
+> By default the Markdown file is **updated in place**. Commit or back it up first, or write the result to a new file with `--output`:
+>
+> ```bash
+> image-migrate-picgo notes.md --output notes.migrated.md
+> ```
+
+## Upload methods
+
+### PicGo Server (default)
+
+Uses the HTTP server built into the PicGo desktop app, at `http://127.0.0.1:36677/upload` by default.
+
+```bash
+# Custom address
+image-migrate-picgo notes.md --server-url http://127.0.0.1:36677/upload
+
+# Server protected by a secret
+image-migrate-picgo notes.md --server-secret <secret>
+```
+
+### PicGo CLI
+
+Uses the [PicGo core](https://github.com/PicGo/PicGo-Core) command line tool. No desktop app is needed, which suits servers and CI.
+
+```bash
+npm install picgo -g
+
+# Configure an uploader (an interactive wizard)
+image-migrate-picgo --configure
+
+# Upload through PicGo CLI
+image-migrate-picgo notes.md --method cli
+```
+
+The configuration is saved to `~/.picgo/config.json` by default. If the configuration file does not exist, `--method cli` starts the wizard automatically.
+
+## CLI options
+
+```text
+image-migrate-picgo [OPTIONS] [MARKDOWN]
+```
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `MARKDOWN` | Markdown file to migrate | — |
+| `-o`, `--output PATH` | Write the result to this file instead of updating `MARKDOWN` | Update in place |
+| `--method [server\|cli]` | Upload method | `server` |
+| `--server-url TEXT` | PicGo Server upload URL | `http://127.0.0.1:36677/upload` |
+| `--server-secret TEXT` | PicGo Server secret, sent as a Bearer token | — |
+| `--picgo-command PATH` | PicGo CLI executable | `picgo` on `PATH` |
+| `--picgo-config PATH` | PicGo CLI configuration file | `~/.picgo/config.json` |
+| `--configure` | Run the PicGo uploader wizard and exit | — |
+
+## Python API
+
+```python
+from image_migrate_picgo import CliUploader, ServerUploader, migrate_markdown
+
+result = migrate_markdown(
+    "notes.md",
+    ServerUploader(),  # or CliUploader()
+    output_path="notes.migrated.md",  # omit to update notes.md in place
+)
+
+print(result.output_path)  # where the result was written
+print(result.migrated_images)  # image references rewritten
+print(result.uploaded_images)  # unique images uploaded
+print(result.urls)  # uploaded URLs
+```
+
+## LICENSE
+
+This project is licensed under the [MIT License](LICENSE).

image_migrate_picgo-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "image-migrate-picgo"
+version = "0.1.0"
+description = "Migrate images in one Markdown file through PicGo"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "markdown-it-py>=4.0,<5",
+    "typer>=0.21,<1",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "markdown",
+    "picgo",
+    "image",
+    "migration",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[[project.authors]]
+name = "left0ver"
+email = "1614674987@qq.com"
+
+[project.scripts]
+image-migrate-picgo = "image_migrate_picgo.cli:app"
+
+[build-system]
+requires = ["uv_build>=0.12.8,<0.13.0"]
+build-backend = "uv_build"

image_migrate_picgo-0.1.0/pyproject.toml.orig

@@ -0,0 +1,31 @@
+[project]
+name = "image-migrate-picgo"
+version = "0.1.0"
+description = "Migrate images in one Markdown file through PicGo"
+readme = "README.md"
+authors = [
+    { name = "left0ver", email = "1614674987@qq.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "markdown-it-py>=4.0,<5",
+    "typer>=0.21,<1",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["markdown", "picgo", "image", "migration"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.scripts]
+image-migrate-picgo = "image_migrate_picgo.cli:app"
+
+[build-system]
+requires = ["uv_build>=0.12.8,<0.13.0"]
+build-backend = "uv_build"

image_migrate_picgo-0.1.0/src/image_migrate_picgo/__init__.py

@@ -0,0 +1,20 @@
+from .core import MigrationResult, image_sources, migrate_markdown, rewrite_markdown
+from .uploaders import (
+    CliUploader,
+    ServerUploader,
+    Uploader,
+    configure_picgo_cli,
+    default_picgo_config,
+)
+
+__all__ = [
+    "CliUploader",
+    "MigrationResult",
+    "ServerUploader",
+    "Uploader",
+    "configure_picgo_cli",
+    "default_picgo_config",
+    "image_sources",
+    "migrate_markdown",
+    "rewrite_markdown",
+]

image_migrate_picgo-0.1.0/src/image_migrate_picgo/cli.py

@@ -0,0 +1,86 @@
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .core import migrate_markdown
+from .uploaders import (
+    CliUploader,
+    ServerUploader,
+    configure_picgo_cli,
+    default_picgo_config,
+)
+
+DEFAULT_PICGO_CONFIG = default_picgo_config()
+
+
+class UploadMethod(str, Enum):
+    server = "server"
+    cli = "cli"
+
+
+app = typer.Typer(
+    help="通过 PicGo 迁移单个 Markdown 文件中的图片",
+    no_args_is_help=True,
+    add_completion=False,
+    pretty_exceptions_show_locals=False,
+)
+
+
+@app.command(epilog=f"PicGo CLI 默认配置文件：{DEFAULT_PICGO_CONFIG}")
+def main(
+    markdown: Annotated[Path | None, typer.Argument(help="Markdown 文件路径")] = None,
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="输出路径，默认更新原文件"),
+    ] = None,
+    method: Annotated[
+        UploadMethod, typer.Option(help="上传方式")
+    ] = UploadMethod.server,
+    server_url: Annotated[
+        str,
+        typer.Option(help="PicGo Server 上传地址"),
+    ] = "http://127.0.0.1:36677/upload",
+    server_secret: Annotated[
+        str | None,
+        typer.Option(help="PicGo Server 访问密钥"),
+    ] = None,
+    picgo_command: Annotated[
+        Path | None,
+        typer.Option(help="PicGo CLI 可执行文件，默认从 PATH 查找 picgo"),
+    ] = None,
+    picgo_config: Annotated[
+        Path,
+        typer.Option(help="PicGo CLI 配置文件"),
+    ] = DEFAULT_PICGO_CONFIG,
+    configure: Annotated[
+        bool,
+        typer.Option("--configure", help="启动 PicGo uploader 配置向导"),
+    ] = False,
+) -> None:
+    if configure:
+        config = configure_picgo_cli(picgo_command, picgo_config)
+        typer.echo(f"PicGo 配置已保存：{config}")
+        return
+    if markdown is None:
+        raise typer.BadParameter("需要提供 Markdown 文件路径", param_hint="markdown")
+
+    uploader = (
+        ServerUploader(server_url, secret=server_secret)
+        if method is UploadMethod.server
+        else CliUploader(picgo_command, config=picgo_config)
+    )
+    result = migrate_markdown(
+        markdown,
+        uploader,
+        output_path=output,
+    )
+    typer.echo(
+        f"已迁移 {result.migrated_images} 处图片，"
+        f"上传 {result.uploaded_images} 个文件：{result.output_path}"
+    )
+
+
+if __name__ == "__main__":
+    app()

image_migrate_picgo-0.1.0/src/image_migrate_picgo/core.py

@@ -0,0 +1,279 @@
+import mimetypes
+from collections.abc import Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass
+from html import escape
+from html.parser import HTMLParser
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from urllib.parse import unquote
+from urllib.request import urlopen
+
+from markdown_it import MarkdownIt
+from markdown_it.rules_inline import backtick as parse_backtick
+from markdown_it.rules_inline import image as parse_image
+
+from .uploaders import Uploader
+
+
+@dataclass(frozen=True)
+class MigrationResult:
+    source_path: Path
+    output_path: Path
+    migrated_images: int
+    uploaded_images: int
+    urls: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class _Image:
+    source: str
+    alt: str
+    title: str | None
+    start: int
+    end: int
+    attributes: tuple[tuple[str, str | None], ...] | None = None
+    self_closing: bool = False
+
+
+class _HtmlImageParser(HTMLParser):
+    def __init__(self, content: str) -> None:
+        super().__init__(convert_charrefs=True)
+        self.images: list[_Image] = []
+        self.line_offsets = [0]
+        for line in content.splitlines(keepends=True):
+            self.line_offsets.append(self.line_offsets[-1] + len(line))
+
+    def _record(
+        self,
+        tag: str,
+        attributes: list[tuple[str, str | None]],
+        self_closing: bool,
+    ) -> None:
+        if tag != "img":
+            return
+        source = next((value for name, value in attributes if name == "src"), None)
+        if not source:
+            return
+        line, column = self.getpos()
+        start = self.line_offsets[line - 1] + column
+        self.images.append(
+            _Image(
+                source=source,
+                alt=next(
+                    (value or "" for name, value in attributes if name == "alt"),
+                    "",
+                ),
+                title=next(
+                    (value for name, value in attributes if name == "title"),
+                    None,
+                ),
+                start=start,
+                end=start + len(self.get_starttag_text()),
+                attributes=tuple(attributes),
+                self_closing=self_closing,
+            )
+        )
+
+    def handle_starttag(
+        self,
+        tag: str,
+        attrs: list[tuple[str, str | None]],
+    ) -> None:
+        self._record(tag, attrs, False)
+
+    def handle_startendtag(
+        self,
+        tag: str,
+        attrs: list[tuple[str, str | None]],
+    ) -> None:
+        self._record(tag, attrs, True)
+
+
+def _parse_image_with_span(state, silent: bool) -> bool:
+    start = state.pos
+    token_count = len(state.tokens)
+    matched = parse_image(state, silent)
+    if matched and not silent and len(state.tokens) > token_count:
+        state.tokens[-1].meta.update(source_start=start, source_end=state.pos)
+    return matched
+
+
+def _parse_backtick_with_span(state, silent: bool) -> bool:
+    start = state.pos
+    token_count = len(state.tokens)
+    matched = parse_backtick(state, silent)
+    if matched and not silent and len(state.tokens) > token_count:
+        state.tokens[-1].meta.update(source_start=start, source_end=state.pos)
+    return matched
+
+
+_markdown = MarkdownIt("commonmark")
+_markdown.inline.ruler.at("image", _parse_image_with_span)
+_markdown.inline.ruler.at("backticks", _parse_backtick_with_span)
+
+
+def _images(content: str) -> list[_Image]:
+    line_offsets = [0]
+    for line in content.splitlines(keepends=True):
+        line_offsets.append(line_offsets[-1] + len(line))
+
+    images: list[_Image] = []
+    protected: list[tuple[int, int]] = []
+    for token in _markdown.parse(content):
+        if token.type in {"fence", "code_block"} and token.map is not None:
+            protected.append((line_offsets[token.map[0]], line_offsets[token.map[1]]))
+            continue
+        if token.type != "inline" or token.children is None or token.map is None:
+            continue
+        block_start = line_offsets[token.map[0]]
+        block_end = line_offsets[token.map[1]]
+        inline_start = content.find(token.content, block_start, block_end)
+        fallback_cursor = block_start
+        for child in token.children:
+            if child.type not in {"image", "code_inline"}:
+                continue
+            relative_start = child.meta["source_start"]
+            relative_end = child.meta["source_end"]
+            if inline_start < 0:
+                markup = token.content[relative_start:relative_end]
+                start = content.find(markup, fallback_cursor, block_end)
+                if start < 0:
+                    raise ValueError("无法确定 Markdown 图片的位置")
+                end = start + len(markup)
+                fallback_cursor = end
+            else:
+                start = inline_start + relative_start
+                end = inline_start + relative_end
+            if child.type == "code_inline":
+                protected.append((start, end))
+                continue
+            images.append(
+                _Image(
+                    source=child.attrGet("src"),
+                    alt=child.content,
+                    title=child.attrGet("title"),
+                    start=start,
+                    end=end,
+                )
+            )
+
+    html_parser = _HtmlImageParser(content)
+    html_parser.feed(content)
+    html_parser.close()
+    protected.extend((image.start, image.end) for image in images)
+    images.extend(
+        image
+        for image in html_parser.images
+        if not any(image.start < end and start < image.end for start, end in protected)
+    )
+    return sorted(images, key=lambda image: image.start)
+
+
+def image_sources(content: str) -> list[str]:
+    return [image.source for image in _images(content)]
+
+
+def rewrite_markdown(content: str, replacements: Mapping[str, str]) -> str:
+    edits: list[tuple[int, int, str]] = []
+    for image in _images(content):
+        if image.source not in replacements:
+            continue
+        title = ""
+        if image.title:
+            escaped_title = image.title.replace("\\", "\\\\").replace('"', '\\"')
+            title = f' "{escaped_title}"'
+        if image.attributes is None:
+            markup = f"![{image.alt}](<{replacements[image.source]}>{title})"
+        else:
+            attributes = " ".join(
+                name
+                if value is None
+                else f'{name}="{escape(replacements[image.source] if name == "src" else value, quote=True)}"'
+                for name, value in image.attributes
+            )
+            ending = " />" if image.self_closing else ">"
+            markup = f"<img {attributes}{ending}"
+        edits.append((image.start, image.end, markup))
+
+    for start, end, markup in reversed(edits):
+        content = content[:start] + markup + content[end:]
+    return content
+
+
+def _decode_data_image(
+    source: str,
+    directory: Path,
+    index: int,
+) -> Path:
+    with urlopen(source) as response:
+        content_type = response.headers.get_content_type()
+        if not content_type.startswith("image/"):
+            raise ValueError("Data URL 的媒体类型需要为 image/*")
+        target = (
+            directory
+            / f"data-{index}{mimetypes.guess_extension(content_type) or '.img'}"
+        )
+        target.write_bytes(response.read())
+    return target
+
+
+def _upload_source(
+    source: str,
+    markdown_path: Path,
+    directory: Path,
+    index: int,
+) -> str | Path:
+    if source.startswith("data:"):
+        return _decode_data_image(source, directory, index)
+    if source.startswith(("http://", "https://", "//")):
+        return f"https:{source}" if source.startswith("//") else source
+    path = Path(unquote(source.split("#", 1)[0].split("?", 1)[0])).expanduser()
+    if not path.is_absolute():
+        path = markdown_path.parent / path
+    return path.resolve(strict=True)
+
+
+def migrate_markdown(
+    markdown_path: str | Path,
+    uploader: Uploader,
+    *,
+    output_path: str | Path | None = None,
+) -> MigrationResult:
+    source_path = Path(markdown_path).expanduser().resolve(strict=True)
+    target_path = (
+        Path(output_path).expanduser().resolve()
+        if output_path is not None
+        else source_path
+    )
+    content = source_path.read_text(encoding="utf-8")
+    all_sources = image_sources(content)
+    sources = list(dict.fromkeys(all_sources))
+
+    if sources:
+        with (
+            TemporaryDirectory(prefix=".image-migrate-picgo-", dir=source_path.parent)
+            if any(source.startswith("data:") for source in sources)
+            else nullcontext(source_path.parent)
+        ) as directory:
+            upload_sources = [
+                _upload_source(source, source_path, Path(directory), index)
+                for index, source in enumerate(sources)
+            ]
+            urls = tuple(uploader.upload(upload_sources))
+        if len(urls) != len(sources):
+            raise RuntimeError("PicGo 返回的 URL 数量与图片数量不一致")
+        replacements = dict(zip(sources, urls, strict=True))
+        migrated = rewrite_markdown(content, replacements)
+    else:
+        urls = ()
+        migrated = content
+
+    target_path.write_text(migrated, encoding="utf-8")
+    return MigrationResult(
+        source_path=source_path,
+        output_path=target_path,
+        migrated_images=len(all_sources),
+        uploaded_images=len(sources),
+        urls=urls,
+    )

image_migrate_picgo-0.1.0/src/image_migrate_picgo/uploaders.py

@@ -0,0 +1,117 @@
+import json
+import shutil
+import subprocess
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Protocol
+from urllib.parse import urlsplit
+from urllib.request import Request, urlopen
+
+
+def default_picgo_config() -> Path:
+    return Path.home() / ".picgo" / "config.json"
+
+
+def _picgo_command(command: str | Path | None) -> str:
+    candidate = "picgo" if command is None else str(Path(command).expanduser())
+    executable = shutil.which(candidate)
+    if executable is None:
+        raise FileNotFoundError(
+            f"没有找到 PicGo CLI：{candidate}。请安装 PicGo CLI 或使用 --picgo-command 指定路径"
+        )
+    return str(Path(executable).resolve(strict=True))
+
+
+def configure_picgo_cli(
+    command: str | Path | None = None,
+    config: str | Path | None = None,
+) -> Path:
+    picgo = _picgo_command(command)
+    config_path = (
+        default_picgo_config() if config is None else Path(config).expanduser()
+    )
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [picgo, "--config", str(config_path), "set", "uploader"],
+        check=True,
+    )
+    return config_path
+
+
+class Uploader(Protocol):
+    def upload(self, sources: Sequence[str | Path]) -> Sequence[str]: ...
+
+
+def _validate_urls(values: object, expected: int) -> list[str]:
+    if not isinstance(values, list) or len(values) != expected:
+        raise RuntimeError("PicGo 返回的 URL 数量与图片数量不一致")
+    if not all(
+        isinstance(value, str) and urlsplit(value).scheme in {"http", "https"}
+        for value in values
+    ):
+        raise RuntimeError("PicGo 返回了无效的图片 URL")
+    return values
+
+
+class ServerUploader:
+    def __init__(
+        self,
+        url: str = "http://127.0.0.1:36677/upload",
+        *,
+        secret: str | None = None,
+        timeout: float = 60,
+    ) -> None:
+        self.url = url
+        self.secret = secret
+        self.timeout = timeout
+
+    def upload(self, sources: Sequence[str | Path]) -> list[str]:
+        body = json.dumps({"list": [str(source) for source in sources]}).encode()
+        headers = {"Content-Type": "application/json"}
+        if self.secret:
+            headers["Authorization"] = f"Bearer {self.secret}"
+        request = Request(self.url, data=body, headers=headers, method="POST")
+        with urlopen(request, timeout=self.timeout) as response:
+            result = json.loads(response.read())
+        if result.get("success") is not True:
+            raise RuntimeError(result.get("message", "PicGo Server 上传失败"))
+        return _validate_urls(result.get("result"), len(sources))
+
+
+class CliUploader:
+    def __init__(
+        self,
+        command: str | Path | None = None,
+        *,
+        config: str | Path | None = None,
+    ) -> None:
+        self.command = _picgo_command(command)
+        config_path = (
+            default_picgo_config() if config is None else Path(config).expanduser()
+        )
+        if not config_path.is_file():
+            print(f"没有找到 PicGo 配置文件，将启动配置向导：{config_path}")
+            configure_picgo_cli(self.command, config_path)
+            if not config_path.is_file():
+                raise FileNotFoundError(f"PicGo 配置文件尚未创建：{config_path}")
+        self.config = str(config_path)
+
+    def upload(self, sources: Sequence[str | Path]) -> list[str]:
+        command = [self.command, "--config", self.config]
+        command.extend(("upload", *(str(source) for source in sources)))
+        result = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        lines = (result.stdout + "\n" + result.stderr).splitlines()
+        urls = [
+            line.strip()
+            for line in lines
+            if urlsplit(line.strip()).scheme in {"http", "https"}
+        ]
+        if not urls:
+            output = "\n".join(line for line in lines if line.strip())
+            raise RuntimeError(output or "PicGo CLI 没有返回图片 URL")
+        return _validate_urls(urls, len(sources))