update version to 0.3.0a6

Signed-off-by: Timo Glastra <timo@animo.id>

Author: TimoGlastra

aries_cloudcontroller/__init__.py

@@ -1,6 +1,4 @@
-from aries_cloudcontroller.acapy_client import (
-    AcaPyClient
-)
+from aries_cloudcontroller.acapy_client import AcaPyClient
 
 from aries_cloudcontroller.api import (
     ActionMenuApi,
@@ -548,4 +546,4 @@
     "ServerApi",
     "TrustpingApi",
     "WalletApi",
-]
+]

aries_cloudcontroller/api/action_menu.py

@@ -14,39 +14,73 @@
     json,
 )
 
-from typing import Dict, List  # noqa: F401
+from typing import Dict, List, Optional  # noqa: F401
 
 from aries_cloudcontroller.model.action_menu_fetch_result import ActionMenuFetchResult
 from aries_cloudcontroller.model.perform_request import PerformRequest
 from aries_cloudcontroller.model.send_menu import SendMenu
 
 
 class ActionMenuApi(Consumer):
+    async def close_active_menu(self, *, conn_id: str) -> Dict:
+        """Close the active menu associated with a connection"""
+        return await self.__close_active_menu(
+            conn_id=conn_id,
+        )
+
+    async def fetch_active_menu(self, *, conn_id: str) -> ActionMenuFetchResult:
+        """Fetch the active menu"""
+        return await self.__fetch_active_menu(
+            conn_id=conn_id,
+        )
+
+    async def perform_action(
+        self, *, conn_id: str, body: Optional[PerformRequest] = None
+    ) -> Dict:
+        """Perform an action associated with the active menu"""
+        return await self.__perform_action(
+            conn_id=conn_id,
+            body=body,
+        )
+
+    async def request_active_menu(self, *, conn_id: str) -> Dict:
+        """Request the active menu"""
+        return await self.__request_active_menu(
+            conn_id=conn_id,
+        )
+
+    async def send_menu(self, *, conn_id: str, body: Optional[SendMenu] = None) -> Dict:
+        """Send an action menu to a connection"""
+        return await self.__send_menu(
+            conn_id=conn_id,
+            body=body,
+        )
+
     @returns.json
     @post("/action-menu/{conn_id}/close")
-    def close_active_menu(self, *, conn_id: str) -> Dict:
-        """Close the active menu associated with a connection"""
+    def __close_active_menu(self, *, conn_id: str) -> Dict:
+        """Internal uplink method for close_active_menu"""
 
     @returns.json
     @post("/action-menu/{conn_id}/fetch")
-    def fetch_active_menu(self, *, conn_id: str) -> ActionMenuFetchResult:
-        """Fetch the active menu"""
+    def __fetch_active_menu(self, *, conn_id: str) -> ActionMenuFetchResult:
+        """Internal uplink method for fetch_active_menu"""
 
     @returns.json
     @json
     @post("/action-menu/{conn_id}/perform")
-    def perform_action(
+    def __perform_action(
         self, *, conn_id: str, body: Body(type=PerformRequest) = {}
     ) -> Dict:
-        """Perform an action associated with the active menu"""
+        """Internal uplink method for perform_action"""
 
     @returns.json
     @post("/action-menu/{conn_id}/request")
-    def request_active_menu(self, *, conn_id: str) -> Dict:
-        """Request the active menu"""
+    def __request_active_menu(self, *, conn_id: str) -> Dict:
+        """Internal uplink method for request_active_menu"""
 
     @returns.json
     @json
     @post("/action-menu/{conn_id}/send-menu")
-    def send_menu(self, *, conn_id: str, body: Body(type=SendMenu) = {}) -> Dict:
-        """Send an action menu to a connection"""
+    def __send_menu(self, *, conn_id: str, body: Body(type=SendMenu) = {}) -> Dict:
+        """Internal uplink method for send_menu"""

aries_cloudcontroller/api/basicmessage.py

@@ -14,14 +14,25 @@
     json,
 )
 
-from typing import Dict, List  # noqa: F401
+from typing import Dict, List, Optional  # noqa: F401
 
 from aries_cloudcontroller.model.send_message import SendMessage
 
 
 class BasicmessageApi(Consumer):
+    async def send_message(
+        self, *, conn_id: str, body: Optional[SendMessage] = None
+    ) -> Dict:
+        """Send a basic message to a connection"""
+        return await self.__send_message(
+            conn_id=conn_id,
+            body=body,
+        )
+
     @returns.json
     @json
     @post("/connections/{conn_id}/send-message")
