wabalink 1.0.0__tar.gz

wabalink-1.0.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: wabalink
+Version: 1.0.0
+Summary: SDK de Python para la API pública de Wabalink (WhatsApp Business): mensajes, chats, contactos, citas, sandbox y webhooks.
+License: MIT
+Project-URL: Repository, https://github.com/DeSoluTec/wabalink/tree/main/sdks/python
+Keywords: whatsapp,whatsapp-business,wabalink,sdk
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# wabalink (Python)
+
+SDK de Python (>=3.9) para la API pública de Wabalink. Sin dependencias.
+
+```bash
+pip install wabalink
+```
+
+```python
+import os
+from wabalink import Wabalink
+
+wl = Wabalink(os.environ["WABALINK_API_KEY"])  # wl_test_… para la sandbox
+
+inbound = wl.sandbox.inbound(from_="573001112233", text="hola")      # simula al cliente
+wl.messages.send_text(inbound["conversation_id"], "¡Hola! ¿En qué te ayudo?")
+wl.messages.send(conversationId=inbound["conversation_id"], type="buttons", text="¿Agendamos?",
+                 buttons=[{"id": "si", "title": "Sí"}, {"id": "no", "title": "No"}])
+wl.appointments.create(contactId="…", startsAt="2026-12-01T15:00:00-05:00")
+for c in wl.contacts.iterate(tag="vip"):
+    print(c["name"])
+```
+
+- `messages`, `contacts` y `appointments` (POST) llevan `Idempotency-Key` automática, igual en los reintentos.
+- Reintenta 429, 5xx y fallas de red (`max_retries=2`). Los 4xx lanzan `WabalinkApiError` (`.status`, `str(e)`, `.details`).
+- Los campos de `send`, `upsert`, etc. son los de la API (`conversationId`, `startsAt`…); `sandbox.inbound(from_=…)` usa `from_` porque `from` es palabra reservada.
+
+## Webhooks
+
+```python
+from flask import Flask, request
+from wabalink import construct_event
+
+@app.post("/wabalink")
+def hook():
+    event = construct_event(request.get_data(), request.headers, os.environ["WABALINK_WEBHOOK_SECRET"])  # lanza si es inválido
+    if event["event"] == "message.received":
+        ...
+    return "", 200  # deduplica por event["id"]
+```
+
+## Desarrollo
+
+```bash
+python3 -m unittest discover -s tests -v
+WABALINK_BASE_URL=http://127.0.0.1:4010/api/v1 WABALINK_API_KEY=wl_test_… python3 -m unittest discover -s tests -v
+```

wabalink-1.0.0/README.md

@@ -0,0 +1,47 @@
+# wabalink (Python)
+
+SDK de Python (>=3.9) para la API pública de Wabalink. Sin dependencias.
+
+```bash
+pip install wabalink
+```
+
+```python
+import os
+from wabalink import Wabalink
+
+wl = Wabalink(os.environ["WABALINK_API_KEY"])  # wl_test_… para la sandbox
+
+inbound = wl.sandbox.inbound(from_="573001112233", text="hola")      # simula al cliente
+wl.messages.send_text(inbound["conversation_id"], "¡Hola! ¿En qué te ayudo?")
+wl.messages.send(conversationId=inbound["conversation_id"], type="buttons", text="¿Agendamos?",
+                 buttons=[{"id": "si", "title": "Sí"}, {"id": "no", "title": "No"}])
+wl.appointments.create(contactId="…", startsAt="2026-12-01T15:00:00-05:00")
+for c in wl.contacts.iterate(tag="vip"):
+    print(c["name"])
+```
+
+- `messages`, `contacts` y `appointments` (POST) llevan `Idempotency-Key` automática, igual en los reintentos.
+- Reintenta 429, 5xx y fallas de red (`max_retries=2`). Los 4xx lanzan `WabalinkApiError` (`.status`, `str(e)`, `.details`).
+- Los campos de `send`, `upsert`, etc. son los de la API (`conversationId`, `startsAt`…); `sandbox.inbound(from_=…)` usa `from_` porque `from` es palabra reservada.
+
+## Webhooks
+
+```python
+from flask import Flask, request
+from wabalink import construct_event
+
+@app.post("/wabalink")
+def hook():
+    event = construct_event(request.get_data(), request.headers, os.environ["WABALINK_WEBHOOK_SECRET"])  # lanza si es inválido
+    if event["event"] == "message.received":
+        ...
+    return "", 200  # deduplica por event["id"]
+```
+
+## Desarrollo
+
+```bash
+python3 -m unittest discover -s tests -v
+WABALINK_BASE_URL=http://127.0.0.1:4010/api/v1 WABALINK_API_KEY=wl_test_… python3 -m unittest discover -s tests -v
+```

