tde 1.0.0__py3-none-any.whl

tde/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

tde/cli.py

@@ -0,0 +1,293 @@
+import argparse
+import base64
+import os
+import re
+import sys
+
+from tde import __version__
+
+
+
+def _supports_colour() -> bool:
+    if os.getenv("NO_COLOR"):          
+        return False
+    if os.getenv("TERM") == "dumb":
+        return False
+    return hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
+
+
+_COLOUR = _supports_colour()
+
+def _c(code: str, text: str) -> str:
+    return f"\033[{code}m{text}\033[0m" if _COLOUR else text
+
+
+def _bold(t: str)   -> str: return _c("1", t)
+def _cyan(t: str)   -> str: return _c("36", t)
+def _green(t: str)  -> str: return _c("32", t)
+def _yellow(t: str) -> str: return _c("33", t)
+def _red(t: str)    -> str: return _c("31", t)
+def _dim(t: str)    -> str: return _c("2", t)
+
+
+
+
+BANNER = rf"""
+  {_cyan("+========================================+")}
+  {_cyan("|")}  {_bold("TDE")} -- {_green("The Data Encoder / Decoder")}    {_cyan("|")}
+  {_cyan("|")}  {_dim(f"v{__version__}  |  Zero-dependency Base64")}    {_cyan("|")}
+  {_cyan("+========================================+")}
+"""
+
+EPILOG = f"""
+{_bold("Examples:")}
+
+  {_green("Encode a string:")}
+    tde encode "hello world"
+
+  {_green("Decode a string:")}
+    tde decode "aGVsbG8gd29ybGQ="
+
+  {_green("URL-safe encode:")}
+    tde encode "https://example.com/api?q=1" --url
+
+  {_green("Strict decode (halt on bad chars):")}
+    tde decode "aGVsbG8gd2!9ybGQ=" --strict
+
+  {_green("Ignore garbage (strip junk, then decode):")}
+    tde decode "aGVsbG8  gd 29ybGQ=" --ignore-garbage
+
+  {_green("File I/O -- read from file, write result to file:")}
+    tde decode -i payload.txt -o output.bin
+
+  {_green("Pipe from another command:")}
+    echo hello | tde encode
+"""
+
+
+class _Formatter(argparse.RawDescriptionHelpFormatter):
+
+    def __init__(self, prog: str, **kwargs):
+        kwargs.setdefault("max_help_position", 30)
+        kwargs.setdefault("width", 80)
+        super().__init__(prog, **kwargs)
+
+
+
+
+def _acquire_input(args) -> bytes:
+  
+    if args.input:
+        path = os.path.expanduser(args.input)
+        if not os.path.isfile(path):
+            _die(f"Input file not found: {path}")
+        try:
+            with open(path, "rb") as fh:
+                return fh.read()
+        except OSError as exc:
+            _die(f"Cannot read file '{path}': {exc}")
+
+    
+    if not sys.stdin.isatty():
+        data = sys.stdin.buffer.read()
+        if data:
+            return data
+
+    
+    if args.data:
+        return args.data.encode("utf-8")
+
+  
+    _die("No input provided. Supply a string, use -i <file>, or pipe data via stdin.")
+
+
+
+
+def _encode(payload: bytes, *, url_safe: bool) -> bytes:
+    if url_safe:
+        encoded = base64.urlsafe_b64encode(payload)
+        return encoded.rstrip(b"=")          
+    return base64.b64encode(payload)
+
+
+def _decode(payload: bytes, *, url_safe: bool, strict: bool,
+            ignore_garbage: bool) -> bytes:
+    text = payload.decode("ascii", errors="ignore")
+
+ 
+    if strict:
+        if url_safe:
+            bad = re.findall(r"[^A-Za-z0-9\-_=\s]", text)
+        else:
+            bad = re.findall(r"[^A-Za-z0-9+/=\s]", text)
+        if bad:
+            unique = sorted(set(bad))
+            _die(
+                f"Strict mode: invalid Base64 character(s) found: "
+                f"{', '.join(repr(c) for c in unique)}\n"
+                f"  Hint: use --ignore-garbage to strip them automatically."
+            )
+
+  
+    if ignore_garbage:
+        if url_safe:
+            text = re.sub(r"[^A-Za-z0-9\-_=]", "", text)
+        else:
+            text = re.sub(r"[^A-Za-z0-9+/=]", "", text)
+    else:
+        
+        text = text.strip()
+
+  
+    if url_safe:
+        pad = 4 - len(text) % 4
+        if pad != 4:
+            text += "=" * pad
+        try:
+            return base64.urlsafe_b64decode(text)
+        except Exception as exc:
+            _die(f"Decoding failed: {exc}")
+
+
+    try:
+        return base64.b64decode(text)
+    except Exception as exc:
+        _die(f"Decoding failed: {exc}")
+
+
+
+
+def _emit(result: bytes, args) -> None:
+    if args.output:
+        path = os.path.expanduser(args.output)
+        try:
+            with open(path, "wb") as fh:
+                fh.write(result)
+            _info(f"Output written to {_bold(path)}")
+        except OSError as exc:
+            _die(f"Cannot write to '{path}': {exc}")
+    else:
+       
+        sys.stdout.buffer.write(result)
+        sys.stdout.buffer.write(b"\n")
+        sys.stdout.buffer.flush()
+
+
+
+
+def _info(msg: str) -> None:
+    _stderr(f"{_green('[OK]')} {msg}")
+
+
+def _stderr(msg: str) -> None:
+    try:
+        sys.stderr.write(msg + "\n")
+    except UnicodeEncodeError:
+        sys.stderr.buffer.write(msg.encode("utf-8", errors="replace"))
+        sys.stderr.buffer.write(b"\n")
+        sys.stderr.buffer.flush()
+
+
+def _die(msg: str, code: int = 1) -> None:
+    _stderr(f"\n{_red('Error:')} {msg}")
+    sys.exit(code)
+
+
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="tde",
+        description=BANNER,
+        epilog=EPILOG,
+        formatter_class=_Formatter,
+    )
+
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"TDE v{__version__}",
+    )
+
+   
+    parser.add_argument(
+        "command",
+        choices=["encode", "decode"],
+        help="Operation to perform: 'encode' or 'decode'.",
+    )
+    parser.add_argument(
+        "data",
+        nargs="?",
+        default=None,
+        help="Inline string payload (optional if using -i or stdin).",
+    )
+
+  
+    io_group = parser.add_argument_group("I/O options")
+    io_group.add_argument(
+        "-i", "--input",
+        metavar="FILE",
+        help="Read payload from FILE instead of stdin/args.",
+    )
+    io_group.add_argument(
+        "-o", "--output",
+        metavar="FILE",
+        help="Write result to FILE instead of stdout.",
+    )
+
+  
+    mod_group = parser.add_argument_group("Advanced modifiers")
+    mod_group.add_argument(
+        "--url",
+        action="store_true",
+        default=False,
+        help="Use URL-safe Base64 alphabet (- _ instead of + /).",
+    )
+    mod_group.add_argument(
+        "--strict",
+        action="store_true",
+        default=False,
+        help="Halt with an error on any non-Base64 character.",
+    )
+    mod_group.add_argument(
+        "--ignore-garbage",
+        action="store_true",
+        default=False,
+        help="Strip whitespace and invalid characters before decoding.",
+    )
+
+    return parser
+
+
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+
+    if args.strict and args.ignore_garbage:
+        _die("--strict and --ignore-garbage are mutually exclusive.\n"
+             "  --strict  demands perfect input.\n"
+             "  --ignore-garbage silently discards bad characters.\n"
+             "  Pick one.")
+
+    payload = _acquire_input(args)
+
+
+    if args.command == "encode":
+        result = _encode(payload, url_safe=args.url)
+    else:
+        result = _decode(
+            payload,
+            url_safe=args.url,
+            strict=args.strict,
+            ignore_garbage=args.ignore_garbage,
+        )
+
+ 
+    _emit(result, args)
+
+
+if __name__ == "__main__":
+    main()

