aircall-api 1.1.0__py3-none-any.whl

aircall/resources/call.py

@@ -0,0 +1,270 @@
+"""Resource module for managing calls"""
+from aircall.resources.base import BaseResource
+from aircall.models import Call
+
+class CallResource(BaseResource):
+    """
+    API Resource for Aircall Calls
+
+    Handles operations relating to calls including status, voicemails, insights and summaries
+    """
+    def list_calls(self, page: int = 1, per_page: int = 20) -> list[Call]:
+        """
+        List all calls with pagination.
+
+        Args:
+            page: Page number (default 1)
+            per_page: Results per page (default 20, max 50)
+
+        Returns:
+            list[Call]: List of Call objects
+        """
+        response = self._get("/calls", params={"page": page, "per_page": per_page})
+        return [Call(**c) for c in response["calls"]]
+
+    def get(self, call_id: int) -> Call:
+        """
+        Get a specific call by ID.
+
+        Args:
+            call_id: The ID of the call to retrieve
+
+        Returns:
+            Call: The call object
+        """
+        response = self._get(f"/calls/{call_id}")
+        return Call(**response["call"])
+
+    def search(self, **params) -> list[Call]:
+        """
+        Search for calls with various filters.
+
+        Args:
+            **params: Search parameters (from, to, tags, etc.)
+
+        Returns:
+            list[Call]: List of Call objects matching the search criteria
+        """
+        response = self._get("/calls/search", params=params)
+        return [Call(**c) for c in response["calls"]]
+
+    def transfer(self, call_id: int, number_id: int, comment: str = None) -> dict:
+        """
+        Transfer a call to another number.
+
+        Args:
+            call_id: The ID of the call to transfer
+            number_id: The ID of the number to transfer to
+            comment: Optional comment for the transfer
+
+        Returns:
+            dict: Transfer response
+        """
+        self._logger.info("Transferring call %s to number %s", call_id, number_id)
+        data = {"number_id": number_id}
+        if comment:
+            data["comment"] = comment
+        result = self._post(f"/calls/{call_id}/transfers", json=data)
+        self._logger.info("Successfully transferred call %s", call_id)
+        return result
+
+    def add_comment(self, call_id: int, content: str) -> dict:
+        """
+        Add a comment to a call.
+
+        Args:
+            call_id: The ID of the call
+            content: The comment content
+
+        Returns:
+            dict: Comment response
+        """
+        return self._post(f"/calls/{call_id}/comments", json={"content": content})
+
+    def add_tags(self, call_id: int, tags: list[str]) -> dict:
+        """
+        Add tags to a call.
+
+        Args:
+            call_id: The ID of the call
+            tags: List of tag names to add
+
+        Returns:
+            dict: Tags response
+        """
+        return self._post(f"/calls/{call_id}/tags", json={"tags": tags})
+
+    def archive(self, call_id: int) -> dict:
+        """
+        Archive a call.
+
+        Args:
+            call_id: The ID of the call to archive
+
+        Returns:
+            dict: Archive response
+        """
+        return self._put(f"/calls/{call_id}/archive")
+
+    def unarchive(self, call_id: int) -> dict:
+        """
+        Unarchive a call.
+
+        Args:
+            call_id: The ID of the call to unarchive
+
+        Returns:
+            dict: Unarchive response
+        """
+        return self._put(f"/calls/{call_id}/unarchive")
+
+    def pause_recording(self, call_id: int) -> dict:
+        """
+        Pause recording for a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Pause recording response
+        """
+        return self._post(f"/calls/{call_id}/pause_recording")
+
+    def resume_recording(self, call_id: int) -> dict:
+        """
+        Resume recording for a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Resume recording response
+        """
+        return self._post(f"/calls/{call_id}/resume_recording")
+
+    def delete_recording(self, call_id: int) -> dict:
+        """
+        Delete the recording of a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Delete recording response
+        """
+        self._logger.warning("Deleting recording for call %s", call_id)
+        result = self._delete(f"/calls/{call_id}/recording")
+        self._logger.info("Successfully deleted recording for call %s", call_id)
+        return result
+
+    def delete_voicemail(self, call_id: int) -> dict:
+        """
+        Delete the voicemail of a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Delete voicemail response
+        """
+        self._logger.warning("Deleting voicemail for call %s", call_id)
+        result = self._delete(f"/calls/{call_id}/voicemail")
+        self._logger.info("Successfully deleted voicemail for call %s", call_id)
+        return result
+
+    def add_insight_cards(self, call_id: int, cards: list[dict]) -> dict:
+        """
+        Add insight cards to a call.
+
+        Args:
+            call_id: The ID of the call
+            cards: List of insight card objects
+
+        Returns:
+            dict: Insight cards response
+        """
+        return self._post(f"/calls/{call_id}/insight_cards", json={"cards": cards})
+
+    def get_transcription(self, call_id: int) -> dict:
+        """
+        Get the transcription of a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Transcription data
+        """
+        return self._get(f"/calls/{call_id}/transcription")
+
+    def get_realtime_transcription(self, call_id: int) -> dict:
+        """
+        Get the real-time transcription of a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Real-time transcription data
+        """
+        return self._get(f"/calls/{call_id}/realtime_transcription")
+
+    def get_sentiments(self, call_id: int) -> dict:
+        """
+        Get sentiment analysis for a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Sentiment analysis data
+        """
+        return self._get(f"/calls/{call_id}/sentiments")
+
+    def get_topics(self, call_id: int) -> dict:
+        """
+        Get topics discussed in a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Topics data
+        """
+        return self._get(f"/calls/{call_id}/topics")
+
+    def get_summary(self, call_id: int) -> dict:
+        """
+        Get the summary of a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Call summary data
+        """
+        return self._get(f"/calls/{call_id}/summary")
+
+    def get_action_items(self, call_id: int) -> dict:
+        """
+        Get action items from a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Action items data
+        """
+        return self._get(f"/calls/{call_id}/action_items")
+
+    def get_playbook_result(self, call_id: int) -> dict:
+        """
+        Get playbook results for a call.
+
+        Args:
+            call_id: The ID of the call
+
+        Returns:
+            dict: Playbook result data
+        """
+        return self._get(f"/calls/{call_id}/playbook_result")