wabalink-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wabalink"
+version = "1.0.0"
+description = "SDK de Python para la API pública de Wabalink (WhatsApp Business): mensajes, chats, contactos, citas, sandbox y webhooks."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["whatsapp", "whatsapp-business", "wabalink", "sdk"]
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/DeSoluTec/wabalink/tree/main/sdks/python"
+
+[tool.setuptools]
+packages = ["wabalink"]

wabalink-1.0.0/setup.cfg

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

wabalink-1.0.0/tests/test_sdk.py

@@ -0,0 +1,107 @@
+import json
+import os
+import threading
+import time
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from wabalink import Wabalink, WabalinkApiError, WabalinkSignatureError, construct_event, sign
+
+
+def serve(handler):
+    reqs = []
+
+    class H(BaseHTTPRequestHandler):
+        def _do(self):
+            n = int(self.headers.get("Content-Length") or 0)
+            body = self.rfile.read(n).decode()
+            reqs.append({"method": self.command, "path": self.path, "headers": dict(self.headers), "body": body})
+            status, payload = handler(self, len(reqs))
+            out = json.dumps(payload).encode()
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(out)))
+            self.end_headers()
+            self.wfile.write(out)
+
+        do_GET = do_POST = do_PATCH = _do
+
+        def log_message(self, *a):
+            pass
+
+    srv = HTTPServer(("127.0.0.1", 0), H)
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    return srv, f"http://127.0.0.1:{srv.server_port}/api/v1", reqs
+
+
+class UnitTests(unittest.TestCase):
+    def test_bearer_y_consulta(self):
+        srv, base, reqs = serve(lambda h, n: (200, []))
+        Wabalink("wl_test_x", base).conversations.list(status="open", limit=5)
+        self.assertEqual(reqs[0]["headers"]["Authorization"], "Bearer wl_test_x")
+        self.assertEqual(reqs[0]["path"], "/api/v1/conversations?status=open&limit=5")
+        srv.shutdown()
+
+    def test_idempotency_key_se_repite_al_reintentar(self):
+        srv, base, reqs = serve(lambda h, n: (503, {}) if n == 1 else (201, {"conversation_id": "c", "message": {}}))
+        r = Wabalink("wl_test_x", base).messages.send_text("c", "hola")
+        self.assertEqual(r["conversation_id"], "c")
+        self.assertEqual(len(reqs), 2)
+        self.assertTrue(reqs[0]["headers"]["Idempotency-Key"])
+        self.assertEqual(reqs[0]["headers"]["Idempotency-Key"], reqs[1]["headers"]["Idempotency-Key"])
+        srv.shutdown()
+
+    def test_4xx_lanza_error_sin_reintentar(self):
+        srv, base, reqs = serve(lambda h, n: (400, {"error": "Ventana de 24 h cerrada"}))
+        with self.assertRaises(WabalinkApiError) as cm:
+            Wabalink("wl_test_x", base).messages.send_text("c", "x")
+        self.assertEqual(cm.exception.status, 400)
+        self.assertEqual(str(cm.exception), "Ventana de 24 h cerrada")
+        self.assertEqual(len(reqs), 1)
+        srv.shutdown()
+
+    def test_iterate_recorre_paginas(self):
+        def h(handler, n):
+            off = int(handler.path.split("offset=")[1].split("&")[0])
+            return 200, {"items": [{"id": f"a{off}"}, {"id": f"b{off}"}], "total": 4}
+        srv, base, _ = serve(h)
+        ids = [c["id"] for c in Wabalink("wl_test_x", base).contacts.iterate(limit=2)]
+        self.assertEqual(ids, ["a0", "b0", "a2", "b2"])
+        srv.shutdown()
+
+    def test_webhooks(self):
+        body = json.dumps({"id": "e1", "event": "message.received", "livemode": False, "data": {}})
+        ts = str(int(time.time()))
+        headers = {"X-Wabalink-Timestamp": ts, "X-Wabalink-Signature": sign("sec", ts, body)}
+        self.assertEqual(construct_event(body, headers, "sec")["id"], "e1")
+        with self.assertRaises(WabalinkSignatureError):
+            construct_event(body + " ", headers, "sec")
+        with self.assertRaises(WabalinkSignatureError):
+            construct_event(body, headers, "otro")
+        old = str(int(ts) - 3600)
+        with self.assertRaises(WabalinkSignatureError):
+            construct_event(body, {"X-Wabalink-Timestamp": old, "X-Wabalink-Signature": sign("sec", old, body)}, "sec")
+
+
+LIVE = os.environ.get("WABALINK_API_KEY", "").startswith("wl_test_") and os.environ.get("WABALINK_BASE_URL")
+
+
+@unittest.skipUnless(LIVE, "sin WABALINK_API_KEY de sandbox")
+class SandboxTests(unittest.TestCase):
+    def test_flujo_completo(self):
+        wl = Wabalink(os.environ["WABALINK_API_KEY"])
+        self.assertFalse(wl.me()["livemode"])
+        wl.sandbox.reset()
+        inbound = wl.sandbox.inbound(from_="573001112233", name="Ana", text="hola")
+        sent = wl.messages.send_text(inbound["conversation_id"], "Hola Ana")
+        self.assertTrue(sent["message"]["wamid"])
+        self.assertGreaterEqual(len(wl.conversations.messages(inbound["conversation_id"])), 2)
+        self.assertTrue(wl.contacts.upsert(phone="+573001112233", tags=["sdk"])["id"])
+        self.assertEqual(wl.conversations.close(inbound["conversation_id"], outcome="resolved")["status"], "closed")
+        self.assertTrue(any(t["name"] == "hello_world" for t in wl.templates()))
+        with self.assertRaises(WabalinkApiError):
+            wl.messages.send(conversationId=inbound["conversation_id"], type="text")
+
+
+if __name__ == "__main__":
+    unittest.main()

