@orcabus/platform-cdk-constructs 0.0.34 → 0.0.36

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq/query_helpers.py

@@ -25,20 +25,22 @@ from typing import List, Unpack
 from fastapi.encoders import jsonable_encoder
 
 from . import get_fastq_request_response_results, get_fastq_request
-from .globals import FASTQ_LIST_ROW_ENDPOINT, FASTQ_SET_ENDPOINT
-from .models import FastqListRow, FastqSet, Job, FastqListRowQueryParameters, FastqSetQueryParameters, \
-    FastqGetResponseParameters, VALID_BATCH_KEYS
+from .globals import FASTQ_ENDPOINT, FASTQ_SET_ENDPOINT
+from .models import (
+    FastqSet, Job, FastqParameters, FastqSetQueryParameters,
+    FastqGetResponseParameters, VALID_BATCH_KEYS, Fastq
+)
 
 
-def get_fastq(fastq_id: str, **kwargs: Unpack[FastqGetResponseParameters]) -> FastqListRow:
+def get_fastq(fastq_id: str, **kwargs: Unpack[FastqGetResponseParameters]) -> Fastq:
     # Raise error if any of the kwargs are not in the FastqSetQueryParameters
     for key in kwargs.keys():
         if key not in FastqGetResponseParameters.__annotations__:
             raise ValueError(f"Invalid parameter: {key}")
 
-    return FastqListRow(
+    return Fastq(
         **get_fastq_request(
-            f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}",
+            f"{FASTQ_ENDPOINT}/{fastq_id}",
             params=dict(kwargs)
         )
     )
@@ -67,17 +69,17 @@ def get_fastq_set(
     )
 
 
-def get_fastqs(**kwargs: Unpack[FastqListRowQueryParameters]) -> List[FastqListRow]:
+def get_fastqs(**kwargs: Unpack[FastqParameters]) -> List[Fastq]:
     """
     Get all fastqs
     """
-    # Raise error if any of the kwargs are not in the FastqListRowQueryParameters
+    # Raise error if any of the kwargs are not in the FastqParameters
     for key in kwargs.keys():
-        if key not in FastqListRowQueryParameters.__annotations__:
+        if key not in FastqParameters.__annotations__:
             raise ValueError(f"Invalid parameter: {key}")
 
     return get_fastq_request_response_results(
-        FASTQ_LIST_ROW_ENDPOINT,
+        FASTQ_ENDPOINT,
         params=dict(kwargs)
     )
 
@@ -89,7 +91,7 @@ def get_fastq_sets(**kwargs: Unpack[FastqSetQueryParameters]) -> List[FastqSet]:
     :param kwargs:
     :return:
     """
-    # Raise error if any of the kwargs are not in the FastqListRowQueryParameters
+    # Raise error if any of the kwargs are not in the FastqParameters
     for key in kwargs.keys():
         if key not in FastqSetQueryParameters.__annotations__:
             raise ValueError(f"Invalid parameter: {key}")
@@ -123,7 +125,7 @@ def get_fastqs_batched(
         item_list: List[str],
         batch_size: int = 100,
         **kwargs
-) -> List[FastqListRow]:
+) -> List[Fastq]:
     """
     Get all fastqs in a list of libraries
     """
@@ -153,7 +155,7 @@ def get_fastqs_batched(
 
 def get_fastqs_in_library_list(
         library_id_list: List[str]
-) -> List[FastqListRow]:
+) -> List[Fastq]:
     """
     Get all fastqs in a list of libraries
     """
@@ -229,8 +231,17 @@ def get_fastqs_in_project(project_id):
 
 
 def get_fastq_list_rows_in_fastq_set(fastq_set_id):
+    """
+    DEPRECATED: Use get_fastqs_in_fastq_set instead
+    """
+    return get_fastqs_in_fastq_set(fastq_set_id)
+
+
+def get_fastqs_in_fastq_set(fastq_set_id: str) -> List[Fastq]:
     """
     Get all fastqs in a fastq set