aircall/resources/company.py

@@ -0,0 +1,29 @@
+"""Resource module for managing company information"""
+from aircall.resources.base import BaseResource
+from aircall.models import Company
+
+
+class CompanyResource(BaseResource):
+    """
+    API Resource for Aircall Company.
+
+    Provides read-only access to company information.
+    Companies cannot be updated or deleted via the API.
+    """
+
+    def get(self) -> Company:
+        """
+        Get company information.
+
+        Returns:
+            Company: Company object with name, users_count, and numbers_count
+
+        Note:
+            Companies are read-only and can only be modified via the Aircall Dashboard.
+
+        Example:
+            >>> company = client.company.get()
+            >>> print(company.name, company.users_count, company.numbers_count)
+        """
+        response = self._get("/company")
+        return Company(**response["company"])

aircall/resources/contact.py

@@ -0,0 +1,192 @@
+"""Resource module for managing contacts"""
+from aircall.resources.base import BaseResource
+from aircall.models import Contact
+
+
+class ContactResource(BaseResource):
+    """
+    API Resource for Aircall Contacts.
+
+    Handles operations relating to contacts including phone numbers and emails.
+    """
+
+    def list_contacts(self, page: int = 1, per_page: int = 20) -> list[Contact]:
+        """
+        List all contacts with pagination.
+
+        Args:
+            page: Page number (default 1)
+            per_page: Results per page (default 20, max 50)
+
+        Returns:
+            list[Contact]: List of Contact objects
+        """
+        response = self._get("/contacts", params={"page": page, "per_page": per_page})
+        return [Contact(**c) for c in response["contacts"]]
+
+    def search(self, **params) -> list[Contact]:
+        """
+        Search for contacts with various filters.
+
+        Args:
+            **params: Search parameters (phone_number, email, etc.)
+
+        Returns:
+            list[Contact]: List of Contact objects matching the search criteria
+        """
+        response = self._get("/contacts/search", params=params)
+        return [Contact(**c) for c in response["contacts"]]
+
+    def get(self, contact_id: int) -> Contact:
+        """
+        Get a specific contact by ID.
+
+        Args:
+            contact_id: The ID of the contact to retrieve
+
+        Returns:
+            Contact: The contact object
+        """
+        response = self._get(f"/contacts/{contact_id}")
+        return Contact(**response["contact"])
+
+    def create(self, **kwargs) -> Contact:
+        """
+        Create a new contact.
+
+        Args:
+            **kwargs: Contact data (first_name, last_name, phone_numbers, emails, etc.)
+
+        Returns:
+            Contact: The created contact object
+        """
+        response = self._post("/contacts", json=kwargs)
+        return Contact(**response["contact"])
+
+    def update(self, contact_id: int, **kwargs) -> Contact:
+        """
+        Update a contact.
+
+        Args:
+            contact_id: The ID of the contact to update
+            **kwargs: Contact fields to update
+
+        Returns:
+            Contact: The updated contact object
+        """
+        response = self._post(f"/contacts/{contact_id}", json=kwargs)
+        return Contact(**response["contact"])
+
+    def delete(self, contact_id: int) -> dict:
+        """
+        Delete a contact.
+
+        Args:
+            contact_id: The ID of the contact to delete
+
+        Returns:
+            dict: Delete response
+        """
+        return self._delete(f"/contacts/{contact_id}")
+
+    def add_phone_number(self, contact_id: int, value: str, label: str = None) -> dict:
+        """
+        Add a phone number to a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            value: The phone number value
+            label: Optional label for the phone number
+
+        Returns:
+            dict: Phone number response
+        """
+        data = {"value": value}
+        if label:
+            data["label"] = label
+        return self._post(f"/contacts/{contact_id}/phone_details", json=data)
+
+    def update_phone_number(self, contact_id: int, phone_number_id: int,
+                          value: str = None, label: str = None) -> dict:
+        """
+        Update a phone number from a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            phone_number_id: The ID of the phone number to update
+            value: New phone number value
+            label: New label for the phone number
+
+        Returns:
+            dict: Update phone number response
+        """
+        data = {}
+        if value:
+            data["value"] = value
+        if label:
+            data["label"] = label
+        return self._put(f"/contacts/{contact_id}/phone_details/{phone_number_id}", json=data)
+
+    def delete_phone_number(self, contact_id: int, phone_number_id: int) -> dict:
+        """
+        Delete a phone number from a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            phone_number_id: The ID of the phone number to delete
+
+        Returns:
+            dict: Delete phone number response
+        """
+        return self._delete(f"/contacts/{contact_id}/phone_details/{phone_number_id}")
+
+    def add_email(self, contact_id: int, value: str, label: str = None) -> dict:
+        """
+        Add an email to a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            value: The email address
+            label: Optional label for the email
+
+        Returns:
+            dict: Email response
+        """
+        data = {"value": value}
+        if label:
+            data["label"] = label
+        return self._post(f"/contacts/{contact_id}/email_details", json=data)
+
+    def update_email(self, contact_id: int, email_id: int,
+                    value: str = None, label: str = None) -> dict:
+        """
+        Update an email from a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            email_id: The ID of the email to update
+            value: New email address
+            label: New label for the email
+
+        Returns:
+            dict: Update email response
+        """
+        data = {}
+        if value:
+            data["value"] = value
+        if label:
+            data["label"] = label
+        return self._put(f"/contacts/{contact_id}/email_details/{email_id}", json=data)
+
+    def delete_email(self, contact_id: int, email_id: int) -> dict:
+        """
+        Delete an email from a contact.
+
+        Args:
+            contact_id: The ID of the contact
+            email_id: The ID of the email to delete
+
+        Returns:
+            dict: Delete email response
+        """
+        return self._delete(f"/contacts/{contact_id}/email_details/{email_id}")

