autosh 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

autosh/md/printer.py

@@ -1,301 +0,0 @@
-import os
-from typing import AsyncGenerator, Literal
-import unicodedata
-
-from autosh.md.state import Color, State
-from autosh.md.stream import TextStream
-
-
-class StreamedMarkdownPrinter:
-    def __init__(self, gen: AsyncGenerator[str, None]):
-        self.stream = TextStream(gen)
-        self.state = State()
-
-    def emit(self, s: str):
-        self.state.emit(s)
-
-    def peek(self):
-        return self.stream.peek()
-
-    async def consume(self, n: int = 1):
-        return await self.stream.consume(n)
-
-    async def check(self, s: str, eof: bool | None = None) -> bool:
-        return await self.stream.check(s, eof)
-
-    async def parse_inline(self, consume_trailing_newline: bool = True):
-        from autosh.md.inline_text import InlineTextPrinter
-
-        itp = InlineTextPrinter(self)
-        await itp.parse_inline(consume_trailing_newline)
-
-    async def parse_heading(self):
-        hashes = 0
-        while True:
-            c = await self.consume()
-            if c == "#":
-                hashes += 1
-            else:
-                break
-        match hashes:
-            case 1:
-                with self.state.style(bold=True, bg=Color.MAGENTA):
-                    with self.state.style(dim=True):
-                        self.emit("#" * hashes + " ")
-                    await self.parse_inline(consume_trailing_newline=False)
-            case 2:
-                with self.state.style(bold=True, underline=True, color=Color.MAGENTA):
-                    with self.state.style(dim=True):
-                        self.emit("#" * hashes + " ")
-                    await self.parse_inline(consume_trailing_newline=False)
-            case 3:
-                with self.state.style(bold=True, color=Color.MAGENTA):
-                    with self.state.style(dim=True):
-                        self.emit("#" * hashes + " ")
-                    await self.parse_inline(consume_trailing_newline=False)
-            case 4:
-                with self.state.style(bold=True, italic=True, color=Color.MAGENTA):
-                    with self.state.style(dim=True):
-                        self.emit("#" * hashes + " ")
-                    await self.parse_inline(consume_trailing_newline=False)
-            case _:
-                with self.state.style(bold=True):
-                    with self.state.style(dim=True):
-                        self.emit("#" * hashes + " ")
-                    await self.parse_inline(consume_trailing_newline=False)
-        await self.consume()  # consume the newline
-        self.emit("\n")
-
-    async def parse_paragraph(self):
-        while True:
-            await self.parse_inline()
-            if (
-                self.peek() != "\n"
-                and not await self.stream.non_paragraph_block_start()
-            ):
-                if self.peek() == "\n":
-                    await self.consume()
-                break
-            else:
-                break
-
-    async def parse_multiline_code(self):
-        with self.state.style(dim=True):
-            self.emit("```")
-            await self.consume(3)
-            while not await self.check("\n```"):
-                c = await self.consume()
-                if c is None:
-                    self.emit("\n")
-                    return
-                self.emit(c)
-            self.emit("\n```\n")
-            await self.consume(4)
-
-    async def parse_list(self, ordered: bool):
-        indents = [0]
-        counter = [1]
-        # first item
-        if ordered:
-            self.emit("1. ")
-            await self.consume()
-        else:
-            self.emit("• ")
-        await self.consume()
-        await self.parse_inline()
-        while True:
-            indent = 0
-            while self.peek() in [" ", "\t", "\n"]:
-                if self.peek() in [" ", "\t"]:
-                    indent += 1
-                if self.peek() == "\n":
-                    indent = 0
-                await self.consume()
-            if self.peek() is None:
-                return
-            if ordered and not await self.stream.ordered_list_label():
-                return
-            if not ordered and not await self.stream.unordered_list_label():
-                return
-            if not ordered:
-                await self.consume()
-            else:
-                while self.peek() is not None and self.peek() != ".":
-                    await self.consume()
-                await self.consume()
-
-            depth = None
-            for i in range(len(indents) - 1):
-                if indents[i] <= indent and indents[i + 1] > indent:
-                    depth = i
-                    break
-            if depth is None and indents[-1] + 2 <= indent:
-                # indent one more level
-                indents.append(indent)
-                depth = len(indents) - 1
-                counter.append(1)
-            elif depth is None:
-                # same as last level
-                depth = len(indents) - 1
-                counter[depth] += 1
-            else:
-                # dedent
-                indents = indents[: depth + 1]
-                counter = counter[: depth + 1]
-                counter[depth] += 1
-            if not ordered:
-                self.emit("  " * depth + "• ")
-            else:
-                self.emit("   " * depth + str(counter[depth]) + ". ")
-            await self.parse_inline()
-
-    async def parse_blockquote(self):
-        from autosh.md.inline_text import InlineTextPrinter
-
-        while True:
-            while self.peek() in [" ", "\t"]:
-                await self.consume()
-            if self.peek() != ">":
-                break
-            await self.consume()
-            with self.state.style(bold=True, dim=True):
-                self.emit(">")
-            with self.state.style(dim=True):
-                itp = InlineTextPrinter(self)
-                await itp.parse_inline_unformatted()
-            if self.peek() == "\n":
-                self.emit("\n")
-                await self.consume()
-
-    async def parse_table(self):
-        def str_size(s: str) -> int:
-            size = 0
-            for c in s:
-                match unicodedata.east_asian_width(c):
-                    case "F" | "W":
-                        size += 2
-                    case _:
-                        size += 1
-            return size
-
-        rows: list[list[str]] = []
-        while True:
-            if self.peek() != "|":
-                break
-            s = "|"
-            await self.consume()
-            while self.peek() not in ["\n", None]:
-                s += self.peek() or ""
-                await self.consume()
-            if self.peek() == "\n":
-                await self.consume()
-            s = s.strip("|")
-            rows.append([c.strip() for c in s.split("|")])
-        # not enough rows
-        if len(rows) < 2:
-            self.emit("| " + " | ".join(rows[0]) + " |\n")
-        # do some simple formatting
-        cols = len(rows[0])
-        col_widths = [0] * cols
-        aligns: list[Literal["left", "right", "center"]] = ["left"] * cols
-        for i, row in enumerate(rows):
-            if i == 1:
-                # check for alignment
-                for j, c in enumerate(row):
-                    if c.startswith(":") and c.endswith(":"):
-                        aligns[j] = "center"
-                    elif c.startswith(":"):
-                        aligns[j] = "left"
-                    elif c.endswith(":"):
-                        aligns[j] = "right"
-                continue
-            for j, c in enumerate(row):
-                col_widths[j] = max(col_widths[j], str_size(c))
-        # print top border
-        with self.state.style(dim=True):
-            for j, c in enumerate(rows[0]):
-                self.emit("┌" if j == 0 else "┬")
-                self.emit("─" * (col_widths[j] + 2))
-            self.emit("┐\n")
-        # print the table
-        for i, row in enumerate(rows):
-            for j, c in enumerate(row):
-                with self.state.style(dim=True):
-                    self.emit("│" if i != 1 else ("├" if j == 0 else "┼"))
-                if i == 1:
-                    text = "─" * (col_widths[j] + 2)
-                else:
-                    s = str_size(c)
-                    align = aligns[j] if i != 0 else "center"
-                    match align:
-                        case "left":
-                            text = c + " " * (col_widths[j] - s)
-                        case "right":
-                            text = " " * (col_widths[j] - s) + c
-                        case "center":
-                            padding = col_widths[j] - s
-                            text = " " * (padding // 2) + c
-                            text += " " * (padding - padding // 2)
-                    text = f" {text} "
-                with self.state.style(dim=i == 1):
-                    self.emit(text)
-            with self.state.style(dim=True):
-                self.emit("│\n" if i != 1 else "┤\n")
-        # print bottom border
-        with self.state.style(dim=True):
-            for j, c in enumerate(rows[0]):
-                self.emit("└" if j == 0 else "┴")
-                self.emit("─" * (col_widths[j] + 2))
-            self.emit("┘\n")
-
-    async def parse_doc(self):
-        await self.stream.init()
-        start = True
-        while True:
-            # Remove leading spaces and empty lines
-            indent = 0
-            while self.peek() in [" ", "\t", "\n"]:
-                if self.peek() in [" ", "\t"]:
-                    indent += 1
-                if self.peek() == "\n":
-                    indent = 0
-                await self.consume()
-            if self.peek() is None:
-                break
-            if not start:
-                self.emit("\n")
-            start = False
-            match c := self.peek():
-                case None:
-                    break
-                # Heading
-                case "#":
-                    await self.parse_heading()
-                # Code
-                case "`" if await self.check("```"):
-                    await self.parse_multiline_code()
-                # Separator
-                case _ if await self.check("---"):
-                    await self.consume(3)
-                    width = min(os.get_terminal_size().columns, 80)
-                    with self.state.style(dim=True):
-                        self.emit("─" * width)
-                # Unordered list
-                case _ if await self.stream.unordered_list_label():
-                    await self.parse_list(False)
-                # Ordered list
-                case _ if await self.stream.ordered_list_label():
-                    await self.parse_list(True)
-                # Blockquote
-                case ">":
-                    await self.parse_blockquote()
-                # Table
-                case "|":
-                    await self.parse_table()
-                # Normal paragraph
-                case _:
-                    await self.parse_paragraph()
-        self.emit("\x1b[0m")  # Reset all
-
-    def __await__(self):
-        return self.parse_doc().__await__()

autosh/md/state.py

@@ -1,136 +0,0 @@
-from dataclasses import dataclass
-from contextlib import contextmanager
-from enum import Enum
-
-HIGHLIGHT_COLOR_START = "35"
-HIGHLIGHT_COLOR_END = "0"
-ESC = "\x1b"
-
-
-class Color(Enum):
-    BLACK = 30, 40
-    RED = 31, 41
-    GREEN = 32, 42
-    YELLOW = 33, 43
-    BLUE = 34, 44
-    MAGENTA = 35, 45
-    CYAN = 36, 46
-    WHITE = 37, 47
-
-    BRIGHT_BLACK = 90, 100
-    BRIGHT_RED = 91, 101
-    BRIGHT_GREEN = 92, 102
-    BRIGHT_YELLOW = 93, 103
-    BRIGHT_BLUE = 94, 104
-    BRIGHT_MAGENTA = 95, 105
-    BRIGHT_CYAN = 96, 106
-    BRIGHT_WHITE = 97, 107
-
-    def __init__(self, foreground: int, background: int):
-        self.foreground = foreground
-        self.background = background
-
-
-@dataclass
-class State:
-    is_bold: bool = False
-    is_dim: bool = False
-    is_italic: bool = False
-    is_underline: bool = False
-    is_strike: bool = False
-    foreground_color: Color | None = None
-    background_color: Color | None = None
-
-    def emit(self, text: str):
-        print(text, end="", flush=True)
-
-    def _enter_scope(
-        self,
-        bold: bool | None = None,
-        dim: bool | None = None,
-        italic: bool | None = None,
-        underline: bool | None = None,
-        strike: bool | None = None,
-        color: Color | None = None,
-        bg: Color | None = None,
-    ) -> "State":
-        old_state = State(
-            is_bold=self.is_bold,
-            is_dim=self.is_dim,
-            is_italic=self.is_italic,
-            is_underline=self.is_underline,
-            is_strike=self.is_strike,
-            foreground_color=self.foreground_color,
-            background_color=self.background_color,
-        )
-        if bold is not None:
-            self.is_bold = bold
-        if dim is not None:
-            self.is_dim = dim
-        if italic is not None:
-            self.is_italic = italic
-        if underline is not None:
-            self.is_underline = underline
-        if strike is not None:
-            self.is_strike = strike
-        if color is not None:
-            self.foreground_color = color
-        if bg is not None:
-            self.background_color = bg
-        self.__apply_all()
-        return old_state
-
-    def _exit_scope(self, old_state: "State"):
-        self.is_bold = old_state.is_bold
-        self.is_dim = old_state.is_dim
-        self.is_italic = old_state.is_italic
-        self.is_underline = old_state.is_underline
-        self.is_strike = old_state.is_strike
-        self.foreground_color = old_state.foreground_color
-        self.background_color = old_state.background_color
-        self.__apply_all()
-
-    @contextmanager
-    def style(
-        self,
-        bold: bool | None = None,
-        dim: bool | None = None,
-        italic: bool | None = None,
-        underline: bool | None = None,
-        strike: bool | None = None,
-        color: Color | None = None,
-        bg: Color | None = None,
-    ):
-        old_state = self._enter_scope(
-            bold=bold,
-            dim=dim,
-            italic=italic,
-            underline=underline,
-            strike=strike,
-            color=color,
-            bg=bg,
-        )
-        yield
-        self._exit_scope(old_state)
-
-    def __apply_all(self):
-        self.emit(f"{ESC}[0m")
-        codes = []
-        if self.is_bold:
-            codes.append(1)
-        if self.is_dim:
-            codes.append(2)
-        if self.is_italic:
-            codes.append(3)
-        if self.is_underline:
-            codes.append(4)
-        if self.is_strike:
-            codes.append(9)
-        if self.foreground_color:
-            codes.append(self.foreground_color.foreground)
-        if self.background_color:
-            codes.append(self.background_color.background)
-
-        codes = ";".join(map(str, codes))
-        if len(codes) > 0:
-            self.emit(f"{ESC}[{codes}m")

autosh/md/stream.py

@@ -1,107 +0,0 @@
-from typing import AsyncGenerator
-
-
-class TextStream:
-    def __init__(self, gen: AsyncGenerator[str, None]):
-        self.__stream = gen
-        self.__buf: str = ""
-        self.__eof = False
-
-    async def init(self):
-        try:
-            self.__buf = await anext(self.__stream)
-        except StopAsyncIteration:
-            self.__eof = True
-
-    async def __ensure_length(self, n: int):
-        while (not self.__eof) and len(self.__buf) < n:
-            try:
-                self.__buf += await anext(self.__stream)
-            except StopAsyncIteration:
-                self.__eof = True
-
-    def peek(self):
-        c = self.__buf[0] if len(self.__buf) > 0 else None
-        return c
-
-    async def check(self, s: str, eof: bool | None = None) -> bool:
-        if len(s) == 0:
-            return True
-        await self.__ensure_length(len(s) + 1)
-        if len(self.__buf) < len(s):
-            return False
-        matched = self.__buf[0 : len(s)] == s
-        if matched:
-            if eof is not None:
-                if eof:
-                    # return false if there is more data
-                    if len(self.__buf) > len(s):
-                        return False
-                else:
-                    # return false if there is no more data
-                    if len(self.__buf) == len(s):
-                        return False
-        return matched
-
-    async def consume(self, n: int = 1):
-        await self.__ensure_length(n)
-        if len(self.__buf) < n:
-            raise ValueError("Not enough data to consume")
-        s = self.__buf[:n]
-        self.__buf = self.__buf[n:]
-        await self.__ensure_length(1)
-        return s
-
-    async def unordered_list_label(self) -> bool:
-        if self.__eof:
-            return False
-        await self.__ensure_length(2)
-        buf = self.__buf
-        if len(buf) < 2:
-            return False
-        if buf[0] in ["-", "+", "*"] and buf[1] == " ":
-            return True
-        return False
-
-    async def ordered_list_label(self) -> bool:
-        if self.__eof:
-            return False
-        await self.__ensure_length(5)
-        buf = self.__buf
-        # \d+\.
-        if len(buf) == 0:
-            return False
-        if not buf[0].isnumeric():
-            return False
-        has_dot = False
-        for i in range(1, 5):
-            if i >= len(buf):
-                return False
-            c = buf[i]
-            if c == ".":
-                if has_dot:
-                    return False
-                has_dot = True
-                continue
-            if c == " ":
-                if has_dot:
-                    return True
-                return False
-            if c.isnumeric():
-                continue
-        return False
-
-    async def non_paragraph_block_start(self):
-        await self.__ensure_length(3)
-        buf = self.__buf[:3] if len(self.__buf) >= 3 else self.__buf
-        if buf.startswith("```"):
-            return True
-        if buf.startswith("---"):
-            return True
-        if buf.startswith("> "):
-            return True
-        if await self.ordered_list_label():
-            return True
-        if await self.unordered_list_label():
-            return True
-        return False

autosh-0.0.3.dist-info/RECORD

@@ -1,22 +0,0 @@
-autosh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autosh/config-template.toml,sha256=iLdCBHIK0czWgNHtwAgvuhV670aiNc-IOmaPHP12i0Y,269
-autosh/config.py,sha256=7DXUSsqHm8dPsXln-NTu8D0_Uwcs2h4sT8pFtQM8tso,2654
-autosh/main.py,sha256=ov8lBOUb7GOa3-WBW00gqKaYrTG3NFYQgIXP3-6Eki4,4975
-autosh/session.py,sha256=pU3AAqI3vEEFdtsXK_1ZV6uXzjkzIG8q3Yo01K-Q6dw,9615
-autosh/md/__init__.py,sha256=0SK4rkynUwR77E8IU-ORJmWou_aTxC6xzQQo-IfAsaM,213
-autosh/md/inline_text.py,sha256=I8CaxksvOpTr1mlUtnk50TVVgF9CLnLsth2ux0cdTM4,6422
-autosh/md/printer.py,sha256=qD3AcGosnPMRAf-KiRw1PUixtP-kS5xFIPFjzGLLT0g,11099
-autosh/md/state.py,sha256=OEp0kUb63HrAN5BPcPx9mxWogofayumH9GZGqLdOoEA,3792
-autosh/md/stream.py,sha256=zaVJR6Kog6EZcuVaGszwgywpysHcn8fRZ0KItmKRhiA,3224
-autosh/plugins/__init__.py,sha256=NXq27wvS97NEH6hTtWRyp-ut0BE9fq5QyKBjXOj39zY,2487
-autosh/plugins/calc.py,sha256=qo0EajIpNPv9PtLNLygyEjVaxo1F6_S62kmoJZq5oLM,581
-autosh/plugins/cli.py,sha256=D6S_QHPmjBBB9gwgXeJrwxUs3u0TNty_tHVICbEPGbs,8522
-autosh/plugins/clock.py,sha256=GGi0HAG6f6-FP1qqGoyCcUj11q_VnkaGArumsMk0CkY,542
-autosh/plugins/code.py,sha256=0JwFzq6ejgbisCqBm_RG1r1WEVNou64ue-siVIpvZqs,2291
-autosh/plugins/search.py,sha256=1d3Gqq6uXu0ntTBpw44Ab_haAySvZLMj3e2MQd3DHO0,2736
-autosh/plugins/web.py,sha256=lmD2JnsqVI1qKgSFrk39851jCZoPyPRaVvHeEFYXylA,2597
-autosh-0.0.3.dist-info/METADATA,sha256=M2wVPjOWoiCXWbYzs216oQ4eUSE_s5-b67-qTufmnRE,1897
-autosh-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-autosh-0.0.3.dist-info/entry_points.txt,sha256=BV7bzUnxG6Z5InEkrfajGCxjooYORC5tZDDZctOPenQ,67
-autosh-0.0.3.dist-info/licenses/LICENSE,sha256=BnLDJsIJe-Dm18unR9DOoSv7QOfAz6LeIQc1yHAjxp0,1066
-autosh-0.0.3.dist-info/RECORD,,