+    :param fastq_set_id:
+    :return:
     """
     return get_fastqs(
         fastqSetId=fastq_set_id
@@ -244,6 +255,6 @@ def get_fastq_jobs(fastq_id: str) -> List[Job]:
     return list(map(
         lambda job_iter_: Job(**job_iter_),
         get_fastq_request_response_results(
-            f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/jobs"
+            f"{FASTQ_ENDPOINT}/{fastq_id}/jobs"
         )
     ))

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq/update_helpers.py

@@ -15,15 +15,15 @@ Update helpers for the update script.
 
 # Local imports
 from . import fastq_patch_request
-from .globals import FASTQ_LIST_ROW_ENDPOINT, FASTQ_SET_ENDPOINT
+from .globals import FASTQ_ENDPOINT, FASTQ_SET_ENDPOINT
 from .models import (
-    QcStats, FastqListRow, ReadCount,
+    QcStats, Fastq, ReadCount,
     FileCompressionInformation, FileStorageObject, ReadSet,
     FastqSet
 )
 
 
-def add_qc_stats(fastq_id: str, qc_stats: QcStats) -> FastqListRow:
+def add_qc_stats(fastq_id: str, qc_stats: QcStats) -> Fastq:
     """
     Add QC stats to a fastq_id.
 
@@ -36,12 +36,12 @@ def add_qc_stats(fastq_id: str, qc_stats: QcStats) -> FastqListRow:
             raise ValueError(f"Invalid parameter: {key}")
 
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/addQcStats",
+        f"{FASTQ_ENDPOINT}/{fastq_id}/addQcStats",
         params=dict(qc_stats)
     )
 
 
-def add_read_count(fastq_id: str, read_count: ReadCount) -> FastqListRow:
+def add_read_count(fastq_id: str, read_count: ReadCount) -> Fastq:
     """
     Add read count to a fastq id
     :param fastq_id:
@@ -53,12 +53,12 @@ def add_read_count(fastq_id: str, read_count: ReadCount) -> FastqListRow:
             raise ValueError(f"Invalid parameter: {key}")
 
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/addReadCount",
+        f"{FASTQ_ENDPOINT}/{fastq_id}/addReadCount",
         params=dict(read_count)
     )
 
 
-def add_file_compression_information(fastq_id: str, file_compression_information: FileCompressionInformation) -> FastqListRow:
+def add_file_compression_information(fastq_id: str, file_compression_information: FileCompressionInformation) -> Fastq:
     """
     Add file compression information to a fastq id
     :param fastq_id:
@@ -70,12 +70,12 @@ def add_file_compression_information(fastq_id: str, file_compression_information
             raise ValueError(f"Invalid parameter: {key}")
 
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/addFileCompressionInformation",
+        f"{FASTQ_ENDPOINT}/{fastq_id}/addFileCompressionInformation",
         params=dict(file_compression_information)
     )
 
 
-def add_ntsm_storage_object(fastq_id: str, ntsm_fastq_storage_object: FileStorageObject) -> FastqListRow:
+def add_ntsm_storage_object(fastq_id: str, ntsm_fastq_storage_object: FileStorageObject) -> Fastq:
     """
     Add a Ntsm storage object to a fastq id.
 
@@ -87,12 +87,12 @@ def add_ntsm_storage_object(fastq_id: str, ntsm_fastq_storage_object: FileStorag
             raise ValueError(f"Invalid parameter: {key}")
 
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/addNtsmStorageObject",
+        f"{FASTQ_ENDPOINT}/{fastq_id}/addNtsmStorageObject",
         params=dict(ntsm_fastq_storage_object)
     )
 
 
-def add_read_set(fastq_id: str, read_set: ReadSet) -> FastqListRow:
+def add_read_set(fastq_id: str, read_set: ReadSet) -> Fastq:
     """
     Add a read set to a fastq id.
 