-    def send_message(self, *, conn_id: str, body: Body(type=SendMessage) = {}) -> Dict:
-        """Send a basic message to a connection"""
+    def __send_message(
+        self, *, conn_id: str, body: Body(type=SendMessage) = {}
+    ) -> Dict:
+        """Internal uplink method for send_message"""

aries_cloudcontroller/api/connection.py

@@ -14,7 +14,7 @@
     json,
 )
 
-from typing import Dict, List  # noqa: F401
+from typing import Dict, List, Optional  # noqa: F401
 
 from aries_cloudcontroller.model.conn_record import ConnRecord
 from aries_cloudcontroller.model.connection_list import ConnectionList
@@ -37,27 +37,161 @@
 
 
 class ConnectionApi(Consumer):
+    async def accept_invitation(
+        self,
+        *,
+        conn_id: str,
+        mediation_id: Optional[str] = None,
+        my_endpoint: Optional[str] = None,
+        my_label: Optional[str] = None
+    ) -> ConnRecord:
+        """Accept a stored connection invitation"""
+        return await self.__accept_invitation(
+            conn_id=conn_id,
+            mediation_id=mediation_id,
+            my_endpoint=my_endpoint,
+            my_label=my_label,
+        )
+
+    async def accept_request(
+        self, *, conn_id: str, my_endpoint: Optional[str] = None
+    ) -> ConnRecord:
+        """Accept a stored connection request"""
+        return await self.__accept_request(
+            conn_id=conn_id,
+            my_endpoint=my_endpoint,
+        )
+
+    async def create_invitation(
+        self,
+        *,
+        alias: Optional[str] = None,
+        auto_accept: Optional[bool] = None,
+        multi_use: Optional[bool] = None,
+        public: Optional[bool] = None,
+        body: Optional[CreateInvitationRequest] = None
+    ) -> InvitationResult:
+        """Create a new connection invitation"""
+        return await self.__create_invitation(
+            alias=alias,
+            auto_accept=auto_accept,
+            multi_use=multi_use,
+            public=public,
+            body=body,
+        )
+
+    async def create_static_connection(
+        self, *, body: Optional[ConnectionStaticRequest] = None
+    ) -> ConnectionStaticResult:
+        """Create a new static connection"""
+        return await self.__create_static_connection(
+            body=body,
+        )
+
+    async def delete_connection(self, *, conn_id: str) -> Dict:
+        """Remove an existing connection record"""
+        return await self.__delete_connection(
+            conn_id=conn_id,
+        )
+
+    async def establish_inbound(self, *, conn_id: str, ref_id: str) -> Dict:
+        """Assign another connection as the inbound connection"""
+        return await self.__establish_inbound(
+            conn_id=conn_id,
+            ref_id=ref_id,
+        )
+
+    async def get_connection(self, *, conn_id: str) -> ConnRecord:
+        """Fetch a single connection record"""
+        return await self.__get_connection(
+            conn_id=conn_id,
+        )
+
+    async def get_connection_endpoint(self, *, conn_id: str) -> EndpointsResult:
+        """Fetch connection remote endpoint"""
+        return await self.__get_connection_endpoint(
+            conn_id=conn_id,
+        )
+
+    async def get_connections(
+        self,
+        *,
+        alias: Optional[str] = None,
+        connection_protocol: Optional[str] = None,
+        invitation_key: Optional[str] = None,
+        my_did: Optional[str] = None,
+        state: Optional[str] = None,
+        their_did: Optional[str] = None,
+        their_role: Optional[str] = None
+    ) -> ConnectionList:
+        """Query agent-to-agent connections"""
+        return await self.__get_connections(
+            alias=alias,
+            connection_protocol=connection_protocol,
+            invitation_key=invitation_key,
+            my_did=my_did,
+            state=state,
+            their_did=their_did,
+            their_role=their_role,
+        )
+
+    async def get_metadata(
+        self, *, conn_id: str, key: Optional[str] = None
+    ) -> ConnectionMetadata:
+        """Fetch connection metadata"""
+        return await self.__get_metadata(
+            conn_id=conn_id,
+            key=key,
+        )
+
+    async def receive_invitation(
+        self,
+        *,
+        alias: Optional[str] = None,
+        auto_accept: Optional[bool] = None,
+        mediation_id: Optional[str] = None,
+        body: Optional[ReceiveInvitationRequest] = None
+    ) -> ConnRecord:
+        """Receive a new connection invitation"""
+        return await self.__receive_invitation(
+            alias=alias,
+            auto_accept=auto_accept,
+            mediation_id=mediation_id,
+            body=body,
+        )
+
+    async def set_metadata(
+        self, *, conn_id: str, body: Optional[ConnectionMetadataSetRequest] = None
+    ) -> ConnectionMetadata:
+        """Set connection metadata"""
+        return await self.__set_metadata(
+            conn_id=conn_id,
+            body=body,
+        )
+
     @returns.json
     @post("/connections/{conn_id}/accept-invitation")
