wirexaapi 1.0.0__tar.gz → 1.1.0__tar.gz

{wirexaapi-1.0.0 → wirexaapi-1.1.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: wirexaapi
-Version: 1.0.0
-Summary: Wirexa API SDK - SignalWire/Twilio compatible voice API client
+Version: 1.1.0
+Summary: Wirexa API SDK - voice API client (SignalWire/Twilio compatible) and Wirexa DB document database client
 Author-email: Wirexa Team <dev@wirexa.io>
 License: MIT
 Project-URL: Homepage, https://github.com/wirexa/wirexa-api
@@ -84,3 +84,35 @@ The rest of your code stays the same!
 ## License
 
 MIT
+
+
+## Wirexa DB (base de datos de documentos)
+
+```python
+from wirexaapi import MongoClient
+
+client = MongoClient(
+    "wirexaapi+srv://usuario:password@cluster0-abc1234.wirexaapi.com/?appName=cluster0",
+    serverSelectionTimeoutMS=5000,
+    connectTimeoutMS=5000,
+    socketTimeoutMS=20000,
+)
+db = client["miapp"]
+users = db["users"]            # las colecciones se crean solas
+
+users.insert_one({"name": "Ana", "age": 30})
+users.find_one({"name": "Ana"})
+for u in users.find({"age": {"$gt": 25}}).sort("name").limit(10):
+    print(u)
+users.update_one({"name": "Ana"}, {"$set": {"age": 31}})
+users.create_index("email", unique=True)
+```
+
+Soporta filtros (`$eq $ne $gt $gte $lt $lte $in $nin $exists $regex $and $or $nor $not $size $all $elemMatch`),
+updates (`$set $unset $inc $mul $min $max $push $addToSet $pull $pop $rename $currentDate $setOnInsert`), upserts,
+`find_one_and_*`, índices (incluidos únicos), `distinct`, `count_documents` y `aggregate`
+(`$match $sort $skip $limit $project $addFields $unset $unwind $group $count $lookup`).
+
+Si tu backend corre en la misma VPS que el cluster, usa la URI local que da el panel
+(`wirexaapi://...@127.0.0.1:27501/?cluster=<id>&tls=false`): ~1 ms por consulta.
+Instala `wirexaapi[srv]` para resolver el registro SRV del cluster.

wirexaapi-1.1.0/README.md

@@ -0,0 +1,96 @@
+# Wirexa API SDK
+
+A production-ready Python SDK for Wirexa API - a self-hosted telephony platform compatible with SignalWire and Twilio REST API.
+
+## Installation
+
+```bash
+pip install wirexaapi
+```
+
+## Quick Start
+
+```python
+from wirexaapi import Client
+
+# Connect to your Wirexa API instance
+client = Client(
+    project_id="your-project-id",
+    api_token="your-api-token", 
+    signalwire_space_url="your-space.example.com:5000"
+)
+
+# Make a call
+call = client.calls.create(
+    to="+573001234567",
+    from_="+18005550100",
+    url="https://your-backend.com/xml",
+    method="POST",
+    timeout=28,
+    record=True,
+    status_callback="https://your-backend.com/status",
+    status_callback_event=["initiated", "ringing", "completed"],
+)
+
+print(f"Call SID: {call.sid}")
+print(f"Call Status: {call.status}")
+```
+
+## Migration from SignalWire
+
+If you're migrating from SignalWire SDK:
+
+```python
+# Before
+from signalwire.rest import Client as SignalWireClient
+
+# After
+from wirexaapi import Client as SignalWireClient
+```
+
+The rest of your code stays the same!
+
+## Features
+
+- Full SignalWire/Twilio API compatibility
+- Call creation, retrieval, and listing
+- Machine Detection (AMD)
+- Recording
+- Status callbacks
+- Async AMD support
+
+## License
+
+MIT
+
+
+## Wirexa DB (base de datos de documentos)
+
+```python
+from wirexaapi import MongoClient
+
+client = MongoClient(
+    "wirexaapi+srv://usuario:password@cluster0-abc1234.wirexaapi.com/?appName=cluster0",
+    serverSelectionTimeoutMS=5000,
+    connectTimeoutMS=5000,
+    socketTimeoutMS=20000,
+)
+db = client["miapp"]
+users = db["users"]            # las colecciones se crean solas
+
+users.insert_one({"name": "Ana", "age": 30})
+users.find_one({"name": "Ana"})
+for u in users.find({"age": {"$gt": 25}}).sort("name").limit(10):
+    print(u)
+users.update_one({"name": "Ana"}, {"$set": {"age": 31}})
+users.create_index("email", unique=True)
+```
+
+Soporta filtros (`$eq $ne $gt $gte $lt $lte $in $nin $exists $regex $and $or $nor $not $size $all $elemMatch`),
+updates (`$set $unset $inc $mul $min $max $push $addToSet $pull $pop $rename $currentDate $setOnInsert`), upserts,
+`find_one_and_*`, índices (incluidos únicos), `distinct`, `count_documents` y `aggregate`
+(`$match $sort $skip $limit $project $addFields $unset $unwind $group $count $lookup`).
+
+Si tu backend corre en la misma VPS que el cluster, usa la URI local que da el panel
+(`wirexaapi://...@127.0.0.1:27501/?cluster=<id>&tls=false`): ~1 ms por consulta.
+Instala `wirexaapi[srv]` para resolver el registro SRV del cluster.

{wirexaapi-1.0.0 → wirexaapi-1.1.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wirexaapi"
-version = "1.0.0"
-description = "Wirexa API SDK - SignalWire/Twilio compatible voice API client"
+version = "1.1.0"
+description = "Wirexa API SDK - voice API client (SignalWire/Twilio compatible) and Wirexa DB document database client"
 readme = "README.md"
 license = {text = "MIT"}
 authors = [

wirexaapi-1.1.0/wirexaapi/__init__.py

@@ -0,0 +1,38 @@
+"""
+Wirexa API SDK - SDK compatible con la API de voz WirexaAPI.
+
+CREDENCIALES (las obtienes del dashboard):
+  space_url  = "your-space.example.com:5000"
+  project_id = "your-project-id"
+  api_token  = "your-api-token"
+
+USO:
+
+  ANTES (SignalWire original):
+    from signalwire.rest import Client
+    client = Client(project_id, api_token, signalwire_space_url=space_url)
+
+  DESPUÉS (Wirexa API):
+    from wirexaapi import Client
+    client = Client(project_id, api_token, signalwire_space_url=space_url)
+
+  El resto del código NO cambia.
+
+BASE DE DATOS (Wirexa DB):
+
+    from wirexaapi import MongoClient
+    client = MongoClient("wirexaapi+srv://user:pass@cluster0-abc1234.wirexaapi.com/")
+    client["miapp"]["users"].insert_one({"name": "Ana"})
+"""
+from wirexaapi.rest import Client
+from wirexaapi.db import (
+    WirexaClient, MongoClient, ASCENDING, DESCENDING, ReturnDocument, ObjectId,
+    WirexaDBError, OperationFailure, DuplicateKeyError, ConnectionFailure,
+    ServerSelectionTimeoutError,
+)
+
+__all__ = [
+    "Client", "WirexaClient", "MongoClient", "ASCENDING", "DESCENDING", "ReturnDocument", "ObjectId",
+    "WirexaDBError", "OperationFailure", "DuplicateKeyError", "ConnectionFailure",
+    "ServerSelectionTimeoutError",
+]

wirexaapi-1.1.0/wirexaapi/db.py

@@ -0,0 +1,665 @@
+"""
+Wirexa DB - cliente de la base de datos de documentos de Wirexa.
+
+USO:
+
+    from wirexaapi import MongoClient   # alias de WirexaClient
+
+    client = MongoClient(
+        "wirexaapi+srv://usuario:password@cluster0-abc1234.wirexaapi.com/?appName=cluster0",
+        serverSelectionTimeoutMS=5000,
+        connectTimeoutMS=5000,
+        socketTimeoutMS=20000,
+    )
+    db = client["miapp"]
+    users = db["users"]                  # o db.users; la colección nace sola
+
+    users.insert_one({"name": "Ana", "age": 30})
+    users.find_one({"name": "Ana"})
+    for u in users.find({"age": {"$gt": 25}}).sort("name").limit(10):
+        print(u)
+    users.update_one({"name": "Ana"}, {"$set": {"age": 31}})
+    users.create_index("email", unique=True)
+
+Si tu backend corre en la misma VPS que el cluster usa la URI local
+(wirexaapi://usuario:password@127.0.0.1:27501/?cluster=<id>&tls=false):
+evita TLS y la red, y responde en ~1 ms.
+"""
+import base64
+import datetime as _dt
+import decimal
+import http.client
+import json
+import re
+import socket
+import ssl
+import threading
+from urllib.parse import parse_qs, unquote, urlsplit
+
+__all__ = [
+    "WirexaClient", "MongoClient", "Database", "Collection", "Cursor",
+    "ASCENDING", "DESCENDING", "ReturnDocument", "ObjectId",
+    "WirexaDBError", "PyMongoError", "OperationFailure", "DuplicateKeyError",
+    "ConnectionFailure", "ServerSelectionTimeoutError", "ConfigurationError",
+]
+
+ASCENDING = 1
+DESCENDING = -1
+DEFAULT_PORT = 443       # vía nginx; pasa por cualquier firewall
+LOCAL_PORT = 27501       # backends en la misma VPS (sin TLS ni red)
+_PATH = "/_wdb/v1/op"
+
+
+class ReturnDocument:
+    BEFORE = False
+    AFTER = True
+
+
+class ObjectId(str):
+    """Los _id generados por el servidor son cadenas de 24 hex (mismo esquema
+    que un ObjectId: ordenan por fecha). Esta clase existe por compatibilidad:
+    ObjectId("...") devuelve la misma cadena."""
+
+    def __new__(cls, oid=None):
+        if oid is None:
+            raise ValueError("ObjectId() sin argumento: deja que el servidor genere el _id")
+        return str.__new__(cls, str(oid))
+
+    @property
+    def generation_time(self):
+        return _dt.datetime.fromtimestamp(int(self[:8], 16), tz=_dt.timezone.utc)
+
+
+# ------------------------------------------------------------------ errores
+
+class WirexaDBError(Exception):
+    pass
+
+
+PyMongoError = WirexaDBError  # mismo nombre que pymongo para except existentes
+
+
+class ConfigurationError(WirexaDBError):
+    pass
+
+
+class ConnectionFailure(WirexaDBError):
+    pass
+
+
+class ServerSelectionTimeoutError(ConnectionFailure):
+    pass
+
+
+class OperationFailure(WirexaDBError):
+    def __init__(self, message, code=None, details=None):
+        super().__init__(message)
+        self.code = code
+        self.details = details or {}
+
+    @property
+    def code_name(self):
+        return self.details.get("codeName")
+
+
+class DuplicateKeyError(OperationFailure):
+    pass
+
+
+# ------------------------------------------------------------------ JSON extendido
+
+def _encode(v):
+    if isinstance(v, dict):
+        return {str(k): _encode(x) for k, x in v.items()}
+    if isinstance(v, (list, tuple, set)):
+        return [_encode(x) for x in v]
+    if isinstance(v, _dt.datetime):
+        if v.tzinfo is None:
+            v = v.replace(tzinfo=_dt.timezone.utc)
+        v = v.astimezone(_dt.timezone.utc)
+        return {"$date": v.strftime("%Y-%m-%dT%H:%M:%S.") + "%03dZ" % (v.microsecond // 1000)}
+    if isinstance(v, _dt.date):
+        return _encode(_dt.datetime(v.year, v.month, v.day, tzinfo=_dt.timezone.utc))
+    if isinstance(v, (bytes, bytearray)):
+        return {"$binary": base64.b64encode(bytes(v)).decode()}
+    if isinstance(v, decimal.Decimal):
+        return {"$numberDecimal": str(v)}
+    if isinstance(v, re.Pattern):
+        opts = ""
+        if v.flags & re.IGNORECASE:
+            opts += "i"
+        if v.flags & re.MULTILINE:
+            opts += "m"
+        if v.flags & re.DOTALL:
+            opts += "s"
+        return {"$regex": v.pattern, "$options": opts}
+    return v
+
+
+def _decode_hook(d):
+    if len(d) == 1:
+        if "$date" in d:
+            s = d["$date"]
+            try:
+                return _dt.datetime.strptime(s, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=_dt.timezone.utc)
+            except (TypeError, ValueError):
+                return d
+        if "$binary" in d:
+            try:
+                return base64.b64decode(d["$binary"])
+            except Exception:
+                return d
+        if "$numberDecimal" in d:
+            return decimal.Decimal(d["$numberDecimal"])
+    return d
+
+
+def _sort_spec(key_or_list, direction=None):
+    """Acepta los mismos formatos que pymongo: "campo", ("campo", -1),
+    [("a", 1), ("b", -1)] o {"a": 1}."""
+    if key_or_list is None:
+        return None
+    if isinstance(key_or_list, str):
+        return [[key_or_list, direction if direction is not None else ASCENDING]]
+    if isinstance(key_or_list, dict):
+        return [[k, v] for k, v in key_or_list.items()]
+    if isinstance(key_or_list, tuple) and len(key_or_list) == 2 and isinstance(key_or_list[0], str) \
+            and isinstance(key_or_list[1], int):
+        return [list(key_or_list)]
+    out = []
+    for item in key_or_list:
+        if isinstance(item, str):
+            out.append([item, ASCENDING])
+        else:
+            out.append([item[0], item[1]])
+    return out
+
+
+def _projection(p):
+    if p is None:
+        return None
+    if isinstance(p, (list, tuple)):
+        return {k: 1 for k in p}
+    return p
+
+
+# ------------------------------------------------------------------ resultados
+
+class InsertOneResult:
+    def __init__(self, inserted_id):
+        self.inserted_id = inserted_id
+        self.acknowledged = True
+
+    def __repr__(self):
+        return "InsertOneResult(%r)" % (self.inserted_id,)
+
+
+class InsertManyResult:
+    def __init__(self, inserted_ids):
+        self.inserted_ids = inserted_ids
+        self.acknowledged = True
+
+
+class UpdateResult:
+    def __init__(self, r):
+        self.matched_count = r.get("matchedCount", 0)
+        self.modified_count = r.get("modifiedCount", 0)
+        self.upserted_id = r.get("upsertedId")
+        self.raw_result = r
+        self.acknowledged = True
+
+    def __repr__(self):
+        return "UpdateResult(matched=%d, modified=%d, upserted_id=%r)" % (
+            self.matched_count, self.modified_count, self.upserted_id)
+
+
+class DeleteResult:
+    def __init__(self, r):
+        self.deleted_count = r.get("deletedCount", 0)
+        self.raw_result = r
+        self.acknowledged = True
+
+    def __repr__(self):
+        return "DeleteResult(deleted=%d)" % self.deleted_count
+
+
+# ------------------------------------------------------------------ cliente
+
+def _parse_uri(uri):
+    parts = urlsplit(uri)
+    scheme = parts.scheme.lower()
+    if scheme not in ("wirexaapi", "wirexaapi+srv", "wirexa", "wirexa+srv"):
+        raise ConfigurationError("la URI debe empezar con wirexaapi:// o wirexaapi+srv://")
+    if not parts.hostname:
+        raise ConfigurationError("la URI no tiene host")
+    q = {k: v[-1] for k, v in parse_qs(parts.query).items()}
+    host = parts.hostname
+    label = host.split(".")[0]
+    cluster = q.get("cluster") or (label.rsplit("-", 1)[1] if "-" in label else "")
+    if not cluster:
+        raise ConfigurationError("no se pudo deducir el id del cluster; añade ?cluster=<id>")
+    local = host in ("127.0.0.1", "localhost", "::1")
+    tls = q.get("tls", q.get("ssl", "false" if local else "true")).lower() != "false"
+    port = parts.port
+    if port is None:
+        port = LOCAL_PORT if local and not tls else DEFAULT_PORT
+        if scheme.endswith("+srv"):
+            port = _resolve_srv(host) or port
+    return {
+        "username": unquote(parts.username or ""),
+        "password": unquote(parts.password or ""),
+        "host": host, "port": port, "tls": tls, "cluster": cluster,
+        "appName": q.get("appName", ""), "options": q,
+    }
+
+
+def _resolve_srv(host):
+    """Resuelve _wirexadb._tcp.<host> si dnspython está instalado; si no,
+    se usa el puerto por defecto (27500)."""
+    try:
+        import dns.resolver  # type: ignore
+    except ImportError:
+        return None
+    try:
+        ans = dns.resolver.resolve("_wirexadb._tcp." + host, "SRV", lifetime=3)
+        best = sorted(ans, key=lambda r: (r.priority, -r.weight))[0]
+        return int(best.port)
+    except Exception:
+        return None
+
+
+class WirexaClient:
+    """Cliente de Wirexa DB. Thread-safe: una conexión keep-alive por hilo."""
+
+    def __init__(self, host=None, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000,
+                 socketTimeoutMS=None, maxPoolSize=100, connect=True, tlsCAFile=None, **kwargs):
+        if host is None:
+            raise ConfigurationError("falta la URI del cluster")
+        cfg = _parse_uri(host)
+        if not cfg["username"]:
+            raise ConfigurationError("la URI no incluye usuario y contraseña")
+        self._cfg = cfg
+        self._connect_timeout = min(connectTimeoutMS, serverSelectionTimeoutMS) / 1000.0
+        self._read_timeout = (socketTimeoutMS / 1000.0) if socketTimeoutMS else 60.0
+        self._ssl = ssl.create_default_context(cafile=tlsCAFile) if cfg["tls"] else None
+        token = base64.b64encode(("%s:%s" % (cfg["username"], cfg["password"])).encode()).decode()
+        self._headers = {
+            "Authorization": "Basic " + token,
+            "X-Wirexa-Cluster": cfg["cluster"],
+            "Content-Type": "application/json",
+            "User-Agent": "wirexaapi-py/db " + (cfg["appName"] or "-"),
+        }
+        self._local = threading.local()
+        self._all = []
+        self._lock = threading.Lock()
+        self._closed = False
+        self.address = (cfg["host"], cfg["port"])
+
+    def _conn(self):
+        c = getattr(self._local, "conn", None)
+        if c is None:
+            host, port = self.address
+            if self._ssl is not None:
+                c = http.client.HTTPSConnection(host, port, timeout=self._connect_timeout, context=self._ssl)
+            else:
+                c = http.client.HTTPConnection(host, port, timeout=self._connect_timeout)
+            self._local.conn = c
+            with self._lock:
+                self._all.append(c)
+        if c.sock is None:
+            try:
+                c.connect()
+            except socket.timeout as e:
+                raise ServerSelectionTimeoutError("%s:%d: %s" % (self.address + (e,)))
+            except OSError as e:
+                raise ConnectionFailure("%s:%d: %s" % (self.address + (e,)))
+            c.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            c.sock.settimeout(self._read_timeout)
+        return c
+
+    def _op(self, op, retry_safe=False, **fields):
+        if self._closed:
+            raise ConnectionFailure("el cliente está cerrado")
+        body = json.dumps(_encode(dict(op=op, **fields)), separators=(",", ":")).encode()
+        for attempt in (0, 1):
+            c = self._conn()
+            reused = getattr(c, "_wdb_used", False)
+            try:
+                c.request("POST", _PATH, body, self._headers)
+                r = c.getresponse()
+                status, raw = r.status, r.read()
+                c._wdb_used = True
+                break
+            except (http.client.RemoteDisconnected, ConnectionResetError, BrokenPipeError,
+                    http.client.CannotSendRequest, http.client.ResponseNotReady) as e:
+                # Conexión keep-alive cerrada por el servidor mientras estaba
+                # ociosa: se reabre y se reintenta una sola vez.
+                c.close()
+                c._wdb_used = False
+                if attempt == 1 or not (reused or retry_safe):
+                    raise ConnectionFailure("%s:%d: %s" % (self.address + (e,)))
+            except socket.timeout as e:
+                c.close()
+                raise ConnectionFailure("timeout esperando respuesta: %s" % e)
+            except OSError as e:
+                c.close()
+                raise ConnectionFailure("%s:%d: %s" % (self.address + (e,)))
+        try:
+            data = json.loads(raw, object_hook=_decode_hook)
+        except ValueError:
+            raise OperationFailure("respuesta inválida del servidor (HTTP %d)" % status)
+        if not data.get("ok"):
+            msg = data.get("errmsg", "error")
+            code = data.get("code")
+            if code == 11000:
+                raise DuplicateKeyError(msg, code, data)
+            raise OperationFailure(msg, code, data)
+        return data
+
+    def __getitem__(self, name):
+        return Database(self, name)
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return Database(self, name)
+
+    def get_database(self, name=None, **kwargs):
+        return Database(self, name or "test")
+
+    def list_database_names(self):
+        return [d["name"] for d in self._op("listDatabases", True)["databases"]]
+
+    def drop_database(self, name):
+        if isinstance(name, Database):
+            name = name.name
+        self._op("dropDatabase", db=name)
+
+    def server_info(self):
+        self._op("ping", True)
+        return {"ok": 1.0, "version": "wirexadb-1"}
+
+    def close(self):
+        self._closed = True
+        with self._lock:
+            for c in self._all:
+                c.close()
+            self._all = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        self.close()
+
+    def __repr__(self):
+        return "WirexaClient(host=%r, cluster=%r)" % ("%s:%d" % self.address, self._cfg["cluster"])
+
+
+MongoClient = WirexaClient  # mismo nombre que pymongo: cambiar solo el import
+
+
+class Database:
+    def __init__(self, client, name):
+        self.client = client
+        self.name = name
+
+    def __getitem__(self, name):
+        return Collection(self, name)
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return Collection(self, name)
+
+    def get_collection(self, name, **kwargs):
+        return Collection(self, name)
+
+    def list_collection_names(self, **kwargs):
+        return self.client._op("listCollections", True, db=self.name)["collections"]
+
+    def drop_collection(self, name):
+        if isinstance(name, Collection):
+            name = name.name
+        self.client._op("drop", db=self.name, coll=name)
+
+    def create_collection(self, name, **kwargs):
+        return Collection(self, name)
+
+    def command(self, cmd, *args, **kwargs):
+        if cmd == "ping" or (isinstance(cmd, dict) and "ping" in cmd):
+            self.client._op("ping", True)
+            return {"ok": 1.0}
+        raise OperationFailure("comando no soportado: %r" % (cmd,))
+
+    def __repr__(self):
+        return "Database(%r)" % self.name
+
+
+class Collection:
+    def __init__(self, database, name):
+        self.database = database
+        self.name = name
+        self._client = database.client
+
+    @property
+    def full_name(self):
+        return "%s.%s" % (self.database.name, self.name)
+
+    def __getattr__(self, name):  # db.users.archived → colección "users.archived"
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return Collection(self.database, "%s.%s" % (self.name, name))
+
+    def __getitem__(self, name):
+        return Collection(self.database, "%s.%s" % (self.name, name))
+
+    def _op(self, op, retry_safe=False, **f):
+        return self._client._op(op, retry_safe, db=self.database.name, coll=self.name, **f)
+
+    # -------- escritura
+    def insert_one(self, document, **kwargs):
+        r = self._op("insertOne", doc=document)
+        if "_id" not in document:
+            document["_id"] = r["insertedId"]  # como pymongo: el dict queda con su _id
+        return InsertOneResult(r["insertedId"])
+
+    def insert_many(self, documents, ordered=True, **kwargs):
+        documents = list(documents)
+        if not documents:
+            raise TypeError("documents debe ser una lista no vacía")
+        r = self._op("insertMany", docs=documents, ordered=ordered)
+        for d, i in zip(documents, r["insertedIds"]):
+            d.setdefault("_id", i)
+        return InsertManyResult(r["insertedIds"])
+
+    def update_one(self, filter, update, upsert=False, **kwargs):
+        return UpdateResult(self._op("updateOne", filter=filter, update=update, upsert=upsert))
+
+    def update_many(self, filter, update, upsert=False, **kwargs):
+        return UpdateResult(self._op("updateMany", filter=filter, update=update, upsert=upsert))
+
+    def replace_one(self, filter, replacement, upsert=False, **kwargs):
+        return UpdateResult(self._op("replaceOne", filter=filter, replacement=replacement, upsert=upsert))
+
+    def delete_one(self, filter, **kwargs):
+        return DeleteResult(self._op("deleteOne", filter=filter))
+
+    def delete_many(self, filter, **kwargs):
+        return DeleteResult(self._op("deleteMany", filter=filter))
+
+    def find_one_and_update(self, filter, update, projection=None, sort=None, upsert=False,
+                            return_document=ReturnDocument.BEFORE, **kwargs):
+        return self._op("findOneAndUpdate", filter=filter, update=update, projection=_projection(projection),
+                        sort=_sort_spec(sort), upsert=upsert,
+                        returnDocument="after" if return_document else "before")["doc"]
+
+    def find_one_and_replace(self, filter, replacement, projection=None, sort=None, upsert=False,
+                             return_document=ReturnDocument.BEFORE, **kwargs):
+        return self._op("findOneAndReplace", filter=filter, replacement=replacement,
+                        projection=_projection(projection), sort=_sort_spec(sort), upsert=upsert,
+                        returnDocument="after" if return_document else "before")["doc"]
+
+    def find_one_and_delete(self, filter, projection=None, sort=None, **kwargs):
+        return self._op("findOneAndDelete", filter=filter, projection=_projection(projection),
+                        sort=_sort_spec(sort))["doc"]
+
+    # -------- lectura
+    def find(self, filter=None, projection=None, skip=0, limit=0, sort=None, **kwargs):
+        return Cursor(self, filter or {}, _projection(projection), skip, limit, _sort_spec(sort))
+
+    def find_one(self, filter=None, projection=None, *args, sort=None, **kwargs):
+        if filter is not None and not isinstance(filter, dict):
+            filter = {"_id": filter}
+        return self._op("findOne", True, filter=filter or {}, projection=_projection(projection),
+                        sort=_sort_spec(sort))["doc"]
+
+    def count_documents(self, filter, skip=0, limit=0, **kwargs):
+        return self._op("countDocuments", True, filter=filter, skip=skip, limit=limit)["n"]
+
+    def estimated_document_count(self, **kwargs):
+        return self._op("estimatedDocumentCount", True)["n"]
+
+    def distinct(self, key, filter=None, **kwargs):
+        return self._op("distinct", True, key=key, filter=filter or {})["values"]
+
+    def aggregate(self, pipeline, **kwargs):
+        return CommandCursor(self._op("aggregate", True, pipeline=list(pipeline))["docs"])
+
+    # -------- índices
+    def create_index(self, keys, unique=False, name=None, **kwargs):
+        f = {"keys": _sort_spec(keys), "unique": bool(unique)}
+        if name:
+            f["name"] = name
+        return self._op("createIndex", **f)["name"]
+
+    def create_indexes(self, indexes):
+        return [self.create_index(i.keys, **i.options) for i in indexes]
+
+    def drop_index(self, index_or_name):
+        name = index_or_name
+        if not isinstance(name, str):
+            spec = _sort_spec(index_or_name)
+            name = "_".join("%s_%s" % (k, d) for k, d in spec)
+        self._op("dropIndex", name=name)
+
+    def list_indexes(self):
+        out = []
+        for i in self._op("listIndexes", True)["indexes"]:
+            i["key"] = {k: d for k, d in i["key"]}
+            out.append(i)
+        return CommandCursor(out)
+
+    def index_information(self):
+        return {i["name"]: {"key": list(i["key"].items()), "unique": i.get("unique", False)}
+                for i in self.list_indexes()}
+
+    def drop(self):
+        self._op("drop")
+
+    def __repr__(self):
+        return "Collection(%r)" % self.full_name
+
+
+class IndexModel:
+    def __init__(self, keys, **kwargs):
+        self.keys = keys
+        self.options = kwargs
+
+
+class Cursor:
+    """Cursor perezoso: la consulta sale al iterar (o con to_list)."""
+
+    def __init__(self, coll, filter, projection, skip, limit, sort):
+        self._coll = coll
+        self._filter = filter
+        self._projection = projection
+        self._skip = skip
+        self._limit = limit
+        self._sort = sort
+        self._docs = None
+        self._pos = 0
+
+    def _check(self):
+        if self._docs is not None:
+            raise WirexaDBError("no se puede modificar un cursor ya iterado")
+
+    def sort(self, key_or_list, direction=None):
+        self._check()
+        self._sort = _sort_spec(key_or_list, direction)
+        return self
+
+    def skip(self, n):
+        self._check()
+        self._skip = n
+        return self
+
+    def limit(self, n):
+        self._check()
+        self._limit = n
+        return self
+
+    def batch_size(self, n):
+        return self
+
+    def _fetch(self):
+        if self._docs is None:
+            self._docs = self._coll._op("find", True, filter=self._filter, projection=self._projection,
+                                        skip=self._skip, limit=self._limit, sort=self._sort)["docs"]
+        return self._docs
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        docs = self._fetch()
+        if self._pos >= len(docs):
+            raise StopIteration
+        d = docs[self._pos]
+        self._pos += 1
+        return d
+
+    next = __next__
+
+    def to_list(self, length=None):
+        docs = self._fetch()[self._pos:]
+        return docs if length is None else docs[:length]
+
+    def rewind(self):
+        self._docs = None
+        self._pos = 0
+        return self
+
+    def close(self):
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        pass
+
+
+class CommandCursor:
+    def __init__(self, docs):
+        self._docs = docs
+        self._pos = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._pos >= len(self._docs):
+            raise StopIteration
+        d = self._docs[self._pos]
+        self._pos += 1
+        return d
+
+    next = __next__
+
+    def to_list(self, length=None):
+        docs = self._docs[self._pos:]
+        return docs if length is None else docs[:length]
+
+    def close(self):
+        pass

{wirexaapi-1.0.0/wirexaapi → wirexaapi-1.1.0/wirexaapi/rest}/__init__.py

@@ -1,23 +1,3 @@
-"""
-Wirexa API SDK - Drop-in replacement del SDK de SignalWire/Twilio.
-
-CREDENCIALES (las obtienes del dashboard):
-  space_url  = "your-space.example.com:5000"
-  project_id = "your-project-id"
-  api_token  = "your-api-token"
-
-USO:
-
-  ANTES (SignalWire original):
-    from signalwire.rest import Client
-    client = Client(project_id, api_token, signalwire_space_url=space_url)
-
-  DESPUÉS (Wirexa API):
-    from wirexaapi import Client
-    client = Client(project_id, api_token, signalwire_space_url=space_url)
-
-  El resto del código NO cambia.
-"""
 from __future__ import annotations
 
 import logging

{wirexaapi-1.0.0 → wirexaapi-1.1.0}/wirexaapi.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: wirexaapi
-Version: 1.0.0
-Summary: Wirexa API SDK - SignalWire/Twilio compatible voice API client
+Version: 1.1.0
+Summary: Wirexa API SDK - voice API client (SignalWire/Twilio compatible) and Wirexa DB document database client
 Author-email: Wirexa Team <dev@wirexa.io>
 License: MIT
 Project-URL: Homepage, https://github.com/wirexa/wirexa-api
@@ -84,3 +84,35 @@ The rest of your code stays the same!
 ## License
 
 MIT
+
+
+## Wirexa DB (base de datos de documentos)
+
+```python
+from wirexaapi import MongoClient
+
+client = MongoClient(
+    "wirexaapi+srv://usuario:password@cluster0-abc1234.wirexaapi.com/?appName=cluster0",
+    serverSelectionTimeoutMS=5000,
+    connectTimeoutMS=5000,
+    socketTimeoutMS=20000,
+)
+db = client["miapp"]
+users = db["users"]            # las colecciones se crean solas
+
+users.insert_one({"name": "Ana", "age": 30})
+users.find_one({"name": "Ana"})
+for u in users.find({"age": {"$gt": 25}}).sort("name").limit(10):
+    print(u)
+users.update_one({"name": "Ana"}, {"$set": {"age": 31}})
+users.create_index("email", unique=True)
+```
+
+Soporta filtros (`$eq $ne $gt $gte $lt $lte $in $nin $exists $regex $and $or $nor $not $size $all $elemMatch`),
+updates (`$set $unset $inc $mul $min $max $push $addToSet $pull $pop $rename $currentDate $setOnInsert`), upserts,
+`find_one_and_*`, índices (incluidos únicos), `distinct`, `count_documents` y `aggregate`
+(`$match $sort $skip $limit $project $addFields $unset $unwind $group $count $lookup`).
+
+Si tu backend corre en la misma VPS que el cluster, usa la URI local que da el panel
+(`wirexaapi://...@127.0.0.1:27501/?cluster=<id>&tls=false`): ~1 ms por consulta.
+Instala `wirexaapi[srv]` para resolver el registro SRV del cluster.

{wirexaapi-1.0.0 → wirexaapi-1.1.0}/wirexaapi.egg-info/SOURCES.txt

@@ -1,8 +1,10 @@
 README.md
 pyproject.toml
 wirexaapi/__init__.py
+wirexaapi/db.py
 wirexaapi.egg-info/PKG-INFO
 wirexaapi.egg-info/SOURCES.txt
 wirexaapi.egg-info/dependency_links.txt
 wirexaapi.egg-info/requires.txt
-wirexaapi.egg-info/top_level.txt
+wirexaapi.egg-info/top_level.txt
+wirexaapi/rest/__init__.py

wirexaapi-1.0.0/README.md

@@ -1,64 +0,0 @@
-# Wirexa API SDK
-
-A production-ready Python SDK for Wirexa API - a self-hosted telephony platform compatible with SignalWire and Twilio REST API.
-
-## Installation
-
-```bash
-pip install wirexaapi
-```
-
-## Quick Start
-
-```python
-from wirexaapi import Client
-
-# Connect to your Wirexa API instance
-client = Client(
-    project_id="your-project-id",
-    api_token="your-api-token", 
-    signalwire_space_url="your-space.example.com:5000"
-)
-
-# Make a call
-call = client.calls.create(
-    to="+573001234567",
-    from_="+18005550100",
-    url="https://your-backend.com/xml",
-    method="POST",
-    timeout=28,
-    record=True,
-    status_callback="https://your-backend.com/status",
-    status_callback_event=["initiated", "ringing", "completed"],
-)
-
-print(f"Call SID: {call.sid}")
-print(f"Call Status: {call.status}")
-```
-
-## Migration from SignalWire
-
-If you're migrating from SignalWire SDK:
-
-```python
-# Before
-from signalwire.rest import Client as SignalWireClient
-
-# After
-from wirexaapi import Client as SignalWireClient
-```
-
-The rest of your code stays the same!
-
-## Features
-
-- Full SignalWire/Twilio API compatibility
-- Call creation, retrieval, and listing
-- Machine Detection (AMD)
-- Recording
-- Status callbacks
-- Async AMD support
-
-## License
-
-MIT