[Librarian] Regenerated @ bb1ac274ed061aeecd32f3c2c4226d23c9c910ce

Author: twilio-dx

CHANGES.md

@@ -3,6 +3,29 @@ twilio-python Changelog
 
 Here you can see the full list of changes between each twilio-python release.
 
+[2023-04-05] Version 8.0.0
+--------------------------
+**Note:** This release contains breaking changes, check our [upgrade guide](./UPGRADE.md###-2023-04-05-7xx-to-8xx) for detailed migration notes.
+
+**Library - Feature**
+- [PR #702](https://github.com/twilio/twilio-python/pull/702): Merge branch '8.0.0-rc' to main. Thanks to [@childish-sambino](https://github.com/childish-sambino)! **(breaking change)**
+
+**Conversations**
+- Expose query parameters `start_date`, `end_date` and `state` in list operation on Conversations resource for sorting and filtering
+
+**Insights**
+- Added answered by filter in Call Summaries
+
+**Lookups**
+- Remove `disposable_phone_number_risk` package **(breaking change)**
+
+**Messaging**
+- Add support for `SOLE_PROPRIETOR` brand type and `SOLE_PROPRIETOR` campaign use case.
+- New Sole Proprietor Brands should be created with `SOLE_PROPRIETOR` brand type. Brand registration requests with `STARTER` brand type will be rejected.
+- New Sole Proprietor Campaigns should be created with `SOLE_PROPRIETOR` campaign use case. Campaign registration requests with `STARTER` campaign use case will be rejected.
+- Add Brand Registrations OTP API
+
+
 [2023-03-22] Version 7.17.0
 ---------------------------
 **Api**

twilio/rest/conversations/v1/conversation/__init__.py

@@ -670,6 +670,9 @@ async def create_async(
 
     def stream(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> Iterator[ConversationInstance]:
@@ -679,6 +682,9 @@ def stream(
         is reached.
         The results are returned as a generator, so this operation is memory efficient.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. stream()
                       guarantees to never return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -689,12 +695,20 @@ def stream(
         :returns: Generator that will yield up to limit results
         """
         limits = self._version.read_limits(limit, page_size)
-        page = self.page(page_size=limits["page_size"])
+        page = self.page(
+            start_date=start_date,
+            end_date=end_date,
+            state=state,
+            page_size=limits["page_size"],
+        )
 
         return self._version.stream(page, limits["limit"])
 
     async def stream_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> AsyncIterator[ConversationInstance]:
@@ -704,6 +718,9 @@ async def stream_async(
         is reached.
         The results are returned as a generator, so this operation is memory efficient.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. stream()
                       guarantees to never return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -714,12 +731,20 @@ async def stream_async(
         :returns: Generator that will yield up to limit results
         """
         limits = self._version.read_limits(limit, page_size)
-        page = await self.page_async(page_size=limits["page_size"])
+        page = await self.page_async(
+            start_date=start_date,
+            end_date=end_date,
+            state=state,
+            page_size=limits["page_size"],
+        )
 
         return self._version.stream_async(page, limits["limit"])
 
     def list(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> List[ConversationInstance]:
@@ -728,6 +753,9 @@ def list(
         Unlike stream(), this operation is eager and will load `limit` records into
         memory before returning.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. list() guarantees
                       never to return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -739,13 +767,19 @@ def list(
         """
         return list(
             self.stream(
+                start_date=start_date,
+                end_date=end_date,
+                state=state,
                 limit=limit,
                 page_size=page_size,
             )
         )
 
     async def list_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> List[ConversationInstance]:
@@ -754,6 +788,9 @@ async def list_async(
         Unlike stream(), this operation is eager and will load `limit` records into
         memory before returning.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. list() guarantees
                       never to return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -766,13 +803,19 @@ async def list_async(
         return [
             record
             async for record in await self.stream_async(
+                start_date=start_date,
+                end_date=end_date,
+                state=state,
                 limit=limit,
                 page_size=page_size,
             )
         ]
 
     def page(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         page_token: Union[str, object] = values.unset,
         page_number: Union[int, object] = values.unset,
         page_size: Union[int, object] = values.unset,
@@ -781,6 +824,9 @@ def page(
         Retrieve a single page of ConversationInstance records from the API.
         Request is executed immediately
 
+        :param start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param page_token: PageToken provided by the API
         :param page_number: Page Number, this value is simply for client state
         :param page_size: Number of records to return, defaults to 50
@@ -789,6 +835,9 @@ def page(
         """
         data = values.of(
             {
+                "StartDate": start_date,
+                "EndDate": end_date,
+                "State": state,
                 "PageToken": page_token,
                 "Page": page_number,
                 "PageSize": page_size,
@@ -800,6 +849,9 @@ def page(
 
     async def page_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         page_token: Union[str, object] = values.unset,
         page_number: Union[int, object] = values.unset,
         page_size: Union[int, object] = values.unset,
@@ -808,6 +860,9 @@ async def page_async(
         Asynchronously retrieve a single page of ConversationInstance records from the API.
         Request is executed immediately
 
+        :param start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param page_token: PageToken provided by the API
         :param page_number: Page Number, this value is simply for client state
         :param page_size: Number of records to return, defaults to 50
@@ -816,6 +871,9 @@ async def page_async(
         """
         data = values.of(
             {
+                "StartDate": start_date,
+                "EndDate": end_date,
+                "State": state,
                 "PageToken": page_token,
                 "Page": page_number,
                 "PageSize": page_size,

twilio/rest/conversations/v1/service/conversation/__init__.py

@@ -710,6 +710,9 @@ async def create_async(
 
     def stream(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> Iterator[ConversationInstance]:
@@ -719,6 +722,9 @@ def stream(
         is reached.
         The results are returned as a generator, so this operation is memory efficient.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. stream()
                       guarantees to never return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -729,12 +735,20 @@ def stream(
         :returns: Generator that will yield up to limit results
         """
         limits = self._version.read_limits(limit, page_size)
-        page = self.page(page_size=limits["page_size"])
+        page = self.page(
+            start_date=start_date,
+            end_date=end_date,
+            state=state,
+            page_size=limits["page_size"],
+        )
 
         return self._version.stream(page, limits["limit"])
 
     async def stream_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> AsyncIterator[ConversationInstance]:
@@ -744,6 +758,9 @@ async def stream_async(
         is reached.
         The results are returned as a generator, so this operation is memory efficient.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. stream()
                       guarantees to never return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -754,12 +771,20 @@ async def stream_async(
         :returns: Generator that will yield up to limit results
         """
         limits = self._version.read_limits(limit, page_size)
-        page = await self.page_async(page_size=limits["page_size"])
+        page = await self.page_async(
+            start_date=start_date,
+            end_date=end_date,
+            state=state,
+            page_size=limits["page_size"],
+        )
 
         return self._version.stream_async(page, limits["limit"])
 
     def list(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> List[ConversationInstance]:
@@ -768,6 +793,9 @@ def list(
         Unlike stream(), this operation is eager and will load `limit` records into
         memory before returning.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. list() guarantees
                       never to return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -779,13 +807,19 @@ def list(
         """
         return list(
             self.stream(
+                start_date=start_date,
+                end_date=end_date,
+                state=state,
                 limit=limit,
                 page_size=page_size,
             )
         )
 
     async def list_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         limit: Optional[int] = None,
         page_size: Optional[int] = None,
     ) -> List[ConversationInstance]:
@@ -794,6 +828,9 @@ async def list_async(
         Unlike stream(), this operation is eager and will load `limit` records into
         memory before returning.
 
+        :param str start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param str end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param "ConversationInstance.State" state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param limit: Upper limit for the number of records to return. list() guarantees
                       never to return more than limit.  Default is no limit
         :param page_size: Number of records to fetch per request, when not set will use
@@ -806,13 +843,19 @@ async def list_async(
         return [
             record
             async for record in await self.stream_async(
+                start_date=start_date,
+                end_date=end_date,
+                state=state,
                 limit=limit,
                 page_size=page_size,
             )
         ]
 
     def page(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         page_token: Union[str, object] = values.unset,
         page_number: Union[int, object] = values.unset,
         page_size: Union[int, object] = values.unset,
@@ -821,6 +864,9 @@ def page(
         Retrieve a single page of ConversationInstance records from the API.
         Request is executed immediately
 
+        :param start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param page_token: PageToken provided by the API
         :param page_number: Page Number, this value is simply for client state
         :param page_size: Number of records to return, defaults to 50
@@ -829,6 +875,9 @@ def page(
         """
         data = values.of(
             {
+                "StartDate": start_date,
+                "EndDate": end_date,
+                "State": state,
                 "PageToken": page_token,
                 "Page": page_number,
                 "PageSize": page_size,
@@ -840,6 +889,9 @@ def page(
 
     async def page_async(
         self,
+        start_date: Union[str, object] = values.unset,
+        end_date: Union[str, object] = values.unset,
+        state: Union["ConversationInstance.State", object] = values.unset,
         page_token: Union[str, object] = values.unset,
         page_number: Union[int, object] = values.unset,
         page_size: Union[int, object] = values.unset,
@@ -848,6 +900,9 @@ async def page_async(
         Asynchronously retrieve a single page of ConversationInstance records from the API.
         Request is executed immediately
 
+        :param start_date: Start date in ISO8601 format for sorting and filtering list of Conversations.
+        :param end_date: End date in ISO8601 format for sorting and filtering list of Conversations.
+        :param state: State for sorting and filtering list of Conversations. Can be `active`, `inactive` or `closed`
         :param page_token: PageToken provided by the API
         :param page_number: Page Number, this value is simply for client state
         :param page_size: Number of records to return, defaults to 50
@@ -856,6 +911,9 @@ async def page_async(
         """
         data = values.of(
             {
+                "StartDate": start_date,
+                "EndDate": end_date,
+                "State": state,
                 "PageToken": page_token,
                 "Page": page_number,
                 "PageSize": page_size,