wasender-cli 0.1.0__py3-none-any.whl

wasender/__init__.py

@@ -0,0 +1,2 @@
+"""Wasender CLI package"""
+__version__ = "0.1.0"

wasender/client.py

@@ -0,0 +1,63 @@
+import httpx
+from typing import Optional, Dict, Any
+
+from .output import print_http_error_and_exit, print_error_and_exit
+
+class WasenderClient:
+    def __init__(self, token: str, base_url: str = "https://wasenderapi.com/api"):
+        self.token = token
+        self.base_url = base_url.rstrip('/')
+        self.headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        try:
+            response.raise_for_status()
+            text = response.text.strip()
+            if not text:
+                return {}
+            try:
+                return response.json()
+            except ValueError:
+                print_error_and_exit(f"Invalid JSON response. Content snippet: {text[:100]}")
+        except httpx.HTTPStatusError as e:
+            try:
+                error_msg = response.json()
+            except Exception:
+                error_msg = response.text
+            print_http_error_and_exit(e.response.status_code, str(error_msg))
+        except httpx.RequestError as e:
+            print_error_and_exit(f"Connection error: {e}")
+
+    def request(self, method: str, path: str, **kwargs) -> Any:
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        
+        # Don't pass auth down implicitly, we already handle it in headers
+        # but just passing headers down
+        req_kwargs = {"headers": self.headers}
+        req_kwargs.update(kwargs)
+        
+        try:
+            with httpx.Client() as client:
+                response = client.request(method, url, **req_kwargs)
+            return self._handle_response(response)
+        except httpx.RequestError as e:
+            print_error_and_exit(f"Connection error: {e}")
+
+    def get(self, path: str, params: Optional[Dict] = None) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Optional[Dict] = None) -> Any:
+        return self.request("POST", path, json=json)
+
+    def put(self, path: str, json: Optional[Dict] = None) -> Any:
+        return self.request("PUT", path, json=json)
+        
+    def patch(self, path: str, json: Optional[Dict] = None) -> Any:
+        return self.request("PATCH", path, json=json)
+
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)

wasender/contacts.py

