markitai 0.3.0__py3-none-any.whl

markitai/workflow/single.py

@@ -0,0 +1,369 @@
+"""Single file workflow processing."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from markitai.security import atomic_write_text
+
+if TYPE_CHECKING:
+    from markitai.config import MarkitaiConfig
+    from markitai.llm import LLMProcessor
+
+
+@dataclass
+class ImageAnalysisResult:
+    """Result of image analysis for a single source file."""
+
+    source_file: str
+    assets: list[dict[str, Any]]
+
+
+@dataclass
+class WorkflowResult:
+    """Result of processing a file through the workflow."""
+
+    markdown: str
+    llm_cost: float = 0.0
+    llm_usage: dict[str, dict[str, Any]] = field(default_factory=dict)
+    image_analysis: ImageAnalysisResult | None = None
+
+
+class SingleFileWorkflow:
+    """Workflow for processing a single file with LLM enhancement.
+
+    This class encapsulates the LLM processing logic extracted from cli.py,
+    including document processing, image analysis, and vision enhancement.
+    """
+
+    def __init__(
+        self,
+        config: MarkitaiConfig,
+        processor: LLMProcessor | None = None,
+        project_dir: Path | None = None,
+        no_cache: bool = False,
+        no_cache_patterns: list[str] | None = None,
+    ) -> None:
+        """Initialize workflow.
+
+        Args:
+            config: Markitai configuration
+            processor: Optional shared LLMProcessor (created if not provided)
+            project_dir: Optional project directory for project-level cache
+            no_cache: If True, skip reading from cache but still write results
+            no_cache_patterns: List of glob patterns to skip cache for specific files
+        """
+        self.config = config
+        self._processor = processor
+        self._project_dir = project_dir
+        self._no_cache = no_cache
+        self._no_cache_patterns = no_cache_patterns
+        self._llm_cost = 0.0
+        self._llm_usage: dict[str, dict[str, Any]] = {}
+
+    @property
+    def processor(self) -> LLMProcessor:
+        """Get or create LLM processor."""
+        if self._processor is None:
+            from markitai.workflow.helpers import create_llm_processor
+
+            # Create a temporary config with the no_cache settings
+            # This is needed because SingleFileWorkflow stores these separately
+            temp_config = self.config.model_copy()
+            temp_config.cache.no_cache = self._no_cache
+            temp_config.cache.no_cache_patterns = self._no_cache_patterns or []
+
+            self._processor = create_llm_processor(
+                temp_config, project_dir=self._project_dir
+            )
+        return self._processor
+
+    def _merge_usage(self, usage: dict[str, dict[str, Any]]) -> None:
+        """Merge usage statistics into workflow totals."""
+        from markitai.workflow.helpers import merge_llm_usage
+
+        merge_llm_usage(self._llm_usage, usage)
+
+    async def process_document_with_llm(
+        self,
+        markdown: str,
+        source: str,
+        output_file: Path,
+        page_images: list[dict] | None = None,
+    ) -> tuple[str, float, dict[str, dict[str, Any]]]:
+        """Process markdown with LLM (clean + frontmatter).
+
+        Args:
+            markdown: Markdown content to process
+            source: Source file name
+            output_file: Output file path for .llm.md
+            page_images: Optional list of page image info dicts
+
+        Returns:
+            Tuple of (markdown, cost_usd, llm_usage)
+        """
+        try:
+            cleaned, frontmatter = await self.processor.process_document(
+                markdown, source
+            )
+
+            # Write LLM version
+            llm_output = output_file.with_suffix(".llm.md")
+            llm_content = self.processor.format_llm_output(cleaned, frontmatter)
+
+            # Append commented image links if provided
+            if page_images:
+                commented_images = [
+                    f"<!-- ![Page {img['page']}](screenshots/{img['name']}) -->"
+                    for img in sorted(page_images, key=lambda x: x.get("page", 0))
+                ]
+                llm_content += "\n\n<!-- Page images for reference -->\n" + "\n".join(
+                    commented_images
+                )
+
+            atomic_write_text(llm_output, llm_content)
+            logger.info(f"Written LLM version: {llm_output}")
+
+            # Use context-based tracking for accurate per-file usage in concurrent scenarios
+            cost = self.processor.get_context_cost(source)
+            usage = self.processor.get_context_usage(source)
+            return markdown, cost, usage
+
+        except Exception as e:
+            logger.warning(f"LLM processing failed: {e}")
+            return markdown, 0.0, {}
+
+    async def analyze_images(
+        self,
+        image_paths: list[Path],
+        markdown: str,
+        output_file: Path,
+        input_path: Path | None = None,
+        concurrency_limit: int | None = None,
+    ) -> tuple[str, float, dict[str, dict[str, Any]], ImageAnalysisResult | None]:
+        """Analyze images with LLM Vision.
+
+        Args:
+            image_paths: List of image file paths
+            markdown: Original markdown content
+            output_file: Output markdown file path
+            input_path: Source input file path
+            concurrency_limit: Max concurrent requests
+
+        Returns:
+            Tuple of (updated markdown, cost_usd, llm_usage, image_analysis_result)
+        """
+        from markitai.llm import ImageAnalysis
+        from markitai.workflow.helpers import detect_language
+
+        alt_enabled = self.config.image.alt_enabled
+        desc_enabled = self.config.image.desc_enabled
+
+        # Use unique context for accurate per-file usage tracking in concurrent scenarios
+        source_path = (
+            str(input_path.resolve()) if input_path else str(output_file.resolve())
+        )
+        context = f"{source_path}:images"
+
+        try:
+            # Detect document language from markdown content
+            language = detect_language(markdown)
+
+            async def analyze_single_image(
+                image_path: Path,
+            ) -> tuple[Path, ImageAnalysis | None, str]:
+                """Analyze a single image."""
+                timestamp = datetime.now().astimezone().isoformat()
+                try:
+                    analysis = await self.processor.analyze_image(
+                        image_path, language=language, context=context
+                    )
+                    return image_path, analysis, timestamp
+                except Exception as e:
+                    logger.warning(f"Failed to analyze image {image_path.name}: {e}")
+                    return image_path, None, timestamp
+
+            # Queue-based analysis with concurrency limit
+            logger.info(f"Analyzing {len(image_paths)} images...")
+            limit = (
+                concurrency_limit
+                if concurrency_limit is not None
+                else self.config.llm.concurrency
+            )
+            worker_count = min(len(image_paths), max(1, limit))
+            queue: asyncio.Queue[Path] = asyncio.Queue()
+            for image_path in image_paths:
+                queue.put_nowait(image_path)
+
+            results_map: dict[Path, tuple[Path, ImageAnalysis | None, str]] = {}
+
+            async def worker() -> None:
+                while True:
+                    try:
+                        image_path = queue.get_nowait()
+                    except asyncio.QueueEmpty:
+                        break
+                    result = await analyze_single_image(image_path)
+                    results_map[image_path] = result
+                    queue.task_done()
+
+            workers = [asyncio.create_task(worker()) for _ in range(worker_count)]
+            await queue.join()
+            for task in workers:
+                task.cancel()
+            await asyncio.gather(*workers, return_exceptions=True)
+
+            results = [results_map[p] for p in image_paths if p in results_map]
+
+            # Collect asset descriptions for JSON output
+            asset_descriptions: list[dict[str, Any]] = []
+
+            # Process results
+            for image_path, analysis, timestamp in results:
+                # Use default values if analysis failed
+                # This ensures the image is still recorded in images.json
+                if analysis is None:
+                    analysis_caption = "Image"
+                    analysis_desc = "Image analysis failed"
+                    analysis_text = ""
+                    analysis_usage: dict[str, Any] = {}
+                else:
+                    analysis_caption = analysis.caption
+                    analysis_desc = analysis.description
+                    analysis_text = analysis.extracted_text or ""
+                    analysis_usage = analysis.llm_usage or {}
+
+                # Collect for JSON output (if desc_enabled)
+                if desc_enabled:
+                    asset_descriptions.append(
+                        {
+                            "asset": str(image_path.resolve()),
+                            "alt": analysis_caption,
+                            "desc": analysis_desc,
+                            "text": analysis_text,
+                            "llm_usage": analysis_usage,
+                            "created": timestamp,
+                        }
+                    )
+
+                # Update alt text in markdown (if alt_enabled)
+                if alt_enabled:
+                    old_pattern = rf"!\[[^\]]*\]\([^)]*{re.escape(image_path.name)}\)"
+                    new_ref = f"![{analysis_caption}](assets/{image_path.name})"
+                    markdown = re.sub(old_pattern, new_ref, markdown)
+
+            # Check if this is a standalone image file
+            from markitai.constants import IMAGE_EXTENSIONS
+
+            is_standalone_image = (
+                input_path is not None
+                and input_path.suffix.lower() in IMAGE_EXTENSIONS
+                and len(image_paths) == 1
+            )
+
+            # Update/create .llm.md file
+            llm_output = output_file.with_suffix(".llm.md")
+            if is_standalone_image and results and results[0][1] is not None:
+                # For standalone images, create rich formatted content with frontmatter
+                from markitai.utils.text import normalize_markdown_whitespace
+                from markitai.workflow.helpers import format_standalone_image_markdown
+
+                # input_path is guaranteed non-None by is_standalone_image check
+                assert input_path is not None
+                _, analysis, _ = results[0]
+                if analysis:
+                    rich_content = format_standalone_image_markdown(
+                        input_path,
+                        analysis,
+                        f"assets/{input_path.name}",
+                        include_frontmatter=True,
+                    )
+                    rich_content = normalize_markdown_whitespace(rich_content)
+                    atomic_write_text(llm_output, rich_content)
+                    logger.info(f"Written LLM version: {llm_output}")
+            elif alt_enabled:
+                # NOTE: Alt text update moved to caller (workflow/core.py) to avoid race condition.
+                # The caller will apply alt text updates after document processing completes.
+                # See P0-4 fix: image analysis no longer waits for .llm.md file.
+                pass
+
+            # Build analysis result for caller to aggregate
+            analysis_result: ImageAnalysisResult | None = None
+            if desc_enabled and asset_descriptions:
+                source_path = (
+                    str(input_path.resolve()) if input_path else output_file.stem
+                )
+                analysis_result = ImageAnalysisResult(
+                    source_file=source_path,
+                    assets=asset_descriptions,
+                )
+
+            # Use context-based tracking for accurate per-file usage in concurrent scenarios
+            return (
+                markdown,
+                self.processor.get_context_cost(context),
+                self.processor.get_context_usage(context),
+                analysis_result,
+            )
+
+        except Exception as e:
+            logger.warning(f"Image analysis failed: {e}")
+            return markdown, 0.0, {}, None
+
+    async def enhance_with_vision(
+        self,
+        extracted_text: str,
+        page_images: list[dict],
+        source: str = "document",
+    ) -> tuple[str, str, float, dict[str, dict[str, Any]]]:
+        """Enhance document by combining extracted text with page images.
+
+        Args:
+            extracted_text: Text extracted by pymupdf4llm/markitdown
+            page_images: List of page image info dicts with 'path' key
+            source: Source file name for logging context
+
+        Returns:
+            Tuple of (cleaned_markdown, frontmatter_yaml, cost_usd, llm_usage)
+        """
+        try:
+            # Sort images by page number
+            def get_page_num(img_info: dict) -> int:
+                return img_info.get("page", 0)
+
+            sorted_images = sorted(page_images, key=get_page_num)
+
+            # Convert to Path list
+            image_paths = [Path(img["path"]) for img in sorted_images]
+
+            logger.info(
+                f"[START] {source}: Enhancing with {len(image_paths)} page images..."
+            )
+
+            # Call the combined enhancement method (clean + frontmatter)
+            (
+                cleaned_content,
+                frontmatter,
+            ) = await self.processor.enhance_document_complete(
+                extracted_text, image_paths, source=source
+            )
+
+            # Use context-based tracking for accurate per-file usage in concurrent scenarios
+            return (
+                cleaned_content,
+                frontmatter,
+                self.processor.get_context_cost(source),
+                self.processor.get_context_usage(source),
+            )
+
+        except Exception as e:
+            logger.warning(f"Document enhancement failed: {e}")
+            basic_frontmatter = f"title: {source}\nsource: {source}"
+            return extracted_text, basic_frontmatter, 0.0, {}

markitai-0.3.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: markitai
+Version: 0.3.0
+Summary: Document to Markdown converter with LLM enhancement
+Project-URL: Homepage, https://markitai.ynewtime.com
+Project-URL: Documentation, https://markitai.ynewtime.com/guide/getting-started
+Project-URL: Repository, https://github.com/Ynewtime/markitai
+Project-URL: Changelog, https://github.com/Ynewtime/markitai/blob/main/CHANGELOG.md
+Author-email: Ynewtime <longqiliuye@gmail.com>
+License-Expression: MIT
+Keywords: converter,docx,llm,markdown,ocr,pdf
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: instructor>=1.14.0
+Requires-Dist: litellm>=1.80.16
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: markitdown[all]>=0.1.4
+Requires-Dist: pillow>=12.1.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pymupdf4llm>=0.2.9
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: pywin32>=310; sys_platform == 'win32'
+Requires-Dist: rapidocr>=3.5.0
+Requires-Dist: rich>=14.2.0
+Provides-Extra: all
+Description-Content-Type: text/markdown
+
+# Markitai
+
+开箱即用的 Markdown 转换器，原生支持 LLM 增强。
+
+## 特性
+
+- **多格式支持** - DOCX/DOC, PPTX/PPT, XLSX/XLS, PDF, TXT, MD, JPG/PNG/WebP, URLs
+- **LLM 增强** - 格式清洗、元数据生成、图片分析
+- **批量处理** - 并发转换、断点恢复、进度显示
+- **OCR 识别** - 扫描版 PDF 和图片文字提取
+- **URL 转换** - 直接转换网页，支持 SPA 浏览器渲染
+
+## 安装
+
+### 一键安装（推荐）
+
+```bash
+# Linux/macOS
+curl -fsSL https://raw.githubusercontent.com/Ynewtime/markitai/main/scripts/setup.sh | sh
+
+# Windows (PowerShell)
+irm https://raw.githubusercontent.com/Ynewtime/markitai/main/scripts/setup.ps1 | iex
+```
+
+### 手动安装
+
+```bash
+# 需要 Python 3.11+
+uv tool install markitai
+
+# 或使用 pip
+pip install --user markitai
+```
+
+## 快速开始
+
+```bash
+# 基础转换
+markitai document.docx
+
+# URL 转换
+markitai https://example.com/article
+
+# LLM 增强
+markitai document.docx --llm
+
+# 使用预设
+markitai document.pdf --preset rich      # LLM + alt + desc + screenshot
+markitai document.pdf --preset standard  # LLM + alt + desc
+markitai document.pdf --preset minimal   # 仅基础转换
+
+# 批量处理
+markitai ./docs -o ./output
+
+# 断点恢复
+markitai ./docs -o ./output --resume
+
+# URL 批量处理（自动识别 .urls 文件）
+markitai urls.urls -o ./output
+```
+
+## 输出结构
+
+```
+output/
+├── document.docx.md        # 基础 Markdown
+├── document.docx.llm.md    # LLM 优化版
+├── assets/
+│   ├── document.docx.0001.jpg
+│   └── images.json         # 图片描述
+├── screenshots/            # 页面截图（--screenshot 时）
+│   └── example_com.full.jpg
+```
+
+## 配置
+
+优先级：命令行 > 环境变量 > 配置文件 > 默认值
+
+```bash
+# 查看配置
+markitai config list
+
+# 初始化配置文件
+markitai config init -o .
+
+# 查看缓存状态
+markitai cache stats
+
+# 清理缓存
+markitai cache clear
+```
+
+配置文件路径：`./markitai.json` 或 `~/.markitai/config.json`
+
+## 环境变量
+
+| 变量 | 说明 |
+|------|------|
+| `OPENAI_API_KEY` | OpenAI API Key |
+| `GEMINI_API_KEY` | Google Gemini API Key |
+| `DEEPSEEK_API_KEY` | DeepSeek API Key |
+| `ANTHROPIC_API_KEY` | Anthropic API Key |
+| `JINA_API_KEY` | Jina Reader API Key（URL 转换） |
+
+## 依赖
+
+- [pymupdf4llm](https://github.com/pymupdf/RAG) - PDF 转换
+- [markitdown](https://github.com/microsoft/markitdown) - Office 文档和 URL 转换
+- [LiteLLM](https://github.com/BerriAI/litellm) - LLM 网关
+- [RapidOCR](https://github.com/RapidAI/RapidOCR) - OCR 识别
+
+## 文档
+
+- [快速开始](https://ynewtime.github.io/markitai/guide/getting-started)
+- [配置说明](https://ynewtime.github.io/markitai/guide/configuration)
+- [CLI 命令参考](https://ynewtime.github.io/markitai/guide/cli)
+
+## License
+
+MIT

markitai-0.3.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+markitai/__init__.py,sha256=nL8_TGxWstLYM-_InoDAX9IVbfSHHjzgH4iroiwdQVI,93
+markitai/batch.py,sha256=qNz6_AF12vK3CEzslvhFcAY7KVSYqtSWhjRM8TdmqoA,49576
+markitai/cli.py,sha256=jnvNvr-sMh3bVCooDnBYtND_kpyblAUCUWncK0_-DcY,144061
+markitai/config.py,sha256=Vop1pal-m2tZ3aNjX6YCMhwsyp4rFMdbaOjJFIlL8oQ,19821
+markitai/config.schema.json,sha256=PiVwmPo3g5fI0qciH7OPhUon-t1gaHa8z4bmDQZaBoo,17400
+markitai/constants.py,sha256=onIkq0He4d6sd_z0dBvsJleurx_6QMQIfVtNKzeeQPg,8084
+markitai/fetch.py,sha256=3ciywXpxvcx0Pw_Ho3gSZVCL8-dTfHdwL9cIlDXEGIA,61460
+markitai/image.py,sha256=KlTCV4GKKXRCjl7vhhJzmTLtO3ATM21R82EcPlJ0xDs,49327
+markitai/json_order.py,sha256=JcBU_49SuQWd0YyJesspurpVDkp8YdibB3ADSMAvQlU,16905
+markitai/llm.py,sha256=XhoG4m6ys_j7uZt5L-b6E6M99x9Zwy1e2aAginawU7w,167464
+markitai/ocr.py,sha256=eiaY1g39w4a-00xp1JZtvO8eHZO34STP_o6yk18m_-w,10394
+markitai/security.py,sha256=QaEeblAAaShkdbF_ojvsHflhoxyCde7licR0BbbCm7A,8113
+markitai/types.py,sha256=dTTpUjBV_GwYZi7JRFFi4_teVJ_gVjpsVVDrcCxKvrw,839
+markitai/urls.py,sha256=ILcZf41C7JzignXV9Ru1QgciogQXQ_W7x0GeD72R-DY,5213
+markitai/converter/__init__.py,sha256=Dr8pHofoGbOTbzfCSBOOxsA_LUa-qrJOpxSPISKdgKY,1184
+markitai/converter/_patches.py,sha256=tPiP3vwpsdr4BGPU2zReBBPwHQOtXvu9vzDZmZfLPHc,3067
+markitai/converter/base.py,sha256=EOU1qLWPNbF9SUQX5bmoWP-AqJz7vypllEV6fMi72Hs,3851
+markitai/converter/image.py,sha256=tSKgi4oDYaXJabGocWE982Soe0k955NY5nNM-br37Es,5874
+markitai/converter/legacy.py,sha256=R089rJyacE4K0KATMjfOQii_sgxK8agjvYm_7jIiVz0,19504
+markitai/converter/office.py,sha256=p9Wl5q_Z7C8LDuSXOdYpIIcDsabrFrIuGmVQ7kX8oms,19059
+markitai/converter/pdf.py,sha256=Riq577qBJI2uz6RzzbMjwDaMfGwNZ50a3gxezqFzQok,26418
+markitai/converter/text.py,sha256=ldWv0iUVblAB7MfqyoV2CGs4k36aBxrhSU_6JwLpWds,1432
+markitai/prompts/__init__.py,sha256=fsVei-9jCqInY2OvtxYQVGxyjriU-r1bOoic8N2lS24,4595
+markitai/prompts/cleaner.md,sha256=QJS-ttDYhkSqFJ5lx5MwCfckGkvk6FzZ1bIRuVqoT5I,4656
+markitai/prompts/document_enhance.md,sha256=mM48qXa38kUdjOuirZBpb4HKFSBpVoqAvV9tEG21dJ0,4116
+markitai/prompts/document_enhance_complete.md,sha256=EoGeODZAY-DkJ0dqJTYqPglMqCgwfZ9N-kRQvnzFFR0,3098
+markitai/prompts/document_process.md,sha256=kOiElomRQBg92hPaN6-QaELcq49ynF9Esby5D0OCzBo,2011
+markitai/prompts/frontmatter.md,sha256=PNzgql9RDwDEaqi-5dDf278XxcVuuYNqe7TMSt7gyNE,998
+markitai/prompts/image_analysis.md,sha256=jn8bvR89MS0ZGcXeeKHXWiWEdVyvWwrf8gHi1jSE-zs,842
+markitai/prompts/image_caption.md,sha256=EZXvBjzdjveTKcM8ePfiBJJ5jkzCjlL5ixmw10OqDJM,305
+markitai/prompts/image_description.md,sha256=Wmwq2V96cawKE3p3QpDOHkybNd3ocJUf1bZGU8_qMDM,403
+markitai/prompts/page_content.md,sha256=Sndp_MABteHImrWln3_k3ZJMQfX0fQH2_AI5Hxcao7E,821
+markitai/prompts/url_enhance.md,sha256=3wzTx_QGSuf7k1zuDKXOtcrA7ofqn0fYmwD7Oh9CaTE,3465
+markitai/utils/__init__.py,sha256=K1OWjX--LON8hbc_yB3zYR8TsZ_sc39CjzMWbcgUznQ,899
+markitai/utils/executor.py,sha256=nEONsq41ZJtnqpne0pXQIMjET1rtyMJTbMYNUUcgKgc,2179
+markitai/utils/mime.py,sha256=uak2YY2Z3Bl6dbZk4Xi47b2BPmFvRJJlzILHeW0G2P0,2566
+markitai/utils/office.py,sha256=apeHynsrcspUJX392wnVheiAf-I1t1WOos41l-Nh_04,8221
+markitai/utils/output.py,sha256=9ZZbuY6G2DoLzpcUcSiKCEdgfZ2jW-2GhRQer7uwJWw,1779
+markitai/utils/paths.py,sha256=7TPh7kkWIzFSDhW67TzAZGFNaTQxaYUfPj6ng5K2SGw,1962
+markitai/utils/text.py,sha256=dtpVk8qz_O7ZLCSEj55EeVPGnZ7Zpif4koaW2pH9mkU,12242
+markitai/workflow/__init__.py,sha256=lw_gRgl_M-kGFuBHMXU5biEu8xI5I2z9SOFb8cLU3Ck,898
+markitai/workflow/core.py,sha256=Q2F8i7Bd5WJ2m3GXYTtqdb7AL6InYHND_w1uh2s4cQ4,25172
+markitai/workflow/helpers.py,sha256=Z256Cm6a4NasqedWwp205IVWZ_-whHlS8mO5xYyGOgQ,16824
+markitai/workflow/single.py,sha256=qwRkmK-3wgYM_EGv9osvXeT_6L0gRJjaHD0RuLNX6uU,14357
+markitai-0.3.0.dist-info/METADATA,sha256=afBehA4YbHk31XfyPXPt4FOJzZtGBCx2XvRT9h7sR8A,4395
+markitai-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+markitai-0.3.0.dist-info/entry_points.txt,sha256=6gpnr_12uwxTs9MqPxphvcZeFQUIk2PtqGRMMneEHsI,46
+markitai-0.3.0.dist-info/RECORD,,

markitai-0.3.0.dist-info/WHEEL

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

markitai-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+markitai = markitai.cli:app