jaxl-python 0.0.16__tar.gz → 0.0.19__tar.gz

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaxl-python
-Version: 0.0.16
+Version: 0.0.19
 Summary: Official Python SDK and CLI for interfacing with the Jaxl API. Manage calls, messages, IVRs, devices, teams, payments, campaigns, streaming transcriptions and AI Agents. Built on OpenAPI, it offers both generated API clients and Pythonic wrappers for ease of use.
 Home-page: https://github.com/jaxl-innovations-private-limited/jaxl-python
 Download-URL: https://github.com/jaxl-innovations-private-limited/jaxl-python/archive/main.zip

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/examples/streaming_aiagent.py

@@ -80,7 +80,7 @@ class JaxlAppStreamingAIAgent(BaseJaxlApp):
             del self._states[req.state.call_id]
         return None
 
-    async def handle_speech_detection(self, speaking: bool) -> None:
+    async def handle_speech_detection(self, call_id: int, speaking: bool) -> None:
         print("🎙️" if speaking else "🤐")
 
     async def handle_transcription(

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/examples/streaming_speech_segments.py

@@ -27,7 +27,7 @@ class JaxlAppStreamingSpeechSegment(BaseJaxlApp):
             num_characters=-1,
         )
 
-    async def handle_speech_detection(self, speaking: bool) -> None:
+    async def handle_speech_detection(self, call_id: int, speaking: bool) -> None:
         print("🎙️" if speaking else "🤐")
 
     async def handle_speech_segment(

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/examples/streaming_transcriptions.py

@@ -27,7 +27,7 @@ class JaxlAppStreamingTranscription(BaseJaxlApp):
             num_characters=-1,
         )
 
-    async def handle_speech_detection(self, speaking: bool) -> None:
+    async def handle_speech_detection(self, call_id: int, speaking: bool) -> None:
         print("🎙️" if speaking else "🤐")
 
     async def handle_transcription(

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/base.py

@@ -27,6 +27,7 @@ from fastapi import WebSocket
 from fastapi.responses import Response as FastApiResponse
 from pydantic import BaseModel, model_validator
 
+from jaxl.api.client.models.call_tag_response import CallTagResponse
 from jaxl.api.client.types import Response
 from jaxl.api.resources.calls import calls_tts
 from jaxl.api.resources.ivrs import IVR_CTA_KEYS
@@ -173,7 +174,7 @@ class BaseJaxlApp:
         """Invoked when a call ends."""
         return None
 
-    async def handle_speech_detection(self, speaking: bool) -> None:
+    async def handle_speech_detection(self, call_id: int, speaking: bool) -> None:
         """Invoked when speech starts and ends."""
         return None
 
@@ -261,3 +262,22 @@ class BaseJaxlApp:
         **kwargs: Any,
     ) -> Response[Any]:
         return calls_tts({"call_id": call_id, "prompt": prompt, "mark": mark})
+
+    async def send_audio(self, call_id: int, slin16: bytes) -> None:
+        """Send raw audio.
+
+        Only available with bidirectional streams.
+        """
+
+    async def clear_audio(self, call_id: int) -> None:
+        """Clear any buffered audio."""
+
+    async def hangup(self, call_id: int) -> Optional[Response[Any]]:
+        """Hangup call by ID"""
+        return None
+
+    async def add_tag(
+        self, call_id: int, tag: str
+    ) -> Optional[Response[CallTagResponse]]:
+        """Add tag to a call by ID."""
+        return None

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/client/_scm_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.16'
-__version_tuple__ = version_tuple = (0, 0, 16)
+__version__ = version = '0.0.19'
+__version_tuple__ = version_tuple = (0, 0, 19)

jaxl_python-0.0.19/jaxl/api/client/api/v1/v1_calls_hangup_retrieve.py

@@ -0,0 +1,118 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import Response
+
+
+def _get_kwargs(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+) -> Dict[str, Any]:
+    url = "{}/v1/calls/{id}/hangup/".format(client.base_url, id=id)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "get",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Any]:
+    if response.status_code == HTTPStatus.OK:
+        return None
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        return None
+    if response.status_code == HTTPStatus.NOT_FOUND:
+        return None
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(f"Unexpected status code: {response.status_code}")
+    else:
+        return None
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any]:
+    """API view set for Call model.
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any]:
+    """API view set for Call model.
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)

