{{ description }}
{{ description }}
{{ article_html[:article_html.find('
')] }} @@ -157,13 +163,14 @@ card_template="""{{ article_html[:article_html.find('
')] }} @@ -171,13 +178,14 @@ card_template="""{{ article_html[:article_html.find('
')] }} @@ -190,6 +198,8 @@ ignore=[ 'jinja_md.md', 'post_template.md', 'publish_html.md', +'CHANGELOG.md', +'feeds.md', ] [[markata.head.meta]] @@ -206,15 +216,18 @@ key='n' [markata.summary] grid_attr = ['tags', 'series'] -[markata.summary.filter_count.drafts] +[[markata.summary.filter_count]] +name='drafts' filter="published == 'False'" color='red' -[markata.summary.filter_count.articles] +[[markata.summary.filter_count]] +name='articles' color='dark_orange' -[markata.summary.filter_count.py_modules] -filter='"plugin" not in slug and "docs" not in path' +[[markata.summary.filter_count]] +name='py_modules' +filter='"plugin" not in slug and "docs" not in str(path)' color="yellow1" [markata.summary.filter_count.published] @@ -222,9 +235,61 @@ filter="published == 'True'" color='green1' [markata.summary.filter_count.plugins] -filter='"plugin" in slug and "docs" not in path' +filter='"plugin" in slug and "docs" not in str(path)' color="blue" [markata.summary.filter_count.docs] -filter="'docs' in path" +filter="'docs' in str(path)" color='purple' + +[markata.post_model] +include = ['date', 'description', 'published', 'slug', 'title', 'content', 'html'] +repr_include = ['date', 'description', 'published', 'slug', 'title', 'output_html'] + +[markata.render_markdown] +backend='markdown-it-py' + +# [markata.markdown_it_py] +# config='gfm-like' +# # markdown_it built-in plugins +# enable = [ "table" ] +# disable = [ "image" ] + +# # markdown_it built-in plugin options +# [markata.markdown_it_py.options_update] +# linkify = true +# html = true +# typographer = true +# highlight = 'markata.plugins.md_it_highlight_code:highlight_code' + +# add custom markdown_it plugins +[[markata.render_markdown.extensions]] +plugin = "mdit_py_plugins.admon:admon_plugin" + +[[markata.render_markdown.extensions]] +plugin = "mdit_py_plugins.admon:admon_plugin" + +[[markata.render_markdown.extensions]] +plugin = "mdit_py_plugins.attrs:attrs_plugin" +config = {spans = true} + +[[markata.render_markdown.extensions]] +plugin = "mdit_py_plugins.attrs:attrs_block_plugin" + +[[markata.render_markdown.extensions]] +plugin = "markata.plugins.mdit_details:details_plugin" + +[[markata.render_markdown.extensions]] +plugin = "mdit_py_plugins.anchors:anchors_plugin" + +[markata.render_markdown.extensions.config] +permalink = true +permalinkSymbol = '' + +[[markata.render_markdown.extensions]] +plugin = "markata.plugins.md_it_wikilinks:wikilinks_plugin" +config = {markata = "markata"} + +[markata.glob] +glob_patterns = "docs/**/*.md,CHANGELOG.md" +use_gitignore = true diff --git a/markata/__about__.py b/markata/__about__.py index ed9d4d87..2b3551ba 100644 --- a/markata/__about__.py +++ b/markata/__about__.py @@ -1 +1 @@ -__version__ = "0.7.4" +__version__ = "0.8.0.dev7" diff --git a/markata/__init__.py b/markata/__init__.py index 67be73dc..cd01c8f3 100644 --- a/markata/__init__.py +++ b/markata/__init__.py @@ -5,20 +5,20 @@ import atexit import datetime -from datetime import timedelta import hashlib import importlib import logging import os -from pathlib import Path import sys import textwrap -from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple +from datetime import timedelta +from pathlib import Path +from typing import Any, Dict, Iterable, Optional -from checksumdir import dirhash -from diskcache import FanoutCache -import frontmatter import pluggy +import pydantic +from checksumdir import dirhash +from diskcache import Cache from rich.console import Console from rich.progress import track from rich.table import Table @@ -54,6 +54,7 @@ ] DEFAULT_HOOKS = [ + "markata.plugins.copy_assets", "markata.plugins.heading_link", "markata.plugins.pyinstrument", "markata.plugins.glob", @@ -62,16 +63,13 @@ "markata.plugins.render_markdown", "markata.plugins.manifest", # "markata.plugins.generator", - "markata.plugins.jinja_md", "markata.plugins.feeds", "markata.plugins.auto_description", "markata.plugins.seo", "markata.plugins.post_template", "markata.plugins.covers", - "markata.plugins.copy_assets", "markata.plugins.publish_html", "markata.plugins.flat_slug", - "markata.plugins.datetime", "markata.plugins.rss", "markata.plugins.icon_resize", "markata.plugins.sitemap", @@ -84,6 +82,10 @@ "markata.plugins.tui", "markata.plugins.setup_logging", "markata.plugins.redirects", + "markata.plugins.post_model", + "markata.plugins.config_model", + "markata.plugins.create_models", + "markata.plugins.jinja_md", ] DEFUALT_CONFIG = { @@ -97,56 +99,83 @@ } -class Post(frontmatter.Post): - html: str - - -def set_phase(function: Callable) -> Any: - def wrapper(self: Markata, *args: Tuple, **kwargs: Dict) -> Any: - self.phase = function.__name__ - self.phase_file.parent.mkdir(exist_ok=True) - self.phase_file.write_text(self.phase) - result = function(self, *args, **kwargs) - self.phase = function.__name__ - self.phase_file.parent.mkdir(exist_ok=True) - self.phase_file.write_text(self.phase) - return result - - return wrapper +class HooksConfig(pydantic.BaseModel): + hooks: list = ["default"] + disabled_hooks: list = [] class Markata: - def __init__(self, console: Console = None) -> None: - self.phase = "starting" + def __init__(self: "Markata", console: Console = None, config=None) -> None: + self.stages_ran = set() + self.threded = False + self._cache = None + self._precache = None self.MARKATA_CACHE_DIR = Path(".") / ".markata.cache" self.MARKATA_CACHE_DIR.mkdir(exist_ok=True) - self.phase_file: Path = self.MARKATA_CACHE_DIR / "phase.txt" + self._pm = pluggy.PluginManager("markata") + self._pm.add_hookspecs(hookspec.MarkataSpecs) + if config is not None: + self.config = config + with self.cache as cache: + self.init_cache_stats = cache.stats() self.registered_attrs = hookspec.registered_attrs - self.configure() + self.post_models = [] + self.config_models = [] + if config is not None: + raw_hooks = config + else: + raw_hooks = standard_config.load("markata") + self.hooks_conf = HooksConfig.parse_obj(raw_hooks) + try: + default_index = self.hooks_conf.hooks.index("default") + hooks = [ + *self.hooks_conf.hooks[:default_index], + *DEFAULT_HOOKS, + *self.hooks_conf.hooks[default_index + 1 :], + ] + self.hooks_conf.hooks = [ + hook for hook in hooks if hook not in self.hooks_conf.disabled_hooks + ] + except ValueError: + # 'default' is not in hooks , do not replace with default_hooks + pass + + self._register_hooks() if console is not None: self._console = console atexit.register(self.teardown) - - with self.cache as cache: - self.init_cache_stats = cache.stats() + self.precache @property - def cache(self) -> FanoutCache: - return FanoutCache(self.MARKATA_CACHE_DIR, statistics=True) + def cache(self: "Markata") -> Cache: + # if self.threded: + # FanoutCache(self.MARKATA_CACHE_DIR, statistics=True) + if self._cache is not None: + return self._cache + self._cache = Cache(self.MARKATA_CACHE_DIR, statistics=True) + + return self._cache - def __getattr__(self, item: str) -> Any: - if item in self._pm.hook.__dict__.keys(): + @property + def precache(self: "Markata") -> None: + if self._precache is None: + self.cache.expire() + self._precache = {k: self.cache.get(k) for k in self.cache.iterkeys()} + return self._precache + + def __getattr__(self: "Markata", item: str) -> Any: + if item in self._pm.hook.__dict__: # item is a hook, return a callable function return lambda: self.run(item) - if item in self.__dict__.keys(): + if item in self.__dict__: # item is an attribute, return it return self.__getitem__(item) - elif item in self.registered_attrs.keys(): + elif item in self.registered_attrs: # item is created by a plugin, run it stage_to_run_to = max( - [attr["lifecycle"] for attr in self.registered_attrs[item]] + [attr["lifecycle"] for attr in self.registered_attrs[item]], ).name self.run(stage_to_run_to) return getattr(self, item) @@ -154,7 +183,7 @@ def __getattr__(self, item: str) -> Any: # Markata does not know what this is, raise raise AttributeError(f"'Markata' object has no attribute '{item}'") - def __rich__(self) -> Table: + def __rich__(self: "Markata") -> Table: grid = Table.grid() grid.add_column("label") grid.add_column("value") @@ -164,65 +193,61 @@ def __rich__(self) -> Table: return grid - def bust_cache(self) -> Markata: + def bust_cache(self: "Markata") -> Markata: with self.cache as cache: cache.clear() return self - @set_phase def configure(self) -> Markata: sys.path.append(os.getcwd()) - self.config = {**DEFUALT_CONFIG, **standard_config.load("markata")} - if isinstance(self.config["glob_patterns"], str): - self.config["glob_patterns"] = self.config["glob_patterns"].split(",") - elif isinstance(self.config["glob_patterns"], list): - self.config["glob_patterns"] = list(self.config["glob_patterns"]) - else: - raise TypeError("glob_patterns must be list or str") - self.glob_patterns = self.config["glob_patterns"] - - if "hooks" not in self.config: - self.hooks = [""] - if isinstance(self.config["hooks"], str): - self.hooks = self.config["hooks"].split(",") - if isinstance(self.config["hooks"], list): - self.hooks = self.config["hooks"] - - if "disabled_hooks" not in self.config: - self.disabled_hooks = [""] - if isinstance(self.config["disabled_hooks"], str): - self.disabled_hooks = self.config["disabled_hooks"].split(",") - if isinstance(self.config["disabled_hooks"], list): - self.disabled_hooks = self.config["disabled_hooks"] - - if not self.config.get("output_dir", "markout").endswith( - self.config.get("path_prefix", "") - ): - self.config["output_dir"] = ( - self.config.get("output_dir", "markout") - + "/" - + self.config.get("path_prefix", "").rstrip("/") - ) - if ( - len((output_split := self.config.get("output_dir", "markout").split("/"))) - > 1 - ): - if "path_prefix" not in self.config.keys(): - self.config["path_prefix"] = "/".join(output_split[1:]) + "/" - if not self.config.get("path_prefix", "").endswith("/"): - self.config["path_prefix"] = self.config.get("path_prefix", "") + "/" - - self.config["output_dir"] = self.config["output_dir"].lstrip("/") - self.config["path_prefix"] = self.config["path_prefix"].lstrip("/") + # self.config = {**DEFUALT_CONFIG, **standard_config.load("markata")} + # if isinstance(self.config["glob_patterns"], str): + # self.config["glob_patterns"] = self.config["glob_patterns"].split(",") + # elif isinstance(self.config["glob_patterns"], list): + # self.config["glob_patterns"] = list(self.config["glob_patterns"]) + # else: + # raise TypeError("glob_patterns must be list or str") + # self.glob_patterns = self.config["glob_patterns"] + + # self.hooks = self.config["hooks"] + + # if "disabled_hooks" not in self.config: + # self.disabled_hooks = [""] + # if isinstance(self.config["disabled_hooks"], str): + # self.disabled_hooks = self.config["disabled_hooks"].split(",") + # if isinstance(self.config["disabled_hooks"], list): + # self.disabled_hooks = self.config["disabled_hooks"] + + # if not self.config.get("output_dir", "markout").endswith( + # self.config.get("path_prefix", "") + # ): + # self.config["output_dir"] = ( + # self.config.get("output_dir", "markout") + + # "/" + + # self.config.get("path_prefix", "").rstrip("/") + # ) + # if ( + # len((output_split := self.config.get("output_dir", "markout").split("/"))) > + # 1 + # ): + # if "path_prefix" not in self.config.keys(): + # self.config["path_prefix"] = "/".join(output_split[1:]) + "/" + # if not self.config.get("path_prefix", "").endswith("/"): + # self.config["path_prefix"] = self.config.get("path_prefix", "") + "/" + + # self.config["output_dir"] = self.config["output_dir"].lstrip("/") + # self.config["path_prefix"] = self.config["path_prefix"].lstrip("/") try: - default_index = self.hooks.index("default") + default_index = self.hooks_conf.hooks.index("default") hooks = [ - *self.hooks[:default_index], + *self.hooks_conf.hooks[:default_index], *DEFAULT_HOOKS, - *self.hooks[default_index + 1 :], + *self.hooks_conf.hooks[default_index + 1 :], + ] + self.config.hooks = [ + hook for hook in hooks if hook not in self.config.disabled_hooks ] - self.hooks = [hook for hook in hooks if hook not in self.disabled_hooks] except ValueError: # 'default' is not in hooks , do not replace with default_hooks pass @@ -284,15 +309,7 @@ def make_hash(self, *keys: str) -> str: return hashlib.md5("".join(str_keys).encode("utf-8")).hexdigest() @property - def phase(self) -> str: - return self._phase - - @phase.setter - def phase(self, value: str) -> None: - self._phase = value - - @property - def content_dir_hash(self) -> str: + def content_dir_hash(self: "Markata") -> str: hashes = [ dirhash(dir) for dir in self.content_directories @@ -301,72 +318,95 @@ def content_dir_hash(self) -> str: return self.make_hash(*hashes) @property - def console(self) -> Console: + def console(self: "Markata") -> Console: try: return self._console except AttributeError: self._console = Console() return self._console - def describe(self) -> dict[str, str]: - return {"version": __version__, "phase": self.phase} + def describe(self: "Markata") -> dict[str, str]: + return {"version": __version__} - def _to_dict(self) -> dict[str, Iterable]: + def _to_dict(self: "Markata") -> dict[str, Iterable]: return {"config": self.config, "articles": [a.to_dict() for a in self.articles]} - def to_dict(self) -> dict: + def to_dict(self: "Markata") -> dict: return self._to_dict() - def to_json(self) -> str: + def to_json(self: "Markata") -> str: import json return json.dumps(self.to_dict(), indent=4, sort_keys=True, default=str) - def _register_hooks(self) -> None: - for hook in self.hooks: + def _register_hooks(self: "Markata") -> None: + sys.path.append(os.getcwd()) + for hook in self.hooks_conf.hooks: try: # module style plugins plugin = importlib.import_module(hook) except ModuleNotFoundError as e: # class style plugins if "." in hook: - mod = importlib.import_module(".".join(hook.split(".")[:-1])) - plugin = getattr(mod, hook.split(".")[-1]) + try: + mod = importlib.import_module(".".join(hook.split(".")[:-1])) + plugin = getattr(mod, hook.split(".")[-1]) + except ModuleNotFoundError as e: + raise ModuleNotFoundError( + f"module {hook} not found\n{sys.path}" + ) from e else: raise e self._pm.register(plugin) - def __iter__(self, description: str = "working...") -> Iterable[frontmatter.Post]: - articles: Iterable[frontmatter.Post] = track( - self.articles, description=description, transient=True, console=self.console + def __iter__( + self: "Markata", description: str = "working..." + ) -> Iterable["Markata.Post"]: + articles: Iterable[Markata.Post] = track( + self.articles, + description=description, + transient=True, + console=self.console, ) return articles - def iter_articles(self, description: str) -> Iterable[frontmatter.Post]: - articles: Iterable[frontmatter.Post] = track( - self.articles, description=description, transient=True, console=self.console + def iter_articles(self: "Markata", description: str) -> Iterable[Markata.Post]: + articles: Iterable[Markata.Post] = track( + self.articles, + description=description, + transient=True, + console=self.console, ) return articles - def teardown(self) -> Markata: + def teardown(self: "Markata") -> Markata: """give special access to the teardown lifecycle method""" self._pm.hook.teardown(markata=self) return self - def run(self, lifecycle: LifeCycle = None) -> Markata: + def run(self: "Markata", lifecycle: LifeCycle = None) -> Markata: if lifecycle is None: - lifecycle = getattr(LifeCycle, max(LifeCycle._member_map_)) + lifecycle = max(LifeCycle._member_map_.values()) if isinstance(lifecycle, str): lifecycle = LifeCycle[lifecycle] - stages_to_run = [m for m in LifeCycle._member_map_ if LifeCycle[m] <= lifecycle] + stages_to_run = [ + m + for m in LifeCycle._member_map_ + if (LifeCycle[m] <= lifecycle) and (m not in self.stages_ran) + ] + + if not stages_to_run: + self.console.log(f"{lifecycle.name} already ran") + return self self.console.log(f"running {stages_to_run}") for stage in stages_to_run: self.console.log(f"{stage} running") getattr(self._pm.hook, stage)(markata=self) + self.stages_ran.add(stage) self.console.log(f"{stage} complete") with self.cache as cache: @@ -374,7 +414,7 @@ def run(self, lifecycle: LifeCycle = None) -> Markata: if hits + misses > 0: self.console.log( - f"lifetime cache hit rate {round(hits/ (hits + misses)*100, 2)}%" + f"lifetime cache hit rate {round(hits/ (hits + misses)*100, 2)}%", ) if misses > 0: @@ -385,7 +425,7 @@ def run(self, lifecycle: LifeCycle = None) -> Markata: if hits + misses > 0: self.console.log( - f"run cache hit rate {round(hits/ (hits + misses)*100, 2)}%" + f"run cache hit rate {round(hits/ (hits + misses)*100, 2)}%", ) if misses > 0: @@ -393,8 +433,8 @@ def run(self, lifecycle: LifeCycle = None) -> Markata: return self - def filter(self, filter: str) -> List: - def evalr(a: Post) -> Any: + def filter(self: "Markata", filter: str) -> list: + def evalr(a: Markata.Post) -> Any: try: return eval( filter, @@ -411,14 +451,14 @@ def evalr(a: Post) -> Any: return [a for a in self.articles if evalr(a)] def map( - self, + self: "Markata", func: str = "title", filter: str = "True", sort: str = "True", reverse: bool = True, - *args: Tuple, - **kwargs: Dict, - ) -> List: + *args: tuple, + **kwargs: dict, + ) -> list: import copy def try_sort(a: Any) -> int: @@ -442,8 +482,9 @@ def try_sort(a: Any) -> int: try: return int( datetime.datetime.combine( - value, datetime.datetime.min.time() - ).timestamp() + value, + datetime.datetime.min.time(), + ).timestamp(), ) except Exception: try: @@ -475,7 +516,8 @@ def try_sort(a: Any) -> int: variable = str(e).split("'")[1] missing_in_posts = self.map( - "path", filter=f'"{variable}" not in post.keys()' + "path", + filter=f'"{variable}" not in post.keys()', ) message = ( f"variable: '{variable}' is missing in {len(missing_in_posts)} posts" @@ -483,7 +525,7 @@ def try_sort(a: Any) -> int: if len(missing_in_posts) > 10: message += ( f"\nfirst 10 paths to posts missing {variable}" - f"[{','.join(missing_in_posts)}..." + f"[{','.join([str(p) for p in missing_in_posts[:10]])}..." ) else: message += f"\npaths to posts missing {variable} {missing_in_posts}" @@ -496,3 +538,4 @@ def try_sort(a: Any) -> int: def load_ipython_extension(ipython): ipython.user_ns["m"] = Markata() ipython.user_ns["markata"] = ipython.user_ns["m"] + ipython.user_ns["markata"] = ipython.user_ns["m"] diff --git a/markata/cli/__main__.py b/markata/cli/__main__.py index 2bbe245a..150e2a3a 100644 --- a/markata/cli/__main__.py +++ b/markata/cli/__main__.py @@ -6,7 +6,7 @@ class MarkataWidget(Widget): - def __init__(self, markata: Markata, widget: str = "server"): + def __init__(self, markata: Markata, widget: str = "server") -> None: super().__init__(widget) self.m = markata self.widget = widget diff --git a/markata/cli/cli.py b/markata/cli/cli.py index 1ce84a0f..66087ac6 100644 --- a/markata/cli/cli.py +++ b/markata/cli/cli.py @@ -40,7 +40,7 @@ def version_callback(value: bool) -> None: from markata import __version__ typer.echo(f"Markata CLI Version: {__version__}") - raise typer.Exit() + raise typer.Exit def json_callback(value: bool) -> None: @@ -48,7 +48,7 @@ def json_callback(value: bool) -> None: from markata import Markata typer.echo(Markata().to_json()) - raise typer.Exit() + raise typer.Exit app = typer.Typer( @@ -60,10 +60,16 @@ def json_callback(value: bool) -> None: @app.callback() def main( version: bool = typer.Option( - None, "--version", callback=version_callback, is_eager=True + None, + "--version", + callback=version_callback, + is_eager=True, ), to_json: bool = typer.Option( - None, "--to-json", callback=json_callback, is_eager=True + None, + "--to-json", + callback=json_callback, + is_eager=True, ), ) -> None: # Do other global stuff, handle other global options here diff --git a/markata/cli/plugins.py b/markata/cli/plugins.py index 4207ada2..446ade39 100644 --- a/markata/cli/plugins.py +++ b/markata/cli/plugins.py @@ -11,7 +11,7 @@ class Plugins: - def __init__(self, markata: "Markata"): + def __init__(self, markata: "Markata") -> None: self.m = markata def __rich__(self) -> Panel: @@ -26,11 +26,14 @@ def __rich__(self) -> Panel: ".".join(plugin.__name__.split(".")[:-1]), ".[/]", plugin.__name__.split(".")[-1], - ] - ) + ], + ), ) return Panel( - grid, title=f"plugins {num_plugins}", border_style="gold1", expand=False + grid, + title=f"plugins {num_plugins}", + border_style="gold1", + expand=False, ) diff --git a/markata/cli/server.py b/markata/cli/server.py index 900f264c..065d1a50 100644 --- a/markata/cli/server.py +++ b/markata/cli/server.py @@ -1,12 +1,16 @@ import atexit -from pathlib import Path import time -from typing import Union +from pathlib import Path +from typing import TYPE_CHECKING, Union +import typer from rich.panel import Panel from markata.hookspec import hook_impl, register_attr +if TYPE_CHECKING: + from markata import Markata + def find_port(port: int = 8000) -> int: """Find a port not in ues starting at given port""" @@ -15,17 +19,17 @@ def find_port(port: int = 8000) -> int: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: if s.connect_ex(("localhost", port)) == 0: return find_port(port=port + 1) - else: - return port + return port class Server: def __init__( - self, + self: "Server", + *, auto_restart: bool = True, directory: Union[str, "Path"] = None, port: int = 8000, - ): + ) -> None: if directory is None: from markata import Markata @@ -88,7 +92,10 @@ def __rich__(self) -> Panel: else: return Panel( - "[red]server died", title=self.title, border_style="red", expand=True + "[red]server died", + title=self.title, + border_style="red", + expand=True, ) @@ -107,13 +114,27 @@ def get_server(self): Markata.server = property(get_server) -if __name__ == "__main__": +def run_server() -> None: from rich.live import Live - from markata import Markata - from .cli import run_until_keyboard_interrupt - m = Markata() with Live(Server(), refresh_per_second=1, screen=True): run_until_keyboard_interrupt() + + +@hook_impl() +def cli(app: typer.Typer, markata: "Markata") -> None: + server_app = typer.Typer() + app.add_typer(server_app) + + @server_app.callback(invoke_without_command=True) + def serve(): + """ + Serve the site locally. + """ + run_server() + + +if __name__ == "__main__": + run_server() diff --git a/markata/cli/summary.py b/markata/cli/summary.py index 5198c844..57b00a89 100644 --- a/markata/cli/summary.py +++ b/markata/cli/summary.py @@ -41,15 +41,18 @@ of posts. ``` -[markata.summary.filter_count.drafts] +[[markata.summary.filter_count]] +name='drafts' filter="published == 'False'" color='red' -[markata.summary.filter_count.articles] +[[markata.summary.filter_count]] +name='articles' color='dark_orange' -[markata.summary.filter_count.py_modules] -filter='"plugin" not in slug and "docs" not in path' +[[markata.summary.filter_count]] +name='py_modules' +filter='"plugin" not in slug and "docs" not in str(path)' color="yellow1" [markata.summary.filter_count.published] @@ -57,11 +60,11 @@ color='green1' [markata.summary.filter_count.plugins] -filter='"plugin" in slug and "docs" not in path' +filter='"plugin" in slug and "docs" not in str(path)' color="blue" [markata.summary.filter_count.docs] -filter="'docs' in path" +filter="'docs' in str(path)" color='purple' ``` @@ -78,11 +81,13 @@ ``` """ from collections import Counter -from typing import TYPE_CHECKING, Union +from typing import List, TYPE_CHECKING, Union from more_itertools import flatten +import pydantic from rich.panel import Panel from rich.table import Table +import typer from markata.hookspec import hook_impl, register_attr @@ -90,6 +95,29 @@ from markata import Markata +class FilterCount(pydantic.BaseModel): + name: str + filter: str = "True" + color: str = "white" + + +class SummaryConfig(pydantic.BaseModel): + grid_attr: List[str] = ["tags", "series"] + filter_count: List[FilterCount] = FilterCount( + name="drafts", filter="published == 'False'", color="red" + ) + + +class Config(pydantic.BaseModel): + summary: SummaryConfig = SummaryConfig() + + +@hook_impl() +@register_attr("config_models") +def config_model(markata: "Markata") -> None: + markata.config_models.append(Config) + + class Summary: def __init__(self, m: "Markata", simple: bool = False) -> None: self.m = m @@ -99,23 +127,22 @@ def get_grid(self) -> None: "create a rich grid to display the summary" self.grid = Table.grid(expand=True) - for name, config in ( - self.m.config.get("summary", {}) - .get("filter_count", {"aricles": {"color": "purple", "filter": "True"}}) - .items() - ): - self.filter_count(name, **config) + for filter_count in self.m.config.summary.filter_count: + self.filter_count(filter_count) - for attr in self.m.config.get("summary", {}).get("grid_attr", []): + for attr in self.m.config.summary.grid_attr: self.grid_attr(attr) return self.grid def filter_count( - self, title: str, filter: str = "True", color: str = "white" + self, + fc: FilterCount, ) -> None: "add a row in the grid for the number of items in a filter config" - self.grid.add_row(f"[{color}]{len(self.m.map(filter=filter))}[/] {title}") + self.grid.add_row( + f"[{fc.color}]{len(self.m.map(filter=fc.filter))}[/] {fc.name}" + ) def grid_attr(self, attr: str) -> None: "add attribute the the object grid" @@ -123,10 +150,10 @@ def grid_attr(self, attr: str) -> None: flatten( [ tags if isinstance(tags, list) else [tags] - for a in self.m.articles + for a in self.m.posts if (tags := a.get(attr, None)) is not None - ] - ) + ], + ), ) if len(posts) > 0: self.grid.add_row() @@ -135,15 +162,16 @@ def grid_attr(self, attr: str) -> None: self.grid.add_row(f'{count} {" "*(3-len(str(count)))} {post}') def __rich__(self) -> Union[Panel, Table]: - try: - grid = self.get_grid() - except Exception: - grid = "Error" + grid = self.get_grid() + if self.simple: return grid else: return Panel( - grid, title="[gold1]summary[/]", border_style="magenta", expand=False + grid, + title="[gold1]summary[/]", + border_style="magenta", + expand=False, ) @@ -162,6 +190,24 @@ def get_summary(self): Markata.summary = property(get_summary) +@hook_impl() +def cli(app: typer.Typer, markata: "Markata") -> None: + """ + Markata hook to implement base cli commands. + """ + summary_app = typer.Typer() + app.add_typer(summary_app, name="summary") + + @summary_app.callback(invoke_without_command=True) + def summary(): + "show the application summary" + from rich import print + + markata.console.quiet = True + + print(Summary(markata, simple=True)) + + if __name__ == "__main__": from rich import print diff --git a/markata/hookspec.py b/markata/hookspec.py index abc84267..8942f6fc 100644 --- a/markata/hookspec.py +++ b/markata/hookspec.py @@ -57,7 +57,7 @@ def decorator_register( "func": func, "funcname": func.__code__.co_name, "lifecycle": getattr(LifeCycle, func.__code__.co_name), - } + }, ) @functools.wraps(func) diff --git a/markata/lifecycle.py b/markata/lifecycle.py index b1254e47..2185a8b7 100644 --- a/markata/lifecycle.py +++ b/markata/lifecycle.py @@ -20,17 +20,25 @@ class LifeCycle(Enum): """ LifeCycle currently supports the following steps. + * configure - load and fix configuration * glob - find files * load - load files + * validate_posts * pre_render - clean up files/metadata before render * render - render content * post_render - clean up rendered content * save - store results to disk + * teardown - runs on exit """ + config_model = auto() + post_model = auto() + create_models = auto() + load_config = auto() configure = auto() + validate_config = auto() glob = auto() load = auto() pre_render = auto() diff --git a/markata/plugins/auto_description.py b/markata/plugins/auto_description.py index ad1c4000..6fe4a8f1 100644 --- a/markata/plugins/auto_description.py +++ b/markata/plugins/auto_description.py @@ -52,7 +52,8 @@ """ from itertools import compress from pathlib import Path -from typing import TYPE_CHECKING, Any, Dict +from typing import Any, Dict, TYPE_CHECKING +import html import commonmark @@ -87,6 +88,7 @@ def get_description(article: "Post") -> str: # deduplicate paragraph_nodes based on unique source position unique_paragraph_nodes = list(compress(paragraph_nodes, unique_mask)) paragraphs = " ".join([p.first_child.literal for p in unique_paragraph_nodes]) + paragraphs = html.escape(paragraphs) return paragraphs @@ -108,10 +110,10 @@ def set_description( config, ) - description_from_cache = cache.get(key) + description_from_cache = markata.precache.get(key) if description_from_cache is None: description = get_description(article)[:max_description] - markata.cache.add(key, description, expire=config["cache_expire"]) + markata.cache.add(key, description, expire=markata.config.default_cache_expire) else: description = description_from_cache @@ -150,7 +152,7 @@ def try_config_get(key: str) -> Any: value for description_key in config if (value := try_config_get(description_key)) - ] + ], ) with markata.cache as cache: diff --git a/markata/plugins/auto_title.py b/markata/plugins/auto_title.py index 7b54534b..d364e1a8 100644 --- a/markata/plugins/auto_title.py +++ b/markata/plugins/auto_title.py @@ -4,7 +4,7 @@ @hook_impl -@register_attr("articles") +@register_attr("articles", "posts") def pre_render(markata) -> None: for article in markata.filter('title==""'): article["title"] = ( diff --git a/markata/plugins/base_cli.py b/markata/plugins/base_cli.py index eefcba5e..1c26ca35 100644 --- a/markata/plugins/base_cli.py +++ b/markata/plugins/base_cli.py @@ -7,7 +7,7 @@ [`list`](https://markata.dev/markata/plugins/base_cli/#list-function) commands as part of the main markata cli. -## Building Your Site with the Cli +# Building Your Site with the Cli Your Markata Site can be build completely from the command line. @@ -22,7 +22,7 @@ [`build`](https://markata.dev/markata/plugins/base_cli/#build-function) section for more examples. -## Listing your articles +# Listing your articles Markata list is a tool to help list out artile attributes right to your terminal. This is very helpful to find articles on larger sites, or @@ -36,7 +36,7 @@ [`list`](https://markata.dev/markata/plugins/base_cli/#list-function) section for more examples. -## Creating "new" things with the cli +# Creating "new" things with the cli The `new` cli is built on copier templates, and allows you to build a new blog from a starter repo, make new posts, and new plugins. Before you start dumping @@ -83,7 +83,9 @@ import shutil import sys import traceback -from typing import Callable, Optional, TYPE_CHECKING +import toml +import json +from typing import Callable, Literal, Optional, TYPE_CHECKING import warnings from rich import print as rich_print @@ -126,7 +128,9 @@ def cli(app: typer.Typer, markata: "Markata") -> None: """ plugins_app = typer.Typer() + config_app = typer.Typer() app.add_typer(plugins_app) + app.add_typer(config_app) @app.command() def tui(ctx: typer.Context) -> None: @@ -146,9 +150,54 @@ def tui(ctx: typer.Context) -> None: def plugins(): "create new things from templates" - @plugins_app.command() - def show() -> None: - rich_print(markata.plugins) + @config_app.callback() + def config(): + "configuration management" + + @config_app.command() + def show( + verbose: bool = typer.Option( + False, + "--verbose", + "-v", + ), + ) -> None: + if verbose: + markata.console.quiet = False + else: + markata.console.quiet = True + rich_print(markata.config) + + @config_app.command() + def generate( + verbose: bool = typer.Option( + False, + "--verbose", + "-v", + ), + ) -> None: + if verbose: + markata.console.quiet = False + else: + markata.console.quiet = True + + rich_print(toml.dumps(json.loads(markata.config.json()))) + + @config_app.command() + def get(key: str) -> None: + keys = key.split(".") + markata.console.quiet = True + keys_processed = "" + value = markata.config + na = Literal["na"] + for key in keys: + value = getattr(value, key, na) + keys_processed = f"{keys_processed}.{key}".strip(".") + if value is na: + rich_print(f"{keys_processed} not found") + sys.exit(1) + + rich_print(value) new_app = typer.Typer() app.add_typer(new_app) @@ -160,8 +209,9 @@ def new(): @new_app.command() def blog( directory: Path = typer.Argument( - ..., help="The directory to create the blog in." - ) + ..., + help="The directory to create the blog in.", + ), ) -> None: """ Create a new blog from using the template from @@ -172,7 +222,8 @@ def blog( typer.echo(f"creating a new project in {directory.absolute()}") url = markata.config.get("starters", {}).get( - "blog", "git+https://github.com/WaylonWalker/markata-blog-starter" + "blog", + "git+https://github.com/WaylonWalker/markata-blog-starter", ) run_copy(url, directory) @@ -188,7 +239,8 @@ def post() -> None: typer.echo(f"creating a new post in {Path().absolute()}/posts") url = markata.config.get("starters", {}).get( - "post", "git+https://github.com/WaylonWalker/markata-post-template" + "post", + "git+https://github.com/WaylonWalker/markata-post-template", ) run_copy(url, Path(".")) @@ -202,10 +254,11 @@ def plugin() -> None: typer.echo( f"creating a new plugin in {Path().absolute()}" - f"/