drp-cli 0.1.3__tar.gz

drp_cli-0.1.3/CLI.md

@@ -0,0 +1,57 @@
+# drp
+
+Drop text and files from the command line — get a link instantly.
+
+```
+pip install drp-cli
+```
+
+## Usage
+
+```bash
+drp setup              # configure host & log in
+drp up notes.txt       # upload a file → prints URL
+drp up "hello world"   # upload text → prints URL
+drp up doc.pdf -k cv   # upload with a custom key
+drp get mykey          # text → stdout, file → saved to disk
+drp get mykey -o a.txt # save file with custom name
+drp rm mykey           # delete a drop
+drp mv mykey newkey    # rename a drop
+drp renew mykey        # renew a drop's expiry (paid)
+drp ls                 # list your drops (requires login)
+drp status             # show config
+drp --version          # show version
+```
+
+## How it works
+
+1. `drp setup` saves your host URL (default: `https://drp.vicnas.me`) and optionally logs you in
+2. `drp up` uploads a file or text string and prints the shareable URL
+3. `drp get` retrieves a drop — text is printed to stdout, files are saved to disk
+4. Works anonymously or logged in — logged-in users get locked drops, longer expiry, and `drp ls`
+
+## Configuration
+
+Config is stored at `~/.config/drp/config.json`:
+
+```json
+{
+  "host": "https://drp.vicnas.me",
+  "email": "you@example.com"
+}
+```
+
+## Self-hosted
+
+Point the CLI at your own instance:
+
+```bash
+drp setup
+# enter your server URL when prompted
+```
+
+See the [server repo](https://github.com/vicnasdev/drp) for deployment instructions.
+
+## License
+
+MIT

drp_cli-0.1.3/LICENSE

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

drp_cli-0.1.3/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: drp-cli
+Version: 0.1.3
+Summary: Drop text and files from the command line — get a link instantly.
+Author: Vic Nas
+License: MIT
+Project-URL: Homepage, https://drp.vicnas.me
+Project-URL: Repository, https://github.com/vicnasdev/drp
+Project-URL: Issues, https://github.com/vicnasdev/drp/issues
+Keywords: cli,file-sharing,pastebin,drops
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# drp
+
+Drop text and files from the command line — get a link instantly.
+
+```
+pip install drp-cli
+```
+
+## Usage
+
+```bash
+drp setup              # configure host & log in
+drp up notes.txt       # upload a file → prints URL
+drp up "hello world"   # upload text → prints URL
+drp up doc.pdf -k cv   # upload with a custom key
+drp get mykey          # text → stdout, file → saved to disk
+drp get mykey -o a.txt # save file with custom name
+drp rm mykey           # delete a drop
+drp mv mykey newkey    # rename a drop
+drp renew mykey        # renew a drop's expiry (paid)
+drp ls                 # list your drops (requires login)
+drp status             # show config
+drp --version          # show version
+```
+
+## How it works
+
+1. `drp setup` saves your host URL (default: `https://drp.vicnas.me`) and optionally logs you in
+2. `drp up` uploads a file or text string and prints the shareable URL
+3. `drp get` retrieves a drop — text is printed to stdout, files are saved to disk
+4. Works anonymously or logged in — logged-in users get locked drops, longer expiry, and `drp ls`
+
+## Configuration
+
+Config is stored at `~/.config/drp/config.json`:
+
+```json
+{
+  "host": "https://drp.vicnas.me",
+  "email": "you@example.com"
+}
+```
+
+## Self-hosted
+
+Point the CLI at your own instance:
+
+```bash
+drp setup
+# enter your server URL when prompted
+```
+
+See the [server repo](https://github.com/vicnasdev/drp) for deployment instructions.
+
+## License
+
+MIT

drp_cli-0.1.3/README.md

@@ -0,0 +1,134 @@
+# drp
+
+Drop files or paste text, get a link instantly. No account, no friction — just a key.
+
+- `/your-key` — view, copy, download, or replace a drop
+- Anonymous text drops expire after **24h** (text) or **90 days** (files)
+- Paid accounts get locked drops, longer expiry, and renewable links
+
+## Features
+
+- **Text & file drops** — paste anything or drag a file, get a shareable URL
+- **Custom keys** — pick a memorable key or get an auto-generated one
+- **Locking** — paid drops are locked to the owner's account; anon drops have a 24h edit window
+- **Expiry & renewal** — paid accounts set explicit expiry dates and can renew any time
+- **Dashboard** — logged-in users see all drops server-side; anon users get a local browser list with export/import
+- **CLI tool** — `drp up file.txt`, `drp up "some text"`, `drp get mykey`
+- **Self-hostable** — deploys to Railway in a few clicks, runs locally with SQLite
+
+## Deploy on Railway
+
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.com?referralCode=ZIdvo-)
+
+1. Fork this repo
+2. New project on Railway → Deploy from GitHub repo
+3. Add a PostgreSQL plugin
+4. Set environment variables:
+
+```
+SECRET_KEY=random_large_string
+DOMAIN=RAILWAY_PUBLIC_DOMAIN
+DB_URL=Postgres.DATABASE_URL
+CLOUDINARY_CLOUD_NAME=
+CLOUDINARY_API_KEY=
+CLOUDINARY_API_SECRET=
+EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
+EMAIL_HOST_USER=you@gmail.com
+EMAIL_HOST_PASSWORD=xxxx xxxx xxxx xxxx
+DEFAULT_FROM_EMAIL=you@gmail.com
+ADMIN_EMAIL=you@gmail.com
+LEMONSQUEEZY_API_KEY=
+LEMONSQUEEZY_SIGNING_SECRET=
+LEMONSQUEEZY_STORE_ID=
+LEMONSQUEEZY_STARTER_VARIANT_ID=
+LEMONSQUEEZY_PRO_VARIANT_ID=
+```
+
+5. Start command:
+
+```
+python manage.py createcachetable && python manage.py collectstatic --noinput && python manage.py migrate && gunicorn project.wsgi --bind 0.0.0.0:$PORT
+```
+
+> Note: run `python manage.py makemigrations` locally the first time before deploying.
+
+## Run locally
+
+```bash
+pip install -r requirements.txt
+cp .env.example .env        # fill in Cloudinary values; leave EMAIL_* blank for console output
+python manage.py migrate
+python manage.py createcachetable
+python manage.py runserver   # or: make dev
+```
+
+Password reset emails print to the terminal in dev — no mail server needed.
+
+## Makefile
+
+```
+make dev            # start Django dev server
+make test           # run all tests (core + cli)
+make migrate        # run migrations
+make install        # pip install -e . (installs drp command)
+```
+
+## Gmail App Password (production email)
+
+Self-service password reset requires an outbound mail account. Gmail works fine:
+
+1. Enable **2-Step Verification** on your Google account
+2. Go to **Security → App passwords**, create one named `drp`
+3. Copy the 16-character password into `EMAIL_HOST_PASSWORD` in your `.env`
+
+500 emails/day free. For higher volume use [Brevo](https://brevo.com) (3,000/mo free).
+
+## CLI
+
+Install from PyPI:
+
+```bash
+pip install drp-cli
+```
+
+Or from source:
+
+```bash
+pip install .         # or: make install
+```
+
+Usage:
+
+```bash
+drp setup             # configure host & log in
+drp up notes.txt      # upload a file → prints URL
+drp up "hello world"  # upload text → prints URL
+drp up doc.pdf -k cv  # upload with custom key
+drp get mykey         # text → stdout, file → saved to disk
+drp get mykey -o a.txt  # save file with custom name
+drp rm mykey          # delete a drop
+drp mv mykey newkey   # rename a drop
+drp renew mykey       # renew expiry (paid)
+drp ls                # list your drops (requires login)
+drp status            # show config
+drp --version         # show version
+```
+
+Works anonymously or logged in. Logged-in users get locked drops, longer expiry, and `drp ls`.
+
+## Plans
+
+| | Free | Starter ($3/mo) | Pro ($8/mo) |
+|---|---|---|---|
+| Max file size | 200 MB | 1 GB | 5 GB |
+| Max text size | 500 KB | 2 MB | 10 MB |
+| Storage | — | 5 GB | 20 GB |
+| Expiry | 24h / 90d | Up to 1 year | Up to 3 years |
+| Locked drops | ✗ | ✓ | ✓ |
+| Renewable | ✗ | ✓ | ✓ |
+
+Upgrade from your account page after signing up — billing is handled via Lemon Squeezy.
+
+## License
+
+MIT

drp_cli-0.1.3/cli/__init__.py

@@ -0,0 +1,3 @@
+"""drp CLI — command-line tool for drp."""
+
+__version__ = '0.1.3'

drp_cli-0.1.3/cli/api.py

@@ -0,0 +1,206 @@
+"""
+HTTP helpers for the drp CLI.
+
+All server communication lives here: CSRF, login, upload, download, delete,
+and key-existence checks.
+"""
+
+import os
+import secrets
+import requests
+from pathlib import Path
+
+
+def get_csrf(host, session):
+    """Hit the home page to pick up the csrftoken cookie."""
+    session.get(f'{host}/', timeout=10)
+    return session.cookies.get('csrftoken', '')
+
+
+def login(host, session, email, password):
+    """Authenticate with the drp server. Returns True on success."""
+    csrf = get_csrf(host, session)
+    res = session.post(
+        f'{host}/auth/login/',
+        data={'email': email, 'password': password, 'csrfmiddlewaretoken': csrf},
+        timeout=10,
+        allow_redirects=False,
+    )
+    return res.status_code in (302, 301)
+
+
+def upload_text(host, session, text, key=None):
+    """Upload text content. Returns the key on success, None on failure."""
+    csrf = get_csrf(host, session)
+    data = {'content': text, 'csrfmiddlewaretoken': csrf}
+    if key:
+        data['key'] = key
+    try:
+        res = session.post(f'{host}/save/', data=data, timeout=30)
+        if res.ok:
+            return res.json().get('key')
+        else:
+            _err(f'upload failed: {res.text[:200]}')
+    except Exception as e:
+        _err(f'upload error: {e}')
+    return None
+
+
+def upload_file(host, session, filepath, key=None):
+    """Upload a file. Returns the key on success, None on failure."""
+    csrf = get_csrf(host, session)
+    data = {'csrfmiddlewaretoken': csrf}
+    if key:
+        data['key'] = key
+    try:
+        with open(filepath, 'rb') as f:
+            res = session.post(
+                f'{host}/save/',
+                files={'file': (os.path.basename(filepath), f)},
+                data=data,
+                timeout=120,
+            )
+        if res.ok:
+            return res.json().get('key')
+        else:
+            _err(f'upload failed: {res.text[:200]}')
+    except Exception as e:
+        _err(f'upload error: {e}')
+    return None
+
+
+def get_drop(host, session, key):
+    """
+    Fetch a drop's content via the JSON API.
+    Returns (kind, content) where kind is 'text' or 'file'.
+    For text drops, content is the string.
+    For file drops, content is (bytes, filename).
+    Returns (None, None) on failure.
+    """
+    try:
+        res = session.get(
+            f'{host}/{key}/',
+            headers={'Accept': 'application/json'},
+            timeout=30,
+        )
+        if not res.ok:
+            if res.status_code == 410:
+                _err('drop has expired')
+            elif res.status_code == 404:
+                _err('drop not found')
+            else:
+                _err(f'server returned {res.status_code}')
+            return None, None
+
+        data = res.json()
+        if data.get('kind') == 'text':
+            return 'text', data.get('content', '')
+
+        # File drop — follow the download redirect
+        dl = session.get(
+            f'{host}{data["download"]}',
+            timeout=120,
+            allow_redirects=True,
+        )
+        if dl.ok:
+            filename = data.get('filename', key)
+            return 'file', (dl.content, filename)
+
+        _err('failed to download file')
+        return None, None
+    except Exception as e:
+        _err(f'get error: {e}')
+        return None, None
+
+
+def delete(host, session, key):
+    """Delete a drop. Returns True on success."""
+    csrf = get_csrf(host, session)
+    try:
+        res = session.delete(
+            f'{host}/{key}/delete/',
+            headers={'X-CSRFToken': csrf},
+            timeout=10,
+        )
+        return res.ok
+    except Exception:
+        return False
+
+
+def rename(host, session, key, new_key):
+    """Rename a drop's key. Returns the new key on success, None on failure."""
+    csrf = get_csrf(host, session)
+    try:
+        res = session.post(
+            f'{host}/{key}/rename/',
+            data={'new_key': new_key, 'csrfmiddlewaretoken': csrf},
+            timeout=10,
+        )
+        if res.ok:
+            return res.json().get('key')
+        _err(res.json().get('error', 'rename failed'))
+    except Exception as e:
+        _err(f'rename error: {e}')
+    return None
+
+
+def renew(host, session, key):
+    """Renew a drop's expiry. Returns (expires_at, renewals) on success."""
+    csrf = get_csrf(host, session)
+    try:
+        res = session.post(
+            f'{host}/{key}/renew/',
+            data={'csrfmiddlewaretoken': csrf},
+            timeout=10,
+        )
+        if res.ok:
+            data = res.json()
+            return data.get('expires_at'), data.get('renewals')
+        _err(res.json().get('error', 'renew failed'))
+    except Exception as e:
+        _err(f'renew error: {e}')
+    return None, None
+
+
+def list_drops(host, session):
+    """List the logged-in user's drops. Returns list of dicts or None."""
+    try:
+        res = session.get(
+            f'{host}/auth/account/',
+            headers={'Accept': 'application/json'},
+            timeout=15,
+        )
+        if res.ok:
+            return res.json().get('drops', [])
+        if res.status_code == 302:
+            _err('not logged in')
+        else:
+            _err(f'server returned {res.status_code}')
+    except Exception as e:
+        _err(f'list error: {e}')
+    return None
+
+
+def key_exists(host, session, key):
+    """Return True if the key exists on the server."""
+    try:
+        res = session.get(f'{host}/check-key/', params={'key': key}, timeout=10)
+        if res.ok:
+            return not res.json().get('available', True)
+    except Exception:
+        pass
+    return False
+
+
+def slug(name):
+    """Turn a filename into a url-safe slug (max 40 chars)."""
+    stem = Path(name).stem
+    safe = ''.join(c if c.isalnum() or c in '-_' else '-' for c in stem).strip('-')
+    return safe[:40] or secrets.token_urlsafe(6)
+
+
+def _err(msg):
+    """Print an error message."""
+    import sys
+    print(f'  ✗ {msg}', file=sys.stderr)
+    

drp_cli-0.1.3/cli/config.py

@@ -0,0 +1,26 @@
+"""
+Config management for the drp CLI.
+
+Stores host and email in ~/.config/drp/config.json.
+"""
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / '.config' / 'drp'
+CONFIG_FILE = CONFIG_DIR / 'config.json'
+
+
+def load(path=None):
+    """Load config from disk. Returns empty dict if missing."""
+    p = Path(path) if path else CONFIG_FILE
+    if p.exists():
+        return json.loads(p.read_text())
+    return {}
+
+
+def save(cfg, path=None):
+    """Save config to disk, creating parent dirs if needed."""
+    p = Path(path) if path else CONFIG_FILE
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(cfg, indent=2) + '\n')

drp_cli-0.1.3/cli/drp.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+drp — command-line tool for dropping text and files.
+
+Usage:
+  drp setup                     # configure host & login
+  drp login                     # (re)authenticate
+  drp up <file>                 # upload a file
+  drp up <file> --key myname    # upload with a custom key
+  drp up "some text"            # upload text
+  drp get <key>                 # download a drop
+  drp rm <key>                  # delete a drop
+  drp mv <key> <new-key>        # rename a drop
+  drp renew <key>               # renew a drop's expiry
+  drp ls                        # list your drops (requires login)
+  drp status                    # show config
+"""
+
+import sys
+import os
+import getpass
+import argparse
+import requests
+
+from cli import config, api
+
+
+def cmd_setup(args):
+    """Interactive first-time setup."""
+    cfg = config.load()
+    print('drp setup')
+    print('─────────')
+    default = cfg.get('host', 'https://drp.vicnas.me')
+    cfg['host'] = input(f'  Host [{default}]: ').strip() or default
+    config.save(cfg)
+
+    answer = input('  Log in now? (y/n) [y]: ').strip().lower()
+    if answer != 'n':
+        cmd_login(args)
+    else:
+        config.save(cfg)
+
+    print(f'\n  ✓ Saved to {config.CONFIG_FILE}')
+
+
+def cmd_login(args):
+    """Log in to drp."""
+    cfg = config.load()
+    host = cfg.get('host', 'https://drp.vicnas.me')
+    email = input('  Email: ').strip()
+    password = getpass.getpass('  Password: ')
+    session = requests.Session()
+    if api.login(host, session, email, password):
+        cfg['email'] = email
+        config.save(cfg)
+        print(f'  ✓ Logged in as {email}')
+    else:
+        print('  ✗ Login failed.')
+        sys.exit(1)
+
+
+def cmd_up(args):
+    """Upload a file or text."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    target = args.target
+    key = args.key
+
+    # If target is a file path that exists, upload as file
+    if os.path.isfile(target):
+        if not key:
+            key = api.slug(os.path.basename(target))
+        result_key = api.upload_file(host, session, target, key=key)
+        if result_key:
+            url = f'{host}/{result_key}/'
+            print(f'{url}')
+        else:
+            sys.exit(1)
+    else:
+        # Treat as text content
+        result_key = api.upload_text(host, session, target, key=key)
+        if result_key:
+            url = f'{host}/{result_key}/'
+            print(f'{url}')
+        else:
+            sys.exit(1)
+
+
+def cmd_get(args):
+    """Download a drop."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    key = args.key
+    kind, content = api.get_drop(host, session, key)
+
+    if kind == 'text':
+        print(content)
+    elif kind == 'file':
+        data, filename = content
+        out = args.output or filename
+        with open(out, 'wb') as f:
+            f.write(data)
+        print(f'  ✓ {out} ({len(data)} bytes)')
+    else:
+        print(f'  ✗ drop not found: {key}')
+        sys.exit(1)
+
+
+def cmd_rm(args):
+    """Delete a drop."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    if api.delete(host, session, args.key):
+        print(f'  ✓ deleted /{args.key}/')
+    else:
+        print(f'  ✗ could not delete /{args.key}/')
+        sys.exit(1)
+
+
+def cmd_mv(args):
+    """Rename a drop's key."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    new_key = api.rename(host, session, args.key, args.new_key)
+    if new_key:
+        print(f'  ✓ /{args.key}/ → /{new_key}/')
+    else:
+        print(f'  ✗ could not rename /{args.key}/')
+        sys.exit(1)
+
+
+def cmd_renew(args):
+    """Renew a drop's expiry."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    expires_at, renewals = api.renew(host, session, args.key)
+    if expires_at:
+        print(f'  ✓ /{args.key}/ renewed (expires {expires_at}, #{renewals})')
+    else:
+        print(f'  ✗ could not renew /{args.key}/')
+        sys.exit(1)
+
+
+def cmd_ls(args):
+    """List your drops."""
+    cfg = config.load()
+    host = cfg.get('host')
+    if not host:
+        print('Not configured. Run: drp setup')
+        sys.exit(1)
+
+    session = requests.Session()
+    _auto_login(cfg, host, session)
+
+    drops = api.list_drops(host, session)
+    if drops is None:
+        print('  ✗ could not list drops (are you logged in?)')
+        sys.exit(1)
+
+    if not drops:
+        print('  (no drops)')
+        return
+
+    for d in drops:
+        kind = d['kind']
+        key = d['key']
+        name = d.get('filename') or ''
+        if kind == 'file' and name:
+            print(f'  {key:30s}  {kind:4s}  {name}')
+        else:
+            print(f'  {key:30s}  {kind:4s}')
+
+
+def cmd_status(args):
+    """Show current config."""
+    cfg = config.load()
+    print('drp status')
+    print('──────────')
+    print(f'  Host:    {cfg.get("host", "(not set)")}')
+    print(f'  Account: {cfg.get("email", "anonymous")}')
+    print(f'  Config:  {config.CONFIG_FILE}')
+
+
+def _auto_login(cfg, host, session):
+    """Silently log in if email is saved. Continues anonymously on failure."""
+    email = cfg.get('email')
+    if email:
+        password = getpass.getpass(f'  Password for {email}: ')
+        if not api.login(host, session, email, password):
+            print('  ⚠ Login failed, continuing as anonymous.')
+
+
+def main():
+    from cli import __version__
+
+    parser = argparse.ArgumentParser(
+        prog='drp',
+        description='Drop text and files from the command line.',
+    )
+    parser.add_argument('--version', '-V', action='version', version=f'%(prog)s {__version__}')
+    sub = parser.add_subparsers(dest='command')
+
+    # setup
+    sub.add_parser('setup', help='Configure host & login')
+
+    # login
+    sub.add_parser('login', help='Log in to drp')
+
+    # up
+    p_up = sub.add_parser('up', help='Upload a file or text')
+    p_up.add_argument('target', help='File path or text string to upload')
+    p_up.add_argument('--key', '-k', default=None, help='Custom key (default: auto from filename)')
+
+    # get
+    p_get = sub.add_parser('get', help='Download a drop')
+    p_get.add_argument('key', help='Drop key to download')
+    p_get.add_argument('--output', '-o', default=None, help='Output filename (files only)')
+
+    # rm
+    p_rm = sub.add_parser('rm', help='Delete a drop')
+    p_rm.add_argument('key', help='Drop key to delete')
+
+    # mv (rename)
+    p_mv = sub.add_parser('mv', help='Rename a drop key')
+    p_mv.add_argument('key', help='Current drop key')
+    p_mv.add_argument('new_key', help='New key')
+
+    # renew
+    p_renew = sub.add_parser('renew', help='Renew a drop expiry')
+    p_renew.add_argument('key', help='Drop key to renew')
+
+    # ls
+    sub.add_parser('ls', help='List your drops (requires login)')
+
+    # status
+    sub.add_parser('status', help='Show config')
+
+    args = parser.parse_args()
+
+    commands = {
+        'setup': cmd_setup,
+        'login': cmd_login,
+        'up': cmd_up,
+        'get': cmd_get,
+        'rm': cmd_rm,
+        'mv': cmd_mv,
+        'renew': cmd_renew,
+        'ls': cmd_ls,
+        'status': cmd_status,
+    }
+
+    if args.command in commands:
+        commands[args.command](args)
+    else:
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

drp_cli-0.1.3/cli/tests.py

@@ -0,0 +1,334 @@
+"""
+Tests for the drp CLI helpers (config, api, slug).
+
+Uses LiveServerTestCase so api functions talk to a real Django instance.
+All tests are self-cleaning (transaction rollback per test).
+"""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from django.contrib.auth.models import User
+from django.test import LiveServerTestCase, override_settings
+
+import requests
+
+from cli import api, config
+
+# Use plain static storage in tests (no collectstatic needed)
+_STATIC_OVERRIDE = override_settings(
+    STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage'
+)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Config
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class ConfigTests(LiveServerTestCase):
+    """config.load / config.save with temp files."""
+
+    def test_load_missing_returns_empty(self):
+        """Loading a non-existent config returns {}."""
+        self.assertEqual(config.load('/tmp/drp_nope_12345.json'), {})
+
+    def test_save_and_load_roundtrip(self):
+        """save → load returns the same data."""
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as f:
+            path = f.name
+        try:
+            cfg = {'host': 'https://example.com', 'email': 'a@b.com'}
+            config.save(cfg, path)
+            loaded = config.load(path)
+            self.assertEqual(loaded, cfg)
+        finally:
+            os.unlink(path)
+
+    def test_save_creates_parent_dirs(self):
+        """save creates missing parent directories."""
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, 'sub', 'dir', 'config.json')
+            config.save({'host': 'x'}, path)
+            self.assertTrue(os.path.exists(path))
+            self.assertEqual(config.load(path), {'host': 'x'})
+
+    def test_save_overwrites(self):
+        """Saving twice overwrites the first value."""
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as f:
+            path = f.name
+        try:
+            config.save({'host': 'old'}, path)
+            config.save({'host': 'new'}, path)
+            self.assertEqual(config.load(path)['host'], 'new')
+        finally:
+            os.unlink(path)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Slug
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class SlugTests(LiveServerTestCase):
+    """api.slug turns filenames into url-safe keys."""
+
+    def test_simple(self):
+        self.assertEqual(api.slug('notes.txt'), 'notes')
+
+    def test_spaces_become_dashes(self):
+        self.assertEqual(api.slug('my cool file.pdf'), 'my-cool-file')
+
+    def test_special_chars_stripped(self):
+        self.assertEqual(api.slug('hello@world!.py'), 'hello-world')
+
+    def test_long_name_truncated(self):
+        name = 'a' * 100 + '.txt'
+        self.assertLessEqual(len(api.slug(name)), 40)
+
+    def test_empty_name_gets_random(self):
+        """An empty stem (e.g. '.bashrc') still produces a non-empty slug."""
+        result = api.slug('.bashrc')
+        # .bashrc stem is '.bashrc' → 'bashrc' after stripping
+        self.assertTrue(len(result) > 0)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# API – CSRF & Login
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@_STATIC_OVERRIDE
+class AuthApiTests(LiveServerTestCase):
+    """CSRF, login, and session handling."""
+
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username='cli@test.com', email='cli@test.com', password='pass1234'
+        )
+        self.session = requests.Session()
+
+    def test_get_csrf_returns_token(self):
+        token = api.get_csrf(self.live_server_url, self.session)
+        self.assertTrue(len(token) > 0)
+
+    def test_login_success(self):
+        ok = api.login(self.live_server_url, self.session, 'cli@test.com', 'pass1234')
+        self.assertTrue(ok)
+
+    def test_login_wrong_password(self):
+        ok = api.login(self.live_server_url, self.session, 'cli@test.com', 'wrong')
+        self.assertFalse(ok)
+
+    def test_login_nonexistent_user(self):
+        ok = api.login(self.live_server_url, self.session, 'no@one.com', 'pass')
+        self.assertFalse(ok)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# API – Upload, Get, Delete (anonymous)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@_STATIC_OVERRIDE
+class AnonDropApiTests(LiveServerTestCase):
+    """Upload / get / delete drops as an anonymous user."""
+
+    def setUp(self):
+        self.session = requests.Session()
+        self.host = self.live_server_url
+
+    # ── Text ──────────────────────────────────────────────────────────────
+
+    def test_upload_text(self):
+        key = api.upload_text(self.host, self.session, 'hello world')
+        self.assertIsNotNone(key)
+        self.assertTrue(len(key) > 0)
+
+    def test_upload_text_custom_key(self):
+        key = api.upload_text(self.host, self.session, 'custom!', key='mykey')
+        self.assertEqual(key, 'mykey')
+
+    def test_get_text_drop(self):
+        key = api.upload_text(self.host, self.session, 'i can be retrieved')
+        kind, content = api.get_drop(self.host, self.session, key)
+        self.assertEqual(kind, 'text')
+        self.assertEqual(content, 'i can be retrieved')
+
+    def test_delete_text_drop(self):
+        key = api.upload_text(self.host, self.session, 'delete me')
+        ok = api.delete(self.host, self.session, key)
+        self.assertTrue(ok)
+        # should be gone
+        self.assertFalse(api.key_exists(self.host, self.session, key))
+
+    # ── File ──────────────────────────────────────────────────────────────
+
+    def test_upload_file(self):
+        with tempfile.NamedTemporaryFile(suffix='.txt', delete=False) as f:
+            f.write(b'file content here')
+            f.flush()
+            path = f.name
+        try:
+            key = api.upload_file(self.host, self.session, path, key='filetest')
+            self.assertEqual(key, 'filetest')
+        finally:
+            os.unlink(path)
+
+    def test_get_file_drop(self):
+        with tempfile.NamedTemporaryFile(suffix='.txt', delete=False) as f:
+            f.write(b'binary data')
+            f.flush()
+            path = f.name
+        try:
+            key = api.upload_file(self.host, self.session, path, key='getfile')
+            kind, content = api.get_drop(self.host, self.session, key)
+            self.assertEqual(kind, 'file')
+            data, filename = content
+            self.assertIn(b'binary data', data)
+        finally:
+            os.unlink(path)
+
+    # ── Key checks ────────────────────────────────────────────────────────
+
+    def test_key_exists_true(self):
+        api.upload_text(self.host, self.session, 'exists', key='taken')
+        self.assertTrue(api.key_exists(self.host, self.session, 'taken'))
+
+    def test_key_exists_false(self):
+        self.assertFalse(api.key_exists(self.host, self.session, 'nope-not-here'))
+
+    # ── Not found ─────────────────────────────────────────────────────────
+
+    def test_get_nonexistent_drop(self):
+        kind, content = api.get_drop(self.host, self.session, 'no-such-key')
+        self.assertIsNone(kind)
+        self.assertIsNone(content)
+
+    def test_delete_nonexistent_drop(self):
+        ok = api.delete(self.host, self.session, 'no-such-key')
+        self.assertFalse(ok)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# API – Authenticated drops
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@_STATIC_OVERRIDE
+class AuthDropApiTests(LiveServerTestCase):
+    """Upload / get / delete drops as a logged-in user."""
+
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username='auth@test.com', email='auth@test.com', password='pass1234'
+        )
+        self.session = requests.Session()
+        self.host = self.live_server_url
+        api.login(self.host, self.session, 'auth@test.com', 'pass1234')
+
+    def test_upload_text_authed(self):
+        key = api.upload_text(self.host, self.session, 'logged in text', key='authtext')
+        self.assertEqual(key, 'authtext')
+
+    def test_upload_file_authed(self):
+        with tempfile.NamedTemporaryFile(suffix='.txt', delete=False) as f:
+            f.write(b'auth file')
+            f.flush()
+            path = f.name
+        try:
+            key = api.upload_file(self.host, self.session, path, key='authfile')
+            self.assertEqual(key, 'authfile')
+        finally:
+            os.unlink(path)
+
+    def test_get_text_authed(self):
+        api.upload_text(self.host, self.session, 'authed content', key='authget')
+        kind, content = api.get_drop(self.host, self.session, 'authget')
+        self.assertEqual(kind, 'text')
+        self.assertEqual(content, 'authed content')
+
+    def test_delete_authed(self):
+        api.upload_text(self.host, self.session, 'bye', key='authdel')
+        ok = api.delete(self.host, self.session, 'authdel')
+        self.assertTrue(ok)
+        self.assertFalse(api.key_exists(self.host, self.session, 'authdel'))
+
+    def test_locked_drop_not_deletable_by_anon(self):
+        """A locked drop can't be deleted from a fresh (anonymous) session."""
+        from core.models import Drop
+        api.upload_text(self.host, self.session, 'locked', key='locktest')
+        Drop.objects.filter(key='locktest').update(locked=True)
+        anon = requests.Session()
+        ok = api.delete(self.host, anon, 'locktest')
+        self.assertFalse(ok)
+
+    def test_rename_drop(self):
+        api.upload_text(self.host, self.session, 'rename me', key='oldname')
+        new_key = api.rename(self.host, self.session, 'oldname', 'newname')
+        self.assertEqual(new_key, 'newname')
+        # old key gone, new key exists
+        self.assertFalse(api.key_exists(self.host, self.session, 'oldname'))
+        self.assertTrue(api.key_exists(self.host, self.session, 'newname'))
+
+    def test_rename_to_taken_key_fails(self):
+        api.upload_text(self.host, self.session, 'first', key='existing')
+        api.upload_text(self.host, self.session, 'second', key='movethis')
+        result = api.rename(self.host, self.session, 'movethis', 'existing')
+        self.assertIsNone(result)
+
+    def test_renew_drop(self):
+        """Paid drops can be renewed."""
+        from core.models import Drop, Plan
+        from django.utils import timezone
+        from datetime import timedelta
+        self.user.profile.plan = Plan.STARTER
+        self.user.profile.save()
+        api.upload_text(self.host, self.session, 'renew me', key='renewtest')
+        # Manually set expires_at to something in the near future
+        drop = Drop.objects.get(key='renewtest')
+        drop.expires_at = timezone.now() + timedelta(days=1)
+        drop.save()
+        expires_at, renewals = api.renew(self.host, self.session, 'renewtest')
+        self.assertIsNotNone(expires_at)
+        self.assertEqual(renewals, 1)
+
+    def test_renew_anon_drop_fails(self):
+        """Anon drops (no expires_at) cannot be renewed."""
+        anon = requests.Session()
+        api.upload_text(self.host, anon, 'no renew', key='anonrenew')
+        expires_at, _ = api.renew(self.host, self.session, 'anonrenew')
+        self.assertIsNone(expires_at)
+
+    def test_list_drops(self):
+        api.upload_text(self.host, self.session, 'list item 1', key='list1')
+        api.upload_text(self.host, self.session, 'list item 2', key='list2')
+        drops = api.list_drops(self.host, self.session)
+        self.assertIsNotNone(drops)
+        keys = [d['key'] for d in drops]
+        self.assertIn('list1', keys)
+        self.assertIn('list2', keys)
+
+    def test_list_drops_anon_fails(self):
+        """Anonymous session can't list drops (requires login)."""
+        anon = requests.Session()
+        drops = api.list_drops(self.host, anon)
+        self.assertIsNone(drops)
+
+    def test_list_drops_empty(self):
+        drops = api.list_drops(self.host, self.session)
+        self.assertIsNotNone(drops)
+        self.assertEqual(len(drops), 0)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Version
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class VersionTests(LiveServerTestCase):
+    """__version__ is importable and looks like semver."""
+
+    def test_version_format(self):
+        from cli import __version__
+        parts = __version__.split('.')
+        self.assertEqual(len(parts), 3)
+        for p in parts:
+            self.assertTrue(p.isdigit())

