publishmd 0.1.0__tar.gz

publishmd-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: publishmd
+Version: 0.1.0
+Summary: Prepare markdown content for publication with configurable processing pipeline
+Author: Mateus Molina
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MateusMolina/publishmd
+Project-URL: Repository, https://github.com/MateusMolina/publishmd.git
+Project-URL: Issues, https://github.com/MateusMolina/publishmd/issues
+Keywords: quarto,markdown,publishing,second-brain,notes,vault,obsidian,journal
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+
+# publishmd
+
+Prepare markdown content for publication with configurable processing pipeline.
+
+***Use Case 1.*** Transform an Obsidian vault into publication-ready content for a Quarto blog. Convert wikilinks, filter content, copy assets, and apply transformations to prepare your notes for publishing.
+
+## Installation
+
+### From Source
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+publishmd -c config.yaml -i /path/to/markdown -o /path/to/output
+```
+
+## Configuration
+
+Create a YAML configuration file to specify the processing pipeline, e.g.:
+
+```yaml
+filters:
+  - name: frontmatter_filter
+    type: publishmd.filters.frontmatter_filter.FrontmatterFilter
+    config:
+      publish: true
+
+emitters:
+  - name: qmd_emitter
+    type: publishmd.emitters.qmd_emitter.QmdEmitter
+  - name: assets_emitter
+    type: publishmd.emitters.assets_emitter.AssetsEmitter
+
+transformers:
+  - name: wikilink_transformer
+    type: publishmd.transformers.wikilink_transformer.WikilinkTransformer
+    config:
+      preserve_aliases: true
+      link_extension: ".qmd"
+  - name: stale_links_transformer
+    type: publishmd.transformers.stale_links_transformer.StaleLinksTransformer
+    config:
+      remove_stale_links: true
+      convert_to_text: true
+```
+
+For more examples, please check the integration tests folder (tests/integration).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

publishmd-0.1.0/README.md

@@ -0,0 +1,58 @@
+# publishmd
+
+Prepare markdown content for publication with configurable processing pipeline.
+
+***Use Case 1.*** Transform an Obsidian vault into publication-ready content for a Quarto blog. Convert wikilinks, filter content, copy assets, and apply transformations to prepare your notes for publishing.
+
+## Installation
+
+### From Source
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+publishmd -c config.yaml -i /path/to/markdown -o /path/to/output
+```
+
+## Configuration
+
+Create a YAML configuration file to specify the processing pipeline, e.g.:
+
+```yaml
+filters:
+  - name: frontmatter_filter
+    type: publishmd.filters.frontmatter_filter.FrontmatterFilter
+    config:
+      publish: true
+
+emitters:
+  - name: qmd_emitter
+    type: publishmd.emitters.qmd_emitter.QmdEmitter
+  - name: assets_emitter
+    type: publishmd.emitters.assets_emitter.AssetsEmitter
+
+transformers:
+  - name: wikilink_transformer
+    type: publishmd.transformers.wikilink_transformer.WikilinkTransformer
+    config:
+      preserve_aliases: true
+      link_extension: ".qmd"
+  - name: stale_links_transformer
+    type: publishmd.transformers.stale_links_transformer.StaleLinksTransformer
+    config:
+      remove_stale_links: true
+      convert_to_text: true
+```
+
+For more examples, please check the integration tests folder (tests/integration).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

publishmd-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "publishmd"
+version = "0.1.0"
+description = "Prepare markdown content for publication with configurable processing pipeline"
+authors = [{name = "Mateus Molina"}]
+license = "MIT"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business",
+]
+keywords = ["quarto", "markdown", "publishing", "second-brain", "notes", "vault", "obsidian", "journal"]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pyyaml>=6.0",
+    "click>=8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black"
+]
+
+[project.urls]
+Homepage = "https://github.com/MateusMolina/publishmd"
+Repository = "https://github.com/MateusMolina/publishmd.git"
+Issues = "https://github.com/MateusMolina/publishmd/issues"
+
+[project.scripts]
+publishmd = "publishmd.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.pytest.ini_options]
+markers = [
+    "unit: marks tests as unit tests (fast, isolated)",
+    "integration: marks tests as integration tests (slower, end-to-end)",
+    "slow: marks tests as slow running",
+]

publishmd-0.1.0/setup.cfg

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

publishmd-0.1.0/src/publishmd/__init__.py

@@ -0,0 +1,3 @@
+"""publishmd - Prepare markdown content for publication."""
+
+__version__ = "0.1.0"

publishmd-0.1.0/src/publishmd/base.py

@@ -0,0 +1,67 @@
+"""Base classes for emitters, transformers, and filters."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Set
+
+
+class Emitter(ABC):
+    """Base class for all emitters."""
+
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize the emitter with configuration."""
+        self.config = config
+
+    @abstractmethod
+    def emit(self, files_to_process: List[Path], output_dir: Path) -> List[Path]:
+        """
+        Emit files to output directory.
+
+        Args:
+            files_to_process: List of files to process and emit
+            output_dir: Target directory for emitted files
+
+        Returns:
+            List of paths to emitted files
+        """
+        pass
+
+
+class Transformer(ABC):
+    """Base class for all transformers."""
+
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize the transformer with configuration."""
+        self.config = config
+
+    @abstractmethod
+    def transform(self, file_path: Path, emitted_files: List[Path]) -> None:
+        """
+        Transform a file in place.
+
+        Args:
+            file_path: Path to the file to transform
+            emitted_files: List of all emitted files for reference
+        """
+        pass
+
+
+class Filter(ABC):
+    """Base class for all filters."""
+
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize the filter with configuration."""
+        self.config = config
+
+    @abstractmethod
+    def should_include(self, file_path: Path) -> bool:
+        """
+        Check if a file should be included based on filter criteria.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            True if the file should be included, False otherwise
+        """
+        pass

