Admin

name	type	size	perms	modified	actions
[parent directory]
__pycache__/	dir	-	0755	2024-04-23 15:27:53
__init__.py	file	6,066 B	0644	2024-03-04 23:07:14	edit
__main__.py	file	8,333 B	0644	2024-03-04 23:07:14	edit
_cell_widths.py	file	10,209 B	0644	2024-03-04 23:07:14	edit
_emoji_codes.py	file	140,235 B	0644	2024-03-04 23:07:14	edit
_emoji_replace.py	file	1,064 B	0644	2024-03-04 23:07:14	edit
_export_format.py	file	2,128 B	0644	2024-03-04 23:07:14	edit
_extension.py	file	241 B	0644	2024-03-04 23:07:14	edit
_fileno.py	file	799 B	0644	2024-03-04 23:07:14	edit
_inspect.py	file	9,695 B	0644	2024-03-04 23:07:14	edit
_log_render.py	file	3,213 B	0644	2024-03-04 23:07:14	edit
_loop.py	file	1,236 B	0644	2024-03-04 23:07:14	edit
_null_file.py	file	1,387 B	0644	2024-03-04 23:07:14	edit
_palettes.py	file	7,063 B	0644	2024-03-04 23:07:14	edit
_pick.py	file	423 B	0644	2024-03-04 23:07:14	edit
_ratio.py	file	5,459 B	0644	2024-03-04 23:07:14	edit
_spinners.py	file	19,919 B	0644	2024-03-04 23:07:14	edit
_stack.py	file	351 B	0644	2024-03-04 23:07:14	edit
_timer.py	file	417 B	0644	2024-03-04 23:07:14	edit
_win32_console.py	file	22,784 B	0644	2024-03-04 23:07:14	edit
_windows.py	file	1,901 B	0644	2024-03-04 23:07:14	edit
_windows_renderer.py	file	2,759 B	0644	2024-03-04 23:07:14	edit
_wrap.py	file	3,404 B	0644	2024-03-04 23:07:14	edit
abc.py	file	878 B	0644	2024-03-04 23:07:14	edit
align.py	file	10,320 B	0644	2024-03-04 23:07:14	edit
ansi.py	file	6,906 B	0644	2024-03-04 23:07:14	edit
bar.py	file	3,263 B	0644	2024-03-04 23:07:14	edit
box.py	file	10,783 B	0644	2024-03-04 23:07:14	edit
cells.py	file	4,780 B	0644	2024-03-04 23:07:14	edit
color.py	file	18,223 B	0644	2024-03-04 23:07:14	edit
color_triplet.py	file	1,054 B	0644	2024-03-04 23:07:14	edit
columns.py	file	7,131 B	0644	2024-03-04 23:07:14	edit
console.py	file	99,101 B	0644	2024-03-04 23:07:14	edit
constrain.py	file	1,288 B	0644	2024-03-04 23:07:14	edit
containers.py	file	5,502 B	0644	2024-03-04 23:07:14	edit
control.py	file	6,606 B	0644	2024-03-04 23:07:14	edit
default_styles.py	file	8,046 B	0644	2024-03-04 23:07:14	edit
diagnose.py	file	924 B	0644	2024-03-04 23:07:14	edit
emoji.py	file	2,465 B	0644	2024-03-04 23:07:14	edit
errors.py	file	642 B	0644	2024-03-04 23:07:14	edit
file_proxy.py	file	1,683 B	0644	2024-03-04 23:07:14	edit
filesize.py	file	2,508 B	0644	2024-03-04 23:07:14	edit
highlighter.py	file	9,585 B	0644	2024-03-04 23:07:14	edit
json.py	file	5,019 B	0644	2024-03-04 23:07:14	edit
jupyter.py	file	3,228 B	0644	2024-03-04 23:07:14	edit
layout.py	file	13,944 B	0644	2024-03-04 23:07:14	edit
live.py	file	14,271 B	0644	2024-03-04 23:07:14	edit
live_render.py	file	3,654 B	0644	2024-03-04 23:07:14	edit
logging.py	file	11,891 B	0644	2024-03-04 23:07:14	edit
markdown.py	file	26,167 B	0644	2024-03-04 23:07:14	edit
markup.py	file	8,427 B	0644	2024-03-04 23:07:14	edit
measure.py	file	5,305 B	0644	2024-03-04 23:07:14	edit
padding.py	file	4,958 B	0644	2024-03-04 23:07:14	edit
pager.py	file	828 B	0644	2024-03-04 23:07:14	edit
palette.py	file	3,288 B	0644	2024-03-04 23:07:14	edit
panel.py	file	10,705 B	0644	2024-03-04 23:07:14	edit
pretty.py	file	35,812 B	0644	2024-03-04 23:07:14	edit
progress.py	file	59,703 B	0644	2024-03-04 23:07:14	edit
progress_bar.py	file	8,164 B	0644	2024-03-04 23:07:14	edit
prompt.py	file	11,292 B	0644	2024-03-04 23:07:14	edit
protocol.py	file	1,367 B	0644	2024-03-04 23:07:14	edit
py.typed	file	0 B	0644	2024-03-04 23:07:14	edit
region.py	file	166 B	0644	2024-03-04 23:07:14	edit
repr.py	file	4,419 B	0644	2024-03-04 23:07:14	edit
rule.py	file	4,590 B	0644	2024-03-04 23:07:14	edit
scope.py	file	2,831 B	0644	2024-03-04 23:07:14	edit
screen.py	file	1,579 B	0644	2024-03-04 23:07:14	edit
segment.py	file	24,210 B	0644	2024-03-04 23:07:14	edit
spinner.py	file	4,339 B	0644	2024-03-04 23:07:14	edit
status.py	file	4,424 B	0644	2024-03-04 23:07:14	edit
style.py	file	27,073 B	0644	2024-03-04 23:07:14	edit
styled.py	file	1,234 B	0644	2024-03-04 23:07:14	edit
syntax.py	file	35,367 B	0644	2024-03-04 23:07:14	edit
table.py	file	39,644 B	0644	2024-03-04 23:07:14	edit
terminal_theme.py	file	3,370 B	0644	2024-03-04 23:07:14	edit
text.py	file	47,300 B	0644	2024-03-04 23:07:14	edit
theme.py	file	3,777 B	0644	2024-03-04 23:07:14	edit
themes.py	file	102 B	0644	2024-03-04 23:07:14	edit
traceback.py	file	29,529 B	0644	2024-03-04 23:07:14	edit
tree.py	file	9,107 B	0644	2024-03-04 23:07:14	edit