drp_cli-0.1.3/drp_cli.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: drp-cli
+Version: 0.1.3
+Summary: Drop text and files from the command line — get a link instantly.
+Author: Vic Nas
+License: MIT
+Project-URL: Homepage, https://drp.vicnas.me
+Project-URL: Repository, https://github.com/vicnasdev/drp
+Project-URL: Issues, https://github.com/vicnasdev/drp/issues
+Keywords: cli,file-sharing,pastebin,drops
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# drp
+
+Drop text and files from the command line — get a link instantly.
+
+```
+pip install drp-cli
+```
+
+## Usage
+
+```bash
+drp setup              # configure host & log in
+drp up notes.txt       # upload a file → prints URL
+drp up "hello world"   # upload text → prints URL
+drp up doc.pdf -k cv   # upload with a custom key
+drp get mykey          # text → stdout, file → saved to disk
+drp get mykey -o a.txt # save file with custom name
+drp rm mykey           # delete a drop
+drp mv mykey newkey    # rename a drop
+drp renew mykey        # renew a drop's expiry (paid)
+drp ls                 # list your drops (requires login)
+drp status             # show config
+drp --version          # show version
+```
+
+## How it works
+
+1. `drp setup` saves your host URL (default: `https://drp.vicnas.me`) and optionally logs you in
+2. `drp up` uploads a file or text string and prints the shareable URL
+3. `drp get` retrieves a drop — text is printed to stdout, files are saved to disk
+4. Works anonymously or logged in — logged-in users get locked drops, longer expiry, and `drp ls`
+
+## Configuration
+
+Config is stored at `~/.config/drp/config.json`:
+
+```json
+{
+  "host": "https://drp.vicnas.me",
+  "email": "you@example.com"
+}
+```
+
+## Self-hosted
+
+Point the CLI at your own instance:
+
+```bash
+drp setup
+# enter your server URL when prompted
+```
+
+See the [server repo](https://github.com/vicnasdev/drp) for deployment instructions.
+
+## License
+
+MIT

drp_cli-0.1.3/drp_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+CLI.md
+LICENSE
+README.md
+pyproject.toml
+cli/__init__.py
+cli/api.py
+cli/config.py
+cli/drp.py
+cli/tests.py
+drp_cli.egg-info/PKG-INFO
+drp_cli.egg-info/SOURCES.txt
+drp_cli.egg-info/dependency_links.txt
+drp_cli.egg-info/entry_points.txt
+drp_cli.egg-info/requires.txt
+drp_cli.egg-info/top_level.txt

drp_cli-0.1.3/drp_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

drp_cli-0.1.3/drp_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+drp = cli.drp:main

drp_cli-0.1.3/drp_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

drp_cli-0.1.3/drp_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+cli

drp_cli-0.1.3/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "drp-cli"
+dynamic = ["version"]
+description = "Drop text and files from the command line — get a link instantly."
+readme = "CLI.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = ["requests>=2.28"]
+authors = [{name = "Vic Nas"}]
+keywords = ["cli", "file-sharing", "pastebin", "drops"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://drp.vicnas.me"
+Repository = "https://github.com/vicnasdev/drp"
+Issues = "https://github.com/vicnasdev/drp/issues"
+
+[project.scripts]
+drp = "cli.drp:main"
+
+[tool.setuptools.dynamic]
+version = {attr = "cli.__version__"}
+
+[tool.setuptools.packages.find]
+include = ["cli*"]

drp_cli-0.1.3/setup.cfg

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