dripfetch 0.1.0__py3-none-any.whl

dripfetch/default_config.yaml

@@ -0,0 +1,80 @@
+background: "#000000"
+
+rain:
+  collision: true
+  intensity: 100
+  character: "│"
+  colors:
+    - [0.50, "#FFFFFF"]
+    - [0.50, "#8747FF"]
+  speeds:
+    - [0.20, 21]
+    - [0.20, 31]
+    - [0.20, 41]
+    - [0.20, 51]
+    - [0.20, 61]
+  lengths:
+    - [0.70, 5]
+    - [0.25, 15]
+    - [0.05, 25]
+
+boxes:
+  border: single
+  border_color: "#FFFFFF"
+  text_color: "#FFFFFF"
+  accent_color: "#8747FF"
+  padding:
+    horizontal: 3
+    vertical: 1
+
+  items:
+    - type: logo
+      logo: macos3
+      colors:
+        - "#FFFFFF"
+        - "#5DFF9C"
+        - "#8747FF"
+        - "#FF5681"
+      position:
+        horizontal: -42
+        vertical: -12
+
+    - type: text
+      text: "Introducing Dripfetch | 0.1.0"
+      colors:
+        text: "#FFFFFF"
+        title: "#8747FF"
+        line: "#8747FF"
+      position:
+        horizontal: 4
+        vertical: -17
+
+
+
+    - type: sysinfo
+      colors:
+        text: "#FFFFFF"
+        title: "#8747FF"
+        line: "#8747FF"
+      position:
+        horizontal: 28
+        vertical: 3
+
+    - type: clock
+      position:
+        horizontal: -40
+        vertical: 17
+      clock_style: double
+      clock_size: medium
+      clock_24h: true
+      show_seconds: false
+      show_am_pm: false
+      blink_colon: true
+      show_date: true
+
+    - type: weather
+      location: Tehran
+      units: metric
+      position:
+        horizontal: -39
+        vertical: 5

dripfetch/rain/__init__.py

@@ -0,0 +1,3 @@
+from .engine import Rain
+
+__all__ = ["Rain"]

dripfetch/rain/collision.py

@@ -0,0 +1,23 @@
+BOX_PADDING = 2
+
+
+def collision(x, old_y, new_y, bounds, enabled, width):
+    if not enabled:
+        return None
+    for left, top, right, bottom in bounds:
+        if old_y < top <= new_y and left <= x <= right:
+            targets = (
+                max(0, left - BOX_PADDING),
+                min(width - 1, right + BOX_PADDING),
+            )
+            return min(
+                targets,
+                key=lambda target: abs(x - target),
+            ), top
+    return None
+
+
+def inside_box(x, y, bounds):
+    return any(
+        left <= x <= right and top <= y <= bottom for left, top, right, bottom in bounds
+    )

dripfetch/rain/colors.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RGBA:
+    r: int
+    g: int
+    b: int
+    a: int = 255
+
+
+def get_rgb(color):
+    color = color.lstrip("#")
+    if len(color) == 6:
+        color += "FF"
+    if len(color) != 8:
+        raise ValueError(f"Invalid color: #{color}")
+    try:
+        return RGBA(
+            int(color[0:2], 16),
+            int(color[2:4], 16),
+            int(color[4:6], 16),
+            int(color[6:8], 16),
+        )
+    except ValueError as exc:
+        raise ValueError(f"Invalid color: #{color}") from exc
+
+
+class ColorManager:
+    def __init__(self):
+        self.colors = {}
+
+    def create_pairs(self, colors, background=None):
+        self.colors = {color: get_rgb(color) for color in colors}
+
+    def attribute(self, color, tail, length):
+        base = self.colors.get(color, get_rgb("#FFFFFF"))
+        brightness = (
+            1.0
+            if length <= 1
+            else max(
+                0.0,
+                min(1.0, 1 - tail / (length - 1)),
+            )
+        )
+        return RGBA(
+            round(base.r * brightness),
+            round(base.g * brightness),
+            round(base.b * brightness),
+            base.a,
+        )

dripfetch/rain/drop.py

@@ -0,0 +1,16 @@
+import time
+from collections import deque
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Drop:
+    x: int
+    head_y: int = -1
+    speed: float = 50
+    length: int = 5
+    color: str = "#FFFFFF"
+    path: deque = field(default_factory=deque)
+    redirect_target: int | None = None
+    active: bool = True
+    last_move: float = field(default_factory=time.monotonic)

