Initial commit: AWS Backup CLI

Author: Ahadxcode

.github/workflows/python-tests.yml

@@ -0,0 +1,26 @@
+
+name: Python Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run tests
+        run: pytest -q

.gitignore

@@ -0,0 +1,21 @@
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+.venv/
+.env
+.env.*
+dist/
+build/
+
+# Backups
+backups/
+*.tar.gz
+*.zip
+
+# OS files
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,107 @@
+
+# Python AWS Backup CLI
+
+A simple, production-ready Python script to compress a directory and upload the archive to **AWS S3**.  
+Includes unit tests (pytest) and CI automation with **GitHub Actions**.
+
+## Features
+- Compress any folder into a timestamped **.zip** (default) or **.tar.gz**
+- Upload the archive to **Amazon S3**
+- Simple CLI interface with sensible defaults
+- Unit tests with **pytest**
+- **GitHub Actions** workflow to run tests on every push/PR
+
+---
+
+## Quickstart
+
+### 1) Clone & set up
+```bash
+git clone https://github.com/your-username/python-aws-backup-cli.git
+cd python-aws-backup-cli
+python -m venv .venv
+# Windows
+. .venv/Scripts/activate
+# macOS/Linux
+# source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+### 2) Configure AWS credentials (one-time)
+Use the AWS CLI or environment variables.
+
+```bash
+# Option A: AWS CLI (recommended)
+aws configure
+# Provide AWS Access Key ID, Secret Access Key, region, output format
+```
+
+Alternatively set env vars before running:
+```bash
+export AWS_ACCESS_KEY_ID=...
+export AWS_SECRET_ACCESS_KEY=...
+export AWS_DEFAULT_REGION=ap-south-1
+```
+
+### 3) Run a local backup (no upload)
+```bash
+python backup.py --source ./my_data --outdir ./backups --format zip
+```
+
+### 4) Backup and upload to S3
+```bash
+python backup_and_s3.py --source ./my_data --outdir ./backups --format zip --bucket your-bucket-name --prefix optional/folder/path/
+```
+
+- `--bucket` is your S3 bucket name.
+- `--prefix` is optional (folder path inside the bucket).
+- Result example: `s3://your-bucket-name/optional/folder/path/backup_my_data_20250101_123000.zip`
+
+---
+
+## Project Structure
+```
+python-aws-backup-cli/
+├─ backup.py                # create compressed backups (zip/tar.gz)
+├─ s3_upload.py             # upload helper for S3
+├─ backup_and_s3.py         # one-shot: create backup + upload
+├─ requirements.txt
+├─ .gitignore
+├─ README.md
+├─ tests/
+│  └─ test_backup.py
+└─ .github/
+   └─ workflows/
+      └─ python-tests.yml   # CI: run pytest on push/PR
+```
+
+---
+
+## Examples
+
+Create a **.zip** archive:
+```bash
+python backup.py -s ./my_data -o ./backups -f zip
+```
+
+Create a **.tar.gz** archive:
+```bash
+python backup.py -s ./my_data -o ./backups -f tar
+```
+
+Backup and **upload to S3** with a prefix:
+```bash
+python backup_and_s3.py -s ./my_data -o ./backups -f zip --bucket my-bucket --prefix daily/ahad/
+```
+
+---
+
+## Notes
+- Windows users: prefer absolute paths or use `./my_data` relative to the project root.
+- Make sure your AWS IAM user/role has `s3:PutObject` permission for your bucket (and `s3:ListBucket` if needed).
+- Large directories: consider excluding patterns (future enhancement).
+
+---
+
+## License
+MIT

backup.py

