HTTP method parameter (#10)

* HTTP method parameter

* Fixing typo in docs

* Added e2e test

* Black

Author: OskarLiew

daeploy/_service/service.py

@@ -26,6 +26,7 @@
     get_service_name,
     get_service_version,
     get_service_root_path,
+    HTTP_METHODS,
 )
 
 setup_logging()
@@ -72,7 +73,11 @@ def get_all_parameters() -> dict:
         self.app.get("/~parameters", tags=["Parameters"])(get_all_parameters)
 
     def entrypoint(
-        self, func: Callable = None, monitor: bool = False, **fastapi_kwargs
+        self,
+        func: Callable = None,
+        method: str = "POST",
+        monitor: bool = False,
+        **fastapi_kwargs,
     ) -> Callable:
         """Registers a function as an entrypoint, which will make it reachable
         as an HTTP method on your host machine.
@@ -88,17 +93,26 @@ def my_function(arg1:type1) -> type2:
 
         Args:
             func (Callable): The decorated function to make an entrypoint for.
+            method (str): HTTP method for entrypoint. Defauts to "POST"
             monitor (bool): Set if the input and output to this entrypoint should
-                be saved to the service's monitoring database.
+                be saved to the service's monitoring database. Defaults to False.
             **fastapi_kwargs: Keyword arguments for the resulting API endpoint.
-                See FastAPI for keyword arguments of the ``FastAPI.post()`` function.
+                See FastAPI for keyword arguments of the ``FastAPI.api_route()``
+                function.
 
         Raises:
             TypeError: If :obj:`func` is not callable.
+            ValueError: If method is not a valid HTTP method.
 
         Returns:
             Callable: The decorated function: :obj:`func`.
         """
+        method = method.upper()
+        if method not in HTTP_METHODS:
+            raise ValueError(
+                f"Invalid HTTP method: {method}." f" Possible options: {HTTP_METHODS}"
+            )
+
         # pylint: disable=protected-access
         def entrypoint_decorator(deco_func):
             funcname = deco_func.__name__
@@ -149,7 +163,9 @@ async def wrapper(_request: Request, *args, **kwargs):
             kwargs.update(fastapi_kwargs)
 
             # Create API endpoint
-            self.app.post(path, tags=["Entrypoints"], **kwargs)(wrapper)
+            self.app.api_route(path, methods=[method], tags=["Entrypoints"], **kwargs)(
+                wrapper
+            )
 
             # Wrap the original func in a pydantic validation wrapper and return that
             return validate_arguments(deco_func)

daeploy/communication.py

@@ -12,6 +12,7 @@
     get_service_version,
     get_headers,
     get_authorized_domains,
+    HTTP_METHODS,
 )
 
 logger = logging.getLogger(__name__)
@@ -163,6 +164,7 @@ def call_service(
     entrypoint_name: str,
     arguments: dict = None,
     service_version: str = None,
+    entrypoint_method: str = "POST",
     **request_kwargs,
 ) -> Any:
     """Call an entrypoint in a different service.
@@ -181,11 +183,18 @@ def call_service(
             The return object(s) of this entrypoint must be jsonable, i.e pass FastAPI's
             jsonable_encoder, otherwise it won't be reachable.
         arguments (dict): Arguments to the entrypoint.
-            In the form: {"argument_name": value, ...}. Default None.
+            In the form: {"argument_name": value, ...}. Defaults to None.
         service_version (str): The specific version of the service to call.
-            Default None, the main version and the shadows versions will be called.
+            Defaults to None, in which case the main version and the shadows
+            versions will be called.
+        entrypoint_method (str): HTTP method of the entrypoint to call. You only need
+            to change this if you have created an entrypoint with a non-default HTTP
+            method. Defaults to "POST".
         **request_kwargs: Keyword arguments to pass on to :func:``requests.post``.
 
+    Raises:
+        ValueError: If entrypoint_method is not a valid HTTP method
+
     Returns:
         Any: The output from the entrypoint in the other service.
     """