aircall/resources/dialer_campaign.py

@@ -0,0 +1,90 @@
+"""Resource module for managing dialer campaigns"""
+from aircall.resources.base import BaseResource
+from aircall.models import DialerCampaign
+
+
+class DialerCampaignResource(BaseResource):
+    """
+    API Resource for Aircall Dialer Campaigns (Power Dialer).
+
+    All operations are scoped to a specific user.
+    """
+
+    def get(self, user_id: int) -> DialerCampaign:
+        """
+        Retrieve a user's dialer campaign.
+
+        Args:
+            user_id: The ID of the user
+
+        Returns:
+            DialerCampaign: The dialer campaign object
+        """
+        response = self._get(f"/users/{user_id}/dialer_campaign")
+        return DialerCampaign(**response["dialer_campaign"])
+
+    def create(self, user_id: int, **kwargs) -> DialerCampaign:
+        """
+        Create a dialer campaign for a user.
+
+        Args:
+            user_id: The ID of the user
+            **kwargs: Dialer campaign data (number_id, phone_numbers, etc.)
+
+        Returns:
+            DialerCampaign: The created dialer campaign object
+        """
+        response = self._post(f"/users/{user_id}/dialer_campaign", json=kwargs)
+        return DialerCampaign(**response["dialer_campaign"])
+
+    def delete(self, user_id: int) -> dict:
+        """
+        Delete a user's dialer campaign.
+
+        Args:
+            user_id: The ID of the user
+
+        Returns:
+            dict: Delete response
+        """
+        return self._delete(f"/users/{user_id}/dialer_campaign")
+
+    def get_phone_numbers(self, user_id: int) -> list[dict]:
+        """
+        Retrieve phone numbers from a user's dialer campaign.
+
+        Args:
+            user_id: The ID of the user
+
+        Returns:
+            list[dict]: List of phone numbers in the campaign
+        """
+        response = self._get(f"/users/{user_id}/dialer_campaign/phone_numbers")
+        return response.get("phone_numbers", [])
+
+    def add_phone_numbers(self, user_id: int, phone_numbers: list[str]) -> dict:
+        """
+        Add phone numbers to a user's dialer campaign.
+
+        Args:
+            user_id: The ID of the user
+            phone_numbers: List of phone numbers to add
+
+        Returns:
+            dict: Add phone numbers response
+        """
+        return self._post(f"/users/{user_id}/dialer_campaign/phone_numbers",
+                         json={"phone_numbers": phone_numbers})
+
+    def delete_phone_number(self, user_id: int, phone_number_id: int) -> dict:
+        """
+        Delete a phone number from a user's dialer campaign.
+
+        Args:
+            user_id: The ID of the user
+            phone_number_id: The ID of the phone number to delete
+
+        Returns:
+            dict: Delete phone number response
+        """
+        return self._delete(f"/users/{user_id}/dialer_campaign/phone_numbers/{phone_number_id}")