dripfetch/rain/engine.py

@@ -0,0 +1,190 @@
+import time
+
+from .collision import collision, inside_box
+from .colors import ColorManager
+from .movement import move_down, move_horizontal
+from .spawning import spawn
+
+
+class Rain:
+    def __init__(self, stdscr, config, box, renderer):
+        self.stdscr = stdscr
+        self.config = config
+        self.box = box
+        self.renderer = renderer
+        self.height, self.width = stdscr.getmaxyx()
+        self.drops = []
+        self.colors = ColorManager()
+        self.paused_at = None
+        self.spawned = 0
+        self.spawned_at = time.monotonic()
+        rain = config.get("rain", {})
+        self.collision = rain.get("collision", True)
+        self.intensity = max(0, float(rain.get("intensity", 1)))
+        self.character = rain.get("character", "│")
+        self.speeds = rain.get("speeds", [])
+        self.lengths = rain.get("lengths", [])
+        self.rain_colors = rain.get("colors", [])
+        colors = dict.fromkeys(color for _, color in self.rain_colors)
+        self.colors.create_pairs(colors or ["#FFFFFF"])
+
+    def _spawn(self, now):
+        self.spawned, self.spawned_at = spawn(
+            self.drops,
+            self.width,
+            self.intensity,
+            self.spawned,
+            self.spawned_at,
+            now,
+            self.speeds,
+            self.lengths,
+            self.rain_colors,
+        )
+
+    def _collision(self, x, old_y, new_y, bounds):
+        return collision(
+            x,
+            old_y,
+            new_y,
+            bounds,
+            self.collision,
+            self.width,
+        )
+
+    @staticmethod
+    def _inside_box(x, y, bounds):
+        return inside_box(x, y, bounds)
+
+    @staticmethod
+    def _inside_box(x, y, bounds):
+        return inside_box(x, y, bounds)
+
+    def _move_horizontal(self, drop):
+        move_horizontal(drop)
+
+    def _move_down(self, drop, bounds):
+        move_down(
+            drop,
+            bounds,
+            self.collision,
+            self.width,
+            self.character,
+        )
+
+    def _update_drop(self, drop, now, bounds):
+        if not drop.active:
+            return
+        interval = max(1.0, float(drop.speed)) / 1000
+        elapsed = now - drop.last_move
+        if elapsed < interval:
+            return
+        steps = min(
+            max(1, int(elapsed / interval)),
+            8,
+        )
+        for _ in range(steps):
+            if drop.redirect_target is None:
+                self._move_down(drop, bounds)
+            else:
+                self._move_horizontal(drop)
+            if drop.head_y - drop.length >= self.height:
+                drop.active = False
+                break
+        drop.last_move = now
+
+    def _draw_drop(self, drop, bounds):
+        if not drop.active:
+            return
+        for tail, (x, y, character) in enumerate(reversed(drop.path)):
+            if tail >= drop.length:
+                break
+            if not (0 <= x < self.width and 0 <= y < self.height):
+                continue
+            if not self.collision and self._inside_box(
+                x,
+                y,
+                bounds,
+            ):
+                continue
+            self.renderer.draw(
+                x,
+                y,
+                character,
+                self.colors.attribute(
+                    drop.color,
+                    tail,
+                    drop.length,
+                ),
+            )
+
+    def update(self):
+        now = time.monotonic()
+        bounds = self.box.get_box_bounds_list()
+        self._spawn(now)
+        alive = []
+        for drop in self.drops:
+            self._update_drop(
+                drop,
+                now,
+                bounds,
+            )
+            if drop.active:
+                alive.append(drop)
+        self.drops = alive
+
+    def draw(self):
+        bounds = self.box.get_box_bounds_list()
+        for drop in self.drops:
+            self._draw_drop(
+                drop,
+                bounds,
+            )
+
+    def pause(self):
+        if self.paused_at is None:
+            self.paused_at = time.monotonic()
+
+    def resume(self):
+        if self.paused_at is None:
+            return
+        delay = time.monotonic() - self.paused_at
+        for drop in self.drops:
+            drop.last_move += delay
+        self.spawned_at += delay
+        self.paused_at = None
+
+    def reset_timing(self):
+        now = time.monotonic()
+        for drop in self.drops:
+            drop.last_move = now
+        self.spawned_at = now
+        self.spawned = 0
+
+    def resize(self):
+        height, width = self.stdscr.getmaxyx()
+        if (height, width) == (self.height, self.width):
+            return False
+        self.height = height
+        self.width = width
+        if self.width <= 0 or self.height <= 0:
+            self.drops.clear()
+            self.reset_timing()
+            return True
+        alive = []
+        for drop in self.drops:
+            if drop.x < 0 or drop.x >= self.width:
+                drop.active = False
+                continue
+            if drop.head_y - drop.length >= self.height:
+                drop.active = False
+                continue
+            if drop.redirect_target is not None:
+                if not 0 <= drop.redirect_target < self.width:
+                    drop.redirect_target = None
+            alive.append(drop)
+        self.drops = alive
+        self.reset_timing()
+        return True
+
+    def close(self):
+        self.drops.clear()

