shortiepy 0.0.0__tar.gz

shortiepy-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ポテト
+
+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.

shortiepy-0.0.0/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: shortiepy
+Version: 0.0.0
+Summary: A local-only URL shortener (˶˘ ³˘)♡
+Author: ポテト ^. .^₎ฅ
+Author-email: "ポテト ^. .^₎ฅ" <nya@cheapnightbot.me>
+License: MIT
+Project-URL: Homepage, https://github.com/CheapNightbot/shortiepy
+Project-URL: Repository, https://github.com/CheapNightbot/shortiepy.git
+Project-URL: Issues, https://github.com/CheapNightbot/shortiepy/issues
+Keywords: cli,shortie,shortiepy,URL shortener
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.3.1
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: Flask>=3.1.2
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: waitress>=3.0.2
+Dynamic: license-file
+
+# shortiepy 🌸
+
+Your local URL shortener (˶˘ ³˘)♡
+
+- 🔒 100% offline - no data leaves your machine
+- 🌈 Cross-platform (Linux/macOS/Windows)
+- 📋 Auto-copies short URLs to clipboard
+- 🎀 Pastel colors & kaomojis everywhere!
+
+## Installation
+
+- **Using `pipx`** [Recommended]
+
+Follow instructions to install `pipx` here: [pipx.pypa.io/stable/installation](https://pipx.pypa.io/stable/installation/) and after installing `pipx` in your system, install `shortiepy`:
+
+```bash
+pipx install shortiepy
+```
+
+- **Using `pip`**
+
+```bash
+pip install shortiepy
+```
+
+## Usage
+
+- **Add a URL**
+
+```bash
+shortiepy add https://example.com
+```
+
+- **Start server**
+
+```bash
+shortiepy serve  # will run in forground
+# OR
+shortiepy start  # will run in background
+```
+
+- **View docs**
+
+```bash
+shortiepy docs
+```
+
+### Create Links from browser
+
+shortiepy supports creating short URLs from within your browser (without having to use CLI `add` command).
+
+You can visit `/new` route and provide `code` (this will be used to generate short url) and `url` (the URL you want to create short link for) query paramters:
+
+- `http://localhost:9876/new?code=meow&url=https://example.com`
+
+    - It will create short link for `https://example.com` using provided short code: `http://localhost:9876/meow`
+
+    - The `code` parameter is optional and can be omitted.
+
+However, vising that URL and route manully is tedious! But if your browser allows it, like I have [Brave](https://brave.com/) browser, you can add a shortcut for it:
+
+- In your browser go to settings and find "search engines". In Brave, it's `brave://settings/searchEngines` and add the following in "Site search":
+
+  - Name: `shortiepy` (or anything you like)
+  - Shortcut: `:sh` (or anything you like)
+  - URL: `http://localhost:9876/new?url=%s`
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+  
+![Add Shortcut in Browser](https://github.com/user-attachments/assets/2f03b437-0452-4f22-9225-e12e10a2b15c)
+
+</details>
+ 
+Now when you want to create a short link, just type `:sh` in url bar and press `spacebar`, then you can paste the URL you want to create short link for and press enter!
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+
+![Use Shortcut to create short link](https://github.com/user-attachments/assets/bf04838a-09f8-4d30-888c-f6c043328ae4)
+
+</details>
+
+## Shell Completion
+
+Get tab-completion with **one command**:
+
+```bash
+shortiepy completion
+```
+
+> Restart your shell or reload config (`source ~/.bashrc` for bash OR `source ~/.zshrc` for zsh).
+> Fish users: no restart needed!
+
+That's it! Works for bash, zsh, and fish.
+
+## Why
+
+For some reason, when I’m working on things or trying to learn something new, my browser ends up filled with tons of tabs—which makes my laptop-chan angry ~ ₍^.  ̫.^₎
+
+I don’t want to close them or bookmark them. I tried manually copying URLs into a `.txt` file, but then I wished there was a simple way to turn long links into short ones I could use later.
+
+I didn’t want to send anything online, and existing self-hosted URL shorteners felt like overkill for such a small need.
+
+So I made this: a minimal, local-only URL shortener. It started as a single script file and isn’t perfect—but it just works! ~ ദ്ദി/ᐠ｡‸｡ᐟ\
+
+
+## For Developers
+
+Want to tinker with `shortiepy` or contribute? Here's how to set it up locally:
+
+- Clone the repository locally and change the directory into it:
+
+```bash
+git clone https://github.com/CheapNightbot/shortiepy.git && cd shortiepy
+```
+
+- Install `shortiepy`:
+
+```bash
+# Create a virtual environment (keeps things clean!)
+python -m venv .venv
+
+# Activate it
+source .venv/bin/activate  # Linux/macOS
+# OR
+.venv\Scripts\activate     # Windows
+
+# Install in editable mode (changes reflect instantly!)
+pip install -e .
+```
+
+Now you can run `shortiepy` from anywhere in your terminal!
+Made a change? It’ll work immediately—no reinstall needed!
+
+### Updating Shell Completions
+
+If you modify CLI commands or options, regenerate completions:
+
+```bash
+./scripts/generate-completions.sh
+```
+
+> This updates the files in `shortiepy/completions/` directory.

shortiepy-0.0.0/README.md

@@ -0,0 +1,144 @@
+# shortiepy 🌸
+
+Your local URL shortener (˶˘ ³˘)♡
+
+- 🔒 100% offline - no data leaves your machine
+- 🌈 Cross-platform (Linux/macOS/Windows)
+- 📋 Auto-copies short URLs to clipboard
+- 🎀 Pastel colors & kaomojis everywhere!
+
+## Installation
+
+- **Using `pipx`** [Recommended]
+
+Follow instructions to install `pipx` here: [pipx.pypa.io/stable/installation](https://pipx.pypa.io/stable/installation/) and after installing `pipx` in your system, install `shortiepy`:
+
+```bash
+pipx install shortiepy
+```
+
+- **Using `pip`**
+
+```bash
+pip install shortiepy
+```
+
+## Usage
+
+- **Add a URL**
+
+```bash
+shortiepy add https://example.com
+```
+
+- **Start server**
+
+```bash
+shortiepy serve  # will run in forground
+# OR
+shortiepy start  # will run in background
+```
+
+- **View docs**
+
+```bash
+shortiepy docs
+```
+
+### Create Links from browser
+
+shortiepy supports creating short URLs from within your browser (without having to use CLI `add` command).
+
+You can visit `/new` route and provide `code` (this will be used to generate short url) and `url` (the URL you want to create short link for) query paramters:
+
+- `http://localhost:9876/new?code=meow&url=https://example.com`
+
+    - It will create short link for `https://example.com` using provided short code: `http://localhost:9876/meow`
+
+    - The `code` parameter is optional and can be omitted.
+
+However, vising that URL and route manully is tedious! But if your browser allows it, like I have [Brave](https://brave.com/) browser, you can add a shortcut for it:
+
+- In your browser go to settings and find "search engines". In Brave, it's `brave://settings/searchEngines` and add the following in "Site search":
+
+  - Name: `shortiepy` (or anything you like)
+  - Shortcut: `:sh` (or anything you like)
+  - URL: `http://localhost:9876/new?url=%s`
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+  
+![Add Shortcut in Browser](https://github.com/user-attachments/assets/2f03b437-0452-4f22-9225-e12e10a2b15c)
+
+</details>
+ 
+Now when you want to create a short link, just type `:sh` in url bar and press `spacebar`, then you can paste the URL you want to create short link for and press enter!
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+
+![Use Shortcut to create short link](https://github.com/user-attachments/assets/bf04838a-09f8-4d30-888c-f6c043328ae4)
+
+</details>
+
+## Shell Completion
+
+Get tab-completion with **one command**:
+
+```bash
+shortiepy completion
+```
+
+> Restart your shell or reload config (`source ~/.bashrc` for bash OR `source ~/.zshrc` for zsh).
+> Fish users: no restart needed!
+
+That's it! Works for bash, zsh, and fish.
+
+## Why
+
+For some reason, when I’m working on things or trying to learn something new, my browser ends up filled with tons of tabs—which makes my laptop-chan angry ~ ₍^.  ̫.^₎
+
+I don’t want to close them or bookmark them. I tried manually copying URLs into a `.txt` file, but then I wished there was a simple way to turn long links into short ones I could use later.
+
+I didn’t want to send anything online, and existing self-hosted URL shorteners felt like overkill for such a small need.
+
+So I made this: a minimal, local-only URL shortener. It started as a single script file and isn’t perfect—but it just works! ~ ദ്ദി/ᐠ｡‸｡ᐟ\
+
+
+## For Developers
+
+Want to tinker with `shortiepy` or contribute? Here's how to set it up locally:
+
+- Clone the repository locally and change the directory into it:
+
+```bash
+git clone https://github.com/CheapNightbot/shortiepy.git && cd shortiepy
+```
+
+- Install `shortiepy`:
+
+```bash
+# Create a virtual environment (keeps things clean!)
+python -m venv .venv
+
+# Activate it
+source .venv/bin/activate  # Linux/macOS
+# OR
+.venv\Scripts\activate     # Windows
+
+# Install in editable mode (changes reflect instantly!)
+pip install -e .
+```
+
+Now you can run `shortiepy` from anywhere in your terminal!
+Made a change? It’ll work immediately—no reinstall needed!
+
+### Updating Shell Completions
+
+If you modify CLI commands or options, regenerate completions:
+
+```bash
+./scripts/generate-completions.sh
+```
+
+> This updates the files in `shortiepy/completions/` directory.

shortiepy-0.0.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shortiepy"
+description = "A local-only URL shortener (˶˘ ³˘)♡"
+keywords = ["cli", "shortie", "shortiepy", "URL shortener"]
+dynamic = ["version"]
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+  {name = "ポテト ^. .^₎ฅ"},
+  {name = "ポテト ^. .^₎ฅ", email = "nya@cheapnightbot.me"},
+]
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Utilities",
+]
+dependencies = [
+    "click>=8.3.1",
+    "colorama>=0.4.6",
+    "Flask>=3.1.2",
+    "pyperclip>=1.11.0",
+    "tabulate>=0.9.0",
+    "waitress>=3.0.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/CheapNightbot/shortiepy"
+Repository = "https://github.com/CheapNightbot/shortiepy.git"
+Issues = "https://github.com/CheapNightbot/shortiepy/issues"
+
+[project.scripts]
+shortiepy = "shortiepy.__main__:cli"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["shortiepy*"]
+
+[tool.setuptools.package-data]
+shortiepy = ["completions/*"]

shortiepy-0.0.0/setup.cfg

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

shortiepy-0.0.0/shortiepy/__main__.py

@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("shortiepy")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+import json
+import os
+import platform
+import secrets
+import shutil
+import sqlite3
+import subprocess
+import sys
+import tempfile
+import webbrowser
+from pathlib import Path
+
+import click
+import pyperclip
+from colorama import init as colorama_init
+from tabulate import tabulate
+from waitress import serve
+
+# --- Kaomoji & Color Helpers ---
+colorama_init()  # Required for Windows
+
+
+def cute_echo(text, fg="bright_magenta"):
+    """Echo with pastel colors and sparkles"""
+    click.echo(click.style(text, fg=fg))
+
+
+def success(text):
+    return click.style(f"🌸 {text}", fg="bright_magenta")
+
+
+def error(text):
+    return click.style(f"❌ {text}", fg="bright_red")
+
+
+def info(text):
+    return click.style(f"ℹ️  {text}", fg="bright_blue")
+
+
+def warn(text):
+    return click.style(f"⚠️  {text}", fg="bright_yellow")
+
+
+class Config:
+    def __init__(self, config_path: Path, default_port):
+        self.config_path = config_path
+        self.default_port = default_port
+        self._port = None  # Lazy-loaded
+
+    @property
+    def port(self):
+        if self._port is None:
+            self._port = self._load()
+        return self._port
+
+    def _load(self):
+        if self.config_path.exists():
+            try:
+                with open(self.config_path) as f:
+                    return json.load(f).get("port", self.default_port)
+            except (json.JSONDecodeError, KeyError):
+                pass
+        return self.default_port
+
+    def save(self, port):
+        """Save new port and update cache"""
+        with open(self.config_path, "w") as f:
+            json.dump({"port": port}, f)
+        self._port = port  # Update cache
+
+
+# Determine OS-specific data directory
+def get_data_dir():
+    home = Path.home()
+    system = platform.system()
+    if system == "Windows":
+        return home / "AppData" / "Roaming" / "shortiepy"
+    elif system == "Darwin":  # macOS
+        return home / "Library" / "Application Support" / "shortiepy"
+    else:  # Linux and others
+        return home / ".local" / "share" / "shortiepy"
+
+
+# Paths
+DATA_DIR = get_data_dir()
+DATA_DIR.mkdir(parents=True, exist_ok=True)  # Create if missing
+DB_PATH = DATA_DIR / "shortiepy.db"
+LOCK_FILE = Path(tempfile.gettempdir()) / "shortiepy.lock"
+LOG_FILE = Path(tempfile.gettempdir()) / "shortiepy.log"
+
+# Config
+CONFIG_PATH = DATA_DIR / "config.json"
+DEFAULT_PORT = 9876
+config = Config(CONFIG_PATH, DEFAULT_PORT)
+
+
+# --- Helper Functions ---
+def generate_code(length=5):
+    return secrets.token_urlsafe(length)[:length]
+
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS urls (
+            code TEXT PRIMARY KEY,
+            url TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """
+    )
+    conn.close()
+
+
+def db_execute(query, params=(), fetch=False, fetchone=False):
+    """Execute DB query safely with automatic connection handling"""
+    try:
+        with sqlite3.connect(DB_PATH) as conn:
+            cur = conn.cursor()
+            cur.execute(query, params)
+            if fetch:
+                return cur.fetchall()
+            if fetchone:
+                return cur.fetchone()
+            return cur.rowcount
+    except sqlite3.OperationalError as e:
+        if "database is locked" in str(e):
+            raise RuntimeError("Database busy! Try again later. (；′⌒`)")
+    except sqlite3.IntegrityError as e:
+        raise RuntimeError(f"Database error: {str(e)}")
+
+
+# --- Flask App (for server) ---
+def create_flask_app():
+    from .app import create_app
+
+    return create_app(config.port)
+
+
+# --- CLI Commands ---
+@click.group()
+@click.version_option(version=__version__, prog_name="shortiepy")
+def cli():
+    """shortiepy: your local URL shortner ( ˶˘ ³˘)♡"""
+    pass
+
+
+@cli.command()
+@click.argument("action", required=False, default="install")
+def completion(action):
+    """Manage shell completions"""
+    if action != "install":
+        cute_echo(warn("Only 'install' is supported"))
+        return
+
+    # Detect shell
+    shell = os.environ.get("SHELL", "").split("/")[-1]
+    home = Path.home()
+
+    if shell == "bash":
+        dest_dir = home / ".local" / "share" / "bash-completion" / "completions"
+        dest_file = dest_dir / "shortiepy"
+        src_file = Path(__file__).parent / "completions" / "shortiepy.bash"
+
+    elif shell == "zsh":
+        dest_dir = home / ".zsh" / "completions"
+        dest_file = dest_dir / "_shortiepy"
+        src_file = Path(__file__).parent / "completions" / "shortiepy.zsh"
+
+    elif shell == "fish":
+        dest_dir = home / ".config" / "fish" / "completions"
+        dest_file = dest_dir / "shortiepy.fish"
+        src_file = Path(__file__).parent / "completions" / "shortiepy.fish"
+
+    else:
+        cute_echo(error(f"Unsupported shell: {shell}"))
+        cute_echo(info("Supported: bash, zsh, fish"))
+        return
+
+    # Create directory
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy file
+    try:
+        shutil.copy(src_file, dest_file)
+        cute_echo(success(f"Installed completion for {shell}!"))
+        if shell == "bash":
+            cute_echo(
+                info(
+                    """Restart your shell or run:
+    source ~/.bashrc"""
+                )
+            )
+        elif shell == "zsh":
+            cute_echo(
+                info(
+                    """Restart your shell or run:
+    source ~/.zshrc"""
+                )
+            )
+        # Fish loads automatically /ᐠ •⩊•マ
+
+    except Exception as e:
+        cute_echo(error(f"Failed to install: {e}"))
+
+
+@cli.command()
+@click.argument("url")
+def add(url):
+    """Add a new URL and copy short link to clipboard"""
+    init_db()
+    code = generate_code()
+
+    try:
+        db_execute("INSERT INTO urls (code, url) VALUES (?, ?)", (code, url))
+        short_url = f"http://localhost:{config.port}/{code}"
+        pyperclip.copy(short_url)
+        cute_echo(success(f"Copied to clipboard: {short_url}"))
+    except sqlite3.IntegrityError:
+        # Very rare, but handle duplicate codes
+        cute_echo(warn("Oops! Code collision (unlikely!) ~ (ᵕ—ᴗ—)"))
+        return add(url)  # retry
+    except RuntimeError as e:
+        cute_echo(error(str(e)))
+
+
+@cli.command()
+@click.argument("code")
+def delete(code):
+    """Delete a short URL by code"""
+    try:
+        deleted = db_execute("DELETE FROM urls WHERE code = ?", (code,))
+    except RuntimeError as e:
+        cute_echo(error(str(e)))
+
+    if deleted:
+        cute_echo(success(f"Deleted: http://localhost:{config.port}/{code}"))
+    else:
+        cute_echo(error(f"Code '{code}' not found! (；′⌒`)"))
+
+
+@cli.command()
+def docs():
+    """Open documentation in browser"""
+    # Check if server is running
+    if not LOCK_FILE.exists():
+        cute_echo(error("Server not running! (；′⌒`)"))
+        cute_echo(
+            info(
+                """Please start the server first:
+    shortiepy serve    →  Foreground server
+    shortiepy start    →  Background server"""
+            )
+        )
+        return
+
+    url = f"http://localhost:{config.port}"
+    try:
+        cute_echo(info(f"Opening docs: {url}"))
+        webbrowser.open(url)
+    except Exception as e:
+        cute_echo(error(f"Failed to open browser: {str(e)}"))
+        cute_echo(info(f"Visit manually: {url}"))
+
+
+@cli.command()
+def list():
+    """List all shortened URLs"""
+    init_db()
+
+    try:
+        rows = db_execute(
+            "SELECT code, url, created_at FROM urls ORDER BY created_at DESC",
+            fetch=True,
+        )
+    except RuntimeError as e:
+        cute_echo(error(str(e)))
+
+    if not rows:
+        cute_echo(warn("(;´༎ຶД༎ຶ`) No links yet! Add one with `shortiepy add <URL>`"))
+        return
+
+    # Prepare data
+    table_data = []
+    for code, url, created in rows:
+        short_url = f"http://localhost:{config.port}/{code}"
+        # Truncate long URLs for readability
+        display_url = (url[:40] + "...") if len(url) > 40 else url
+        table_data.append((code, short_url, display_url, created))
+
+    headers = ["Code", "Short URL", "Original URL", "Created At"]
+    output = tabulate(table_data, headers=headers, tablefmt="rounded_grid")
+    cute_echo(info("Your shortiepy links:"))
+    click.echo(output)
+
+
+@cli.command(name="serve")
+@click.option("--port", default=DEFAULT_PORT, help="Port to run shortiepy on")
+def run(port):
+    """Start the local redirect server"""
+    config.save(port)
+    cute_echo(info(f"Running shortiepy server on http://localhost:{config.port}"))
+    cute_echo(warn("Press CTRL + C to stop the server. (๑•̀ㅂ•́)و✧"))
+    app = create_flask_app()
+    serve(app=app, host="localhost", port=config.port)
+
+
+@cli.command(name="config")
+def show_config():
+    """Show shortiepy configurations"""
+    config_data = [
+        ("Version", __version__),
+        ("Port", str(config.port)),
+        ("Host", "localhost"),
+        ("Data Directory", str(DATA_DIR)),
+        ("Database", str(DB_PATH)),
+        ("Config File", str(CONFIG_PATH)),
+        ("Log File", str(LOG_FILE)),
+        ("Lock File", str(LOCK_FILE)),
+    ]
+
+    click.echo(tabulate(config_data, tablefmt="rounded_grid"))
+
+
+@cli.command()
+@click.option("--port", default=DEFAULT_PORT, help="Port to run shortiepy on")
+def start(port):
+    """Start shortiepy server in the background"""
+    config.save(port)
+
+    if LOCK_FILE.exists():
+        with open(LOCK_FILE) as f:
+            pid = int(f.read().strip())
+        try:
+            os.kill(pid, 0)
+            cute_echo(info(f"Server already running (PID: {pid})"))
+            cute_echo(info(f"URL: http://localhost:{config.port}"))
+            return
+        except OSError:
+            LOCK_FILE.unlink()
+
+    package_dir = Path(__file__).parent.resolve()
+    if not (package_dir / "__main__.py").exists():
+        raise RuntimeError("Cannot find shortiepy package")
+
+    # Create a minimal script to start the server
+    server_script = f"""
+import sys
+sys.path.insert(0, {repr(str(package_dir))})
+from shortiepy.__main__ import create_flask_app, DB_PATH
+from waitress import serve
+
+app = create_flask_app()
+serve(app=app, host="localhost", port={port})
+"""
+
+    # Start in background
+    proc = subprocess.Popen(
+        [sys.executable, "-c", server_script],
+        stdout=open(LOG_FILE, "w"),
+        stderr=subprocess.STDOUT,
+        start_new_session=True,
+    )
+
+    with open(LOCK_FILE, "w") as f:
+        f.write(str(proc.pid))
+
+    cute_echo(success(f"Started server (PID: {proc.pid})"))
+    cute_echo(info(f"Logs: {LOG_FILE}"))
+    cute_echo(info(f"URL: http://localhost:{config.port}"))
+
+
+@cli.command()
+def stop():
+    """Stop the background server"""
+    if not os.path.exists(LOCK_FILE):
+        cute_echo(warn("No background server running („• ֊ •„)"))
+        return
+
+    with open(LOCK_FILE) as f:
+        pid = int(f.read().strip())
+
+    try:
+        os.kill(pid, 15)  # SIGTERM
+        os.remove(LOCK_FILE)
+        cute_echo(success(f"Stopped server (PID: {pid}) ദ്ദി◝ ⩊ ◜.ᐟ"))
+    except ProcessLookupError:
+        cute_echo(error("Server not found. Cleaning up lock file."))
+        os.remove(LOCK_FILE)
+
+
+@cli.command()
+def status():
+    """Show server status and stats"""
+    if LOCK_FILE.exists():
+        with open(LOCK_FILE) as f:
+            try:
+                pid = int(f.read().strip())
+                os.kill(pid, 0)  # Check if running
+                cute_echo(success(f"Server: Running (PID: {pid}) (˶˃ ᵕ ˂˶) .ᐟ.ᐟ"))
+            except (OSError, ValueError):
+                cute_echo(warn("Server: Stopped (stale lock)"))
+                LOCK_FILE.unlink()
+    else:
+        cute_echo(warn("Server: Stopped (•˕ •マ.ᐟ"))
+
+    # Show DB stats
+    init_db()
+    conn = sqlite3.connect(DB_PATH)
+    count = conn.execute("SELECT COUNT(*) FROM urls").fetchone()[0]
+    conn.close()
+    cute_echo(info(f"Total URLs: {count}"))

shortiepy-0.0.0/shortiepy/app.py

@@ -0,0 +1,109 @@
+import sqlite3
+from pathlib import Path
+
+from flask import Flask, abort, redirect, render_template, request
+
+from .__main__ import __version__, db_execute, generate_code
+
+
+def create_app(config_port):
+    app = Flask(
+        __name__,
+        template_folder=Path(__file__).parent / "templates",
+        static_folder=Path(__file__).parent / "static",
+    )
+
+    app.config["PORT"] = config_port
+
+    @app.context_processor
+    def inject_version():
+        return {"version": __version__}
+
+    @app.route("/")
+    def index():
+        try:
+            count = db_execute("SELECT COUNT(*) FROM urls", fetchone=True)[0]
+        except RuntimeError:
+            count = -1
+        return render_template("index.html", total_urls=count, port=app.config["PORT"])
+
+    @app.route("/<code>")
+    def redirect_url(code):
+        try:
+            row = db_execute(
+                "SELECT url FROM urls WHERE code = ?", (code,), fetchone=True
+            )
+        except RuntimeError:
+            abort(404)
+        return redirect(row[0])
+
+    @app.route("/new")
+    def create_short_url():
+        code = request.args.get("code") or generate_code()
+        url = request.args.get("url")
+        templete_file = "message.html"
+
+        if not url:
+            return (
+                render_template(
+                    templete_file,
+                    title="❌ Missing Parameters",
+                    message="Use: <code>/new?code=your_code&url=https://example.com</code>",
+                    link="/",
+                ),
+                400,
+            )
+
+        try:
+            db_execute("INSERT INTO urls (code, url) VALUES (?, ?)", (code, url))
+            short_url = f"http://localhost:{app.config['PORT']}/{code}"
+            return render_template(
+                templete_file,
+                title="✨ Success!",
+                message=f"Created short URL: <a href='{short_url}' target='_blank' rel='nofollow noopener'>{short_url}</a>",
+                link="/",
+            )
+        except RuntimeError:
+            return (
+                render_template(
+                    templete_file,
+                    title="⚠️ Code Exists",
+                    message=f"Code '{code}' is already taken!",
+                    link="/",
+                ),
+                409,
+            )
+
+    @app.route("/list")
+    def list_urls():
+        try:
+            rows = db_execute(
+                "SELECT code, url, created_at FROM urls ORDER BY created_at DESC",
+                fetch=True,
+            )
+        except RuntimeError:
+            rows = []
+
+        urls = []
+        for code, url, created in rows:
+            short_url = f"http://localhost:{app.config['PORT']}/{code}"
+            display_url = (url[:50] + "...") if len(url) > 50 else url
+            urls.append(
+                {
+                    "code": code,
+                    "short_url": short_url,
+                    "display_url": display_url,
+                    "created": created,
+                }
+            )
+        return render_template("list.html", urls=urls, port=app.config["PORT"])
+
+    @app.route("/delete/<code>", methods=["POST"])
+    def delete_url(code):
+        try:
+            db_execute("DELETE FROM urls WHERE code = ?", (code,))
+        except RuntimeError:
+            return {"success": False, "message": "Failed to delete URL."}, 500
+        return {"success": True}
+
+    return app

shortiepy-0.0.0/shortiepy/completions/shortiepy.bash

@@ -0,0 +1,29 @@
+_shortiepy_completion() {
+    local IFS=$'\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD _SHORTIEPY_COMPLETE=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+_shortiepy_completion_setup() {
+    complete -o nosort -F _shortiepy_completion shortiepy
+}
+
+_shortiepy_completion_setup;
+

shortiepy-0.0.0/shortiepy/completions/shortiepy.fish

@@ -0,0 +1,18 @@
+function _shortiepy_completion;
+    set -l response (env _SHORTIEPY_COMPLETE=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) shortiepy);
+
+    for completion in $response;
+        set -l metadata (string split "," $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            echo $metadata[2];
+        end;
+    end;
+end;
+
+complete --no-files --command shortiepy --arguments "(_shortiepy_completion)";
+

shortiepy-0.0.0/shortiepy/completions/shortiepy.zsh

@@ -0,0 +1,41 @@
+#compdef shortiepy
+
+_shortiepy_completion() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[shortiepy] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) _SHORTIEPY_COMPLETE=zsh_complete shortiepy)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    # autoload from fpath, call function directly
+    _shortiepy_completion "$@"
+else
+    # eval/source/. command, register function for later
+    compdef _shortiepy_completion shortiepy
+fi
+

shortiepy-0.0.0/shortiepy.egg-info/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: shortiepy
+Version: 0.0.0
+Summary: A local-only URL shortener (˶˘ ³˘)♡
+Author: ポテト ^. .^₎ฅ
+Author-email: "ポテト ^. .^₎ฅ" <nya@cheapnightbot.me>
+License: MIT
+Project-URL: Homepage, https://github.com/CheapNightbot/shortiepy
+Project-URL: Repository, https://github.com/CheapNightbot/shortiepy.git
+Project-URL: Issues, https://github.com/CheapNightbot/shortiepy/issues
+Keywords: cli,shortie,shortiepy,URL shortener
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.3.1
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: Flask>=3.1.2
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: waitress>=3.0.2
+Dynamic: license-file
+
+# shortiepy 🌸
+
+Your local URL shortener (˶˘ ³˘)♡
+
+- 🔒 100% offline - no data leaves your machine
+- 🌈 Cross-platform (Linux/macOS/Windows)
+- 📋 Auto-copies short URLs to clipboard
+- 🎀 Pastel colors & kaomojis everywhere!
+
+## Installation
+
+- **Using `pipx`** [Recommended]
+
+Follow instructions to install `pipx` here: [pipx.pypa.io/stable/installation](https://pipx.pypa.io/stable/installation/) and after installing `pipx` in your system, install `shortiepy`:
+
+```bash
+pipx install shortiepy
+```
+
+- **Using `pip`**
+
+```bash
+pip install shortiepy
+```
+
+## Usage
+
+- **Add a URL**
+
+```bash
+shortiepy add https://example.com
+```
+
+- **Start server**
+
+```bash
+shortiepy serve  # will run in forground
+# OR
+shortiepy start  # will run in background
+```
+
+- **View docs**
+
+```bash
+shortiepy docs
+```
+
+### Create Links from browser
+
+shortiepy supports creating short URLs from within your browser (without having to use CLI `add` command).
+
+You can visit `/new` route and provide `code` (this will be used to generate short url) and `url` (the URL you want to create short link for) query paramters:
+
+- `http://localhost:9876/new?code=meow&url=https://example.com`
+
+    - It will create short link for `https://example.com` using provided short code: `http://localhost:9876/meow`
+
+    - The `code` parameter is optional and can be omitted.
+
+However, vising that URL and route manully is tedious! But if your browser allows it, like I have [Brave](https://brave.com/) browser, you can add a shortcut for it:
+
+- In your browser go to settings and find "search engines". In Brave, it's `brave://settings/searchEngines` and add the following in "Site search":
+
+  - Name: `shortiepy` (or anything you like)
+  - Shortcut: `:sh` (or anything you like)
+  - URL: `http://localhost:9876/new?url=%s`
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+  
+![Add Shortcut in Browser](https://github.com/user-attachments/assets/2f03b437-0452-4f22-9225-e12e10a2b15c)
+
+</details>
+ 
+Now when you want to create a short link, just type `:sh` in url bar and press `spacebar`, then you can paste the URL you want to create short link for and press enter!
+
+<details>
+  <summary>Click to See Screen Recording of above steps!</summary>
+
+![Use Shortcut to create short link](https://github.com/user-attachments/assets/bf04838a-09f8-4d30-888c-f6c043328ae4)
+
+</details>
+
+## Shell Completion
+
+Get tab-completion with **one command**:
+
+```bash
+shortiepy completion
+```
+
+> Restart your shell or reload config (`source ~/.bashrc` for bash OR `source ~/.zshrc` for zsh).
+> Fish users: no restart needed!
+
+That's it! Works for bash, zsh, and fish.
+
+## Why
+
+For some reason, when I’m working on things or trying to learn something new, my browser ends up filled with tons of tabs—which makes my laptop-chan angry ~ ₍^.  ̫.^₎
+
+I don’t want to close them or bookmark them. I tried manually copying URLs into a `.txt` file, but then I wished there was a simple way to turn long links into short ones I could use later.
+
+I didn’t want to send anything online, and existing self-hosted URL shorteners felt like overkill for such a small need.
+
+So I made this: a minimal, local-only URL shortener. It started as a single script file and isn’t perfect—but it just works! ~ ദ്ദി/ᐠ｡‸｡ᐟ\
+
+
+## For Developers
+
+Want to tinker with `shortiepy` or contribute? Here's how to set it up locally:
+
+- Clone the repository locally and change the directory into it:
+
+```bash
+git clone https://github.com/CheapNightbot/shortiepy.git && cd shortiepy
+```
+
+- Install `shortiepy`:
+
+```bash
+# Create a virtual environment (keeps things clean!)
+python -m venv .venv
+
+# Activate it
+source .venv/bin/activate  # Linux/macOS
+# OR
+.venv\Scripts\activate     # Windows
+
+# Install in editable mode (changes reflect instantly!)
+pip install -e .
+```
+
+Now you can run `shortiepy` from anywhere in your terminal!
+Made a change? It’ll work immediately—no reinstall needed!
+
+### Updating Shell Completions
+
+If you modify CLI commands or options, regenerate completions:
+
+```bash
+./scripts/generate-completions.sh
+```
+
+> This updates the files in `shortiepy/completions/` directory.

shortiepy-0.0.0/shortiepy.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+shortiepy/__init__.py
+shortiepy/__main__.py
+shortiepy/app.py
+shortiepy.egg-info/PKG-INFO
+shortiepy.egg-info/SOURCES.txt
+shortiepy.egg-info/dependency_links.txt
+shortiepy.egg-info/entry_points.txt
+shortiepy.egg-info/requires.txt
+shortiepy.egg-info/top_level.txt
+shortiepy/completions/shortiepy.bash
+shortiepy/completions/shortiepy.fish
+shortiepy/completions/shortiepy.zsh

shortiepy-0.0.0/shortiepy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

shortiepy-0.0.0/shortiepy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shortiepy = shortiepy.__main__:cli

shortiepy-0.0.0/shortiepy.egg-info/requires.txt

@@ -0,0 +1,6 @@
+click>=8.3.1
+colorama>=0.4.6
+Flask>=3.1.2
+pyperclip>=1.11.0
+tabulate>=0.9.0
+waitress>=3.0.2

shortiepy-0.0.0/shortiepy.egg-info/top_level.txt

@@ -0,0 +1 @@
+shortiepy