@@ -104,48 +104,62 @@ def add_read_set(fastq_id: str, read_set: ReadSet) -> FastqListRow:
             raise ValueError(f"Invalid parameter: {key}")
 
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/addFastqPairStorageObject",
+        f"{FASTQ_ENDPOINT}/{fastq_id}/addFastqPairStorageObject",
         params=dict(read_set)
     )
 
 
-def detach_read_set(fastq_id: str) -> FastqListRow:
+def detach_read_set(fastq_id: str) -> Fastq:
     """
     Detach a read set to a fastq id.
 
     :param fastq_id: Fastq str
     """
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/detachFastqPairStorageObject"
+        f"{FASTQ_ENDPOINT}/{fastq_id}/detachFastqPairStorageObject"
     )
 
 
-def validate_fastq(fastq_id: str) -> FastqListRow:
+def validate_fastq(fastq_id: str) -> Fastq:
     """
     Validate a fastq id.
 
     :param fastq_id: Fastq str
     """
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/validate"
+        f"{FASTQ_ENDPOINT}/{fastq_id}/validate"
     )
 
 
-def invalidate_fastq(fastq_id: str) -> FastqListRow:
+def invalidate_fastq(fastq_id: str) -> Fastq:
     """
     Invalidate a fastq id.
 
     :param fastq_id: Fastq str
     """
     return fastq_patch_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/invalidate"
+        f"{FASTQ_ENDPOINT}/{fastq_id}/invalidate"
     )
 
 
 def link_fastq_list_row_to_fastq_set(fastq_id: str, fastq_set_id: str) -> FastqSet:
     """
+    Deprecated: Use `link_fastq_to_fast_set` instead.
     Link a fastq id to a fastq set.
 
+    :param fastq_id:
+    :param fastq_set_id:
+    :return:
+    """
+    return link_fastq_to_fastq_set(
+        fastq_id=fastq_id,
+        fastq_set_id=fastq_set_id
+    )
+
+
+def link_fastq_to_fastq_set(fastq_id: str, fastq_set_id: str) -> FastqSet:
+    """
+    Link a fastq id to a fastq set.
     :param fastq_id:
     :param fastq_set_id:
     :return:
@@ -156,6 +170,16 @@ def link_fastq_list_row_to_fastq_set(fastq_id: str, fastq_set_id: str) -> FastqS
 
 
 def unlink_fastq_list_row_from_fastq_set(fastq_id: str, fastq_set_id: str) -> FastqSet:
+    """
+    Deprecated: Use `unlink_fastq_from_fastq_set` instead.
+    """
+    return unlink_fastq_from_fastq_set(
+        fastq_id=fastq_id,
+        fastq_set_id=fastq_set_id
+    )
+
+
+def unlink_fastq_from_fastq_set(fastq_id: str, fastq_set_id: str) -> FastqSet:
     """
     Unlink a fastq id from a fastq set.
 

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq/workflow_helpers.py

@@ -8,15 +8,16 @@ Workflow helpers - a collection of helper functions for the workflow
 
 # Standard library imports
 from typing import List
+
 # Local imports
 from . import get_fastq_request
-from .globals import FASTQ_LIST_ROW_ENDPOINT, FASTQ_SET_ENDPOINT
+from .globals import FASTQ_ENDPOINT, FASTQ_SET_ENDPOINT
 from .models import FastqListRowDict
 
 
 def to_fastq_list_row(fastq_id) -> FastqListRowDict:
     return get_fastq_request(
-        f"{FASTQ_LIST_ROW_ENDPOINT}/{fastq_id}/toFastqListRow"
+        f"{FASTQ_ENDPOINT}/{fastq_id}/toFastqListRow"
     )
 
 def to_fastq_list_rows(fastq_set_id: str) -> List[FastqListRowDict]:

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_decompression/create_helpers.py