editing: layout.py

from abc import ABC, abstractmethod
from itertools import islice
from operator import itemgetter
from threading import RLock
from typing import (
    TYPE_CHECKING,
    Dict,
    Iterable,
    List,
    NamedTuple,
    Optional,
    Sequence,
    Tuple,
    Union,
)

from ._ratio import ratio_resolve
from .align import Align
from .console import Console, ConsoleOptions, RenderableType, RenderResult
from .highlighter import ReprHighlighter
from .panel import Panel
from .pretty import Pretty
from .region import Region
from .repr import Result, rich_repr
from .segment import Segment
from .style import StyleType

if TYPE_CHECKING:
    from rich.tree import Tree

class LayoutRender(NamedTuple):
    """An individual layout render."""

region: Region
    render: List[List[Segment]]

RegionMap = Dict["Layout", Region]
RenderMap = Dict["Layout", LayoutRender]

class LayoutError(Exception):
    """Layout related error."""

class NoSplitter(LayoutError):
    """Requested splitter does not exist."""

class _Placeholder:
    """An internal renderable used as a Layout placeholder."""

highlighter = ReprHighlighter()

def __init__(self, layout: "Layout", style: StyleType = "") -> None:
        self.layout = layout
        self.style = style

def __rich_console__(
        self, console: Console, options: ConsoleOptions
    ) -> RenderResult:
        width = options.max_width
        height = options.height or options.size.height
        layout = self.layout
        title = (
            f"{layout.name!r} ({width} x {height})"
            if layout.name
            else f"({width} x {height})"
        )
        yield Panel(
            Align.center(Pretty(layout), vertical="middle"),
            style=self.style,
            title=self.highlighter(title),
            border_style="blue",
            height=height,
        )

class Splitter(ABC):
    """Base class for a splitter."""

name: str = ""

@abstractmethod
    def get_tree_icon(self) -> str:
        """Get the icon (emoji) used in layout.tree"""

@abstractmethod
    def divide(
        self, children: Sequence["Layout"], region: Region
    ) -> Iterable[Tuple["Layout", Region]]:
        """Divide a region amongst several child layouts.

Args:
            children (Sequence(Layout)): A number of child layouts.
            region (Region): A rectangular region to divide.
        """

class RowSplitter(Splitter):
    """Split a layout region in to rows."""

name = "row"

def get_tree_icon(self) -> str:
        return "[layout.tree.row]⬌"

def divide(
        self, children: Sequence["Layout"], region: Region
    ) -> Iterable[Tuple["Layout", Region]]:
        x, y, width, height = region
        render_widths = ratio_resolve(width, children)
        offset = 0
        _Region = Region
        for child, child_width in zip(children, render_widths):
            yield child, _Region(x + offset, y, child_width, height)
            offset += child_width

class ColumnSplitter(Splitter):
    """Split a layout region in to columns."""