dripfetch/rain/movement.py

@@ -0,0 +1,46 @@
+from .collision import collision
+
+
+def move_horizontal(drop):
+    target = drop.redirect_target
+    if target is None:
+        return
+    direction = 1 if target > drop.x else -1
+    drop.x += direction
+    drop.path.append((drop.x, drop.head_y, "─"))
+    if drop.x == target:
+        drop.path[-1] = (
+            drop.x,
+            drop.head_y,
+            "┐" if direction > 0 else "┌",
+        )
+        drop.redirect_target = None
+
+
+def move_down(drop, bounds, collision_enabled, width, character):
+    old_x = drop.x
+    old_y = drop.head_y
+    hit = collision(
+        old_x,
+        old_y,
+        old_y + 1,
+        bounds,
+        collision_enabled,
+        width,
+    )
+    if hit:
+        target, top = hit
+        drop.head_y = top - 1
+        drop.redirect_target = target
+        corner = "└" if target > old_x else "┘"
+        if drop.path:
+            drop.path[-1] = (
+                old_x,
+                drop.head_y,
+                corner,
+            )
+        else:
+            drop.path.append((old_x, drop.head_y, corner))
+        return
+    drop.head_y += 1
+    drop.path.append((drop.x, drop.head_y, character))

dripfetch/rain/spawning.py

@@ -0,0 +1,59 @@
+import random
+from collections import deque
+
+from .drop import Drop
+
+SPAWN_INTERVAL = 5
+
+
+def choose(values, default):
+    if not values:
+        return default
+    return random.choices(
+        [value for _, value in values],
+        [weight for weight, _ in values],
+    )[0]
+
+
+def new_drop(width, speeds, lengths, rain_colors):
+    if width <= 0:
+        return None
+    length = max(1, int(choose(lengths, 5)))
+    return Drop(
+        x=random.randrange(width),
+        head_y=-1,
+        speed=max(1, float(choose(speeds, 50))),
+        length=length,
+        color=choose(rain_colors, "#FFFFFF"),
+        path=deque(maxlen=length),
+    )
+
+
+def spawn(
+    drops,
+    width,
+    intensity,
+    spawned,
+    spawned_at,
+    now,
+    speeds,
+    lengths,
+    rain_colors,
+):
+    if not intensity or not width:
+        return spawned, now
+    elapsed = min(now - spawned_at, 0.25)
+    spawned_at = now
+    spawned += elapsed * intensity / SPAWN_INTERVAL
+    count = int(spawned)
+    spawned -= count
+    for _ in range(count):
+        drop = new_drop(
+            width,
+            speeds,
+            lengths,
+            rain_colors,
+        )
+        if drop is not None:
+            drops.append(drop)
+    return spawned, spawned_at

dripfetch/terminal.py