@@ -4,31 +4,31 @@
 Create the job
 """
 
-from typing import List, Optional
+from typing import List, Optional, Unpack
 
 from . import fastq_decompression_post_request
 from .globals import JOB_ENDPOINT
-from .models import Job, JobType
+from .models import Job, JobType, JobCreateParameters
 
 
 def create_job(
-        fastq_id_list: List[str],
-        output_uri_prefix: str = None,
-        job_type: Optional[JobType] = None,
+    **kwargs: Unpack[JobCreateParameters]
 ) -> Job:
     """
     Create the job
     """
-    if job_type is None:
-        job_type = 'FASTQ_DECOMPRESSION'
+
+    # Raise error if any of the kwargs are not in the FastqListRowQueryParameters
+    for key in kwargs.keys():
+        if key not in JobCreateParameters.__annotations__:
+            raise ValueError(f"Invalid parameter: {key}")
+
+    non_null_kwargs = dict(filter(
+        lambda kv_iter_: kv_iter_[1] is not None,
+        kwargs.items()
+    ))
 
     return fastq_decompression_post_request(
         JOB_ENDPOINT,
-        params={
-            "fastqIdList": fastq_id_list,
-            "jobType": job_type,
-            "outputUriPrefix": output_uri_prefix,
-        }
+        params=non_null_kwargs
     )
-
-

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_decompression/models.py

@@ -80,6 +80,13 @@ class Job(TypedDict):
     outputs: NotRequired[JobOutputType]
 
 
+class JobCreateParameters(TypedDict):
+    fastqIdList: List[str]
+    jobType: JobType
+    maxReads: NotRequired[int]
+    outputUriPrefix: NotRequired[str]
+
+
 class JobQueryParameters(TypedDict):
     fastqId: NotRequired[str]
     fastqSetId: NotRequired[str]

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/__init__.py

@@ -6,7 +6,10 @@ from typing import Dict, Optional
 # Local imports
 from .globals import FASTQ_UNARCHIVING_SUBDOMAIN_NAME
 from ..utils.requests_helpers import (
-    get_request_response_results, get_url, patch_request, get_request
+    get_request_response_results,
+    get_url,
+    patch_request,
+    get_request
 )
 
 

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/create_helpers.py

@@ -16,12 +16,12 @@ def create_job(fastq_ids: List[str], job_type: Optional[JobType] = None) -> Job:
     Create the job
     """
     if job_type is None:
-        job_type = JobType.S3_UNARCHIVING
+        job_type = 'S3_UNARCHIVING'
 
     return fastq_unarchiving_post_request(
         JOB_ENDPOINT,
         params={
             "fastqIds": fastq_ids,
-            "jobType": job_type.value
+            "jobType": job_type
         }
     )

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/globals.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 
 import re
-from enum import Enum
 
 # AWS PARAMETERS
 FASTQ_UNARCHIVING_SUBDOMAIN_NAME = "fastq-unarchiving"
@@ -12,10 +11,3 @@ JOB_ENDPOINT = "api/v1/jobs"
 # REGEX
 ORCABUS_ULID_REGEX_MATCH = re.compile(r'^[a-z0-9]{3}\.[A-Z0-9]{26}$')
 
-
-class JobStatus(Enum):
-    PENDING = "PENDING"
-    RUNNING = "RUNNING"
-    FAILED = "FAILED"
-    ABORTED = "ABORTED"
-    SUCCEEDED = "SUCCEEDED"

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/models.py

@@ -13,28 +13,27 @@
 
 from typing import (
     TypedDict, NotRequired,
+    Literal
 )
 
-from enum import Enum
+JobType = Literal[
+    "S3_UNARCHIVING",
+]
 
 
-class JobType(Enum):
-    S3_UNARCHIVING = "S3_UNARCHIVING"
-
-
-class JobStatus(Enum):
-    PENDING = "PENDING"
-    RUNNING = "RUNNING"
-    FAILED = "FAILED"
-    ABORTED = "ABORTED"
-    SUCCEEDED = "SUCCEEDED"
-
+JobStatusType = Literal[
+    "PENDING",
+    "RUNNING",
+    "FAILED",
+    "ABORTED",
+    "SUCCEEDED",
+]
 
 class Job(TypedDict):
     id: str
     jobType: JobType
     stepsExecutionArn: str