name = "column"

def get_tree_icon(self) -> str:
        return "[layout.tree.column]⬍"

def divide(
        self, children: Sequence["Layout"], region: Region
    ) -> Iterable[Tuple["Layout", Region]]:
        x, y, width, height = region
        render_heights = ratio_resolve(height, children)
        offset = 0
        _Region = Region
        for child, child_height in zip(children, render_heights):
            yield child, _Region(x, y + offset, width, child_height)
            offset += child_height

@rich_repr
class Layout:
    """A renderable to divide a fixed height in to rows or columns.

Args:
        renderable (RenderableType, optional): Renderable content, or None for placeholder. Defaults to None.
        name (str, optional): Optional identifier for Layout. Defaults to None.
        size (int, optional): Optional fixed size of layout. Defaults to None.
        minimum_size (int, optional): Minimum size of layout. Defaults to 1.
        ratio (int, optional): Optional ratio for flexible layout. Defaults to 1.
        visible (bool, optional): Visibility of layout. Defaults to True.
    """

splitters = {"row": RowSplitter, "column": ColumnSplitter}

def __init__(
        self,
        renderable: Optional[RenderableType] = None,
        *,
        name: Optional[str] = None,
        size: Optional[int] = None,
        minimum_size: int = 1,
        ratio: int = 1,
        visible: bool = True,
    ) -> None:
        self._renderable = renderable or _Placeholder(self)
        self.size = size
        self.minimum_size = minimum_size
        self.ratio = ratio
        self.name = name
        self.visible = visible
        self.splitter: Splitter = self.splitters["column"]()
        self._children: List[Layout] = []
        self._render_map: RenderMap = {}
        self._lock = RLock()

def __rich_repr__(self) -> Result:
        yield "name", self.name, None
        yield "size", self.size, None
        yield "minimum_size", self.minimum_size, 1
        yield "ratio", self.ratio, 1

@property
    def renderable(self) -> RenderableType:
        """Layout renderable."""
        return self if self._children else self._renderable

@property
    def children(self) -> List["Layout"]:
        """Gets (visible) layout children."""
        return [child for child in self._children if child.visible]

@property
    def map(self) -> RenderMap:
        """Get a map of the last render."""
        return self._render_map

def get(self, name: str) -> Optional["Layout"]:
        """Get a named layout, or None if it doesn't exist.

Args:
            name (str): Name of layout.

Returns:
            Optional[Layout]: Layout instance or None if no layout was found.
        """
        if self.name == name:
            return self
        else:
            for child in self._children:
                named_layout = child.get(name)
                if named_layout is not None:
                    return named_layout
        return None

def __getitem__(self, name: str) -> "Layout":
        layout = self.get(name)
        if layout is None:
            raise KeyError(f"No layout with name {name!r}")
        return layout

@property
    def tree(self) -> "Tree":
        """Get a tree renderable to show layout structure."""
        from rich.styled import Styled
        from rich.table import Table
        from rich.tree import Tree

def summary(layout: "Layout") -> Table:
            icon = layout.splitter.get_tree_icon()

table = Table.grid(padding=(0, 1, 0, 0))

text: RenderableType = (
                Pretty(layout) if layout.visible else Styled(Pretty(layout), "dim")
            )
            table.add_row(icon, text)
            _summary = table
            return _summary

layout = self
        tree = Tree(
            summary(layout),
            guide_style=f"layout.tree.{layout.splitter.name}",
            highlight=True,
        )

def recurse(tree: "Tree", layout: "Layout") -> None:
            for child in layout._children:
                recurse(
                    tree.add(
                        summary(child),
                        guide_style=f"layout.tree.{child.splitter.name}",
                    ),
                    child,
                )

recurse(tree, self)
        return tree

def split(
        self,
        *layouts: Union["Layout", RenderableType],
        splitter: Union[Splitter, str] = "column",
    ) -> None:
        """Split the layout in to multiple sub-layouts.

Args:
            *layouts (Layout): Positional arguments should be (sub) Layout instances.
            splitter (Union[Splitter, str]): Splitter instance or name of splitter.
        """
        _layouts = [
            layout if isinstance(layout, Layout) else Layout(layout)
            for layout in layouts
        ]
        try:
            self.splitter = (
                splitter
                if isinstance(splitter, Splitter)
                else self.splitters[splitter]()
            )
        except KeyError:
            raise NoSplitter(f"No splitter called {splitter!r}")
        self._children[:] = _layouts

def add_split(self, *layouts: Union["Layout", RenderableType]) -> None:
        """Add a new layout(s) to existing split.

Args:
            *layouts (Union[Layout, RenderableType]): Positional arguments should be renderables or (sub) Layout instances.

"""
        _layouts = (
            layout if isinstance(layout, Layout) else Layout(layout)
            for layout in layouts
        )
        self._children.extend(_layouts)