publishmd-0.1.0/src/publishmd/cli.py

@@ -0,0 +1,70 @@
+"""Command-line interface for publishmd."""
+
+import click
+from pathlib import Path
+from typing import Dict, Any
+
+from .processor import Processor
+
+
+@click.command()
+@click.option(
+    "--config",
+    "-c",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+    help="Path to the YAML configuration file",
+)
+@click.option(
+    "--input-dir",
+    "-i",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    required=True,
+    help="Input directory containing markdown files",
+)
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(path_type=Path),
+    required=True,
+    help="Output directory for processed files",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose output",
+)
+def main(config: Path, input_dir: Path, output_dir: Path, verbose: bool) -> None:
+    """Prepare markdown content for publication."""
+
+    if verbose:
+        click.echo(f"Loading configuration from: {config}")
+        click.echo(f"Input directory: {input_dir}")
+        click.echo(f"Output directory: {output_dir}")
+
+    try:
+        # Create CLI overrides dictionary
+        cli_overrides: Dict[str, Any] = {
+            "verbose": verbose,
+        }
+
+        # Initialize processor
+        processor = Processor(config, cli_overrides)
+
+        if verbose:
+            click.echo(f"Loaded {len(processor.emitters)} emitters")
+            click.echo(f"Loaded {len(processor.transformers)} transformers")
+
+        # Process files
+        processor.process(input_dir, output_dir)
+
+        click.echo("Conversion completed successfully!")
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+if __name__ == "__main__":
+    main()

publishmd-0.1.0/src/publishmd/config.py

@@ -0,0 +1,146 @@
+"""Configuration loading and plugin management."""
+
+import importlib
+import yaml
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+from .base import Emitter, Transformer, Filter
+
+
+class ConfigLoader:
+    """Loads and validates configuration from YAML files."""
+
+    @staticmethod
+    def load_config(config_path: Union[str, Path]) -> Dict[str, Any]:
+        """
+        Load configuration from a YAML file.
+
+        Args:
+            config_path: Path to the YAML configuration file
+
+        Returns:
+            Dictionary containing the configuration
+        """
+        config_path = Path(config_path)
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+
+        return config or {}
+
+    @staticmethod
+    def validate_config(config: Dict[str, Any]) -> None:
+        """
+        Validate the configuration structure.
+
+        Args:
+            config: Configuration dictionary to validate
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        if not isinstance(config, dict):
+            raise ValueError("Configuration must be a dictionary")
+
+        # At least one of these sections must be present
+        required_sections = ["emitters", "transformers", "filters"]
+        if not any(section in config for section in required_sections):
+            raise ValueError(
+                f"Configuration must contain at least one of: {', '.join(required_sections)}"
+            )
+
+        for section in ["emitters", "transformers", "filters"]:
+            if section in config:
+                if not isinstance(config[section], list):
+                    raise ValueError(f"'{section}' must be a list")
+
+                for item in config[section]:
+                    if not isinstance(item, dict):
+                        raise ValueError(
+                            f"Each item in '{section}' must be a dictionary"
+                        )
+
+                    if "name" not in item:
+                        raise ValueError(f"Each item in '{section}' must have a 'name'")
+
+                    if "type" not in item:
+                        raise ValueError(f"Each item in '{section}' must have a 'type'")
+
+
+class PluginLoader:
+    """Loads and instantiates plugins from configuration."""
+
+    @staticmethod
+    def load_plugin_class(class_path: str) -> type:
+        """
+        Load a plugin class from a module path.
+
+        Args:
+            class_path: Full module path to the class (e.g., 'module.submodule.ClassName')
+
+        Returns:
+            The loaded class
+        """
+        module_path, class_name = class_path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+
+    @staticmethod
+    def load_emitters(config: List[Dict[str, Any]]) -> List[Emitter]:
+        """
+        Load emitter instances from configuration.
+
+        Args:
+            config: List of emitter configurations
+
+        Returns:
+            List of instantiated emitters
+        """
+        emitters = []
+        for emitter_config in config:
+            plugin_class = PluginLoader.load_plugin_class(emitter_config["type"])
+            plugin_config = emitter_config.get("config", {})
+            emitter = plugin_class(plugin_config)
+            emitters.append(emitter)
+        return emitters
+
+    @staticmethod
+    def load_transformers(config: List[Dict[str, Any]]) -> List[Transformer]:
+        """
+        Load transformer instances from configuration.
+
+        Args:
+            config: List of transformer configurations
+
+        Returns:
+            List of instantiated transformers
+        """
+        transformers = []
+        for transformer_config in config:
+            plugin_class = PluginLoader.load_plugin_class(transformer_config["type"])
+            plugin_config = transformer_config.get("config", {})
+            transformer = plugin_class(plugin_config)
+            transformers.append(transformer)
+        return transformers
+
+    @staticmethod
+    def load_filters(config: List[Dict[str, Any]]) -> List[Filter]:
+        """
+        Load filter instances from configuration.
+
+        Args:
+            config: List of filter configurations
+
+        Returns:
+            List of instantiated filters
+        """
+        filters = []
+        for filter_config in config:
+            plugin_class = PluginLoader.load_plugin_class(filter_config["type"])
+            plugin_config = filter_config.get("config", {})
+            filter_instance = plugin_class(plugin_config)
+            filters.append(filter_instance)
+        return filters

publishmd-0.1.0/src/publishmd/emitters/__init__.py

@@ -0,0 +1 @@
+"""Emitters package."""