-    status: JobStatus
+    status: JobStatusType
     startTime: str
     endTime: str
     errorMessages: str
@@ -42,7 +41,7 @@ class Job(TypedDict):
 
 class JobQueryParameters(TypedDict):
     fastqId: NotRequired[str]
-    status: NotRequired[JobStatus]
+    status: NotRequired[JobStatusType]
     createdAfter: NotRequired[str]
     createdBefore: NotRequired[str]
     completedAfter: NotRequired[str]

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/query_helpers.py

@@ -14,7 +14,7 @@ from typing import List, Unpack
 
 # Local imports
 from . import get_fastq_unarchiving_request_response_results
-from .models import Job, JobStatus, JobQueryParameters
+from .models import Job, JobStatusType, JobQueryParameters
 
 from .globals import JOB_ENDPOINT
 
@@ -40,7 +40,7 @@ def get_unarchiving_job_list(**kwargs: Unpack[JobQueryParameters]) -> List[Job]:
 
 def get_job_list_for_fastq(
         fastq_id: str,
-        job_status: JobStatus
+        job_status: JobStatusType
 ) -> List[Job]:
     """
     Check if fastq in job list
@@ -48,5 +48,5 @@ def get_job_list_for_fastq(
     """
     return get_unarchiving_job_list(
         fastqId=fastq_id,
-        status=job_status.value
+        status=job_status
     )

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq_unarchiving/update_helpers.py

@@ -17,13 +17,13 @@ from typing import Optional
 
 # Local imports
 from . import fastq_unarchiving_patch_request
-from .globals import JobStatus, JOB_ENDPOINT
-from .models import Job
+from .globals import JOB_ENDPOINT
+from .models import Job, JobStatusType
 
 
 def update_status(
         job_id: str,
-        job_status: JobStatus,
+        job_status: JobStatusType,
         error_message: Optional[str] = None
 ) -> Job:
     """

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/filemanager/__init__.py

@@ -40,10 +40,12 @@ def get_file_manager_request(
 
 def file_manager_patch_request(
         endpoint: str,
+        json_data: Optional[Dict] = None,
         params: Optional[Dict] = None
 ):
     return patch_request(
         get_file_manager_url(endpoint),
+        json_data=json_data,
         params=params
     )
 

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/filemanager/file_helpers.py

@@ -1,24 +1,30 @@
 #!/usr/bin/env python3
+
+# Standard imports
+import json
 from functools import reduce
 from operator import concat
 from typing import List, Dict, Union
 import typing
-
 import boto3
+from datetime import datetime, timedelta, timezone
+from urllib.parse import urlparse
+from itertools import batched
 
+# Local imports
 from .errors import S3FileNotFoundError, S3DuplicateFileCopyError
-from .models import FileObject
+from .models import FileObject, StorageClassPriority
 from ..utils.miscell import get_bucket_key_pair_from_uri
-from . import get_file_manager_request_response_results, get_file_manager_request, file_manager_patch_request
+from . import (
+    get_file_manager_request_response_results,
+    get_file_manager_request,
+    file_manager_patch_request
+)
 from .globals import (
     S3_LIST_ENDPOINT,
     S3_BUCKETS_BY_ACCOUNT_ID,
-    S3_PREFIXES_BY_ACCOUNT_ID,
-    StorageEnum, StoragePriority,
+    S3_PREFIXES_BY_ACCOUNT_ID
 )
-from datetime import datetime, timedelta, timezone
-from urllib.parse import urlparse
-from itertools import batched
 
 if typing.TYPE_CHECKING:
     from mypy_boto3_sts import STSClient
@@ -94,7 +100,7 @@ def get_file_object_from_ingest_id(ingest_id: str, **kwargs) -> FileObject:
     ))
 
     # Order by storage class
-    file_objects_list.sort(key=lambda file_obj_iter_: StoragePriority[StorageEnum(file_obj_iter_['storageClass']).name].value)
+    file_objects_list.sort(key=lambda file_obj_iter_: StorageClassPriority[file_obj_iter_['storageClass']])
 
     # Return as a FileObject model
     return file_objects_list[0]
@@ -263,8 +269,9 @@ def get_s3_objs_from_ingest_ids_map(ingest_ids: List[str], **kwargs) -> List[Dic
             continue
 
         s3_objects_match.sort(
-            key=lambda s3_object_iter_: StoragePriority[
-                StorageEnum(s3_object_iter_['fileObject']['storageClass']).name].value
+            key=lambda s3_object_iter_: StorageClassPriority[
+                s3_object_iter_['fileObject']['storageClass']
+            ]
         )
 
         s3_objects_by_ingest_id_filtered.append(

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/filemanager/globals.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-from enum import Enum
 
 # AWS PARAMETERS
 FILEMANAGER_SUBDOMAIN_NAME = "file"
@@ -41,30 +40,3 @@ S3_PREFIXES_BY_ACCOUNT_ID = {
     },
 }
 
-# FROM FileManager Schema
-# "DeepArchive"
-# "Glacier"
-# "GlacierIr"
-# "IntelligentTiering"
-# "OnezoneIa"
-# "Outposts"
-# "ReducedRedundancy"
-# "Snow"
-# "Standard"
-# "StandardIa"
-class StorageEnum(Enum):
-    STANDARD = "Standard"
-    STANDARD_IA = "StandardIa"
-    INTELLIGENT_TIERING = "IntelligentTiering"
-    GLACIER_INSTANT_RETRIEVAL = "GlacierIr"
-    GLACIER = "Glacier"
-    DEEP_ARCHIVE = "DeepArchive"
-
-
-class StoragePriority(Enum):
-    STANDARD = 1
-    STANDARD_IA = 2
-    INTELLIGENT_TIERING = 3
-    GLACIER_INSTANT_RETRIEVAL = 4
-    GLACIER = 5
-    DEEP_ARCHIVE = 6

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/filemanager/models.py

@@ -1,4 +1,9 @@
-from typing import Optional, TypedDict, Dict
+from typing import (
+    Optional,
+    TypedDict,
+    Dict,
+    Literal
+)
 
 """
 Example File Object response