tde-1.0.0.dist-info/METADATA

@@ -0,0 +1,345 @@
+Metadata-Version: 2.4
+Name: tde
+Version: 1.0.0
+Summary: TDE — Tanishq's Decoder & Encoder. A fast, dependency-free Base64 CLI tool.
+Home-page: https://github.com/tanishqzope/TDE-Tool
+Author: Tanishq Zope
+Author-email: tanishqzope5@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="https://img.shields.io/badge/TDE-v1.0.0-00C853?style=for-the-badge&logo=python&logoColor=white" alt="Version"/>
+  <img src="https://img.shields.io/badge/Python-3.7+-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Python"/>
+  <img src="https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge" alt="License"/>
+  <img src="https://img.shields.io/badge/Dependencies-Zero-success?style=for-the-badge" alt="Dependencies"/>
+  <img src="https://img.shields.io/badge/Platform-Win%20%7C%20Linux%20%7C%20macOS-blue?style=for-the-badge" alt="Platform"/>
+</p>
+
+<h1 align="center">🔐 TDE — Tanishq's Decoder & Encoder</h1>
+
+<p align="center">
+  <strong>A fast, lightweight, dependency-free CLI tool for Base64 encoding & decoding.</strong><br/>
+  Built purely with Python's standard libraries — zero security overhead, absolute portability.
+</p>
+
+<p align="center">
+  <a href="#-features">Features</a> •
+  <a href="#-installation">Installation</a> •
+  <a href="#-usage">Usage</a> •
+  <a href="#%EF%B8%8F-architecture">Architecture</a> •
+  <a href="#-contributing">Contributing</a> •
+  <a href="#-license">License</a>
+</p>
+
+---
+
+## ✨ Features
+
+| Feature | Description |
+|---|---|
+| 🚫 **Zero Dependencies** | Runs natively using only built-in Python libraries — nothing to install, nothing to break |
+| 🖥️ **Cross-Platform** | Works seamlessly on Command Prompt, PowerShell, Git Bash, WSL, and Linux/macOS terminals |
+| 📁 **File I/O** | Read from and write directly to files for handling large payloads or binaries |
+| 🌐 **URL-Safe Mode** | Seamlessly handle JSON Web Tokens (JWTs) and URL parameters with `-` `_` alphabet |
+| 🛡️ **Strict Validation** | Catch malformed data streams instantly with `--strict` mode |
+| 🧹 **Garbage Collection** | Force-decode messy inputs by stripping invalid characters automatically |
+| 🔄 **Pipe Support** | Chain with other CLI tools via stdin/stdout piping |
+| 🎨 **Coloured Output** | ANSI colour support with automatic graceful degradation |
+
+---
+
+## 📦 Installation
+
+> **Prerequisites:** Python 3.7 or higher
+
+### Quick Install
+
+```bash
+git clone https://github.com/tanishqzope/TDE-Tool.git
+cd TDE-Tool
+pip install .
+```
+
+Once installed, the `tde` command is globally available from **any terminal**.
+
+### Verify Installation
+
+```bash
+tde --version
+# Output: TDE v1.0.0
+```
+
+---
+
+## 🚀 Usage
+
+### Basic Encoding & Decoding
+
+```bash
+# Encode a string to Base64
+tde encode "hello world"
+# Output: aGVsbG8gd29ybGQ=
+
+# Decode a Base64 string
+tde decode "aGVsbG8gd29ybGQ="
+# Output: hello world
+```
+
+### 🌐 URL-Safe Mode (`--url`)
+
+Generate Base64 strings safe for web transit — replaces `+`/`/` with `-`/`_` and strips `=` padding. Perfect for **JWTs** and **URL parameters**.
+
+```bash
+tde encode "https://example.com/api?token=abc" --url
+# Output: aHR0cHM6Ly9leGFtcGxlLmNvbS9hcGk_dG9rZW49YWJj
+```
+
+### 🛡️ Strict Mode (`--strict`)
+
+Forces the tool to **halt immediately** with a clear error if the input contains any non-Base64 characters.
+
+```bash
+tde decode "aGVsbG8gd2!9ybGQ=" --strict
+# Error: Strict mode: invalid Base64 character(s) found: '!'
+#   Hint: use --ignore-garbage to strip them automatically.
+```
+
+### 🧹 Ignore Garbage (`--ignore-garbage`)
+
+Strips whitespace, newlines, and invalid characters before decoding — perfect for messy copy-paste inputs.
+
+```bash
+tde decode "aGVsbG8  gd 29ybGQ=" --ignore-garbage
+# Output: hello world
+```
+
+### 📁 File Operations
+
+Read a payload from a file and write the decoded output to a new file:
+
+```bash
+# Encode a file's contents
+tde encode -i secret.txt -o encoded_payload.txt
+
+# Decode back to original
+tde decode -i encoded_payload.txt -o original.txt
+```
+
+### 🔄 Piping Support
+
+Chain TDE with other CLI tools:
+
+```bash
+# Pipe from echo
+echo "sensitive data" | tde encode
+
+# Chain with curl
+curl -s https://api.example.com/data | tde decode
+
+# Pipe between TDE commands (round-trip)
+echo "hello" | tde encode | tde decode
+```
+
+### 📋 Full Help Menu
+
+```bash
+tde --help
+```
+
+```
+  +========================================+
+  |  TDE -- The Data Encoder / Decoder     |
+  |  v1.0.0  |  Zero-dependency Base64     |
+  +========================================+
+
+positional arguments:
+  {encode,decode}    Operation to perform: 'encode' or 'decode'.
+  data               Inline string payload (optional if using -i or stdin).
+
+I/O options:
+  -i, --input FILE   Read payload from FILE instead of stdin/args.
+  -o, --output FILE  Write result to FILE instead of stdout.
+
+Advanced modifiers:
+  --url              Use URL-safe Base64 alphabet (- _ instead of + /).
+  --strict           Halt with an error on any non-Base64 character.
+  --ignore-garbage   Strip whitespace and invalid characters before decoding.
+```
+
+---
+
+## 🏗️ Architecture
+
+### High-Level Overview
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                        tde <command> [data] [flags]              │
+└──────────────────┬───────────────────────────────────────────────┘
+                   │
+                   ▼
+┌──────────────────────────────────────────────────────────────────┐
+│                    1. ARGUMENT PARSER (argparse)                 │
+│  ┌─────────┐   ┌─────────┐   ┌────────┐   ┌─────────────────┐    │
+│  │ command │   │  data   │   │ flags  │   │   I/O options   │    │
+│  │encode/  │   │(inline) │   │--url   │   │ -i input file   │    │
+│  │decode   │   │         │   │--strict│   │ -o output file  │    │
+│  └────┬────┘   └────┬────┘   └───┬────┘   └────────┬────────┘    │
+└───────┼──────────────┼───────────┼──────────────────┼────────────┘
+        │              │           │                  │
+        ▼              ▼           │                  │
+┌──────────────────────────────────┼──────────────────┼────────────┐
+│          2. INPUT ROUTER         │                  │            │
+│  Priority Hierarchy:             │                  │            │
+│  ┌──────────────────────┐        │                  │            │
+│  │ 1. File  (-i flag)   │◄───────┼──────────────────┘            │
+│  │ 2. Stdin (piped)     │        │                               │
+│  │ 3. Arg   (inline)    │        │                               │
+│  └──────────┬───────────┘        │                               │
+└─────────────┼────────────────────┼───────────────────────────────┘
+              │                    │
+              ▼                    ▼
+┌──────────────────────────────────────────────────────────────────┐
+│                   3. PROCESSING CORE                             │
+│                                                                  │
+│  ┌─ ENCODE ──────────────────────────────────────────────────┐   │
+│  │  input bytes ──► b64encode() ──► result                   │   │
+│  │  --url?       ──► urlsafe_b64encode() ──► strip '=' pad   │   │
+│  └───────────────────────────────────────────────────────────┘   │
+│                                                                  │
+│  ┌─ DECODE ──────────────────────────────────────────────────┐   │
+│  │  --strict?          ──► regex validate ──► halt on bad    │   │
+│  │  --ignore-garbage?  ──► regex strip junk chars            │   │
+│  │  --url?             ──► restore padding ──► urlsafe_b64   │   │
+│  │  (default)          ──► b64decode() ──► result            │   │
+│  └───────────────────────────────────────────────────────────┘   │
+└──────────────────────────┬───────────────────────────────────────┘
+                           │
+                           ▼
+┌──────────────────────────────────────────────────────────────────┐
+│                    4. OUTPUT ROUTER                              │
+│  ┌───────────────────────────────────────────────────────────┐   │
+│  │  -o flag set?  ──► Write bytes to file                    │   │
+│  │  (default)     ──► Print to stdout                        │   │
+│  └───────────────────────────────────────────────────────────┘   │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+### Data Flow
+
+```
+User Input ──► Argument Parser ──► Input Router ──► Processing Core ──► Output Router
+                   │                    │                  │                   │
+              Parse command        Read from:         Apply flags:       Deliver to:
+              & flags             • File (-i)        • --url             • File (-o)
+                                  • Stdin (pipe)     • --strict          • Stdout
+                                  • Inline arg       • --ignore-garbage
+```
+
+### Module Structure
+
+```
+TDE-Tool/
+├── .gitignore           # Git ignore rules
+├── LICENSE              # MIT License
+├── README.md            # This file
+├── setup.py             # Installer with console_scripts entry point
+└── tde/                 # Main package
+    ├── __init__.py      # Version constant (__version__ = "1.0.0")
+    └── cli.py           # Complete CLI implementation
+                         #   ├── ANSI colour helpers
+                         #   ├── Banner & help formatter
+                         #   ├── _acquire_input()   → Input Router
+                         #   ├── _encode()           → Encoding engine
+                         #   ├── _decode()           → Decoding engine
+                         #   ├── _emit()             → Output Router
+                         #   └── main()              → Entry point
+```
+
+---
+
+## 🔧 CLI Reference
+
+| Argument | Type | Description |
+|---|---|---|
+| `encode` | Command | Convert input to Base64 |
+| `decode` | Command | Convert Base64 back to original |
+| `<data>` | Positional | Inline string payload |
+| `-i`, `--input` | Flag | Read payload from a file |
+| `-o`, `--output` | Flag | Write result to a file |
+| `-v`, `--version` | Flag | Show version (`TDE v1.0.0`) |
+| `-h`, `--help` | Flag | Show help menu with examples |
+| `--url` | Modifier | Use URL-safe Base64 alphabet |
+| `--strict` | Modifier | Error on invalid characters |
+| `--ignore-garbage` | Modifier | Strip invalid characters before decoding |
+
+> ⚠️ `--strict` and `--ignore-garbage` are **mutually exclusive** — they cannot be used together.
+
+---
+
+## 🎯 Use Cases
+
+| Scenario | Command |
+|---|---|
+| 🔑 Encode API keys for config files | `tde encode "sk-abc123secret"` |
+| 🌐 Generate URL-safe JWT tokens | `tde encode "payload" --url` |
+| 📧 Decode email attachments | `tde decode -i attachment.b64 -o file.pdf` |
+| 🧪 Validate Base64 integrity | `tde decode "data..." --strict` |
+| 📋 Clean up messy copy-paste | `tde decode "broken data" --ignore-garbage` |
+| 🔄 Round-trip verification | `echo "test" \| tde encode \| tde decode` |
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how you can help:
+
+1. **Fork** the repository
+2. **Create** a feature branch (`git checkout -b feature/awesome-feature`)
+3. **Commit** your changes (`git commit -m "Add awesome feature"`)
+4. **Push** to the branch (`git push origin feature/awesome-feature`)
+5. **Open** a Pull Request
+
+### Guidelines
+
+- Use only Python standard library — **no external dependencies**
+- Maintain cross-platform compatibility
+- Add comments for complex logic
+- Test on both Windows and Linux/macOS
+
+---
+
+## 📄 License
+
+This project is licensed under the **MIT License** — see the [LICENSE](LICENSE) file for details.
+
+---
+
+## 👤 Author
+
+**Tanishq Zope** — [@tanishqzope](https://github.com/tanishqzope)
+
+---
+
+<p align="center">
+  <sub>Built with ❤️ and pure Python. No dependencies were harmed in the making of this tool.</sub>
+</p>

tde-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+tde/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+tde/cli.py,sha256=R-8RIZPJinDEXNdwwWCv0TeM7wq6AlzObV85ixb4veA,7164
+tde-1.0.0.dist-info/licenses/LICENSE,sha256=aaHKA_NthNc1NiIeuPxs_1zL8VTlYlY-zqbTqPpRuiQ,1069
+tde-1.0.0.dist-info/METADATA,sha256=vRQlYsn4sbAgvsHDTfDXLbu1SF1Su6aMe7GoQANJQuY,15633
+tde-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tde-1.0.0.dist-info/entry_points.txt,sha256=bCr2PfEF4FhYGbiU47UVw99Ru5rk3f0uHdAy8L-znGA,37
+tde-1.0.0.dist-info/top_level.txt,sha256=v0tXPRi-QeUe7-sR39AFkSG53g-Cuv_b0R_8lwc5DQ0,4
+tde-1.0.0.dist-info/RECORD,,

tde-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tde-1.0.0.dist-info/entry_points.txt

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

tde-1.0.0.dist-info/licenses/LICENSE

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

tde-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tde