-    def accept_invitation(
+    def __accept_invitation(
         self,
         *,
         conn_id: str,
         mediation_id: Query = None,
         my_endpoint: Query = None,
         my_label: Query = None
     ) -> ConnRecord:
-        """Accept a stored connection invitation"""
+        """Internal uplink method for accept_invitation"""
 
     @returns.json
     @post("/connections/{conn_id}/accept-request")
-    def accept_request(self, *, conn_id: str, my_endpoint: Query = None) -> ConnRecord:
-        """Accept a stored connection request"""
+    def __accept_request(
+        self, *, conn_id: str, my_endpoint: Query = None
+    ) -> ConnRecord:
+        """Internal uplink method for accept_request"""
 
     @returns.json
     @json
     @post("/connections/create-invitation")
-    def create_invitation(
+    def __create_invitation(
         self,
         *,
         alias: Query = None,
@@ -66,39 +200,39 @@ def create_invitation(
         public: Query = None,
         body: Body(type=CreateInvitationRequest) = {}
     ) -> InvitationResult:
-        """Create a new connection invitation"""
+        """Internal uplink method for create_invitation"""
 
     @returns.json
     @json
     @post("/connections/create-static")
-    def create_static_connection(
+    def __create_static_connection(
         self, *, body: Body(type=ConnectionStaticRequest) = {}
     ) -> ConnectionStaticResult:
-        """Create a new static connection"""
+        """Internal uplink method for create_static_connection"""
 
     @returns.json
     @delete("/connections/{conn_id}")
-    def delete_connection(self, *, conn_id: str) -> Dict:
-        """Remove an existing connection record"""
+    def __delete_connection(self, *, conn_id: str) -> Dict:
+        """Internal uplink method for delete_connection"""
 
     @returns.json
     @post("/connections/{conn_id}/establish-inbound/{ref_id}")
-    def establish_inbound(self, *, conn_id: str, ref_id: str) -> Dict:
-        """Assign another connection as the inbound connection"""
+    def __establish_inbound(self, *, conn_id: str, ref_id: str) -> Dict:
+        """Internal uplink method for establish_inbound"""
 
     @returns.json
     @get("/connections/{conn_id}")
-    def get_connection(self, *, conn_id: str) -> ConnRecord:
-        """Fetch a single connection record"""
+    def __get_connection(self, *, conn_id: str) -> ConnRecord:
+        """Internal uplink method for get_connection"""
 
     @returns.json
     @get("/connections/{conn_id}/endpoints")
-    def get_connection_endpoint(self, *, conn_id: str) -> EndpointsResult:
-        """Fetch connection remote endpoint"""
+    def __get_connection_endpoint(self, *, conn_id: str) -> EndpointsResult:
+        """Internal uplink method for get_connection_endpoint"""
 
     @returns.json
     @get("/connections")
-    def get_connections(
+    def __get_connections(
         self,
         *,
         alias: Query = None,
@@ -109,30 +243,30 @@ def get_connections(
         their_did: Query = None,
         their_role: Query = None
     ) -> ConnectionList:
-        """Query agent-to-agent connections"""
+        """Internal uplink method for get_connections"""
 
     @returns.json
     @get("/connections/{conn_id}/metadata")
-    def get_metadata(self, *, conn_id: str, key: Query = None) -> ConnectionMetadata:
-        """Fetch connection metadata"""
+    def __get_metadata(self, *, conn_id: str, key: Query = None) -> ConnectionMetadata:
+        """Internal uplink method for get_metadata"""
 
     @returns.json
     @json
     @post("/connections/receive-invitation")
-    def receive_invitation(
+    def __receive_invitation(
         self,
         *,
         alias: Query = None,
         auto_accept: Query = None,
         mediation_id: Query = None,
         body: Body(type=ReceiveInvitationRequest) = {}
     ) -> ConnRecord:
-        """Receive a new connection invitation"""
+        """Internal uplink method for receive_invitation"""
 
     @returns.json
     @json
     @post("/connections/{conn_id}/metadata")
-    def set_metadata(
+    def __set_metadata(
         self, *, conn_id: str, body: Body(type=ConnectionMetadataSetRequest) = {}
     ) -> ConnectionMetadata:
-        """Set connection metadata"""
+        """Internal uplink method for set_metadata"""