jaxl_python-0.0.19/jaxl/api/client/api/v1/v1_calls_tags_create.py

@@ -0,0 +1,194 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.call_tag_request import CallTagRequest
+from ...models.call_tag_response import CallTagResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    call_id: str,
+    *,
+    client: AuthenticatedClient,
+    json_body: CallTagRequest,
+) -> Dict[str, Any]:
+    url = "{}/v1/calls/{call_id}/tags/".format(client.base_url, call_id=call_id)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(
+    *, client: Client, response: httpx.Response
+) -> Optional[Union[Any, CallTagResponse]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = CallTagResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        response_400 = cast(Any, None)
+        return response_400
+    if response.status_code == HTTPStatus.PRECONDITION_FAILED:
+        response_412 = cast(Any, None)
+        return response_412
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(f"Unexpected status code: {response.status_code}")
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Client, response: httpx.Response
+) -> Response[Union[Any, CallTagResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    call_id: str,
+    *,
+    client: AuthenticatedClient,
+    json_body: CallTagRequest,
+) -> Response[Union[Any, CallTagResponse]]:
+    """Create call tag
+
+    Args:
+        call_id (str):
+        json_body (CallTagRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, CallTagResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        call_id=call_id,
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    call_id: str,
+    *,
+    client: AuthenticatedClient,
+    json_body: CallTagRequest,
+) -> Optional[Union[Any, CallTagResponse]]:
+    """Create call tag
+
+    Args:
+        call_id (str):
+        json_body (CallTagRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, CallTagResponse]]
+    """
+
+    return sync_detailed(
+        call_id=call_id,
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    call_id: str,
+    *,
+    client: AuthenticatedClient,
+    json_body: CallTagRequest,
+) -> Response[Union[Any, CallTagResponse]]:
+    """Create call tag
+
+    Args:
+        call_id (str):
+        json_body (CallTagRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, CallTagResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        call_id=call_id,
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    call_id: str,
+    *,
+    client: AuthenticatedClient,
+    json_body: CallTagRequest,
+) -> Optional[Union[Any, CallTagResponse]]:
+    """Create call tag
+
+    Args:
+        call_id (str):
+        json_body (CallTagRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, CallTagResponse]]
+    """
+
+    return (
+        await asyncio_detailed(
+            call_id=call_id,
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/client/models/__init__.py

@@ -22,6 +22,7 @@ from .call_add_request_request import CallAddRequestRequest
 from .call_cost import CallCost
 from .call_location_epoch import CallLocationEpoch
 from .call_metadata import CallMetadata
+from .call_tag_request import CallTagRequest
 from .call_tag_response import CallTagResponse
 from .call_token_request import CallTokenRequest
 from .call_token_response import CallTokenResponse
@@ -191,6 +192,7 @@ __all__ = (
     "CallCost",
     "CallLocationEpoch",
     "CallMetadata",
+    "CallTagRequest",
     "CallTagResponse",
     "CallTokenRequest",
     "CallTokenResponse",

jaxl_python-0.0.19/jaxl/api/client/models/call_tag_request.py

@@ -0,0 +1,66 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="CallTagRequest")
+
+
+@attr.s(auto_attribs=True)
+class CallTagRequest:
+    """
+    Attributes:
+        name (str):
+    """
+
+    name: str
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        call_tag_request = cls(
+            name=name,
+        )
+
+        call_tag_request.additional_properties = d
+        return call_tag_request
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/resources/apps.py

@@ -34,7 +34,10 @@ from jaxl.api.base import (
     JaxlWebhookRequest,
     JaxlWebhookResponse,
 )
+from jaxl.api.client.models.call_tag_response import CallTagResponse
+from jaxl.api.client.types import Response
 from jaxl.api.resources.accounts import accounts_me
+from jaxl.api.resources.calls import calls_hangup, calls_tag_add
 from jaxl.api.resources.silence import SilenceDetector
 
 
@@ -129,6 +132,42 @@ def _start_server(
     ) -> None:
         asyncio.create_task(_ttask_done_callback_async(req, task, tsid))
 
+    wss: Dict[int, WebSocket] = {}
+
+    async def _add_tag(call_id: int, tag: str) -> Response[CallTagResponse]:
+        return calls_tag_add({"call_id": call_id, "tag": tag})
+
+    async def _hangup(call_id: int) -> Response[Any]:
+        return calls_hangup({"call_id": call_id})
+
+    async def _clear_audio(call_id: int) -> None:
+        try:
+            await wss[call_id].send_text(json.dumps({"event": "clear"}))
+        # pylint: disable=broad-exception-caught
+        except Exception as exc:
+            logger.warning(f"⚠️ clear_audio failure: {exc}")
+
+    async def _send_audio(call_id: int, slin16: bytes) -> None:
+        try:
+            await wss[call_id].send_text(
+                json.dumps(
+                    {
+                        "event": "media",
+                        "media": {
+                            "payload": base64.b64encode(slin16).decode("ascii"),
+                        },
+                    }
+                )
+            )
+        # pylint: disable=broad-exception-caught
+        except Exception as exc:
+            logger.warning(f"⚠️ send_audio failure: {exc}")
+
+    app.send_audio = _send_audio  # type: ignore[method-assign]
+    app.clear_audio = _clear_audio  # type: ignore[method-assign]
+    app.add_tag = _add_tag  # type: ignore[method-assign]
+    app.hangup = _hangup  # type: ignore[method-assign]
+
     @server.api_route(
         "/webhook/",
         methods=["POST", "DELETE"],
@@ -193,6 +232,7 @@ def _start_server(
         slin16s: List[bytes] = []
 
         await ws.accept()
+        wss[state["call_id"]] = ws
 
         # pylint: disable=too-many-nested-blocks
         try:
@@ -210,7 +250,7 @@ def _start_server(
                     # Manage speech segments
                     if change is True:
                         speaking = change
-                        await app.handle_speech_detection(speaking)
+                        await app.handle_speech_detection(state["call_id"], speaking)
                         if len(slin16s) == 0:
                             # Silence just got detected, copy over
                             # last speech_frame_threshold of frames
@@ -220,7 +260,7 @@ def _start_server(
                         slin16s.append(slin16)
                     elif change is False:
                         speaking = change
-                        await app.handle_speech_detection(speaking)
+                        await app.handle_speech_detection(state["call_id"], speaking)
                         # print("🤐")
                         if len(slin16s) > 0:
                             # Invoke speech segment handlers
@@ -250,6 +290,7 @@ def _start_server(
         except WebSocketDisconnect:
             pass
         finally:
+            del wss[state["call_id"]]
             if ws.client_state != WebSocketState.DISCONNECTED:
                 await ws.close()
 

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/resources/calls.py

@@ -9,13 +9,15 @@ with or without modification, is strictly prohibited.
 
 import argparse
 import uuid
-from typing import Any, Dict, List, Optional, Tuple, cast
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
 from jaxl.api._client import JaxlApiModule, jaxl_api_client
 from jaxl.api.client.api.v1 import (
     v1_calls_add_create,
+    v1_calls_hangup_retrieve,
     v1_calls_list,
     v1_calls_retrieve,
+    v1_calls_tags_create,
     v1_calls_token_create,
     v1_calls_tts_create,
     v1_calls_usage_retrieve,
@@ -24,6 +26,8 @@ from jaxl.api.client.models.call import Call
 from jaxl.api.client.models.call_add_request_request import (
     CallAddRequestRequest,
 )
+from jaxl.api.client.models.call_tag_request import CallTagRequest
+from jaxl.api.client.models.call_tag_response import CallTagResponse
 from jaxl.api.client.models.call_token_request import CallTokenRequest
 from jaxl.api.client.models.call_token_response import CallTokenResponse
 from jaxl.api.client.models.call_tts_request_request import (
@@ -56,7 +60,7 @@ def calls_usage(args: Dict[str, Any]) -> Response[CallUsageResponse]:
 
 def ivrs_create_adhoc(
     message: str,
-    inputs: Optional[Dict[str, Tuple[str, str, str]]] = None,
+    inputs: Optional[Dict[str, Tuple[str, str, Union[List[str], str]]]] = None,
     hangup: bool = False,
 ) -> int:
     if (hangup is True and inputs is not None) or (hangup is False and inputs is None):
@@ -128,7 +132,20 @@ def calls_create(args: Dict[str, Any]) -> Response[CallTokenResponse]:
                 cta, value = parts[1].split("=", 1)
                 if cta not in IVR_CTA_KEYS or input_ not in IVR_INPUTS:
                     raise ValueError(f"Invalid CTA key {cta} or input {input_}")
-                inputs[input_] = (name, cta, value)
+                inputs[input_] = (
+                    name,
+                    cta,
+                    (
+                        value.split(",")
+                        if cta
+                        in (
+                            "devices",
+                            "appusers",
+                            "teams",
+                        )
+                        else value
+                    ),
+                )
             ivr_id = ivrs_create_adhoc(message, inputs)
             if ivr_id is None:
                 raise ValueError("Unable to create ad-hoc IVR")
@@ -213,8 +230,27 @@ def calls_tts(args: Dict[str, Any]) -> Response[Any]:
     )
 
 
-# def calls_hangup(args: Optional[Dict[str, Any]] = None) -> Response[PaginatedCallList]:
-#     pass
+def calls_tag_add(args: Dict[str, Any]) -> Response[CallTagResponse]:
+    return v1_calls_tags_create.sync_detailed(
+        call_id=args["call_id"],
+        client=jaxl_api_client(
+            JaxlApiModule.CALL,
+            credentials=args.get("credentials", None),
+            auth_token=args.get("auth_token", None),
+        ),
+        json_body=CallTagRequest(name=args["tag"]),
+    )
+
+
+def calls_hangup(args: Dict[str, Any]) -> Response[Any]:
+    return v1_calls_hangup_retrieve.sync_detailed(
+        id=args["call_id"],
+        client=jaxl_api_client(
+            JaxlApiModule.CALL,
+            credentials=args.get("credentials", None),
+            auth_token=args.get("auth_token", None),
+        ),
+    )
 
 
 def _subparser(parser: argparse.ArgumentParser) -> None:
@@ -350,8 +386,14 @@ def _subparser(parser: argparse.ArgumentParser) -> None:
     calls_get_parser.set_defaults(func=calls_get, _arg_keys=["call_id"])
 
     # hangup
-    # calls_hangup_parser = subparsers.add_parser("hangup", help="Hangup calls")
-    # calls_hangup_parser.set_defaults(func=calls_hangup, _arg_keys=[])
+    calls_hangup_parser = subparsers.add_parser("hangup", help="Hangup call")
+    calls_hangup_parser.add_argument(
+        "--call-id",
+        type=int,
+        required=True,
+        help="Call ID",
+    )
+    calls_hangup_parser.set_defaults(func=calls_hangup, _arg_keys=["call_id"])
 
     # transfer
 
@@ -403,3 +445,9 @@ class JaxlCallsSDK:
 
     def get(self, **kwargs: Any) -> Response[Call]:
         return calls_get(kwargs)
+
+    def add_tag(self, **kwargs: Any) -> Response[CallTagResponse]:
+        return calls_tag_add(kwargs)
+
+    def hangup(self, **kwargs: Any) -> Response[Any]:
+        return calls_hangup(kwargs)

{jaxl_python-0.0.16 → jaxl_python-0.0.19}/jaxl/api/resources/ivrs.py

@@ -87,7 +87,7 @@ def ivrs_options_create(
                 appusers=args.get("appusers"),
                 collections=(
                     IVRCollectionRequest(
-                        type=IdEnum.VALUE_1,
+                        type=IdEnum.VALUE_2,
                         collection_ids=args["teams"],
                     )
                     if args.get("teams")