@@ -26,6 +31,23 @@ Example File Object response
     }
 """
 
+StorageClassType = Literal[
+    "Standard",
+    "StandardIa",
+    "IntelligentTiering",
+    "GlacierIr",
+    "Glacier",
+    "DeepArchive",
+]
+
+StorageClassPriority: Dict[StorageClassType, int] = {
+    "Standard": 1,
+    "StandardIa": 2,
+    "IntelligentTiering": 3,
+    "GlacierIr": 4,
+    "Glacier": 5,
+    "DeepArchive": 6,
+}
 
 class FileObject(TypedDict):
     # Identifier
@@ -47,7 +69,7 @@ class FileObject(TypedDict):
     numberReordered: int
     sequencer: str
     size: int
-    storageClass: str
+    storageClass: StorageClassType
 
     # Attribute attributes
     attributes: Optional[Dict]

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/utils/requests_helpers.py

@@ -9,6 +9,8 @@ from copy import deepcopy
 
 from requests import HTTPError
 
+from fastapi.encoders import jsonable_encoder
+
 # Locals
 from .aws_helpers import (
     get_orcabus_token, get_hostname
@@ -103,7 +105,11 @@ def get_request(url: str, params: Optional[Dict] = None) -> Dict:
     return response.json()
 
 
-def patch_request(url: str, params: Optional[Dict] = None) -> Dict:
+def patch_request(
+        url: str,
+        json_data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+) -> Dict:
     # Get authorization header
     headers = {
         "Authorization": f"Bearer {get_orcabus_token()}"
@@ -119,7 +125,8 @@ def patch_request(url: str, params: Optional[Dict] = None) -> Dict:
     response = requests.patch(
         url,
         headers=headers,
-        json=req_params
+        params=req_params,
+        json=json_data
     )
 
     try: