vicifast 0.1.0__tar.gz

vicifast-0.1.0/LICENSE

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

vicifast-0.1.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: vicifast
+Version: 0.1.0
+Summary: The VICIfast API for Python: phone numbers, calls, billing and webhooks.
+License: MIT
+Project-URL: Documentation, https://vicifast.com/api-docs
+Project-URL: Homepage, https://vicifast.com
+Keywords: vicifast,vicidial,phone numbers,did,telephony,api,webhooks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Communications :: Telephony
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# vicifast
+
+The [VICIfast API](https://vicifast.com/api-docs) for Python 3.8 and later:
+buy and manage phone numbers, place back-orders, read calls, recordings and
+transcripts, follow your wallet, and check the webhooks we send you. Built on
+the standard library only, with no dependencies.
+
+```sh
+pip install vicifast
+```
+
+## Use
+
+```python
+import os
+from vicifast import Vicifast
+
+vf = Vicifast(api_key=os.environ["VICIFAST_API_KEY"])
+
+print(vf.get_balance()["data"]["balance_cents"])
+
+found = vf.search_numbers(area_code="305", limit=5)
+order = vf.purchase_numbers({"numbers": [found["data"][0]["number"]]})
+```
+
+Make keys under **API → Keys** in the dashboard. A `vf_test_…` key works
+against the sandbox: the same calls, with nothing charged and no real numbers
+touched. Use one while you build.
+
+Each operation in the [reference](https://vicifast.com/api-docs) is a method
+named after its `operationId` in snake*case. Path parameters come first,
+positionally, then the request body. Query parameters are keyword arguments. A
+parameter whose name is a Python keyword takes a trailing underscore:
+`vf.list_calls(from*="2026-10-01")`.
+
+## Pages
+
+A list answers one page at a time. `paginate` walks every page for you:
+
+```python
+for number in vf.paginate("listNumbers", status="active"):
+    print(number["number"], number["routing"])
+```
+
+The calls export is CSV, one file per page:
+
+```python
+with open("calls.csv", "w") as out:
+    for i, csv in enumerate(vf.export_call_files(window="30d")):
+        out.write(csv if i == 0 else csv.split("\n", 1)[1])
+```
+
+## Errors and retries
+
+Anything other than a success raises `VicifastError`. It carries the HTTP
+`status`, a `code` to branch on (`insufficient_funds`, `rate_limited`, …), a
+`message`, the offending `param` when there is one, and a `request_id` to quote
+to support.
+
+A request that is safe to repeat is retried up to `max_retries` times (default 2) on 408, 429 and 5xx, and when the connection fails. A 429 waits for
+`Retry-After`. Reads are always safe to repeat. Calls that spend or move money
+(a purchase, a release, a back-order, a transcript) are safe too, because each
+one is sent with an `Idempotency-Key`: the same key on every retry, so a
+retried purchase still buys once. The client makes the key for you, or you can
+pass your own as `idempotency_key=`.
+
+## Webhooks
+
+Check every request against the endpoint's signing secret before trusting it.
+Pass the body exactly as it arrived:
+
+```python
+from flask import Flask, abort, request
+from vicifast import parse_event
+
+app = Flask(__name__)
+
+@app.post("/vicifast")
+def vicifast():
+    try:
+        event = parse_event(request.get_data(), request.headers.get("X-VICIfast-Signature"), os.environ["VICIFAST_WEBHOOK_SECRET"])
+    except ValueError:
+        abort(400)
+    if event["type"] == "call.inbound.completed":
+        ...
+    return "", 200
+```
+
+`verify_signature(body, header, secret)` gives you the same check as a
+boolean. A request signed more than five minutes ago is refused.
+
+Licensed MIT. This package is generated from
+[vicifast.com/api-docs/openapi.json](https://vicifast.com/api-docs/openapi.json).

vicifast-0.1.0/README.md

@@ -0,0 +1,93 @@
+# vicifast
+
+The [VICIfast API](https://vicifast.com/api-docs) for Python 3.8 and later:
+buy and manage phone numbers, place back-orders, read calls, recordings and
+transcripts, follow your wallet, and check the webhooks we send you. Built on
+the standard library only, with no dependencies.
+
+```sh
+pip install vicifast
+```
+
+## Use
+
+```python
+import os
+from vicifast import Vicifast
+
+vf = Vicifast(api_key=os.environ["VICIFAST_API_KEY"])
+
+print(vf.get_balance()["data"]["balance_cents"])
+
+found = vf.search_numbers(area_code="305", limit=5)
+order = vf.purchase_numbers({"numbers": [found["data"][0]["number"]]})
+```
+
+Make keys under **API → Keys** in the dashboard. A `vf_test_…` key works
+against the sandbox: the same calls, with nothing charged and no real numbers
+touched. Use one while you build.
+
+Each operation in the [reference](https://vicifast.com/api-docs) is a method
+named after its `operationId` in snake*case. Path parameters come first,
+positionally, then the request body. Query parameters are keyword arguments. A
+parameter whose name is a Python keyword takes a trailing underscore:
+`vf.list_calls(from*="2026-10-01")`.
+
+## Pages
+
+A list answers one page at a time. `paginate` walks every page for you:
+
+```python
+for number in vf.paginate("listNumbers", status="active"):
+    print(number["number"], number["routing"])
+```
+
+The calls export is CSV, one file per page:
+
+```python
+with open("calls.csv", "w") as out:
+    for i, csv in enumerate(vf.export_call_files(window="30d")):
+        out.write(csv if i == 0 else csv.split("\n", 1)[1])
+```
+
+## Errors and retries
+
+Anything other than a success raises `VicifastError`. It carries the HTTP
+`status`, a `code` to branch on (`insufficient_funds`, `rate_limited`, …), a
+`message`, the offending `param` when there is one, and a `request_id` to quote
+to support.
+
+A request that is safe to repeat is retried up to `max_retries` times (default 2) on 408, 429 and 5xx, and when the connection fails. A 429 waits for
+`Retry-After`. Reads are always safe to repeat. Calls that spend or move money
+(a purchase, a release, a back-order, a transcript) are safe too, because each
+one is sent with an `Idempotency-Key`: the same key on every retry, so a
+retried purchase still buys once. The client makes the key for you, or you can
+pass your own as `idempotency_key=`.
+
+## Webhooks
+
+Check every request against the endpoint's signing secret before trusting it.
+Pass the body exactly as it arrived:
+
+```python
+from flask import Flask, abort, request
+from vicifast import parse_event
+
+app = Flask(__name__)
+
+@app.post("/vicifast")
+def vicifast():
+    try:
+        event = parse_event(request.get_data(), request.headers.get("X-VICIfast-Signature"), os.environ["VICIFAST_WEBHOOK_SECRET"])
+    except ValueError:
+        abort(400)
+    if event["type"] == "call.inbound.completed":
+        ...
+    return "", 200
+```
+
+`verify_signature(body, header, secret)` gives you the same check as a
+boolean. A request signed more than five minutes ago is refused.
+
+Licensed MIT. This package is generated from
+[vicifast.com/api-docs/openapi.json](https://vicifast.com/api-docs/openapi.json).

vicifast-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vicifast"
+version = "0.1.0"
+description = "The VICIfast API for Python: phone numbers, calls, billing and webhooks."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = []
+keywords = ["vicifast", "vicidial", "phone numbers", "did", "telephony", "api", "webhooks"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Communications :: Telephony",
+]
+
+[project.urls]
+Documentation = "https://vicifast.com/api-docs"
+Homepage = "https://vicifast.com"
+
+[tool.setuptools]
+packages = ["vicifast"]
+
+[tool.setuptools.package-data]
+vicifast = ["py.typed"]

vicifast-0.1.0/setup.cfg

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

vicifast-0.1.0/tests/test_client.py

@@ -0,0 +1,162 @@
+"""The client against a stub server on localhost: what it sends, when it
+retries, how errors and pages come back. Run: python -m unittest"""
+
+import hashlib
+import hmac
+import json
+import threading
+import time
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlparse
+
+from vicifast import Vicifast, VicifastError, parse_event, verify_signature
+
+SEEN = []
+HANDLER = [None]
+
+
+class Stub(BaseHTTPRequestHandler):
+    def _any(self):
+        n = int(self.headers.get("content-length") or 0)
+        body = self.rfile.read(n).decode() if n else ""
+        SEEN.append({"method": self.command, "url": self.path, "headers": dict(self.headers), "body": body})
+        status, headers, out = HANDLER[0](SEEN[-1], len(SEEN))
+        self.send_response(status)
+        for k, v in headers.items():
+            self.send_header(k, v)
+        self.end_headers()
+        self.wfile.write(out.encode())
+
+    do_GET = do_POST = do_PATCH = do_DELETE = _any
+
+    def log_message(self, *args):
+        pass
+
+
+def js(status, body, **headers):
+    return status, dict({"Content-Type": "application/json"}, **{k.replace("_", "-"): v for k, v in headers.items()}), json.dumps(body)
+
+
+class ClientTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.server = HTTPServer(("127.0.0.1", 0), Stub)
+        threading.Thread(target=cls.server.serve_forever, daemon=True).start()
+        cls.base = "http://127.0.0.1:%d/" % cls.server.server_port
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.shutdown()
+
+    def setUp(self):
+        del SEEN[:]
+        self.slept = []
+
+    def client(self, **kw):
+        return Vicifast(api_key="vf_test_abc", base_url=self.base, sleep=self.slept.append, **kw)
+
+    def test_auth_query_and_path(self):
+        HANDLER[0] = lambda s, n: js(200, {"data": {}})
+        c = self.client()
+        self.assertFalse(c.livemode)
+        c.get_number("+13055550100")
+        c.list_calls(limit=5, from_="2026-10-01", answered=True, status=None)
+        self.assertEqual(SEEN[0]["url"], "/api/v1/numbers/%2B13055550100")
+        self.assertEqual(SEEN[0]["headers"]["Authorization"], "Bearer vf_test_abc")
+        self.assertTrue(SEEN[0]["headers"]["User-Agent"].startswith("vicifast-python/"))
+        self.assertNotIn("Idempotency-Key", SEEN[0]["headers"])
+        self.assertEqual(SEEN[1]["url"], "/api/v1/calls?limit=5&from=2026-10-01&answered=true")
+
+    def test_purchase_reuses_one_idempotency_key_across_retries(self):
+        HANDLER[0] = lambda s, n: js(503, {"error": {"code": "service_unavailable", "message": "busy"}}) if n < 3 else js(201, {"data": {"id": "ord_1"}})
+        out = self.client().purchase_numbers({"numbers": ["+13055550100"]})
+        self.assertEqual(out, {"data": {"id": "ord_1"}})
+        self.assertEqual(len(SEEN), 3)
+        keys = {s["headers"]["Idempotency-Key"] for s in SEEN}
+        self.assertEqual(len(keys), 1)
+        self.assertEqual(len(next(iter(keys))), 36)
+        self.assertEqual(json.loads(SEEN[0]["body"]), {"numbers": ["+13055550100"]})
+
+    def test_own_idempotency_key(self):
+        HANDLER[0] = lambda s, n: js(201, {"data": {}})
+        self.client().place_backorder({"lines": []}, idempotency_key="mine-1")
+        self.assertEqual(SEEN[0]["headers"]["Idempotency-Key"], "mine-1")
+
+    def test_429_waits_for_retry_after_then_gives_up(self):
+        HANDLER[0] = lambda s, n: js(429, {"error": {"code": "rate_limited", "message": "slow down"}}, retry_after="7", x_request_id="req_9")
+        with self.assertRaises(VicifastError) as ctx:
+            self.client(max_retries=1).get_balance()
+        e = ctx.exception
+        self.assertEqual((e.status, e.code, e.request_id), (429, "rate_limited", "req_9"))
+        self.assertEqual(len(SEEN), 2)
+        self.assertEqual(self.slept, [7.0])
+
+    def test_unsafe_call_not_retried(self):
+        HANDLER[0] = lambda s, n: js(503, {"error": {"code": "service_unavailable", "message": "x"}})
+        with self.assertRaises(VicifastError):
+            self.client().create_webhook_endpoint({"url": "https://x.test", "events": []})
+        self.assertEqual(len(SEEN), 1)
+
+    def test_error_fields(self):
+        HANDLER[0] = lambda s, n: js(402, {"error": {"code": "insufficient_funds", "message": "Top up", "param": "numbers", "details": {"short_cents": 120}}})
+        with self.assertRaises(VicifastError) as ctx:
+            self.client().purchase_numbers({"numbers": ["+1"]})
+        e = ctx.exception
+        self.assertEqual((str(e), e.param, e.details), ("Top up", "numbers", {"short_cents": 120}))
+        self.assertEqual(len(SEEN), 1)
+
+    def test_missing_path_param(self):
+        with self.assertRaisesRegex(ValueError, "number is required"):
+            self.client().get_number("")
+        self.assertEqual(len(SEEN), 0)
+
+    def test_paginate(self):
+        pages = {
+            None: {"data": [{"id": "a"}, {"id": "b"}], "has_more": True, "next_cursor": "c2"},
+            "c2": {"data": [{"id": "c"}], "has_more": True, "next_cursor": "c3"},
+            "c3": {"data": [{"id": "d"}], "has_more": False, "next_cursor": None},
+        }
+        HANDLER[0] = lambda s, n: js(200, pages[(parse_qs(urlparse(s["url"]).query).get("cursor") or [None])[0]])
+        ids = [c["id"] for c in self.client().paginate("listCalls", window="30d")]
+        self.assertEqual(ids, ["a", "b", "c", "d"])
+        self.assertEqual([s["url"] for s in SEEN], ["/api/v1/calls?window=30d", "/api/v1/calls?window=30d&cursor=c2", "/api/v1/calls?window=30d&cursor=c3"])
+        with self.assertRaises(ValueError):
+            list(self.client().paginate("getBalance"))
+
+    def test_export_files(self):
+        def h(s, n):
+            more = "cursor" not in s["url"]
+            return 200, dict({"Content-Type": "text/csv; charset=utf-8"}, **({"X-Next-Cursor": "k2"} if more else {})), ("id\n1\n2\n" if more else "id\n3\n")
+        HANDLER[0] = h
+        self.assertEqual(list(self.client().export_call_files(limit=2)), ["id\n1\n2\n", "id\n3\n"])
+        self.assertEqual(SEEN[1]["url"], "/api/v1/calls/export?limit=2&cursor=k2")
+
+
+class SignatureTest(unittest.TestCase):
+    secret = "whsec_sdk_test"
+    body = json.dumps({"id": "evt_1", "type": "number.purchased", "data": {"note": "café ✓"}}, ensure_ascii=False)
+
+    def sign(self, body, t, secret=None):
+        mac = hmac.new((secret or self.secret).encode(), ("%d." % t).encode() + body.encode(), hashlib.sha256).hexdigest()
+        return "t=%d,v1=%s" % (t, mac)
+
+    def test_accepts_exactly_the_genuine_request(self):
+        now = int(time.time())
+        self.assertTrue(verify_signature(self.body, self.sign(self.body, now), self.secret))
+        self.assertTrue(verify_signature(self.body.encode(), self.sign(self.body, now), self.secret))
+        self.assertFalse(verify_signature(self.body + " ", self.sign(self.body, now), self.secret))
+        self.assertFalse(verify_signature(self.body, self.sign(self.body, now, "whsec_other"), self.secret))
+        self.assertFalse(verify_signature(self.body, self.sign(self.body, now - 600), self.secret))
+        self.assertFalse(verify_signature(self.body, "nonsense", self.secret))
+        self.assertFalse(verify_signature(self.body, None, self.secret))
+
+    def test_parse_event(self):
+        now = int(time.time())
+        self.assertEqual(parse_event(self.body, self.sign(self.body, now), self.secret)["id"], "evt_1")
+        with self.assertRaises(ValueError):
+            parse_event(self.body, self.sign(self.body, now - 600), self.secret)
+
+
+if __name__ == "__main__":
+    unittest.main()

vicifast-0.1.0/vicifast/__init__.py

@@ -0,0 +1,8 @@
+"""The VICIfast API: phone numbers, calls, billing and webhooks. https://vicifast.com/api-docs"""
+
+from ._operations import OPERATIONS
+from .client import VERSION, Vicifast, VicifastError
+from .webhooks import parse_event, verify_signature
+
+__version__ = VERSION
+__all__ = ["OPERATIONS", "VERSION", "Vicifast", "VicifastError", "parse_event", "verify_signature"]

vicifast-0.1.0/vicifast/_operations.py

@@ -0,0 +1,245 @@
+# GENERATED by scripts/generate-sdks.mts from sdks/openapi.json. Do not edit.
+# openapi.json sha256 fb0c46ff891048f01557614f3c70c6883ff55f6e45d6e7024252bfaba49a429c
+# fmt: off
+from typing import Any, Dict, Optional
+
+OPERATIONS: Dict[str, Dict[str, Any]] = {
+    "addCidGroupNumbers": {"method": "POST", "path": "/api/v1/servers/{id}/cid-groups/{group}/numbers", "path_params": ["id", "group"], "idempotent": False, "list": False},
+    "bulkUpdateNumbers": {"method": "PATCH", "path": "/api/v1/numbers", "path_params": [], "idempotent": False, "list": False},
+    "cancelBackorder": {"method": "POST", "path": "/api/v1/backorders/{id}/cancel", "path_params": ["id"], "idempotent": True, "list": False},
+    "createTranscript": {"method": "POST", "path": "/api/v1/calls/{id}/transcript", "path_params": ["id"], "idempotent": True, "list": False},
+    "createWebhookEndpoint": {"method": "POST", "path": "/api/v1/webhook-endpoints", "path_params": [], "idempotent": False, "list": False},
+    "deleteWebhookEndpoint": {"method": "DELETE", "path": "/api/v1/webhook-endpoints/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "deliverBackorder": {"method": "POST", "path": "/api/v1/sandbox/backorders/{id}/deliver", "path_params": ["id"], "idempotent": False, "list": False},
+    "enrollInJourney": {"method": "POST", "path": "/api/v1/journeys/{id}/enroll", "path_params": ["id"], "idempotent": True, "list": False},
+    "exportCalls": {"method": "GET", "path": "/api/v1/calls/export", "path_params": [], "idempotent": False, "list": False},
+    "getBackorder": {"method": "GET", "path": "/api/v1/backorders/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "getBalance": {"method": "GET", "path": "/api/v1/billing/balance", "path_params": [], "idempotent": False, "list": False},
+    "getCall": {"method": "GET", "path": "/api/v1/calls/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "getCidGroup": {"method": "GET", "path": "/api/v1/servers/{id}/cid-groups/{group}", "path_params": ["id", "group"], "idempotent": False, "list": False},
+    "getEvent": {"method": "GET", "path": "/api/v1/events/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "getNumber": {"method": "GET", "path": "/api/v1/numbers/{number}", "path_params": ["number"], "idempotent": False, "list": False},
+    "getOrder": {"method": "GET", "path": "/api/v1/orders/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "getRecordingLink": {"method": "GET", "path": "/api/v1/calls/{id}/recording", "path_params": ["id"], "idempotent": False, "list": False},
+    "getTranscript": {"method": "GET", "path": "/api/v1/calls/{id}/transcript", "path_params": ["id"], "idempotent": False, "list": False},
+    "getWebhookEndpoint": {"method": "GET", "path": "/api/v1/webhook-endpoints/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+    "listBackorders": {"method": "GET", "path": "/api/v1/backorders", "path_params": [], "idempotent": False, "list": True},
+    "listCalls": {"method": "GET", "path": "/api/v1/calls", "path_params": [], "idempotent": False, "list": True},
+    "listCidGroups": {"method": "GET", "path": "/api/v1/servers/{id}/cid-groups", "path_params": ["id"], "idempotent": False, "list": False},
+    "listEvents": {"method": "GET", "path": "/api/v1/events", "path_params": [], "idempotent": False, "list": True},
+    "listMessages": {"method": "GET", "path": "/api/v1/messages", "path_params": [], "idempotent": False, "list": True},
+    "listNumbers": {"method": "GET", "path": "/api/v1/numbers", "path_params": [], "idempotent": False, "list": True},
+    "listOrders": {"method": "GET", "path": "/api/v1/orders", "path_params": [], "idempotent": False, "list": True},
+    "listRenewals": {"method": "GET", "path": "/api/v1/billing/renewals", "path_params": [], "idempotent": False, "list": False},
+    "listServers": {"method": "GET", "path": "/api/v1/servers", "path_params": [], "idempotent": False, "list": False},
+    "listTransactions": {"method": "GET", "path": "/api/v1/billing/transactions", "path_params": [], "idempotent": False, "list": True},
+    "listWebhookDeliveries": {"method": "GET", "path": "/api/v1/webhook-endpoints/{id}/deliveries", "path_params": ["id"], "idempotent": False, "list": True},
+    "listWebhookEndpoints": {"method": "GET", "path": "/api/v1/webhook-endpoints", "path_params": [], "idempotent": False, "list": False},
+    "placeBackorder": {"method": "POST", "path": "/api/v1/backorders", "path_params": [], "idempotent": True, "list": False},
+    "purchaseNumbers": {"method": "POST", "path": "/api/v1/numbers/purchase", "path_params": [], "idempotent": True, "list": False},
+    "releaseNumbers": {"method": "POST", "path": "/api/v1/numbers/release", "path_params": [], "idempotent": True, "list": False},
+    "removeCidGroupNumbers": {"method": "POST", "path": "/api/v1/servers/{id}/cid-groups/{group}/numbers/remove", "path_params": ["id", "group"], "idempotent": False, "list": False},
+    "resendEvent": {"method": "POST", "path": "/api/v1/events/{id}/resend", "path_params": ["id"], "idempotent": False, "list": False},
+    "resetSandbox": {"method": "POST", "path": "/api/v1/sandbox/reset", "path_params": [], "idempotent": False, "list": False},
+    "rotateWebhookSecret": {"method": "POST", "path": "/api/v1/webhook-endpoints/{id}/rotate-secret", "path_params": ["id"], "idempotent": False, "list": False},
+    "searchNumbers": {"method": "GET", "path": "/api/v1/numbers/available", "path_params": [], "idempotent": False, "list": True},
+    "sendMessage": {"method": "POST", "path": "/api/v1/messages", "path_params": [], "idempotent": True, "list": False},
+    "sendTestWebhook": {"method": "POST", "path": "/api/v1/webhook-endpoints/{id}/test", "path_params": ["id"], "idempotent": False, "list": False},
+    "setSandboxWallet": {"method": "POST", "path": "/api/v1/sandbox/wallet", "path_params": [], "idempotent": False, "list": False},
+    "simulateInboundCall": {"method": "POST", "path": "/api/v1/sandbox/inbound-calls", "path_params": [], "idempotent": False, "list": False},
+    "timeTravel": {"method": "POST", "path": "/api/v1/sandbox/time-travel", "path_params": [], "idempotent": False, "list": False},
+    "updateNumber": {"method": "PATCH", "path": "/api/v1/numbers/{number}", "path_params": ["number"], "idempotent": False, "list": False},
+    "updateWebhookEndpoint": {"method": "PATCH", "path": "/api/v1/webhook-endpoints/{id}", "path_params": ["id"], "idempotent": False, "list": False},
+}
+
+
+class Operations:
+    """One method per API operation. Query parameters are keyword arguments;
+    one that is a Python keyword takes a trailing underscore (from_="2026-10-01")."""
+
+    def call(self, operation: str, path: Optional[Dict[str, str]] = None, query: Optional[Dict[str, Any]] = None, body: Any = None, idempotency_key: Optional[str] = None) -> Any:  # pragma: no cover
+        raise NotImplementedError
+
+    def add_cid_group_numbers(self, id: str, group: str, body: Any, **query: Any) -> Any:
+        """Put numbers into a CID group. POST /api/v1/servers/{id}/cid-groups/{group}/numbers"""
+        return self.call("addCidGroupNumbers", path={"id": id, "group": group}, query=query or None, body=body, idempotency_key=None)
+
+    def bulk_update_numbers(self, body: Any, **query: Any) -> Any:
+        """Change many numbers at once. PATCH /api/v1/numbers"""
+        return self.call("bulkUpdateNumbers", path=None, query=query or None, body=body, idempotency_key=None)
+
+    def cancel_backorder(self, id: str, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Cancel a back-order. POST /api/v1/backorders/{id}/cancel"""
+        return self.call("cancelBackorder", path={"id": id}, query=query or None, body=None, idempotency_key=idempotency_key)
+
+    def create_transcript(self, id: str, body: Any = None, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Transcribe a call. POST /api/v1/calls/{id}/transcript"""
+        return self.call("createTranscript", path={"id": id}, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def create_webhook_endpoint(self, body: Any, **query: Any) -> Any:
+        """Add a webhook endpoint. POST /api/v1/webhook-endpoints"""
+        return self.call("createWebhookEndpoint", path=None, query=query or None, body=body, idempotency_key=None)
+
+    def delete_webhook_endpoint(self, id: str, **query: Any) -> Any:
+        """Remove a webhook endpoint. DELETE /api/v1/webhook-endpoints/{id}"""
+        return self.call("deleteWebhookEndpoint", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def deliver_backorder(self, id: str, body: Any = None, **query: Any) -> Any:
+        """Simulate a back-order delivery. POST /api/v1/sandbox/backorders/{id}/deliver"""
+        return self.call("deliverBackorder", path={"id": id}, query=query or None, body=body, idempotency_key=None)
+
+    def enroll_in_journey(self, id: str, body: Any, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Enrol a lead in a journey. POST /api/v1/journeys/{id}/enroll"""
+        return self.call("enrollInJourney", path={"id": id}, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def export_calls(self, **query: Any) -> Any:
+        """Export calls as CSV. GET /api/v1/calls/export"""
+        return self.call("exportCalls", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def get_backorder(self, id: str, **query: Any) -> Any:
+        """Get a back-order. GET /api/v1/backorders/{id}"""
+        return self.call("getBackorder", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_balance(self, **query: Any) -> Any:
+        """Get the wallet balance. GET /api/v1/billing/balance"""
+        return self.call("getBalance", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def get_call(self, id: str, **query: Any) -> Any:
+        """Get a call. GET /api/v1/calls/{id}"""
+        return self.call("getCall", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_cid_group(self, id: str, group: str, **query: Any) -> Any:
+        """Get a CID group, with its numbers. GET /api/v1/servers/{id}/cid-groups/{group}"""
+        return self.call("getCidGroup", path={"id": id, "group": group}, query=query or None, body=None, idempotency_key=None)
+
+    def get_event(self, id: str, **query: Any) -> Any:
+        """Get an event, with its deliveries. GET /api/v1/events/{id}"""
+        return self.call("getEvent", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_number(self, number: str, **query: Any) -> Any:
+        """Get a number. GET /api/v1/numbers/{number}"""
+        return self.call("getNumber", path={"number": number}, query=query or None, body=None, idempotency_key=None)
+
+    def get_order(self, id: str, **query: Any) -> Any:
+        """Get an order, with its numbers. GET /api/v1/orders/{id}"""
+        return self.call("getOrder", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_recording_link(self, id: str, **query: Any) -> Any:
+        """Get a recording link. GET /api/v1/calls/{id}/recording"""
+        return self.call("getRecordingLink", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_transcript(self, id: str, **query: Any) -> Any:
+        """Get a call's transcript. GET /api/v1/calls/{id}/transcript"""
+        return self.call("getTranscript", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def get_webhook_endpoint(self, id: str, **query: Any) -> Any:
+        """Get a webhook endpoint. GET /api/v1/webhook-endpoints/{id}"""
+        return self.call("getWebhookEndpoint", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def list_backorders(self, **query: Any) -> Any:
+        """List back-orders. GET /api/v1/backorders"""
+        return self.call("listBackorders", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_calls(self, **query: Any) -> Any:
+        """List calls. GET /api/v1/calls"""
+        return self.call("listCalls", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_cid_groups(self, id: str, **query: Any) -> Any:
+        """List a server's CID groups. GET /api/v1/servers/{id}/cid-groups"""
+        return self.call("listCidGroups", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def list_events(self, **query: Any) -> Any:
+        """List events. GET /api/v1/events"""
+        return self.call("listEvents", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_messages(self, **query: Any) -> Any:
+        """List messages. GET /api/v1/messages"""
+        return self.call("listMessages", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_numbers(self, **query: Any) -> Any:
+        """List your numbers. GET /api/v1/numbers"""
+        return self.call("listNumbers", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_orders(self, **query: Any) -> Any:
+        """List orders. GET /api/v1/orders"""
+        return self.call("listOrders", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_renewals(self, **query: Any) -> Any:
+        """List upcoming renewals. GET /api/v1/billing/renewals"""
+        return self.call("listRenewals", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_servers(self, **query: Any) -> Any:
+        """List your servers. GET /api/v1/servers"""
+        return self.call("listServers", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_transactions(self, **query: Any) -> Any:
+        """List wallet transactions. GET /api/v1/billing/transactions"""
+        return self.call("listTransactions", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def list_webhook_deliveries(self, id: str, **query: Any) -> Any:
+        """List deliveries to an endpoint. GET /api/v1/webhook-endpoints/{id}/deliveries"""
+        return self.call("listWebhookDeliveries", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def list_webhook_endpoints(self, **query: Any) -> Any:
+        """List webhook endpoints. GET /api/v1/webhook-endpoints"""
+        return self.call("listWebhookEndpoints", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def place_backorder(self, body: Any, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Place a back-order. POST /api/v1/backorders"""
+        return self.call("placeBackorder", path=None, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def purchase_numbers(self, body: Any, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Buy numbers. POST /api/v1/numbers/purchase"""
+        return self.call("purchaseNumbers", path=None, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def release_numbers(self, body: Any, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Give numbers back. POST /api/v1/numbers/release"""
+        return self.call("releaseNumbers", path=None, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def remove_cid_group_numbers(self, id: str, group: str, body: Any, **query: Any) -> Any:
+        """Take numbers out of a CID group. POST /api/v1/servers/{id}/cid-groups/{group}/numbers/remove"""
+        return self.call("removeCidGroupNumbers", path={"id": id, "group": group}, query=query or None, body=body, idempotency_key=None)
+
+    def resend_event(self, id: str, body: Any = None, **query: Any) -> Any:
+        """Send an event again. POST /api/v1/events/{id}/resend"""
+        return self.call("resendEvent", path={"id": id}, query=query or None, body=body, idempotency_key=None)
+
+    def reset_sandbox(self, **query: Any) -> Any:
+        """Start the sandbox over. POST /api/v1/sandbox/reset"""
+        return self.call("resetSandbox", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def rotate_webhook_secret(self, id: str, **query: Any) -> Any:
+        """Rotate the signing secret. POST /api/v1/webhook-endpoints/{id}/rotate-secret"""
+        return self.call("rotateWebhookSecret", path={"id": id}, query=query or None, body=None, idempotency_key=None)
+
+    def search_numbers(self, **query: Any) -> Any:
+        """Search numbers for sale. GET /api/v1/numbers/available"""
+        return self.call("searchNumbers", path=None, query=query or None, body=None, idempotency_key=None)
+
+    def send_message(self, body: Any, idempotency_key: Optional[str] = None, **query: Any) -> Any:
+        """Send a message. POST /api/v1/messages"""
+        return self.call("sendMessage", path=None, query=query or None, body=body, idempotency_key=idempotency_key)
+
+    def send_test_webhook(self, id: str, body: Any, **query: Any) -> Any:
+        """Send a test event. POST /api/v1/webhook-endpoints/{id}/test"""
+        return self.call("sendTestWebhook", path={"id": id}, query=query or None, body=body, idempotency_key=None)
+
+    def set_sandbox_wallet(self, body: Any, **query: Any) -> Any:
+        """Set the sandbox wallet. POST /api/v1/sandbox/wallet"""
+        return self.call("setSandboxWallet", path=None, query=query or None, body=body, idempotency_key=None)
+
+    def simulate_inbound_call(self, body: Any, **query: Any) -> Any:
+        """Simulate an inbound call. POST /api/v1/sandbox/inbound-calls"""
+        return self.call("simulateInboundCall", path=None, query=query or None, body=body, idempotency_key=None)
+
+    def time_travel(self, body: Any, **query: Any) -> Any:
+        """Move the sandbox on in time. POST /api/v1/sandbox/time-travel"""
+        return self.call("timeTravel", path=None, query=query or None, body=body, idempotency_key=None)
+
+    def update_number(self, number: str, body: Any, **query: Any) -> Any:
+        """Update a number. PATCH /api/v1/numbers/{number}"""
+        return self.call("updateNumber", path={"number": number}, query=query or None, body=body, idempotency_key=None)
+
+    def update_webhook_endpoint(self, id: str, body: Any, **query: Any) -> Any:
+        """Change a webhook endpoint. PATCH /api/v1/webhook-endpoints/{id}"""
+        return self.call("updateWebhookEndpoint", path={"id": id}, query=query or None, body=body, idempotency_key=None)

vicifast-0.1.0/vicifast/client.py

@@ -0,0 +1,179 @@
+"""The HTTP half of the client: auth, retries, errors and pages.
+
+The operations themselves are generated (_operations.py) from the OpenAPI
+document; this file is written by hand and is not touched by the generator.
+"""
+
+import json
+import random
+import time
+import uuid
+from typing import Any, Callable, Dict, Iterator, Optional, Tuple
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+from ._operations import OPERATIONS, Operations
+
+VERSION = "0.1.0"
+RETRYABLE = {408, 429, 500, 502, 503, 504}
+
+
+class VicifastError(Exception):
+    """An answer that was not a success, as the API describes it. Branch on `code`."""
+
+    def __init__(self, status: int, body: Any, request_id: Optional[str]) -> None:
+        err = body.get("error", {}) if isinstance(body, dict) else {}
+        self.status = status
+        self.code: str = err.get("code") or "http_error"
+        self.message: str = err.get("message") or "HTTP %d" % status
+        self.param: Optional[str] = err.get("param")
+        self.details: Optional[Dict[str, Any]] = err.get("details")
+        self.request_id = request_id  # quote this to support
+        super().__init__(self.message)
+
+    def __repr__(self) -> str:
+        return "VicifastError(status=%d, code=%r, message=%r)" % (self.status, self.code, self.message)
+
+
+def _backoff(attempt: int) -> float:
+    return min(8.0, 0.5 * 2 ** attempt)
+
+
+class Vicifast(Operations):
+    """
+    client = Vicifast(api_key="vf_test_...")
+    for number in client.paginate("listNumbers", status="active"):
+        print(number["number"])
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://vicifast.com",
+        max_retries: int = 2,
+        timeout: float = 30.0,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        if not api_key:
+            raise ValueError("Vicifast: api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self.timeout = timeout
+        self._sleep = sleep
+
+    @property
+    def livemode(self) -> bool:
+        """True for a live key; a test key works against the sandbox."""
+        return self.api_key.startswith("vf_live_")
+
+    def call(
+        self,
+        operation: str,
+        path: Optional[Dict[str, str]] = None,
+        query: Optional[Dict[str, Any]] = None,
+        body: Any = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        """Any operation by its id. The named methods (client.list_numbers(...)) call this."""
+        return self._request(operation, path, query, body, idempotency_key)[0]
+
+    def _request(
+        self,
+        operation: str,
+        path: Optional[Dict[str, str]],
+        query: Optional[Dict[str, Any]],
+        body: Any,
+        idempotency_key: Optional[str],
+    ) -> Tuple[Any, Dict[str, str]]:
+        op = OPERATIONS.get(operation)
+        if op is None:
+            raise ValueError("unknown operation %r" % operation)
+        url_path = op["path"]
+        for name in op["path_params"]:
+            value = (path or {}).get(name)
+            if value is None or value == "":
+                raise ValueError("%s: %s is required" % (operation, name))
+            url_path = url_path.replace("{%s}" % name, quote(str(value), safe=""))
+        params = []
+        for key, value in (query or {}).items():
+            if value is None:
+                continue
+            if isinstance(value, bool):
+                value = "true" if value else "false"
+            params.append((key[:-1] if key.endswith("_") else key, value))
+        url = self.base_url + url_path + ("?" + urlencode(params) if params else "")
+
+        headers = {
+            "Authorization": "Bearer " + self.api_key,
+            "Accept": "application/json",
+            "User-Agent": "vicifast-python/" + VERSION,
+        }
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+        # Made once and sent on every retry: a retried purchase is still one purchase.
+        if op["idempotent"]:
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+        safe = op["method"] == "GET" or op["idempotent"]
+
+        attempt = 0
+        while True:
+            req = Request(url, data=data, headers=headers, method=op["method"])
+            try:
+                with urlopen(req, timeout=self.timeout) as res:
+                    raw = res.read()
+                    res_headers = {k.lower(): v for k, v in res.headers.items()}
+                    status = res.status
+            except HTTPError as e:
+                raw = e.read()
+                res_headers = {k.lower(): v for k, v in e.headers.items()}
+                status = e.code
+            except (URLError, TimeoutError, ConnectionError):
+                if safe and attempt < self.max_retries:
+                    self._sleep(_backoff(attempt) * (0.5 + random.random() / 2))
+                    attempt += 1
+                    continue
+                raise
+
+            if status in RETRYABLE and safe and attempt < self.max_retries:
+                after = res_headers.get("retry-after", "")
+                self._sleep(float(after) if after.isdigit() and int(after) > 0 else _backoff(attempt))
+                attempt += 1
+                continue
+
+            is_json = "json" in res_headers.get("content-type", "")
+            if status >= 400:
+                try:
+                    parsed = json.loads(raw.decode("utf-8")) if is_json else None
+                except ValueError:
+                    parsed = None
+                raise VicifastError(status, parsed, res_headers.get("x-request-id"))
+            text = raw.decode("utf-8")
+            return (json.loads(text) if is_json and text else text), res_headers
+
+    def paginate(self, operation: str, path: Optional[Dict[str, str]] = None, **query: Any) -> Iterator[Any]:
+        """Every item of a list operation, fetching the next page as you go."""
+        if not OPERATIONS.get(operation, {}).get("list"):
+            raise ValueError("%s is not a list operation" % operation)
+        while True:
+            page = self.call(operation, path=path, query=query)
+            for item in page["data"]:
+                yield item
+            if not page.get("has_more") or not page.get("next_cursor"):
+                return
+            query = dict(query, cursor=page["next_cursor"])
+
+    def export_call_files(self, **query: Any) -> Iterator[str]:
+        """The calls export, one CSV file at a time: up to `limit` rows each
+        (10,000 unless you say, at most 50,000), until every call that matches
+        is out. Each file has its own header row."""
+        while True:
+            text, headers = self._request("exportCalls", None, query, None, None)
+            yield text
+            cursor = headers.get("x-next-cursor")
+            if not cursor:
+                return
+            query = dict(query, cursor=cursor)

vicifast-0.1.0/vicifast/webhooks.py

@@ -0,0 +1,45 @@
+"""Checking that a webhook request came from VICIfast."""
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Optional, Union
+
+
+def verify_signature(
+    raw_body: Union[bytes, str],
+    header: Optional[str],
+    secret: str,
+    tolerance_sec: int = 300,
+    now: Optional[float] = None,
+) -> bool:
+    """X-VICIfast-Signature is `t=<unix seconds>,v1=<hex HMAC-SHA256 of
+    "<t>.<raw body>" with the endpoint's secret>`. Pass the body exactly as it
+    arrived, before parsing. A timestamp older than tolerance_sec (default
+    five minutes) is refused, so a captured request cannot be replayed."""
+    if not header:
+        return False
+    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
+    try:
+        t = int(parts.get("t", ""))
+    except ValueError:
+        return False
+    if abs((time.time() if now is None else now) - t) > tolerance_sec:
+        return False
+    body = raw_body.encode("utf-8") if isinstance(raw_body, str) else raw_body
+    want = hmac.new(secret.encode("utf-8"), str(t).encode() + b"." + body, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(parts.get("v1", ""), want)
+
+
+def parse_event(
+    raw_body: Union[bytes, str],
+    header: Optional[str],
+    secret: str,
+    tolerance_sec: int = 300,
+    now: Optional[float] = None,
+) -> Any:
+    """The event, once its signature checks out; raises ValueError otherwise."""
+    if not verify_signature(raw_body, header, secret, tolerance_sec, now):
+        raise ValueError("VICIfast webhook: the signature does not match, or the request is too old")
+    return json.loads(raw_body)

vicifast-0.1.0/vicifast.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: vicifast
+Version: 0.1.0
+Summary: The VICIfast API for Python: phone numbers, calls, billing and webhooks.
+License: MIT
+Project-URL: Documentation, https://vicifast.com/api-docs
+Project-URL: Homepage, https://vicifast.com
+Keywords: vicifast,vicidial,phone numbers,did,telephony,api,webhooks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Communications :: Telephony
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# vicifast
+
+The [VICIfast API](https://vicifast.com/api-docs) for Python 3.8 and later:
+buy and manage phone numbers, place back-orders, read calls, recordings and
+transcripts, follow your wallet, and check the webhooks we send you. Built on
+the standard library only, with no dependencies.
+
+```sh
+pip install vicifast
+```
+
+## Use
+
+```python
+import os
+from vicifast import Vicifast
+
+vf = Vicifast(api_key=os.environ["VICIFAST_API_KEY"])
+
+print(vf.get_balance()["data"]["balance_cents"])
+
+found = vf.search_numbers(area_code="305", limit=5)
+order = vf.purchase_numbers({"numbers": [found["data"][0]["number"]]})
+```
+
+Make keys under **API → Keys** in the dashboard. A `vf_test_…` key works
+against the sandbox: the same calls, with nothing charged and no real numbers
+touched. Use one while you build.
+
+Each operation in the [reference](https://vicifast.com/api-docs) is a method
+named after its `operationId` in snake*case. Path parameters come first,
+positionally, then the request body. Query parameters are keyword arguments. A
+parameter whose name is a Python keyword takes a trailing underscore:
+`vf.list_calls(from*="2026-10-01")`.
+
+## Pages
+
+A list answers one page at a time. `paginate` walks every page for you:
+
+```python
+for number in vf.paginate("listNumbers", status="active"):
+    print(number["number"], number["routing"])
+```
+
+The calls export is CSV, one file per page:
+
+```python
+with open("calls.csv", "w") as out:
+    for i, csv in enumerate(vf.export_call_files(window="30d")):
+        out.write(csv if i == 0 else csv.split("\n", 1)[1])
+```
+
+## Errors and retries
+
+Anything other than a success raises `VicifastError`. It carries the HTTP
+`status`, a `code` to branch on (`insufficient_funds`, `rate_limited`, …), a
+`message`, the offending `param` when there is one, and a `request_id` to quote
+to support.
+
+A request that is safe to repeat is retried up to `max_retries` times (default 2) on 408, 429 and 5xx, and when the connection fails. A 429 waits for
+`Retry-After`. Reads are always safe to repeat. Calls that spend or move money
+(a purchase, a release, a back-order, a transcript) are safe too, because each
+one is sent with an `Idempotency-Key`: the same key on every retry, so a
+retried purchase still buys once. The client makes the key for you, or you can
+pass your own as `idempotency_key=`.
+
+## Webhooks
+
+Check every request against the endpoint's signing secret before trusting it.
+Pass the body exactly as it arrived:
+
+```python
+from flask import Flask, abort, request
+from vicifast import parse_event
+
+app = Flask(__name__)
+
+@app.post("/vicifast")
+def vicifast():
+    try:
+        event = parse_event(request.get_data(), request.headers.get("X-VICIfast-Signature"), os.environ["VICIFAST_WEBHOOK_SECRET"])
+    except ValueError:
+        abort(400)
+    if event["type"] == "call.inbound.completed":
+        ...
+    return "", 200
+```
+
+`verify_signature(body, header, secret)` gives you the same check as a
+boolean. A request signed more than five minutes ago is refused.
+
+Licensed MIT. This package is generated from
+[vicifast.com/api-docs/openapi.json](https://vicifast.com/api-docs/openapi.json).

vicifast-0.1.0/vicifast.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_client.py
+vicifast/__init__.py
+vicifast/_operations.py
+vicifast/client.py
+vicifast/py.typed
+vicifast/webhooks.py
+vicifast.egg-info/PKG-INFO
+vicifast.egg-info/SOURCES.txt
+vicifast.egg-info/dependency_links.txt
+vicifast.egg-info/top_level.txt

vicifast-0.1.0/vicifast.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vicifast-0.1.0/vicifast.egg-info/top_level.txt

@@ -0,0 +1 @@
+vicifast