aircall/resources/integration.py

@@ -0,0 +1,53 @@
+"""Resource module for managing integrations"""
+from aircall.resources.base import BaseResource
+from aircall.models import Integration
+
+
+class IntegrationResource(BaseResource):
+    """
+    API Resource for Aircall Integrations.
+
+    Handles operations for managing third-party integrations.
+    """
+
+    def get(self) -> Integration:
+        """
+        Retrieve integration information for the current API client.
+
+        Returns:
+            Integration: The integration object
+
+        Example:
+            >>> integration = client.integration.get()
+            >>> print(integration.name, integration.active)
+        """
+        response = self._get("/integrations/me")
+        return Integration(**response["integration"])
+
+    def enable(self) -> Integration:
+        """
+        Enable the integration.
+
+        Returns:
+            Integration: The updated integration object
+
+        Example:
+            >>> integration = client.integration.enable()
+            >>> print(integration.active)  # True
+        """
+        response = self._post("/integrations/enable")
+        return Integration(**response["integration"])
+
+    def disable(self) -> Integration:
+        """
+        Disable the integration.
+
+        Returns:
+            Integration: The updated integration object
+
+        Example:
+            >>> integration = client.integration.disable()
+            >>> print(integration.active)  # False
+        """
+        response = self._post("/integrations/disable")
+        return Integration(**response["integration"])