@@ -0,0 +1,69 @@
+import typer
+from .output import print_json_obj
+from .client import WasenderClient
+
+app = typer.Typer()
+
+def get_client(ctx: typer.Context) -> WasenderClient:
+    return ctx.obj
+
+@app.command("list")
+def list_contacts(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts")
+    print_json_obj(result)
+
+@app.command("add")
+def add_or_edit_contact(ctx: typer.Context, session_id: str, phone: str, name: str):
+    client = get_client(ctx)
+    payload = {"phone": phone, "name": name}
+    result = client.post(f"sessions/{session_id}/contacts", json=payload)
+    print_json_obj(result)
+
+@app.command("get")
+def get_contact_info(ctx: typer.Context, session_id: str, jid: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/{jid}")
+    print_json_obj(result)
+
+@app.command("picture")
+def get_contact_picture(ctx: typer.Context, session_id: str, jid: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/{jid}/picture")
+    print_json_obj(result)
+
+@app.command("block")
+def block_contact(ctx: typer.Context, session_id: str, jid: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/contacts/{jid}/block")
+    print_json_obj(result)
+
+@app.command("unblock")
+def unblock_contact(ctx: typer.Context, session_id: str, jid: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/contacts/{jid}/unblock")
+    print_json_obj(result)
+
+@app.command("check")
+def check_jid_on_whatsapp(ctx: typer.Context, session_id: str, phone: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/check/{phone}")
+    print_json_obj(result)
+
+@app.command("lid")
+def get_lid_from_phone_number(ctx: typer.Context, session_id: str, phone: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/lid/{phone}")
+    print_json_obj(result)
+
+@app.command("phone")
+def get_phone_number_from_lid(ctx: typer.Context, session_id: str, lid: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/phone/{lid}")
+    print_json_obj(result)
+
+@app.command("search")
+def search_contacts(ctx: typer.Context, session_id: str, query: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/contacts/search", params={"q": query})
+    print_json_obj(result)

wasender/groups.py

@@ -0,0 +1,96 @@
+import typer
+from typing import Optional
+from .output import print_json_obj
+from .client import WasenderClient
+
+app = typer.Typer()
+
+def get_client(ctx: typer.Context) -> WasenderClient:
+    return ctx.obj
+
+@app.command("list")
+def list_groups(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/groups")
+    print_json_obj(result)
+
+@app.command("create")
+def create_group(ctx: typer.Context, session_id: str, name: str, participants: str = typer.Option(..., help="Comma separated jids")):
+    client = get_client(ctx)
+    payload = {"name": name, "participants": participants.split(",")}
+    result = client.post(f"sessions/{session_id}/groups", json=payload)
+    print_json_obj(result)
+
+@app.command("metadata")
+def get_group_metadata(ctx: typer.Context, session_id: str, group_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/groups/{group_id}")
+    print_json_obj(result)
+
+@app.command("participants")
+def get_group_participants(ctx: typer.Context, session_id: str, group_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/groups/{group_id}/participants")
+    print_json_obj(result)
+
+@app.command("add")
+def add_group_participants(ctx: typer.Context, session_id: str, group_id: str, participants: str = typer.Option(..., help="Comma separated jids")):
+    client = get_client(ctx)
+    payload = {"participants": participants.split(",")}
+    result = client.post(f"sessions/{session_id}/groups/{group_id}/participants", json=payload)
+    print_json_obj(result)
+
+@app.command("remove")
+def remove_group_participants(ctx: typer.Context, session_id: str, group_id: str, participants: str = typer.Option(..., help="Comma separated jids")):
+    client = get_client(ctx)
+    # DELETE might not take a body based on std conventions, but if Wasender does, we pass json here.
+    payload = {"participants": participants.split(",")}
+    # Usually Wasender has a specific POST endpoint for removing or accepts DELETE with body
+    # Let's assume POST to /remove or similar if DELETE body is flaky:
+    # We will use client.request method
+    result = client.request("DELETE", f"sessions/{session_id}/groups/{group_id}/participants", json=payload)
+    print_json_obj(result)
+
+@app.command("update-participants")
+def update_group_participants(ctx: typer.Context, session_id: str, group_id: str, action: str = typer.Option(..., help="promote|demote"), participants: str = typer.Option(..., help="Comma separated jids")):
+    client = get_client(ctx)
+    payload = {"action": action, "participants": participants.split(",")}
+    result = client.patch(f"sessions/{session_id}/groups/{group_id}/participants", json=payload)
+    print_json_obj(result)
+
+@app.command("settings")
+def update_group_settings(ctx: typer.Context, session_id: str, group_id: str, subject: Optional[str] = typer.Option(None, "--subject", "-s"), description: Optional[str] = typer.Option(None, "--description", "-d"), announce: Optional[bool] = typer.Option(None, "--announce", "-a")):
+    client = get_client(ctx)
+    payload = {}
+    if subject is not None:
+        payload["subject"] = subject
+    if description is not None:
+        payload["description"] = description
+    if announce is not None:
+        payload["announce"] = announce
+    result = client.patch(f"sessions/{session_id}/groups/{group_id}/settings", json=payload)
+    print_json_obj(result)
+
+@app.command("leave")
+def leave_group(ctx: typer.Context, session_id: str, group_id: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/groups/{group_id}/leave")
+    print_json_obj(result)
+
+@app.command("invite-link")
+def generate_invite_link(ctx: typer.Context, session_id: str, group_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/groups/{group_id}/invite-link")
+    print_json_obj(result)
+
+@app.command("accept-invite")
+def accept_group_invite(ctx: typer.Context, session_id: str, invite_code: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/groups/accept-invite/{invite_code}")
+    print_json_obj(result)
+
+@app.command("search")
+def search_groups(ctx: typer.Context, session_id: str, query: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/groups/search", params={"q": query})
+    print_json_obj(result)

wasender/main.py

@@ -0,0 +1,45 @@
+import os
+import typer
+from .output import set_output_mode, print_error_and_exit
+from .client import WasenderClient
+
+from dotenv import load_dotenv
+
+from . import sessions
+from . import messages
+from . import contacts
+from . import groups
+
+# Load environment variables from a .env file if it exists
+load_dotenv()
+
+app = typer.Typer(help="WasenderAPI CLI Tool")
+
+app.add_typer(sessions.app, name="sessions", help="Manage WhatsApp sessions")
+app.add_typer(messages.app, name="messages", help="Send and manage messages")
+app.add_typer(contacts.app, name="contacts", help="Manage contacts")
+app.add_typer(groups.app, name="groups", help="Manage groups")
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    token: str = typer.Option(None, "--token", "-t", help="API Auth Token. Or use WASENDER_TOKEN env var.", envvar="WASENDER_TOKEN"),
+    base_url: str = typer.Option("https://wasenderapi.com/api", "--base-url", "-u", help="Base URL of the WasenderAPI.", envvar="WASENDER_BASE_URL"),
+    raw: bool = typer.Option(False, "--raw", help="Output raw JSON (for piping)"),
+    quiet: bool = typer.Option(False, "--quiet", help="Suppress output, only exit codes")
+):
+    set_output_mode(raw=raw, quiet=quiet)
+    
+    if not token:
+        # Check env var directly in case typer envvar mapping has quirks
+        token = os.environ.get("WASENDER_TOKEN")
+
+    if not token and ctx.invoked_subcommand:
+        # Only require token if we are not asking for help or version
+        set_output_mode(False, False) # Show error even if quiet since we failed explicitly
+        print_error_and_exit("WASENDER_TOKEN environment variable or --token flag is required.")
+        
+    ctx.obj = WasenderClient(token=token or "", base_url=base_url)
+
+if __name__ == "__main__":
+    app()

wasender/messages.py

@@ -0,0 +1,161 @@
+import typer
+from typing import Optional, List
+from .output import print_json_obj
+from .client import WasenderClient
+import os
+
+app = typer.Typer()
+
+def get_client(ctx: typer.Context) -> WasenderClient:
+    return ctx.obj
+
+# Media helper for file uploading
+def _upload_or_pass(client: WasenderClient, url_or_path: str):
+    # Depending on API, you might need multipart upload or just passing the URL.
+    # Wasender typically supports URL. For actual files, we use form upload if local.
+    if os.path.exists(url_or_path) and os.path.isfile(url_or_path):
+        import httpx
+        from .output import print_error_and_exit
+        try:
+            url = f"{client.base_url}/media/upload"
+            with open(url_or_path, "rb") as f:
+                try:
+                    with httpx.Client() as c:
+                        # Assuming an endpoint for file upload exists, if not we have to pass it in multipart
+                        # Since WasenderAPI expects URLs or handles multipart in the same message endpoint,
+                        pass
+                except Exception as e:
+                    pass
+        except Exception:
+            pass
+    # For now, we will pass it as a URL or assume the API handles it directly
+    return url_or_path
+
+@app.command("text")
+def send_text_message(ctx: typer.Context, session_id: str, to: str, message: str):
+    client = get_client(ctx)
+    payload = {"to": to, "text": message}
+    result = client.post(f"send-message", json=payload)
+    print_json_obj(result)
+
+@app.command("mention")
+def send_mention_message(ctx: typer.Context, session_id: str, to: str, message: str, mentions: str = typer.Option(..., help="Comma separated jids")):
+    client = get_client(ctx)
+    payload = {"to": to, "text": message, "mentions": mentions.split(",")}
+    result = client.post(f"sessions/{session_id}/messages/text", json=payload)
+    print_json_obj(result)
+    
+@app.command("image")
+def send_image_message(ctx: typer.Context, session_id: str, to: str, url_or_path: str):
+    client = get_client(ctx)
+    if os.path.isfile(url_or_path):
+        # We assume there's a multipart upload or Wasender accepts base64
+        # We will use multipart form data if it's a file
+        with open(url_or_path, "rb") as f:
+            files = {"file": f}
+            data = {"to": to}
+            result = client.request("POST", f"sessions/{session_id}/messages/image", data=data, files=files, headers={"Content-Type": None}) # Let httpx handle content type
+            print_json_obj(result)
+            return
+
+    payload = {"to": to, "image": url_or_path}
+    result = client.post(f"sessions/{session_id}/messages/image", json=payload)
+    print_json_obj(result)
+
+@app.command("audio")
+def send_audio_message(ctx: typer.Context, session_id: str, to: str, url_or_path: str):
+    client = get_client(ctx)
+    if os.path.isfile(url_or_path):
+        with open(url_or_path, "rb") as f:
+            files = {"file": f}
+            data = {"to": to}
+            result = client.request("POST", f"sessions/{session_id}/messages/audio", data=data, files=files, headers={"Content-Type": None})
+            print_json_obj(result)
+            return
+            
+    payload = {"to": to, "audio": url_or_path}
+    result = client.post(f"sessions/{session_id}/messages/audio", json=payload)
+    print_json_obj(result)
+
+@app.command("video")
+def send_video_message(ctx: typer.Context, session_id: str, to: str, url_or_path: str):
+    client = get_client(ctx)
+    if os.path.isfile(url_or_path):
+        with open(url_or_path, "rb") as f:
+            files = {"file": f}
+            data = {"to": to}
+            result = client.request("POST", f"sessions/{session_id}/messages/video", data=data, files=files, headers={"Content-Type": None})
+            print_json_obj(result)
+            return
+            
+    payload = {"to": to, "video": url_or_path}
+    result = client.post(f"sessions/{session_id}/messages/video", json=payload)
+    print_json_obj(result)
+
+@app.command("document")
+def send_document_message(ctx: typer.Context, session_id: str, to: str, url_or_path: str):
+    client = get_client(ctx)
+    if os.path.isfile(url_or_path):
+        with open(url_or_path, "rb") as f:
+            files = {"file": f}
+            data = {"to": to}
+            result = client.request("POST", f"sessions/{session_id}/messages/document", data=data, files=files, headers={"Content-Type": None})
+            print_json_obj(result)
+            return
+            
+    payload = {"to": to, "document": url_or_path}
+    result = client.post(f"sessions/{session_id}/messages/document", json=payload)
+    print_json_obj(result)
+
+@app.command("location")
+def send_location_message(ctx: typer.Context, session_id: str, to: str, lat: float, lng: float):
+    client = get_client(ctx)
+    payload = {"to": to, "location": {"degreesLatitude": lat, "degreesLongitude": lng}}
+    result = client.post(f"sessions/{session_id}/messages/location", json=payload)
+    print_json_obj(result)
+
+@app.command("contact")
+def send_contact_message(ctx: typer.Context, session_id: str, to: str, vcard: str):
+    client = get_client(ctx)
+    payload = {"to": to, "vcard": vcard}
+    result = client.post(f"sessions/{session_id}/messages/contact", json=payload)
+    print_json_obj(result)
+
+@app.command("poll")
+def send_poll_message(ctx: typer.Context, session_id: str, to: str, question: str, options: str = typer.Option(..., help="Comma-separated options")):
+    client = get_client(ctx)
+    payload = {"to": to, "poll": {"name": question, "options": options.split(",")}}
+    result = client.post(f"sessions/{session_id}/messages/poll", json=payload)
+    print_json_obj(result)
+
+@app.command("presence")
+def send_presence_update(ctx: typer.Context, session_id: str, to: str, status: str = typer.Argument(..., help="available|composing|recording|paused")):
+    client = get_client(ctx)
+    payload = {"to": to, "presence": status}
+    result = client.post(f"sessions/{session_id}/messages/presence", json=payload)
+    print_json_obj(result)
+
+@app.command("resend")
+def resend_message(ctx: typer.Context, session_id: str, message_id: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/messages/{message_id}/resend")
+    print_json_obj(result)
+
+@app.command("edit")
+def edit_message(ctx: typer.Context, session_id: str, message_id: str, new_text: str):
+    client = get_client(ctx)
+    payload = {"text": new_text}
+    result = client.patch(f"sessions/{session_id}/messages/{message_id}", json=payload)
+    print_json_obj(result)
+
+@app.command("delete")
+def delete_message(ctx: typer.Context, session_id: str, message_id: str):
+    client = get_client(ctx)
+    result = client.delete(f"sessions/{session_id}/messages/{message_id}")
+    print_json_obj(result)
+
+@app.command("info")
+def get_message_info(ctx: typer.Context, session_id: str, message_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/messages/{message_id}")
+    print_json_obj(result)

wasender/output.py

@@ -0,0 +1,31 @@
+import sys
+from rich.console import Console
+
+console = Console()
+
+_raw = False
+_quiet = False
+
+def set_output_mode(raw: bool, quiet: bool):
+    global _raw, _quiet
+    _raw = raw
+    _quiet = quiet
+
+def print_json_obj(data):
+    if _quiet:
+        return
+    if _raw:
+        import json
+        print(json.dumps(data))
+    else:
+        console.print_json(data=data)
+
+def print_error_and_exit(message: str, code: int = 1):
+    if not _quiet:
+        console.print(f"[bold red]Error[/bold red]: {message}")
+    sys.exit(code)
+
+def print_http_error_and_exit(status_code: int, message: str):
+    if not _quiet:
+        console.print(f"[bold red]Error {status_code}[/bold red]: {message}")
+    sys.exit(1)

wasender/sessions.py

@@ -0,0 +1,72 @@
+import httpx
+import typer
+from typing import Optional
+from .output import print_json_obj
+from .client import WasenderClient
+
+app = typer.Typer()
+
+def get_client(ctx: typer.Context) -> WasenderClient:
+    return ctx.obj
+
+@app.command("list")
+def list_sessions(ctx: typer.Context, page: int = 1, limit: int = 10):
+    client = get_client(ctx)
+    result = client.get("sessions", params={"page": page, "limit": limit})
+    print_json_obj(result)
+
+@app.command("get")
+def get_session(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}")
+    print_json_obj(result)
+
+@app.command("user")
+def get_session_user(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/user")
+    print_json_obj(result)
+
+@app.command("create")
+def create_session(ctx: typer.Context, name: str = typer.Option(..., prompt=True), webhook: Optional[str] = None):
+    client = get_client(ctx)
+    payload = {"name": name}
+    if webhook:
+        payload["webhook"] = webhook
+    result = client.post("sessions", json=payload)
+    print_json_obj(result)
+
+@app.command("update")
+def update_session(ctx: typer.Context, session_id: str, name: Optional[str] = None, webhook: Optional[str] = None):
+    client = get_client(ctx)
+    payload = {}
+    if name is not None:
+        payload["name"] = name
+    if webhook is not None:
+        payload["webhook"] = webhook
+    result = client.patch(f"sessions/{session_id}", json=payload)
+    print_json_obj(result)
+
+@app.command("connect")
+def connect_session(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/connect")
+    print_json_obj(result)
+
+@app.command("disconnect")
+def disconnect_session(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.post(f"sessions/{session_id}/disconnect")
+    print_json_obj(result)
+
+@app.command("message-logs")
+def get_message_logs(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/message-logs")
+    print_json_obj(result)
+
+@app.command("session-logs")
+def get_session_logs(ctx: typer.Context, session_id: str):
+    client = get_client(ctx)
+    result = client.get(f"sessions/{session_id}/logs")
+    print_json_obj(result)

wasender_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: wasender-cli
+Version: 0.1.0
+Summary: A production-grade CLI tool for the WasenderAPI
+Author-email: Tapatio Solutions <girishdudhwal@gmail.com>
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# Wasender CLI
+
+A production-grade CLI tool for the WasenderAPI using Python with Typer.
+
+## Installation
+
+1. Make sure you have Python 3.9+ installed.
+2. Install the CLI in editable mode:
+   ```bash
+   pip install -e .
+   ```
+
+## Setup
+
+You must set your Wasender API token. You can pass it via `--token`, set an environment variable, or use a `.env` file.
+
+**Option 1: `.env` file (Recommended)**
+Create a `.env` file in the directory where you run the CLI:
+```ini
+WASENDER_TOKEN=your_token_here
+```
+
+**Option 2: Environment Variable**
+```bash
+export WASENDER_TOKEN=your_token_here
+# On Windows PowerShell:
+# $env:WASENDER_TOKEN="your_token_here"
+```
+
+## Examples
+
+### Sessions Group
+```bash
+wasender sessions list
+wasender sessions create --name "My Session"
+```
+
+### Messages Group
+```bash
+wasender messages text my_session 1234567890 "Hello from Wasender CLI!"
+wasender messages image my_session 1234567890 https://example.com/image.png
+```
+
+### Contacts Group
+```bash
+wasender contacts list my_session
+wasender contacts add my_session 1234567890 "John Doe"
+```
+
+### Groups Group
+```bash
+wasender groups list my_session
+wasender groups create my_session "Test Group" --participants 1234567890@s.whatsapp.net,0987654321@s.whatsapp.net
+```
+
+Use `wasender --help` or `wasender <group> --help` to see all available commands and options.

wasender_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+wasender/__init__.py,sha256=S9eLObttReEuA_m5THSNfyQrTbKLm40FyO8rfvYGLkk,49
+wasender/client.py,sha256=y7Uh50ejidcXtvJdBLMR3rhxXh_IrInUIzV7sKxU9p8,2408
+wasender/contacts.py,sha256=fT6ZuthZUqNA50JqAStdhR5mYpZRG0JLRWBSa9xeV6w,2450
+wasender/groups.py,sha256=Cdpug5_FfcAtXd79UiucBn7xiwf37DBzUaeWzqyTuTk,4410
+wasender/main.py,sha256=WxsYyYpECRWUaLt6oOILFZ38GE98CTkEKyIxjsPErY4,1767
+wasender/messages.py,sha256=nnus0EcXNtjuQI7zEm7tlBhvz7bm71ctvCgTTLnIDDA,7011
+wasender/output.py,sha256=BCPw4fOLkgKeUqzDHpJD4RcqGU4QjhvP8-4nr2Zy2ws,703
+wasender/sessions.py,sha256=-e_bUS6zSEo3fWxOIWAyDaSQwcHdYg7u4U-KtRGpvQo,2357
+wasender_cli-0.1.0.dist-info/licenses/LICENSE,sha256=77T62lnNdRZj0p9ri4jCBWdP3mKnY-z5R1WjtOgOgjk,1074
+wasender_cli-0.1.0.dist-info/METADATA,sha256=8aEH6E8ezSaOiwAgUo7-ulFB_KQF3otlwqge0v3uh1g,2015
+wasender_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wasender_cli-0.1.0.dist-info/entry_points.txt,sha256=Q1VSEyDfTa04fHLne7uAAo-awfehw9Doa--iBTQEqYY,47
+wasender_cli-0.1.0.dist-info/top_level.txt,sha256=pEMIDpGhre1TscVONhw6I9mVWgI2DQdJH9JXE3wKRv8,9
+wasender_cli-0.1.0.dist-info/RECORD,,

wasender_cli-0.1.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
+

wasender_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wasender = wasender.main:app

wasender_cli-0.1.0.dist-info/licenses/LICENSE

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

wasender_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wasender