@@ -0,0 +1,48 @@
+
+from pathlib import Path
+from datetime import datetime
+import argparse, zipfile, tarfile, sys
+
+def create_backup(source: Path, outdir: Path, fmt: str = "zip") -> Path:
+    """Create a compressed archive of `source` inside `outdir`.
+    fmt: 'zip' or 'tar' (tar -> .tar.gz)
+    Returns the path to the created archive.
+    """
+    source = Path(source)
+    outdir = Path(outdir)
+    if not source.exists() or not source.is_dir():
+        print(f"ERROR: Source folder not found: {source}")
+        sys.exit(1)
+
+    outdir.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    if fmt == "zip":
+        archive = outdir / f"backup_{source.name}_{ts}.zip"
+        with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as zf:
+            for path in source.rglob("*"):
+                zf.write(path, arcname=path.relative_to(source))
+    elif fmt == "tar":
+        archive = outdir / f"backup_{source.name}_{ts}.tar.gz"
+        with tarfile.open(archive, "w:gz") as tf:
+            tf.add(source, arcname=source.name)
+    else:
+        print("ERROR: Unknown format. Use 'zip' or 'tar'.")
+        sys.exit(2)
+
+    print(f"✅ Backup created: {archive}")
+    return archive
+
+def main():
+    p = argparse.ArgumentParser(description="Compress a directory into zip/tar.gz")
+    p.add_argument("-s","--source", default="my_data", help="Folder to back up")
+    p.add_argument("-o","--outdir", default="backups", help="Where to store backups")
+    p.add_argument("-f","--format", choices=["zip","tar"], default="zip", help="Archive format")
+    args = p.parse_args()
+
+    src = Path(args.source).expanduser().resolve()
+    out = Path(args.outdir).expanduser().resolve()
+    create_backup(src, out, args.format)
+
+if __name__ == "__main__":
+    main()

backup_and_s3.py

@@ -0,0 +1,28 @@
+
+from pathlib import Path
+from backup import create_backup
+from s3_upload import upload_to_s3
+import argparse
+
+def main():
+    p = argparse.ArgumentParser(description="Create backup and upload to S3")
+    p.add_argument("-s","--source", default="my_data", help="Folder to back up")
+    p.add_argument("-o","--outdir", default="backups", help="Where to store backups")
+    p.add_argument("-f","--format", choices=["zip","tar"], default="zip", help="Archive format")
+    p.add_argument("--bucket", required=True, help="S3 bucket name")
+    p.add_argument("--prefix", default="", help="Optional S3 key prefix (folder path in bucket)")
+    args = p.parse_args()
+
+    src = Path(args.source).expanduser().resolve()
+    out = Path(args.outdir).expanduser().resolve()
+
+    archive = create_backup(src, out, args.format)
+
+    # Construct object key
+    prefix = args.prefix.strip("/")
+    key = f"{prefix}/{archive.name}" if prefix else archive.name
+
+    upload_to_s3(archive, args.bucket, key)
+
+if __name__ == "__main__":
+    main()

my_data/sample.txt

@@ -0,0 +1 @@
+hello

requirements.txt

@@ -0,0 +1,3 @@
+
+boto3>=1.34.0
+pytest>=8.0.0

s3_upload.py

@@ -0,0 +1,14 @@
+
+import boto3
+from pathlib import Path
+
+def upload_to_s3(file_path: Path, bucket: str, key: str | None = None):
+    """Upload a file to S3. Requires AWS credentials to be configured in env or AWS CLI."""
+    file_path = Path(file_path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    s3 = boto3.client("s3")
+    key = key or file_path.name
+    s3.upload_file(str(file_path), bucket, key)
+    print(f"☁️ Uploaded to s3://{bucket}/{key}")

tests/test_backup.py

@@ -0,0 +1,27 @@
+
+from pathlib import Path
+from backup import create_backup
+
+def test_backup_creates_zip(tmp_path: Path):
+    # Arrange: create dummy data
+    src = tmp_path / "data"
+    src.mkdir()
+    (src / "a.txt").write_text("hello")
+    out = tmp_path / "out"
+
+    # Act
+    archive = create_backup(src, out, "zip")
+
+    # Assert
+    assert archive.exists()
+    assert archive.suffix == ".zip"
+
+def test_backup_creates_tar(tmp_path: Path):
+    src = tmp_path / "data"
+    src.mkdir()
+    (src / "a.txt").write_text("hello")
+    out = tmp_path / "out"
+
+    archive = create_backup(src, out, "tar")
+    assert archive.exists()
+    assert archive.name.endswith(".tar.gz")