@@ -0,0 +1,193 @@
+import curses
+import os
+import sys
+
+
+class RGBA:
+    __slots__ = ("a", "b", "g", "r")
+
+    def __init__(
+        self,
+        r,
+        g,
+        b,
+        a=255,
+    ):
+        self.r = r
+        self.g = g
+        self.b = b
+        self.a = a
+
+    def __eq__(self, other):
+        if not isinstance(other, RGBA):
+            return NotImplemented
+        return (
+            self.r == other.r
+            and self.g == other.g
+            and self.b == other.b
+            and self.a == other.a
+        )
+
+    def __hash__(self):
+        return hash(
+            (
+                self.r,
+                self.g,
+                self.b,
+                self.a,
+            )
+        )
+
+
+def parse_color(value):
+    value = value.lstrip("#")
+    if len(value) == 6:
+        value += "FF"
+    if len(value) != 8:
+        raise ValueError(f"Invalid color: #{value}")
+    try:
+        return RGBA(
+            int(value[0:2], 16),
+            int(value[2:4], 16),
+            int(value[4:6], 16),
+            int(value[6:8], 16),
+        )
+    except ValueError as exc:
+        raise ValueError(f"Invalid color: #{value}") from exc
+
+
+class Renderer:
+    def __init__(
+        self,
+        stdscr,
+        background,
+    ):
+        self.stdscr = stdscr
+        self.background = background
+        self.width = 0
+        self.height = 0
+        self.current = {}
+
+    def resize(self):
+        height, width = self.stdscr.getmaxyx()
+        if width == self.width and height == self.height:
+            return False
+        self.width = width
+        self.height = height
+        self.current.clear()
+        try:
+            curses.resizeterm(
+                height,
+                width,
+            )
+        except curses.error:
+            pass
+        return True
+
+    def begin(self):
+        resized = self.resize()
+        self.current = {
+            (x, y): (
+                " ",
+                None,
+                self.background,
+            )
+            for y in range(self.height)
+            for x in range(self.width)
+        }
+        return resized
+
+    def draw(
+        self,
+        x,
+        y,
+        text,
+        foreground=None,
+        background=None,
+    ):
+        if not text or y < 0 or y >= self.height:
+            return
+        background = self.background if background is None else background
+        start = max(0, x)
+        end = min(
+            x + len(text),
+            self.width,
+        )
+        for column in range(start, end):
+            self.current[(column, y)] = (
+                text[column - x],
+                foreground,
+                background,
+            )
+
+    def _foreground(self, color):
+        if color is None:
+            return "\x1b[39m"
+        return f"\x1b[38;2;{color.r};{color.g};{color.b}m"
+
+    def _background_color(self, color):
+        if color is None:
+            color = self.background
+        if not color.a:
+            return "\x1b[49m"
+        return f"\x1b[48;2;{color.r};{color.g};{color.b}m"
+
+    def end(self):
+        output = ["\x1b[H"]
+        foreground = None
+        background = None
+        last_x = -1
+        last_y = -1
+        for (x, y), (
+            character,
+            color,
+            bg,
+        ) in sorted(
+            self.current.items(),
+            key=lambda item: item[0][1],
+        ):
+            if y != last_y or x != last_x:
+                output.append(f"\x1b[{y + 1};{x + 1}H")
+            if color != foreground:
+                output.append(self._foreground(color))
+                foreground = color
+            if bg != background:
+                output.append(self._background_color(bg))
+                background = bg
+            output.append(character)
+            last_x = x + 1
+            last_y = y
+        output.append("\x1b[0m")
+        try:
+            os.write(
+                sys.stdout.fileno(),
+                "".join(output).encode(),
+            )
+        except OSError:
+            pass
+
+
+def terminal_write(sequence):
+    try:
+        os.write(
+            sys.stdout.fileno(),
+            sequence.encode(),
+        )
+    except OSError:
+        pass
+
+
+def setup(stdscr):
+    curses.curs_set(0)
+    curses.noecho()
+    curses.cbreak()
+    curses.start_color()
+    curses.use_default_colors()
+    curses.mousemask(curses.BUTTON1_CLICKED)
+    stdscr.keypad(True)
+    stdscr.leaveok(True)
+    terminal_write("\x1b[?1049h\x1b[?25l\x1b[0m\x1b[2J\x1b[H")
+
+
+def cleanup():
+    terminal_write("\x1b[0m\x1b[?25h\x1b[?1049l")

dripfetch-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: dripfetch
+Version: 0.1.0
+Summary: A customizable terminal system information display with animated rain.
+Author: Amir Shygun
+License: MIT License
+        
+        Copyright (c) 2026 Amir Shygun
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: terminal,system information,fetch,curses,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System
+Classifier: Topic :: Terminals
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: ruamel.yaml
+Dynamic: license-file
+
+# dripfetch
+A customizable terminal system information display with animated rain.