@@ -197,6 +206,13 @@ def call_service(
     else:
         url = f"{get_daeploy_manager_url()}/services/{service_name}/{entrypoint_name}"
 
+    entrypoint_method = entrypoint_method.upper()
+    if entrypoint_method not in HTTP_METHODS:
+        raise ValueError(
+            f"Invalid HTTP method: {entrypoint_method}."
+            f" Possible options: {HTTP_METHODS}"
+        )
+
     arguments = arguments if arguments else {}
 
     logger_msg = f"Calling entrypoint: {entrypoint_name} in service: {service_name}"
@@ -208,7 +224,7 @@ def call_service(
     logger.info(f"Sending POST request to: {url}")
 
     response = request(
-        "POST",
+        entrypoint_method,
         url=url,
         auth_domains=get_authorized_domains(),
         headers=get_headers(),

daeploy/utilities.py

@@ -6,6 +6,7 @@
 
 UNKNOWN_NAME = "unknown"
 UNKNOWN_VERSION = "0.0.0"
+HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "TRACE", "PATCH"]
 
 
 def get_daeploy_manager_url() -> str:

docs/source/content/advanced_tutorials/sdk_typing.rst

@@ -304,7 +304,7 @@ that pydantic supports to find which schema fits you data type.
 
 
 .. note:: Using :py:class:`~daeploy.data_types.ArrayInput` and
-  :py:class:`~daeploy.data_types.dataFrameInput` as input type can be likened to using
+  :py:class:`~daeploy.data_types.DataFrameInput` as input type can be likened to using
   ``list`` or ``dict`` and doesn't give as much control of the validation as the
   pydantic models. So in some cases it might be better to use pydantic and convert
   the data inside of the entrypoint.

tests/e2e_test/downstream/downstream.py

@@ -27,6 +27,11 @@ def raise_notification() -> str:
     return "Done"
 
 
+@service.entrypoint(method="GET")
+def get_method() -> str:
+    return "Get - Got - Gotten"
+
+
 class model1(BaseModel):
     name: str
     sirname: str

tests/e2e_test/e2e_test.py

@@ -253,14 +253,16 @@ def test_reaching_daeploy_entrypoint_with_basemodel_args(
 def test_call_service_multiple_cases(
     dummy_manager, cli_auth_login, services, logs, headers
 ):
-    url = "http://localhost/services/upstream/call_downstream_method"
+    url = "http://localhost/services/upstream/"
+    url_downstream_post = url + "call_downstream_method"
+    url_downstream_get = url + "call_downstream_get_method"
 
     unique_name = str(uuid.uuid1())
 
     # Correct arguments
     resp = requests.request(
         "POST",
-        url=url,
+        url=url_downstream_post,
         json={
             "service_name": "downstream",
             "entrypoint_name": "hello",
@@ -282,7 +284,7 @@ def test_call_service_multiple_cases(
     unique_name = str(uuid.UUID)
     resp = requests.request(
         "POST",
-        url=url,
+        url=url_downstream_post,
         json={
             "service_name": "downstream",
             "entrypoint_name": "hello",
@@ -298,7 +300,7 @@ def test_call_service_multiple_cases(
     unique_name = str(uuid.uuid1())
     resp = requests.request(
         "POST",
-        url=url,
+        url=url_downstream_post,
         json={
             "service_name": "downstream",
             "entrypoint_name": "hello",
@@ -314,7 +316,7 @@ def test_call_service_multiple_cases(
     unique_name = str(uuid.uuid1())
     resp = requests.request(
         "POST",
-        url=url,
+        url=url_downstream_post,
         json={
             "service_name": "downstream",
             "entrypoint_name": "hello_TYPO",
@@ -330,7 +332,7 @@ def test_call_service_multiple_cases(
     unique_name = str(uuid.uuid1())
     resp = requests.request(
         "POST",
-        url=url,
+        url=url_downstream_post,
         json={
             "service_name": "downstream_TYPO",
             "entrypoint_name": "hello",
@@ -342,6 +344,19 @@ def test_call_service_multiple_cases(
     upstream_logs = logs("upstream")
     assert "Not Found" in upstream_logs
 
+    # Call get method
+    resp = requests.request(
+        "POST",
+        url=url_downstream_get,
+        json={
+            "service_name": "downstream",
+        },
+        headers=headers,
+    )
+
+    assert resp.status_code == 200
+    assert resp.json() == "Get - Got - Gotten"
+
 
 def test_raised_notification_from_service_ends_up_at_manager(
     dummy_manager, cli_auth_login, services, headers

tests/e2e_test/upstream/upstream.py

@@ -20,5 +20,13 @@ def call_downstream_method(service_name, entrypoint_name, arguments):
     return greeting
 
 
+@service.entrypoint
+def call_downstream_get_method(service_name):
+    response = call_service(
+        service_name=service_name, entrypoint_name="get_method", entrypoint_method="GET"
+    )
+    return response
+
+
 if __name__ == "__main__":
     service.run()

tests/sdk_test/daeploy_test.py

@@ -479,6 +479,23 @@ def test_call_service_log_args(request, caplog):
         assert f"{arguments}" in caplog.text
 
 
+@patch("daeploy.communication.request")
+def test_call_service_invalid_method(request):
+    service_name = "myservice"
+    entrypoint_name = "mymethod"
+    arguments = {"value": 10, "active": False}
+    version = "1.0.0"
+
+    with pytest.raises(ValueError):
+        call_service(
+            service_name=service_name,
+            entrypoint_name=entrypoint_name,
+            service_version=version,
+            arguments=arguments,
+            entrypoint_method="NOT A HTTP METHOD",
+        )
+
+
 def test_local_invocation_pydantic_validation():
     service = _Service()
     wrapped = service.entrypoint(valid_entrypoint_method_args)
@@ -562,6 +579,60 @@ def test_entrypoint_not_monitored():
     service.store.assert_not_called()
 
 
+def test_entrypoint_get():
+    service = _Service()
+    service.entrypoint(monitor=False, method="GET")(valid_entrypoint_method_args)
+    client = TestClient(service.app)
+
+    req = {"name": "Rune", "age": 100}
+    response = client.get(
+        "/valid_entrypoint_method_args",
+        json=req,
+        headers={"accept": "application/json"},
+    )
+    assert response.status_code == 200
+
+
+def test_entrypoint_invalid_method():
+    service = _Service()
+    with pytest.raises(ValueError):
+        service.entrypoint(monitor=False, method="NOT A HTTP METHOD")(
+            valid_entrypoint_method_args
+        )
+
+
+@patch("daeploy.communication.request")
+def test_call_service_get_entrypoint(request):
+    service_name = "myservice"
+    entrypoint_name = "mymethod"
+    version = "1.0.0"
+    arguments = {"value": 10, "active": False}
+
+    call_service(
+        service_name=service_name,
+        entrypoint_name=entrypoint_name,
+        arguments=arguments,
+        service_version=version,
+        entrypoint_method="GET",
+    )
+
+    expected_url = f"http://host.docker.internal/services/{service_name}_{version}/{entrypoint_name}"
+    auth_domains = ["localhost"]
+    expected_headers = {
+        "Authorization": "Bearer unknown",
+        "Content-Type": "application/json",
+        "Host": "localhost",
+    }
+
+    request.assert_called_with(
+        "GET",
+        url=expected_url,
+        auth_domains=auth_domains,
+        headers=expected_headers,
+        json=arguments,
+    )
+
+
 def test_call_every_decorator():
     service = _Service()