dataverse-sdk 2.2.2__tar.gz → 2.3.1__tar.gz

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataverse-sdk
-Version: 2.2.2
+Version: 2.3.1
 Summary: Dataverse SDK For Python
 Home-page: 
 Author: LinkerVision
@@ -55,19 +55,21 @@ Interaction with the Dataverse site starts with an instance of the `DataverseCli
 ```Python
 from dataverse_sdk import *
 from dataverse_sdk.connections import get_connection
+from dataverse_sdk.constants import DataverseHost
+
 client = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
 )
 assert client is get_connection("default")
 
 # Should provide different alias if you are trying to connect to different workspaces
 client2 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
+    host=DataverseHost.PRODUCTION.value, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
 )
 assert client2 is get_connection(client2.alias)
 
 client3 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
 )
 assert client3 is get_connection(client3.alias)
 ```

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/README.md

@@ -28,19 +28,21 @@ Interaction with the Dataverse site starts with an instance of the `DataverseCli
 ```Python
 from dataverse_sdk import *
 from dataverse_sdk.connections import get_connection
+from dataverse_sdk.constants import DataverseHost
+
 client = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
 )
 assert client is get_connection("default")
 
 # Should provide different alias if you are trying to connect to different workspaces
 client2 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
+    host=DataverseHost.PRODUCTION.value, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
 )
 assert client2 is get_connection(client2.alias)
 
 client3 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
 )
 assert client3 is get_connection(client3.alias)
 ```

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/apis/backend.py

@@ -460,6 +460,19 @@ class BackendAPI:
         )
         return resp.json()
 