wabalink-1.0.0/wabalink/__init__.py

@@ -0,0 +1,6 @@
+from .client import Wabalink, WabalinkError, WabalinkApiError, WabalinkConnectionError
+from .webhooks import construct_event, sign, WabalinkSignatureError
+
+__all__ = ["Wabalink", "WabalinkError", "WabalinkApiError", "WabalinkConnectionError",
+           "construct_event", "sign", "WabalinkSignatureError"]
+__version__ = "1.0.0"

wabalink-1.0.0/wabalink/client.py

@@ -0,0 +1,188 @@
+import json
+import os
+import random
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Dict, Iterator, List, Optional
+
+_IDEMPOTENT_PATHS = {"/messages", "/contacts", "/appointments"}
+
+
+class WabalinkError(Exception):
+    def __init__(self, message: str, status: Optional[int] = None, body: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+class WabalinkApiError(WabalinkError):
+    """Respuesta 4xx/5xx de la API. str(e) es el `error` del servidor."""
+
+    @property
+    def details(self) -> Any:
+        return self.body.get("details") if isinstance(self.body, dict) else None
+
+
+class WabalinkConnectionError(WabalinkError):
+    """Falla de red o tiempo agotado tras agotar los reintentos."""
+
+
+def _clean(d: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    return {k: v for k, v in (d or {}).items() if v is not None}
+
+
+class _Group:
+    def __init__(self, c: "Wabalink"):
+        self._c = c
+
+
+class _Conversations(_Group):
+    def list(self, status: Optional[str] = None, phone_id: Optional[str] = None, limit: Optional[int] = None) -> List[dict]:
+        return self._c.request("GET", "/conversations", query={"status": status, "phoneId": phone_id, "limit": limit})
+
+    def get(self, id: str) -> dict:
+        return self._c.request("GET", f"/conversations/{id}")
+
+    def messages(self, id: str, before: Optional[str] = None, before_id: Optional[str] = None, limit: Optional[int] = None) -> List[dict]:
+        return self._c.request("GET", f"/conversations/{id}/messages", query={"before": before, "beforeId": before_id, "limit": limit})
+
+    def handoff(self, id: str, to: str, note: Optional[str] = None) -> dict:
+        return self._c.request("POST", f"/conversations/{id}/handoff", body=_clean({"to": to, "note": note}))
+
+    def close(self, id: str, outcome: Optional[str] = None, topic: Optional[str] = None,
+              sale_amount: Optional[float] = None, note: Optional[str] = None) -> dict:
+        return self._c.request("POST", f"/conversations/{id}/close",
+                               body=_clean({"outcome": outcome, "topic": topic, "saleAmount": sale_amount, "note": note}))
+
+
+class _Messages(_Group):
+    def send(self, idempotency_key: Optional[str] = None, **body: Any) -> dict:
+        """send(conversationId=…, type="text", text="…"). Los campos son los de POST /messages."""
+        return self._c.request("POST", "/messages", body=_clean(body), idempotency_key=idempotency_key)
+
+    def send_text(self, conversation_id: str, text: str, idempotency_key: Optional[str] = None) -> dict:
+        return self.send(idempotency_key=idempotency_key, conversationId=conversation_id, type="text", text=text)
+
+
+class _Contacts(_Group):
+    def list(self, **params: Any) -> dict:
+        return self._c.request("GET", "/contacts", query=params)
+
+    def get(self, id: str) -> dict:
+        return self._c.request("GET", f"/contacts/{id}")
+
+    def upsert(self, idempotency_key: Optional[str] = None, **body: Any) -> dict:
+        return self._c.request("POST", "/contacts", body=_clean(body), idempotency_key=idempotency_key)
+
+    def update(self, id: str, **body: Any) -> dict:
+        return self._c.request("PATCH", f"/contacts/{id}", body=_clean(body))
+
+    def iterate(self, limit: int = 100, **params: Any) -> Iterator[dict]:
+        """Recorre todas las páginas."""
+        offset = 0
+        while True:
+            page = self.list(limit=limit, offset=offset, **params)
+            yield from page["items"]
+            offset += limit
+            if offset >= page["total"] or not page["items"]:
+                return
+
+
+class _Appointments(_Group):
+    def list(self, **params: Any) -> List[dict]:
+        return self._c.request("GET", "/appointments", query=params)
+
+    def create(self, idempotency_key: Optional[str] = None, **body: Any) -> dict:
+        return self._c.request("POST", "/appointments", body=_clean(body), idempotency_key=idempotency_key)
+
+    def update(self, id: str, **body: Any) -> dict:
+        return self._c.request("PATCH", f"/appointments/{id}", body=_clean(body))
+
+
+class _Sandbox(_Group):
+    def inbound(self, **body: Any) -> dict:
+        """inbound(from_="573001112233", text="hola"). `from_` se envía como `from`."""
+        if "from_" in body:
+            body["from"] = body.pop("from_")
+        return self._c.request("POST", "/sandbox/messages", body=_clean(body))
+
+    def reset(self) -> dict:
+        return self._c.request("POST", "/sandbox/reset", body={})
+
+
+class Wabalink:
+    """Cliente de la API pública. api_key: wl_live_… (real) o wl_test_… (sandbox)."""
+
+    def __init__(self, api_key: str, base_url: Optional[str] = None, max_retries: int = 2, timeout: float = 30.0):
+        if not api_key:
+            raise ValueError("Wabalink: falta api_key (wl_live_… o wl_test_…)")
+        self.api_key = api_key
+        self.base_url = (base_url or os.environ.get("WABALINK_BASE_URL") or "https://www.wabalink.com/api/v1").rstrip("/")
+        self.max_retries = max_retries
+        self.timeout = timeout
+        self.conversations = _Conversations(self)
+        self.messages = _Messages(self)
+        self.contacts = _Contacts(self)
+        self.appointments = _Appointments(self)
+        self.sandbox = _Sandbox(self)
+
+    @property
+    def is_test_key(self) -> bool:
+        return self.api_key.startswith("wl_test_")
+
+    def me(self) -> dict:
+        return self.request("GET", "/me")
+
+    def tags(self) -> List[dict]:
+        return self.request("GET", "/tags")
+
+    def templates(self) -> List[dict]:
+        return self.request("GET", "/templates")
+
+    def request(self, method: str, path: str, query: Optional[Dict[str, Any]] = None, body: Any = None,
+                idempotency_key: Optional[str] = None) -> Any:
+        url = self.base_url + path
+        q = {k: ("true" if v is True else "false" if v is False else v) for k, v in _clean(query).items()}
+        if q:
+            url += "?" + urllib.parse.urlencode(q)
+        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "application/json", "User-Agent": "wabalink-python/1.0.0"}
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode()
+            headers["Content-Type"] = "application/json"
+        # Misma llave en todos los reintentos: reintentar nunca duplica un mensaje.
+        if method == "POST" and path in _IDEMPOTENT_PATHS:
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+        elif idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+
+        last: Exception = WabalinkError("sin intentos")
+        for attempt in range(self.max_retries + 1):
+            if attempt:
+                time.sleep(min(8.0, 0.4 * 2 ** (attempt - 1)) + random.random() * 0.1)
+            req = urllib.request.Request(url, data=data, method=method, headers=headers)
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                    text = res.read().decode()
+                    return json.loads(text) if text else None
+            except urllib.error.HTTPError as e:
+                text = e.read().decode()
+                try:
+                    payload = json.loads(text) if text else None
+                except ValueError:
+                    payload = text
+                msg = payload.get("error") if isinstance(payload, dict) and payload.get("error") else f"HTTP {e.code}"
+                last = WabalinkApiError(msg, e.code, payload)
+                # 409: la primera petición con esa Idempotency-Key sigue en curso → se reintenta.
+                if e.code in (429, 409) or e.code >= 500:
+                    ra = e.headers.get("Retry-After")
+                    if attempt < self.max_retries and ra and ra.isdigit():
+                        time.sleep(min(int(ra), 30))
+                    continue
+                raise last
+            except (urllib.error.URLError, TimeoutError, OSError) as e:
+                last = WabalinkConnectionError(f"No se pudo conectar con Wabalink: {e}")
+        raise last

wabalink-1.0.0/wabalink/webhooks.py

@@ -0,0 +1,41 @@
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Mapping, Optional, Union
+
+from .client import WabalinkError
+
+
+class WabalinkSignatureError(WabalinkError):
+    """Firma de webhook inválida o fuera de tolerancia."""
+
+
+def sign(secret: str, timestamp: Union[str, int], raw_body: Union[str, bytes]) -> str:
+    """Firma esperada: sha256=HMAC(secreto, "<timestamp>.<cuerpo>")."""
+    body = raw_body.decode("utf-8") if isinstance(raw_body, bytes) else raw_body
+    mac = hmac.new(secret.encode(), f"{timestamp}.{body}".encode(), hashlib.sha256).hexdigest()
+    return "sha256=" + mac
+
+
+def construct_event(raw_body: Union[str, bytes], headers: Mapping[str, str], secret: str,
+                    tolerance_seconds: int = 300, now: Optional[float] = None) -> Any:
+    """Verifica un webhook y devuelve el evento (dict).
+
+    `raw_body` es el cuerpo EXACTO recibido. Deduplica por event["id"]: los reintentos conservan la id.
+    """
+    lower = {k.lower(): v for k, v in headers.items()}
+    ts = lower.get("x-wabalink-timestamp")
+    sig = lower.get("x-wabalink-signature")
+    if not ts or not sig:
+        raise WabalinkSignatureError("Faltan las cabeceras X-Wabalink-Timestamp o X-Wabalink-Signature")
+    if tolerance_seconds > 0:
+        try:
+            drift = abs((now if now is not None else time.time()) - float(ts))
+        except ValueError:
+            drift = float("inf")
+        if drift > tolerance_seconds:
+            raise WabalinkSignatureError("Marca de tiempo fuera de tolerancia")
+    if not hmac.compare_digest(sign(secret, ts, raw_body), sig):
+        raise WabalinkSignatureError("Firma inválida")
+    return json.loads(raw_body)

wabalink-1.0.0/wabalink.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: wabalink
+Version: 1.0.0
+Summary: SDK de Python para la API pública de Wabalink (WhatsApp Business): mensajes, chats, contactos, citas, sandbox y webhooks.
+License: MIT
+Project-URL: Repository, https://github.com/DeSoluTec/wabalink/tree/main/sdks/python
+Keywords: whatsapp,whatsapp-business,wabalink,sdk
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# wabalink (Python)
+
+SDK de Python (>=3.9) para la API pública de Wabalink. Sin dependencias.
+
+```bash
+pip install wabalink
+```
+
+```python
+import os
+from wabalink import Wabalink
+
+wl = Wabalink(os.environ["WABALINK_API_KEY"])  # wl_test_… para la sandbox
+
+inbound = wl.sandbox.inbound(from_="573001112233", text="hola")      # simula al cliente
+wl.messages.send_text(inbound["conversation_id"], "¡Hola! ¿En qué te ayudo?")
+wl.messages.send(conversationId=inbound["conversation_id"], type="buttons", text="¿Agendamos?",
+                 buttons=[{"id": "si", "title": "Sí"}, {"id": "no", "title": "No"}])
+wl.appointments.create(contactId="…", startsAt="2026-12-01T15:00:00-05:00")
+for c in wl.contacts.iterate(tag="vip"):
+    print(c["name"])
+```
+
+- `messages`, `contacts` y `appointments` (POST) llevan `Idempotency-Key` automática, igual en los reintentos.
+- Reintenta 429, 5xx y fallas de red (`max_retries=2`). Los 4xx lanzan `WabalinkApiError` (`.status`, `str(e)`, `.details`).
+- Los campos de `send`, `upsert`, etc. son los de la API (`conversationId`, `startsAt`…); `sandbox.inbound(from_=…)` usa `from_` porque `from` es palabra reservada.
+
+## Webhooks
+
+```python
+from flask import Flask, request
+from wabalink import construct_event
+
+@app.post("/wabalink")
+def hook():
+    event = construct_event(request.get_data(), request.headers, os.environ["WABALINK_WEBHOOK_SECRET"])  # lanza si es inválido
+    if event["event"] == "message.received":
+        ...
+    return "", 200  # deduplica por event["id"]
+```
+
+## Desarrollo
+
+```bash
+python3 -m unittest discover -s tests -v
+WABALINK_BASE_URL=http://127.0.0.1:4010/api/v1 WABALINK_API_KEY=wl_test_… python3 -m unittest discover -s tests -v
+```

wabalink-1.0.0/wabalink.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tests/test_sdk.py
+wabalink/__init__.py
+wabalink/client.py
+wabalink/webhooks.py
+wabalink.egg-info/PKG-INFO
+wabalink.egg-info/SOURCES.txt
+wabalink.egg-info/dependency_links.txt
+wabalink.egg-info/top_level.txt

wabalink-1.0.0/wabalink.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wabalink-1.0.0/wabalink.egg-info/top_level.txt

@@ -0,0 +1 @@
+wabalink