def split_row(self, *layouts: Union["Layout", RenderableType]) -> None:
        """Split the layout in to a row (layouts side by side).

Args:
            *layouts (Layout): Positional arguments should be (sub) Layout instances.
        """
        self.split(*layouts, splitter="row")

def split_column(self, *layouts: Union["Layout", RenderableType]) -> None:
        """Split the layout in to a column (layouts stacked on top of each other).

Args:
            *layouts (Layout): Positional arguments should be (sub) Layout instances.
        """
        self.split(*layouts, splitter="column")

def unsplit(self) -> None:
        """Reset splits to initial state."""
        del self._children[:]

def update(self, renderable: RenderableType) -> None:
        """Update renderable.

Args:
            renderable (RenderableType): New renderable object.
        """
        with self._lock:
            self._renderable = renderable

def refresh_screen(self, console: "Console", layout_name: str) -> None:
        """Refresh a sub-layout.

Args:
            console (Console): Console instance where Layout is to be rendered.
            layout_name (str): Name of layout.
        """
        with self._lock:
            layout = self[layout_name]
            region, _lines = self._render_map[layout]
            (x, y, width, height) = region
            lines = console.render_lines(
                layout, console.options.update_dimensions(width, height)
            )
            self._render_map[layout] = LayoutRender(region, lines)
            console.update_screen_lines(lines, x, y)

def _make_region_map(self, width: int, height: int) -> RegionMap:
        """Create a dict that maps layout on to Region."""
        stack: List[Tuple[Layout, Region]] = [(self, Region(0, 0, width, height))]
        push = stack.append
        pop = stack.pop
        layout_regions: List[Tuple[Layout, Region]] = []
        append_layout_region = layout_regions.append
        while stack:
            append_layout_region(pop())
            layout, region = layout_regions[-1]
            children = layout.children
            if children:
                for child_and_region in layout.splitter.divide(children, region):
                    push(child_and_region)

region_map = {
            layout: region
            for layout, region in sorted(layout_regions, key=itemgetter(1))
        }
        return region_map

def render(self, console: Console, options: ConsoleOptions) -> RenderMap:
        """Render the sub_layouts.

Args:
            console (Console): Console instance.
            options (ConsoleOptions): Console options.

Returns:
            RenderMap: A dict that maps Layout on to a tuple of Region, lines
        """
        render_width = options.max_width
        render_height = options.height or console.height
        region_map = self._make_region_map(render_width, render_height)
        layout_regions = [
            (layout, region)
            for layout, region in region_map.items()
            if not layout.children
        ]
        render_map: Dict["Layout", "LayoutRender"] = {}
        render_lines = console.render_lines
        update_dimensions = options.update_dimensions

for layout, region in layout_regions:
            lines = render_lines(
                layout.renderable, update_dimensions(region.width, region.height)
            )
            render_map[layout] = LayoutRender(region, lines)
        return render_map

def __rich_console__(
        self, console: Console, options: ConsoleOptions
    ) -> RenderResult:
        with self._lock:
            width = options.max_width or console.width
            height = options.height or console.height
            render_map = self.render(console, options.update_dimensions(width, height))
            self._render_map = render_map
            layout_lines: List[List[Segment]] = [[] for _ in range(height)]
            _islice = islice
            for region, lines in render_map.values():
                _x, y, _layout_width, layout_height = region
                for row, line in zip(
                    _islice(layout_lines, y, y + layout_height), lines
                ):
                    row.extend(line)

new_line = Segment.line()
            for layout_row in layout_lines:
                yield from layout_row
                yield new_line

if __name__ == "__main__":
    from rich.console import Console

console = Console()
    layout = Layout()

layout.split_column(
        Layout(name="header", size=3),
        Layout(ratio=1, name="main"),
        Layout(size=10, name="footer"),
    )

layout["main"].split_row(Layout(name="side"), Layout(name="body", ratio=2))

layout["body"].split_row(Layout(name="content", ratio=2), Layout(name="s2"))

layout["s2"].split_column(
        Layout(name="top"), Layout(name="middle"), Layout(name="bottom")
    )

layout["side"].split_column(Layout(layout.tree, name="left1"), Layout(name="left2"))

layout["content"].update("foo")

console.print(layout)

cancel

Admin

editing: layout.py

Deskripsi Program

Informasi Donatur

Laa Ba’sa Thahuurun Insyaa Allah

Terkumpul

Target

Tentukan Nominal Sedekahmu

Laa Ba’sa Thahuurun Insyaa Allah

⁠Masukkan Nominal Sedekah *

Terkumpul

Target