+    def create_custom_model(self, **kwargs):
+        permission = kwargs.pop("permission", "")
+        if permission:
+            self.headers["X-Request-Source"] = permission
+
+        resp = self.send_request(
+            url=f"{self.host}/api/ml_models/custom-model/",
+            method="post",
+            headers=self.headers,
+            data=kwargs,
+        )
+        return resp.json()
+
 
 class AsyncBackendAPI:
     def __init__(

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/client.py

@@ -26,6 +26,7 @@ from .exceptions.client import (
 )
 from .schemas.api import (
     AttributeAPISchema,
+    CreateCustomModelAPISchema,
     DatasetAPISchema,
     OntologyAPISchema,
     ProjectAPISchema,
@@ -690,10 +691,14 @@ class DataverseClient:
             raise InvalidProcessError("The project type is not VQA!")
         output_list = []
         for question in project.ontology.classes:
+            answer = question.attributes[0]
+            option_list = [opt.value for opt in answer.options]
             output_list.append(
                 {
                     "question_id": question.rank,
                     "question": question.extended_class["question"],
+                    "type": answer.type,
+                    "options": option_list,
                 }
             )
         import json
@@ -1747,6 +1752,38 @@ of this project OR has been added before"
             )
         return create_dataset_uuid
 
+    @staticmethod
+    def create_custom_model(
+        project: Project,
+        name: str,
+        input_classes: list[str],
+        resolution_width: int,
+        resolution_height: int,
+        model_structure: str,
+        weight_url: str,
+        client: Optional["DataverseClient"] = None,
+        client_alias: Optional[str] = None,
+        permission: str = "",
+    ):
+        try:
+            payload = CreateCustomModelAPISchema(
+                project_id=project.id,
+                name=name,
+                input_classes=input_classes,
+                resolution_width=resolution_width,
+                resolution_height=resolution_height,
+                model_structure=model_structure,
+                weight_url=weight_url,
+            ).model_dump()
+        except ValidationError as e:
+            raise APIValidationError(f"Something wrong when creating custom model: {e}")
+
+        api, _ = DataverseClient._get_api_client(
+            client=client, client_alias=client_alias, is_async=False
+        )
+
+        api.create_custom_model(**payload, permission=permission)
+
     @staticmethod
     async def run_generate_presigned_urls(
         file_paths: list, api: AsyncBackendAPI, data_folder: str

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/export/base.py

@@ -12,6 +12,7 @@ class ExportAnnotationBase(abc.ABC):
         sequence_frame_map: dict[int, dict[int, list[int]]],
         datarow_generator_func: Callable[[list], Generator[dict]],
         annotation_name: str,
+        is_sequential: bool,
         *args,
         **kwargs,
     ) -> Generator[bytes, str]:

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/export/coco.py

@@ -22,7 +22,7 @@ from .constant import (
     ExportFormat,
 )
 from .exporter import Exporter
-from .utils import convert_to_bytes
+from .utils import convert_to_bytes, gen_empty_vai
 
 
 @Exporter.register(format=ExportFormat.COCO)
@@ -156,6 +156,9 @@ def convert_annotation(
                 datarow["items"].get("predictions", {}).get(annotation_name, {})
             )
 
+        if not target_visionai:
+            target_visionai = gen_empty_vai(datarow=datarow, sequence_folder_url="")
+
         (
             category_idx_map,
             image_update,

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/export/exporter.py

@@ -77,6 +77,7 @@ class Exporter:
         sequence_frame_map: dict,
         question_id_map: dict,
         annotation_name: str,
+        is_sequential: bool,
     ) -> AsyncGenerator[tuple[bytes, str]]:
         async for data, path in self.export_annot.producer(
             class_names=class_names,
@@ -85,6 +86,7 @@ class Exporter:
             target_folder=self.target_folder,
             datarow_generator_func=await self._gen(self.curation_api),
             annotation_name=annotation_name,
+            is_sequential=is_sequential,
         ):
             if not path:
                 continue
@@ -141,7 +143,7 @@ class Exporter:
                 gen: AsyncGenerator = curation_api.get_datarows(
                     id_set_list=id_chunks,
                     batch_size=BATCH_SIZE,
-                    fields="id,items,vlm_items,url,frame_id,image_width,image_height,sensor_name,original_url",
+                    fields="id,items,vlm_items,url,frame_id,image_width,image_height,sensor_name,original_url,type",
                 )
                 async for batched_datarow in gen:
                     for datarow in batched_datarow:
@@ -238,9 +240,9 @@ def get_datarow_sequences(
         for frame_datarow_id, datarow_id_list in sequence_frame_map[
             sequence_datarow_id
         ].items():
-            new_datarows_sequence_map[sequence_order][
-                frame_datarow_id
-            ] = datarow_id_list
+            new_datarows_sequence_map[sequence_order][frame_datarow_id] = (
+                datarow_id_list
+            )
             if not is_sequential or sequence_datarow_id == NONE_SEQUENCE_DATAROW_ID:
                 sequence_order += 1
         if is_sequential:

dataverse_sdk-2.3.1/dataverse_sdk/export/utils.py

@@ -0,0 +1,53 @@
+import json
+from typing import Union
+
+from visionai_data_format.schemas.visionai_schema import (
+    Frame,
+    FrameProperties,
+    FramePropertyStream,
+)
+
+from ..apis.third_party import ThirdPartyAPI
+
+
+def convert_to_bytes(obj: Union[dict, list, str]) -> bytes:
+    if isinstance(obj, (dict, list)):
+        jstr = json.dumps(obj)
+    elif isinstance(obj, str):
+        jstr = obj
+    else:
+        raise TypeError("un-support type")
+    return bytes(jstr, encoding="utf8")
+
+
+async def download_url_file_async(data_url: str) -> bytes | None:
+    # get data from url link
+    try:
+        data: bytes = await ThirdPartyAPI.async_download_file(
+            url=data_url, method="GET"
+        )
+    except Exception:
+        print(f"Retrieving data from url {data_url} error")
+        return None
+    return data
+
+
+def gen_empty_vai(datarow: dict, sequence_folder_url: str) -> dict:
+    new_sensor_data_folder = f"{sequence_folder_url}/data/{datarow['sensor_name']}/"
+    dest_url = f"{new_sensor_data_folder}{datarow['url'].split('/')[-1]}"
+
+    # generate visionai empty frame
+    frames = {}
+    frame_num = datarow["frame_id"]
+    frames[frame_num] = Frame(
+        frame_properties=FrameProperties(
+            streams={datarow["sensor_name"]: FramePropertyStream(uri=dest_url)}
+        ),
+        objects={},
+    ).model_dump(exclude_none=True)
+    if datarow["type"] == "image":
+        stream = {datarow["sensor_name"]: {"type": "camera", "uri": dest_url}}
+    else:
+        stream = {datarow["sensor_name"]: {"type": "lidar", "uri": dest_url}}
+
+    return {"frames": frames, "streams": stream}

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/export/visionai.py

@@ -19,7 +19,7 @@ from .constant import (
     ExportFormat,
 )
 from .exporter import Exporter
-from .utils import convert_to_bytes
+from .utils import convert_to_bytes, gen_empty_vai
 
 
 def merge_intervals(intervals: list[tuple[int, int]]):
@@ -227,7 +227,9 @@ def aggregate_static_annotations(
     return large_data
 
 
-def update_streams_uri(streams: dict, sequence_folder_url: str) -> dict:
+def update_streams_uri(
+    streams: dict, sequence_folder_url: str, original_file_name: Optional[str] = None
+) -> dict:
     """Update streams under frames uri
 
     Example:
@@ -246,6 +248,8 @@ def update_streams_uri(streams: dict, sequence_folder_url: str) -> dict:
         streams data contains multiple sensors and its uri
     sequence_folder_url : str
         sequence folder url destination
+    original_file_name: Optional[str]
+        original file name for the given image/pcd
 
 
     Returns
@@ -259,6 +263,8 @@ def update_streams_uri(streams: dict, sequence_folder_url: str) -> dict:
         old_uri_path_list = stream_data["uri"].split("/")
         file_path = "/".join(old_uri_path_list[-3:])
         stream_data["uri"] = sequence_folder_url + file_path
+        if original_file_name is not None:
+            stream_data["original_file_name"] = original_file_name
     return current_streams
 
 
@@ -419,6 +425,7 @@ def aggregate_datarows_annotations(
             datarow_id: int = datarow["id"]
             datarow_items: dict = datarow["items"]
             frame_num = int(datarow["frame_id"])
+            original_file_name = os.path.basename(datarow["original_url"])
 
             if annotation_name == GROUNDTRUTH:
                 vai = copy.deepcopy(datarow_items.get(GROUND_TRUTH_ANNOTATION_NAME, {}))
@@ -427,6 +434,11 @@ def aggregate_datarows_annotations(
                     datarow_items.get("predictions", {}).get(annotation_name, {})
                 )
 
+            if not vai:
+                vai = gen_empty_vai(
+                    datarow=datarow, sequence_folder_url=sequence_folder_url
+                )
+
             # we could retrieve the first data of frames under items
             # since each items inside datarow contains only one frames
             try:
@@ -485,6 +497,7 @@ def aggregate_datarows_annotations(
                 update_streams_uri(
                     streams=frame["frame_properties"]["streams"],
                     sequence_folder_url=sequence_folder_url,
+                    original_file_name=original_file_name,
                 )
             )
             # coordinate system can be optional in visionai
@@ -494,7 +507,9 @@ def aggregate_datarows_annotations(
             if current_vai_sensor not in streams:
                 streams.update(
                     update_streams_uri(
-                        streams=vai["streams"], sequence_folder_url=sequence_folder_url
+                        streams=vai["streams"],
+                        sequence_folder_url=sequence_folder_url,
+                        original_file_name=None,
                     )
                 )
         if not current_frame.get("objects"):
@@ -506,17 +521,17 @@ def aggregate_datarows_annotations(
     # list out all frames number of combined frames
     frame_num_set = {int(num) for num in combined_frames.keys()}
     # combine all objects under visionai
-    static_objects_map: dict[
-        str, list[tuple[int, dict]]
-    ] = aggregate_static_annotations(
-        datarows=all_datarows, root_key="objects", annotation_name=annotation_name
+    static_objects_map: dict[str, list[tuple[int, dict]]] = (
+        aggregate_static_annotations(
+            datarows=all_datarows, root_key="objects", annotation_name=annotation_name
+        )
     )
 
     # combine all contexts under visionai
-    static_contexts_map: dict[
-        str, list[tuple[int, dict]]
-    ] = aggregate_static_annotations(
-        datarows=all_datarows, root_key="contexts", annotation_name=annotation_name
+    static_contexts_map: dict[str, list[tuple[int, dict]]] = (
+        aggregate_static_annotations(
+            datarows=all_datarows, root_key="contexts", annotation_name=annotation_name
+        )
     )
 
     # retrieve tags under visionai
@@ -562,7 +577,7 @@ def aggregate_datarows_annotations(
         visionai["contexts"] = combined_contexts_map
     if tags_under_visionai:
         visionai["tags"] = tags_under_visionai
-    return VisionAIModel(**{"visionai": visionai}).dict()
+    return VisionAIModel(**{"visionai": visionai}).model_dump(exclude_none=True)
 
 
 @Exporter.register(format=ExportFormat.VISIONAI)
@@ -626,48 +641,79 @@ class ExportVisionAI(ExportAnnotationBase):
         annotation_name: str,
         datarow_id_to_frame_datarow_id: dict[int, int],
         current_batch: list[dict],
-        pre_frame_datarow_id: int,
+        pre_frame_datarow_id: int | None,
         last_batch: bool,
-    ) -> list[tuple[bytes, str]]:
+        is_sequential: bool,
+    ) -> tuple[
+        list[tuple[bytes, str]],
+        defaultdict[int, list[dict]],
+        list[int],
+        int | None,
+        list[dict],
+    ]:
         annotation_results = []
 
+        def create_aggregated_annotation(
+            frame_datarows: dict, seq_id: int
+        ) -> tuple[bytes, str]:
+            """Helper to create aggregated annotation bytes and path."""
+            annot_bytes = convert_to_bytes(
+                aggregate_datarows_annotations(
+                    frame_datarows=frame_datarows,
+                    sequence_folder_url=os.path.join(
+                        target_folder, f"{seq_id:012d}", ""
+                    ),
+                    annotation_name=annotation_name,
+                )
+            )
+            anno_path = os.path.join(
+                f"{seq_id:012d}", "annotations", annotation_name, "visionai.json"
+            )
+            return (annot_bytes, anno_path)
+
+        if is_sequential:
+            async for datarow in datarow_generator_func(datarow_id_list):
+                frame_datarow_id = datarow_id_to_frame_datarow_id[datarow["id"]]
+                sequence_frame_datarows[frame_datarow_id].append(datarow)
+                current_batch.append(datarow)
+
+            sequence_id = frame_datarow_id_to_sequence_id[frame_datarow_id]
+            annotation_results.append(
+                create_aggregated_annotation(sequence_frame_datarows, sequence_id)
+            )
+            sequence_frame_datarows = defaultdict(list)
+
+            return (
+                annotation_results,
+                sequence_frame_datarows,
+                datarow_id_list,
+                pre_frame_datarow_id,
+                current_batch,
+            )
+
         async for datarow in datarow_generator_func(datarow_id_list):
             frame_datarow_id = datarow_id_to_frame_datarow_id[datarow["id"]]
             current_batch.append(datarow)
-            sequence_frame_datarows[frame_datarow_id].append(datarow)
             if pre_frame_datarow_id is None:
                 pre_frame_datarow_id = frame_datarow_id
+                sequence_frame_datarows[frame_datarow_id].append(datarow)
             elif pre_frame_datarow_id != frame_datarow_id:
-                sequence_id = frame_datarow_id_to_sequence_id[pre_frame_datarow_id]
-                annot_bytes: bytes = convert_to_bytes(
-                    aggregate_datarows_annotations(
-                        frame_datarows=sequence_frame_datarows,
-                        sequence_folder_url=f"{target_folder.rstrip('/')}/"
-                        + f"{sequence_id:012d}/",
-                        annotation_name=annotation_name,
+                # export previous frame when frame_datarow_id changes
+                pre_sequence_id = frame_datarow_id_to_sequence_id[pre_frame_datarow_id]
+                annotation_results.append(
+                    create_aggregated_annotation(
+                        sequence_frame_datarows, pre_sequence_id
                     )
                 )
-                anno_path = os.path.join(
-                    f"{sequence_id:012d}", "annotations", "groundtruth", "visionai.json"
-                )
-                annotation_results.append((annot_bytes, anno_path))
                 sequence_frame_datarows.pop(pre_frame_datarow_id)
+                sequence_frame_datarows[frame_datarow_id].append(datarow)
                 pre_frame_datarow_id = frame_datarow_id
 
         if last_batch:
             sequence_id = frame_datarow_id_to_sequence_id[frame_datarow_id]
-            annot_bytes: bytes = convert_to_bytes(
-                aggregate_datarows_annotations(
-                    frame_datarows=sequence_frame_datarows,
-                    sequence_folder_url=f"{target_folder.rstrip('/')}/"
-                    + f"{sequence_id:012d}/",
-                    annotation_name=annotation_name,
-                )
+            annotation_results.append(
+                create_aggregated_annotation(sequence_frame_datarows, sequence_id)
             )
-            anno_path = os.path.join(
-                f"{sequence_id:012d}", "annotations", "groundtruth", "visionai.json"
-            )
-            annotation_results.append((annot_bytes, anno_path))
             sequence_frame_datarows = defaultdict(list)
 
         return (
@@ -684,6 +730,7 @@ class ExportVisionAI(ExportAnnotationBase):
         sequence_frame_map: dict[int, dict[int, list[int]]],
         datarow_generator_func: Callable[[list], AsyncGenerator[dict]],
         annotation_name: str,
+        is_sequential: bool,
         *_,
         **kwargs,
     ) -> AsyncGenerator[bytes, str]:
@@ -705,10 +752,10 @@ class ExportVisionAI(ExportAnnotationBase):
                         datarow_id_list.extend(datarow_ids)
                         frame_datarow_id_to_sequence_id[frame_datarow_id] = sequence_id
                         for datarow_id in datarow_ids:
-                            datarow_id_to_frame_datarow_id[
-                                datarow_id
-                            ] = frame_datarow_id
-                        if len(datarow_id_list) >= BATCH_SIZE:
+                            datarow_id_to_frame_datarow_id[datarow_id] = (
+                                frame_datarow_id
+                            )
+                        if not is_sequential and len(datarow_id_list) >= BATCH_SIZE:
                             (
                                 annotation_results,
                                 sequence_frame_datarows,
@@ -726,6 +773,7 @@ class ExportVisionAI(ExportAnnotationBase):
                                 current_batch,
                                 pre_frame_datarow_id,
                                 last_batch=False,
+                                is_sequential=is_sequential,
                             )
                             results = await self.download_batch(
                                 session,
@@ -741,11 +789,49 @@ class ExportVisionAI(ExportAnnotationBase):
                             current_batch = []
                             datarow_id_list = []
 
-                        if len(annotation_results) >= BATCH_SIZE:
                             for annotation_result in annotation_results:
                                 yield annotation_result
                             annotation_results = []
-
+                    if is_sequential:
+                        # process sequence
+                        (
+                            annotation_results,
+                            sequence_frame_datarows,
+                            datarow_id_list,
+                            pre_frame_datarow_id,
+                            current_batch,
+                        ) = await self.process_datarows(
+                            datarow_generator_func,
+                            datarow_id_list,
+                            frame_datarow_id_to_sequence_id,
+                            sequence_frame_datarows,
+                            target_folder,
+                            annotation_name,
+                            datarow_id_to_frame_datarow_id,
+                            current_batch,
+                            pre_frame_datarow_id,
+                            last_batch=False,
+                            is_sequential=is_sequential,
+                        )
+                        # download sequence
+                        results = await self.download_batch(
+                            session,
+                            semaphore,
+                            current_batch,
+                            datarow_id_to_frame_datarow_id,
+                            frame_datarow_id_to_sequence_id,
+                        )
+                        for result in results:
+                            if result:
+                                yield result
+                                progress_bar.update(1)
+                        current_batch = []
+                        datarow_id_list = []
+                        for annotation_result in annotation_results:
+                            yield annotation_result
+                        annotation_results = []
+
+                # update for non-sequential last batch
                 if datarow_id_list:
                     (
                         annotation_results,
@@ -764,6 +850,7 @@ class ExportVisionAI(ExportAnnotationBase):
                         current_batch,
                         pre_frame_datarow_id,
                         last_batch=True,
+                        is_sequential=is_sequential,
                     )
                     results = await self.download_batch(
                         session,

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/export/yolo.py

@@ -16,7 +16,7 @@ from .constant import (
     ExportFormat,
 )
 from .exporter import Exporter
-from .utils import convert_to_bytes
+from .utils import convert_to_bytes, gen_empty_vai
 
 
 @Exporter.register(format=ExportFormat.YOLO)
@@ -152,6 +152,9 @@ def convert_annotation(
             datarow["items"].get("predictions", {}).get(annotation_name, {})
         )
 
+    if not visionai_dict:
+        visionai_dict = gen_empty_vai(datarow=datarow, sequence_folder_url="")
+
     (category_map, image_labels_map, _, _) = VAItoYOLO.convert_single_visionai_to_yolo(
         dest_img_folder="",
         visionai_dict={"visionai": visionai_dict},

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/schemas/api.py

@@ -1,5 +1,5 @@
 import re
-from typing import Optional, Union
+from typing import Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, field_validator
 
@@ -133,3 +133,13 @@ class DatasetAPISchema(BaseModel):
     annotations: Optional[list[str]] = []
     access_key_id: Optional[str] = None
     secret_access_key: Optional[str] = None
+
+
+class CreateCustomModelAPISchema(BaseModel):
+    project_id: int
+    name: str
+    input_classes: list[str]
+    resolution_width: int
+    resolution_height: int
+    model_structure: Literal["yolov9-c", "yolov9-e", "yolov9-s"]
+    weight_url: str

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk/schemas/client.py

@@ -1,5 +1,5 @@
 import re
-from typing import Optional, Union
+from typing import Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic_core.core_schema import ValidationInfo
@@ -543,3 +543,28 @@ class MLModel(BaseModel):
         return DataverseClient.get_convert_record(
             convert_record_id=convert_record_id, client_alias=self.client_alias
         )
+
+    def create_custom_model(
+        self,
+        project: Project,
+        name: str,
+        input_classes: list[str],
+        resolution_width: int,
+        resolution_height: int,
+        model_structure: Literal["yolov9-c", "yolov9-e", "yolov9-s"],
+        weight_url: str,
+        permission: str = "",
+    ):
+        from ..client import DataverseClient
+
+        return DataverseClient.create_custom_model(
+            project=project,
+            name=name,
+            input_classes=input_classes,
+            resolution_width=resolution_width,
+            resolution_height=resolution_height,
+            model_structure=model_structure,
+            weight_url=weight_url,
+            client_alias=self.client_alias,
+            permission=permission,
+        )

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/dataverse_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataverse-sdk
-Version: 2.2.2
+Version: 2.3.1
 Summary: Dataverse SDK For Python
 Home-page: 
 Author: LinkerVision
@@ -55,19 +55,21 @@ Interaction with the Dataverse site starts with an instance of the `DataverseCli
 ```Python
 from dataverse_sdk import *
 from dataverse_sdk.connections import get_connection
+from dataverse_sdk.constants import DataverseHost
+
 client = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="***", service_id="xxxx-xxxx-xx-xxx", alias="default", force = False
 )
 assert client is get_connection("default")
 
 # Should provide different alias if you are trying to connect to different workspaces
 client2 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
+    host=DataverseHost.PRODUCTION.value, email="account-2", password="***", service_id="xxxx-xxxx-xx-xxx", alias="client2", force = False
 )
 assert client2 is get_connection(client2.alias)
 
 client3 = DataverseClient(
-    host=DataverseHost.PRODUCTION, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
+    host=DataverseHost.PRODUCTION.value, email="XXX", password="", service_id="xxxx-xxxx-xx-xxx", access_token="xxx"
 )
 assert client3 is get_connection(client3.alias)
 ```

{dataverse_sdk-2.2.2 → dataverse_sdk-2.3.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 AUTHOR = "LinkerVision"
 PACKAGE_NAME = "dataverse-sdk"
-PACKAGE_VERSION = "2.2.2"
+PACKAGE_VERSION = "2.3.1"
 DESC = "Dataverse SDK For Python"
 with open("README.md", encoding="utf-8") as fh:
     long_description = fh.read()

dataverse_sdk-2.2.2/dataverse_sdk/export/utils.py

@@ -1,26 +0,0 @@
-import json
-from typing import Union
-
-from ..apis.third_party import ThirdPartyAPI
-
-
-def convert_to_bytes(obj: Union[dict, list, str]) -> bytes:
-    if isinstance(obj, (dict, list)):
-        jstr = json.dumps(obj)
-    elif isinstance(obj, str):
-        jstr = obj
-    else:
-        raise TypeError("un-support type")
-    return bytes(jstr, encoding="utf8")
-
-
-async def download_url_file_async(data_url: str) -> bytes | None:
-    # get data from url link
-    try:
-        data: bytes = await ThirdPartyAPI.async_download_file(
-            url=data_url, method="GET"
-        )
-    except Exception:
-        print(f"Retrieving data from url {data_url} error")
-        return None
-    return data