datamint 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

datamint/apihandler/root_api_handler.py

@@ -57,13 +57,13 @@ class RootAPIHandler(BaseAPIHandler):
                                             mimetype: Optional[str] = None,
                                             anonymize: bool = False,
                                             anonymize_retain_codes: Sequence[tuple] = [],
-                                            tags: list[str] = None,
-                                            mung_filename: Sequence[int] | Literal['all'] = None,
+                                            tags: list[str] = [],
+                                            mung_filename: Sequence[int] | Literal['all'] | None = None,
                                             channel: Optional[str] = None,
                                             session=None,
                                             modality: Optional[str] = None,
                                             publish: bool = False,
-                                            metadata_file: Optional[str] = None,
+                                            metadata_file: Optional[str | dict] = None,
                                             ) -> str:
         if _is_io_object(file_path):
             name = file_path.name
@@ -121,21 +121,29 @@ class RootAPIHandler(BaseAPIHandler):
             metadata_content = None
             metadata_dict = None
             if metadata_file is not None:
-                try:
-                    with open(metadata_file, 'r') as metadata_f:
-                        metadata_content = metadata_f.read()
-                        metadata_dict = json.loads(metadata_content)
-                        metadata_dict_lower = {k.lower(): v for k, v in metadata_dict.items() if isinstance(k, str)}
-                        try:
-                            if modality is None:
-                                if 'modality' in metadata_dict_lower:
-                                    modality = metadata_dict_lower['modality']
-                        except Exception as e:
-                            _LOGGER.debug(f"Failed to extract modality from metadata file {metadata_file}: {e}")
-                            _LOGGER.debug(f"Metadata dict: {metadata_dict}")
-                except Exception as e:
-                    _LOGGER.warning(f"Failed to read metadata file {metadata_file}: {e}")
-
+                if isinstance(metadata_file, dict):
+                    # Metadata is already a dictionary
+                    metadata_dict = metadata_file
+                    metadata_content = json.dumps(metadata_dict)
+                    _LOGGER.debug("Using provided metadata dictionary")
+                else:
+                    # Metadata is a file path
+                    try:
+                        with open(metadata_file, 'r') as metadata_f:
+                            metadata_content = metadata_f.read()
+                            metadata_dict = json.loads(metadata_content)
+                    except Exception as e:
+                        _LOGGER.warning(f"Failed to read metadata file {metadata_file}: {e}")
+
+                # Extract modality from metadata if available
+                if metadata_dict is not None:
+                    metadata_dict_lower = {k.lower(): v for k, v in metadata_dict.items() if isinstance(k, str)}
+                    try:
+                        if modality is None:
+                            if 'modality' in metadata_dict_lower:
+                                modality = metadata_dict_lower['modality']
+                    except Exception as e:
+                        _LOGGER.debug(f"Failed to extract modality from metadata: {e}")
 
             form = aiohttp.FormData()
             url = self._get_endpoint_url(RootAPIHandler.ENDPOINT_RESOURCES)
@@ -150,19 +158,18 @@ class RootAPIHandler(BaseAPIHandler):
                 form.add_field('channel', channel)
             if modality is not None:
                 form.add_field('modality', modality)
-            # form.add_field('bypass_inbox', 'true' if publish else 'false') # Does not work!
+            form.add_field('bypass_inbox', 'true' if publish else 'false')
             if tags is not None and len(tags) > 0:
                 # comma separated list of tags
-                tags = ','.join([l.strip() for l in tags])
-                form.add_field('tags', tags)
+                form.add_field('tags', ','.join([l.strip() for l in tags]))
 
             # Add JSON metadata if provided
             if metadata_content is not None:
                 try:
-                    _LOGGER.debug(f"Adding metadata from {metadata_file}")
+                    _LOGGER.debug("Adding metadata to form data")
                     form.add_field('metadata', metadata_content, content_type='application/json')
                 except Exception as e:
-                    _LOGGER.warning(f"Failed to read metadata file {metadata_file}: {e}")
+                    _LOGGER.warning(f"Failed to add metadata to form: {e}")
 
             request_params = {
                 'method': 'POST',
@@ -189,7 +196,6 @@ class RootAPIHandler(BaseAPIHandler):
     async def _upload_resources_async(self,
                                       files_path: Sequence[str | IO],
                                       mimetype: Optional[str] = None,
-                                      batch_id: Optional[str] = None,
                                       anonymize: bool = False,
                                       anonymize_retain_codes: Sequence[tuple] = [],
                                       on_error: Literal['raise', 'skip'] = 'raise',
@@ -200,7 +206,7 @@ class RootAPIHandler(BaseAPIHandler):
                                       publish: bool = False,
                                       segmentation_files: Optional[list[dict]] = None,
                                       transpose_segmentation: bool = False,
-                                      metadata_files: Optional[list[Optional[str]]] = None,
+                                      metadata_files: Optional[list[str | dict | None]] = None,
                                       ) -> list[str]:
         if on_error not in ['raise', 'skip']:
             raise ValueError("on_error must be either 'raise' or 'skip'")
@@ -212,7 +218,7 @@ class RootAPIHandler(BaseAPIHandler):
             metadata_files = _infinite_gen(None)
 
         async with aiohttp.ClientSession() as session:
-            async def __upload_single_resource(file_path, segfiles: dict, metadata_file: Optional[str]):
+            async def __upload_single_resource(file_path, segfiles: dict[str, list | dict], metadata_file: str | dict | None):
                 async with self.semaphore:
                     rid = await self._upload_single_resource_async(
                         file_path=file_path,
@@ -233,8 +239,9 @@ class RootAPIHandler(BaseAPIHandler):
                         if isinstance(names, dict):
                             names = _infinite_gen(names)
                         frame_indices = segfiles.get('frame_index', _infinite_gen(None))
-                        _LOGGER.debug(f"Segmentation files: {fpaths}")
-                        for f, name, frame_index in zip(fpaths, names, frame_indices):
+                        for f, name, frame_index in tqdm(zip(fpaths, names, frame_indices),
+                                                         desc=f"Uploading segmentations for {file_path}",
+                                                         total=len(fpaths)):
                             if f is not None:
                                 await self._upload_segmentations_async(rid,
                                                                        file_path=f,
@@ -257,6 +264,9 @@ class RootAPIHandler(BaseAPIHandler):
                 other_files_path.append(f)
 
         orig_len = len(dicoms_files_path)
+        if orig_len == 0:
+            _LOGGER.debug("No DICOM files found to assemble.")
+            return files_path, False
         dicoms_files_path = dicom_utils.assemble_dicoms(dicoms_files_path, return_as_IO=True)
 
         new_len = len(dicoms_files_path)
@@ -269,15 +279,100 @@ class RootAPIHandler(BaseAPIHandler):
 
         return files_path, assembled
 
+    def upload_resource(self,
+                        file_path: str | IO | pydicom.dataset.Dataset,
+                        mimetype: Optional[str] = None,
+                        anonymize: bool = False,
+                        anonymize_retain_codes: Sequence[tuple] = [],
+                        on_error: Literal['raise', 'skip'] = 'raise',
+                        tags: Optional[Sequence[str]] = None,
+                        mung_filename: Sequence[int] | Literal['all'] | None = None,
+                        channel: Optional[str] = None,
+                        publish: bool = False,
+                        publish_to: Optional[str] = None,
+                        segmentation_files: list[str] | dict | None = None,
+                        transpose_segmentation: bool = False,
+                        modality: Optional[str] = None,
+                        assemble_dicoms: bool = True,
+                        metadata: dict | str | None = None
+                        ) -> str | Exception:
+        """
+        Uploads a single resource (examples: DICOM file, NIfTI file, pydicom object)
+
+        Args:
+            file_path: The path to the resource file or a list of paths to resources files.
+            mimetype: The mimetype of the resources. If None, it will be guessed.
+            anonymize: Whether to anonymize the dicoms or not.
+            anonymize_retain_codes: The tags to retain when anonymizing the dicoms.
+            on_error: Whether to raise an exception when an error occurs or to skip the error.
+            tags: The tags to add to the resources.
+            mung_filename: The parts of the filepath to keep when renaming the resource file.
+                ''all'' keeps all parts.
+            channel: The channel to upload the resources to. An arbitrary name to group the resources.
+            publish: Whether to directly publish the resources or not. They will have the 'published' status.
+            publish_to: The project name or id to publish the resources to.
+                They will have the 'published' status and will be added to the project.
+                If this is set, `publish` parameter is ignored.
+            segmentation_files: The segmentation files to upload. 
+                If it is a dict, it should have two keys: 'files' and 'names'.
+                    - files: A list of paths to the segmentation files. Example: ['seg1.nii.gz', 'seg2.nii.gz'].
+                    - names: Can be a list (same size of `files`) of labels for the segmentation files. Example: ['Brain', 'Lung']. Or a dictionary mapping a pixel value to a label. Example: {'1': 'Brain', '2': 'Lung'}.
+            transpose_segmentation: Whether to transpose the segmentation files or not.
+            modality: The modality of the resources.
+            assemble_dicoms: Whether to assemble the dicom files or not based on the SeriesInstanceUID and InstanceNumber attributes.
+            metadata: JSON metadata to include with each resource.
+                Can be a file path (str) or an already loaded dictionary (dict).
+
+        Raises:
+            ResourceNotFoundError: If `publish_to` is supplied, and the project does not exists.
+
+        Returns:
+            str | Exception: A resource ID or an error.
+
+        Example:
+            .. code-block:: python
+
+                file_path = '/path/to/resource.dcm'
+                segfiles = {'files': ['/path/to/seg_brain.nii.gz', '/path/to/seg_lung.nii.gz'],
+                            'names': ['Brain', 'Lung']}
+                result = api_handler.upload_resource(
+                    file_path=file_path,
+                    mimetype='application/dicom',
+                    anonymize=True,
+                    tags=['example', 'dicom'],
+                    segmentation_files=segfiles,
+                    metadata={'PatientID': '12345'}
+                )
+        """
+
+        result = self.upload_resources(
+            files_path=[file_path],
+            mimetype=mimetype,
+            anonymize=anonymize,
+            anonymize_retain_codes=anonymize_retain_codes,
+            on_error=on_error,
+            tags=tags,
+            mung_filename=mung_filename,
+            channel=channel,
+            publish=publish,
+            publish_to=publish_to,
+            segmentation_files=[segmentation_files] if segmentation_files is not None else None,
+            transpose_segmentation=transpose_segmentation,
+            modality=modality,
+            assemble_dicoms=assemble_dicoms,
+            metadata=metadata
+        )
+
+        return result[0]
+
     def upload_resources(self,
                          files_path: str | IO | Sequence[str | IO] | pydicom.dataset.Dataset,
                          mimetype: Optional[str] = None,
                          anonymize: bool = False,
                          anonymize_retain_codes: Sequence[tuple] = [],
                          on_error: Literal['raise', 'skip'] = 'raise',
-                         labels=None,
                          tags: Optional[Sequence[str]] = None,
-                         mung_filename: Sequence[int] | Literal['all'] = None,
+                         mung_filename: Sequence[int] | Literal['all'] | None = None,
                          channel: Optional[str] = None,
                          publish: bool = False,
                          publish_to: Optional[str] = None,
@@ -285,7 +380,7 @@ class RootAPIHandler(BaseAPIHandler):
                          transpose_segmentation: bool = False,
                          modality: Optional[str] = None,
                          assemble_dicoms: bool = True,
-                         metadata_files: Optional[list[Optional[str]]] = None
+                         metadata: list[str | dict | None] | dict | str | None = None
                          ) -> list[str | Exception] | str | Exception:
         """
         Upload resources.
@@ -296,9 +391,6 @@ class RootAPIHandler(BaseAPIHandler):
             anonymize (bool): Whether to anonymize the dicoms or not.
             anonymize_retain_codes (Sequence[tuple]): The tags to retain when anonymizing the dicoms.
             on_error (Literal['raise', 'skip']): Whether to raise an exception when an error occurs or to skip the error.
-            labels: 
-                .. deprecated:: 0.11.0
-                    Use `tags` instead.
             tags (Optional[Sequence[str]]): The tags to add to the resources.
             mung_filename (Sequence[int] | Literal['all']): The parts of the filepath to keep when renaming the resource file.
                 ''all'' keeps all parts.
@@ -308,24 +400,33 @@ class RootAPIHandler(BaseAPIHandler):
                 They will have the 'published' status and will be added to the project.
                 If this is set, `publish` parameter is ignored.
             segmentation_files (Optional[list[Union[list[str], dict]]]): The segmentation files to upload.
+                If each element is a dict, it should have two keys: 'files' and 'names'.
+                    - files: A list of paths to the segmentation files. Example: ['seg1.nii.gz', 'seg2.nii.gz'].
+                    - names: Can be a list (same size of `files`) of labels for the segmentation files. Example: ['Brain', 'Lung']. 
             transpose_segmentation (bool): Whether to transpose the segmentation files or not.
             modality (Optional[str]): The modality of the resources.
-            assemble_dicoms (bool): Whether to assemble the dicom files or not based on the SOPInstanceUID and InstanceNumber attributes.
-            metadata_files (Optional[list[Optional[str]]]): JSON metadata files to include with each resource.
+            assemble_dicoms (bool): Whether to assemble the dicom files or not based on the SeriesInstanceUID and InstanceNumber attributes.
+            metadatas (Optional[list[str | dict | None]]): JSON metadata to include with each resource.
+                Must have the same length as `files_path`.
+                Can be file paths (str) or already loaded dictionaries (dict).
 
         Raises:
             ResourceNotFoundError: If `publish_to` is supplied, and the project does not exists.
 
         Returns:
-            list[str]: The list of new created dicom_ids.
+            list[str | Exception]: A list of resource IDs or errors.
         """
 
         if on_error not in ['raise', 'skip']:
             raise ValueError("on_error must be either 'raise' or 'skip'")
-        if labels is not None and tags is None:
-            tags = labels
 
-        files_path, is_list = RootAPIHandler.__process_files_parameter(files_path)
+        files_path, is_multiple_resources = RootAPIHandler.__process_files_parameter(files_path)
+        if isinstance(metadata, (str, dict)):
+            _LOGGER.debug("Converting metadatas to a list")
+            metadata = [metadata]
+
+        if metadata is not None and len(metadata) != len(files_path):
+            raise ValueError("The number of metadata files must match the number of resources.")
         if assemble_dicoms:
             files_path, assembled = self._assemble_dicoms(files_path)
             assemble_dicoms = assembled
@@ -333,7 +434,7 @@ class RootAPIHandler(BaseAPIHandler):
         if segmentation_files is not None:
             if assemble_dicoms:
                 raise NotImplementedError("Segmentation files cannot be uploaded when assembling dicoms yet.")
-            if is_list:
+            if is_multiple_resources:
                 if len(segmentation_files) != len(files_path):
                     raise ValueError("The number of segmentation files must match the number of resources.")
             else:
@@ -344,6 +445,15 @@ class RootAPIHandler(BaseAPIHandler):
 
             segmentation_files = [segfiles if (isinstance(segfiles, dict) or segfiles is None) else {'files': segfiles}
                                   for segfiles in segmentation_files]
+            
+            for segfiles in segmentation_files:
+                if 'files' not in segfiles:
+                    raise ValueError("segmentation_files must contain a 'files' key with a list of file paths.")
+                if 'names' in segfiles:
+                    # same length as files
+                    if isinstance(segfiles['names'], (list, tuple)) and len(segfiles['names']) != len(segfiles['files']):
+                        raise ValueError("segmentation_files['names'] must have the same length as segmentation_files['files'].")
+
         loop = asyncio.get_event_loop()
         task = self._upload_resources_async(files_path=files_path,
                                             mimetype=mimetype,
@@ -357,32 +467,32 @@ class RootAPIHandler(BaseAPIHandler):
                                             segmentation_files=segmentation_files,
                                             transpose_segmentation=transpose_segmentation,
                                             modality=modality,
-                                            metadata_files=metadata_files,
+                                            metadata_files=metadata,
                                             )
 
         resource_ids = loop.run_until_complete(task)
         _LOGGER.info(f"Resources uploaded: {resource_ids}")
 
-        if publish_to is not None or publish:
-            _USER_LOGGER.info('Publishing resources')
+        if publish_to is not None:
+            _USER_LOGGER.info('Adding resources to project')
             resource_ids_succ = [rid for rid in resource_ids if not isinstance(rid, Exception)]
             try:
-                self.publish_resources(resource_ids_succ, publish_to)
+                self.add_to_project(resource_ids_succ, publish_to)
             except Exception as e:
-                _LOGGER.error(f"Error publishing resources: {e}")
+                _LOGGER.error(f"Error adding resources to project: {e}")
                 if on_error == 'raise':
                     raise e
 
-        if is_list:
+        if is_multiple_resources:
             return resource_ids
         return resource_ids[0]
 
     def publish_resources(self,
-                          resource_ids: Union[str, Sequence[str]],
+                          resource_ids: str | Sequence[str],
                           project_name: Optional[str] = None,
                           ) -> None:
         """
-        Publish a resource, chaging its status to 'published'.
+        Publish a resource, changing its status to 'published'.
 
         Args:
             resource_ids (str|Sequence[str]): The resource unique id or a list of resource unique ids.
@@ -430,6 +540,39 @@ class RootAPIHandler(BaseAPIHandler):
 
         self._run_request(params)
 
+    def add_to_project(self,
+                       resource_ids: str | Sequence[str],
+                       project_name: str,
+                       ) -> None:
+        """
+        Add resources to a project.
+
+        Args:
+            resource_ids (str|Sequence[str]): The resource unique id or a list of resource unique ids.
+            project_name (str): The project name or id to add the resource to.
+
+        Raises:
+            ResourceNotFoundError: If the resource does not exists or the project does not exists.
+
+        """
+        if isinstance(resource_ids, str):
+            resource_ids = [resource_ids]
+
+        # get the project id by its name
+        project = self.get_project_by_name(project_name)
+        if 'error' in project:
+            raise ResourceNotFoundError('project', {'project_name': project_name})
+
+        dataset_id = project['dataset_id']
+
+        params = {
+            'method': 'POST',
+            'url': f'{self.root_url}/datasets/{dataset_id}/resources',
+            'json': {'resource_ids_to_add': resource_ids, 'all_files_selected': False}
+        }
+
+        self._run_request(params)
+
     def get_project_by_id(self, project_id: str) -> dict:
         """
         Get a project by its id.
@@ -481,31 +624,34 @@ class RootAPIHandler(BaseAPIHandler):
 
     @staticmethod
     def __process_files_parameter(file_path: str | IO | Sequence[str | IO] | pydicom.dataset.Dataset) -> tuple[Sequence[str | IO], bool]:
+        """
+        Process the file_path parameter to ensure it is a list of file paths or IO objects.
+        """
         if isinstance(file_path, pydicom.dataset.Dataset):
             file_path = to_bytesio(file_path, file_path.filename)
 
         if isinstance(file_path, str):
             if os.path.isdir(file_path):
                 is_list = True
-                file_path = [f'{file_path}/{f}' for f in os.listdir(file_path)]
+                new_file_path = [f'{file_path}/{f}' for f in os.listdir(file_path)]
             else:
                 is_list = False
-                file_path = [file_path]
+                new_file_path = [file_path]
         # Check if is an IO object
         elif _is_io_object(file_path):
             is_list = False
-            file_path = [file_path]
+            new_file_path = [file_path]
         elif not hasattr(file_path, '__len__'):
             if hasattr(file_path, '__iter__'):
                 is_list = True
-                file_path = list(file_path)
+                new_file_path = list(file_path)
             else:
                 is_list = False
-                file_path = [file_path]
+                new_file_path = [file_path]
         else:
             is_list = True
-
-        return file_path, is_list
+            new_file_path = file_path
+        return new_file_path, is_list
 
     def get_resources_by_ids(self, ids: str | Sequence[str]) -> dict[str, Any] | Sequence[dict[str, Any]]:
         """
@@ -520,9 +666,6 @@ class RootAPIHandler(BaseAPIHandler):
         Raises:
             ResourceNotFoundError: If the resource does not exists.
 
-        Example:
-            >>> api_handler.get_resources_by_ids('resource_id')
-            >>> api_handler.get_resources_by_ids(['resource_id1', 'resource_id2'])
         """
         input_is_a_string = isinstance(ids, str)  # used later to return a single object or a list of objects
         if input_is_a_string:
@@ -547,7 +690,6 @@ class RootAPIHandler(BaseAPIHandler):
                       status: Optional[ResourceStatus] = None,
                       from_date: Optional[date] = None,
                       to_date: Optional[date] = None,
-                      labels=None,
                       tags: Optional[Sequence[str]] = None,
                       modality: Optional[str] = None,
                       mimetype: Optional[str] = None,
@@ -555,7 +697,6 @@ class RootAPIHandler(BaseAPIHandler):
                       order_field: Optional[ResourceFields] = None,
                       order_ascending: Optional[bool] = None,
                       channel: Optional[str] = None,
-                      project_id: Optional[str] = None,
                       project_name: Optional[str] = None,
                       filename: Optional[str] = None
                       ) -> Generator[dict, None, None]:
@@ -568,9 +709,6 @@ class RootAPIHandler(BaseAPIHandler):
             status (ResourceStatus): The resource status. Possible values: 'inbox', 'published', 'archived' or None. If None, it will return all resources.
             from_date (Optional[date]): The start date.
             to_date (Optional[date]): The end date.
-            labels: 
-                .. deprecated:: 0.11.0
-                    Use `tags` instead.
             tags (Optional[list[str]]): The tags to filter the resources.
             modality (Optional[str]): The modality of the resources.
             mimetype (Optional[str]): The mimetype of the resources.
@@ -585,12 +723,6 @@ class RootAPIHandler(BaseAPIHandler):
             >>> for resource in api_handler.get_resources(status='inbox'):
             >>>     print(resource)
         """
-        if labels is not None and tags is None:
-            tags = labels
-
-        if project_id is not None and project_name is not None:
-            _LOGGER.warning("Both project_id and project_name were provided.")
-
         # Convert datetime objects to ISO format
         if from_date:
             from_date = from_date.isoformat()
@@ -608,7 +740,6 @@ class RootAPIHandler(BaseAPIHandler):
             "order_field": order_field,
             "order_by_asc": order_ascending,
             "channel_name": channel,
-            "projectId": project_id,
             "filename": filename,
         }
         if project_name is not None:
@@ -669,17 +800,15 @@ class RootAPIHandler(BaseAPIHandler):
         yield from self._run_pagination_request(request_params,
                                                 return_field='data')
 
-    def set_resource_tags(self, resource_id: str,
-                          tags: Sequence[str] = None,
-                          frame_labels: Sequence[dict] = None
+    def set_resource_tags(self, 
+                          resource_id: str,
+                          tags: Sequence[str],
                           ):
         url = f"{self._get_endpoint_url(RootAPIHandler.ENDPOINT_RESOURCES)}/{resource_id}/tags"
         data = {}
 
         if tags is not None:
             data['tags'] = tags
-        if frame_labels is not None:
-            data['frame_labels'] = frame_labels
 
         request_params = {'method': 'PUT',
                           'url': url,
@@ -880,8 +1009,6 @@ class RootAPIHandler(BaseAPIHandler):
         Returns:
             list[dict]: A list of dictionaries with the users information.
 
-        Example:
-            >>> api_handler.get_users()
         """
         request_params = {
             'method': 'GET',
@@ -905,6 +1032,7 @@ class RootAPIHandler(BaseAPIHandler):
             password (Optional[str]): The user password.
             firstname (Optional[str]): The user first name.
             lastname (Optional[str]): The user last name.
+            roles (Optional[list[str]]): The user roles. If None, the user will be created with the default role.
 
         Returns:
             dict: The user information.
@@ -932,6 +1060,13 @@ class RootAPIHandler(BaseAPIHandler):
 
         Example:
             >>> api_handler.get_projects()
+            [{'id': '15ab9105-6e92-48c0-bb21-8e1325ec4305',
+            'name': 'Example Project',
+            'description': 'this is an example project',
+            'created_at': '2025-04-23T14:41:03.475Z',
+            'created_by': 'user@mail.com',
+            (...)}
+            ]
         """
         request_params = {
             'method': 'GET',
@@ -939,36 +1074,22 @@ class RootAPIHandler(BaseAPIHandler):
         }
         return self._run_request(request_params).json()['data']
 
-    @deprecated(version='0.12.0', reason="Use :meth:`~get_resources` with project_id parameter instead.")
-    def get_resources_by_project(self, project_id: str) -> Generator[dict, None, None]:
-        """
-        Get the resources by project.
-
-        Args:
-            project_id (str): The project id.
-
-        Returns:
-            list[dict]: The list of resources.
-
-        Example:
-            >>> api_handler.get_resources_by_project('project_id')
-        """
-        request_params = {
-            'method': 'GET',
-            'url': f'{self.root_url}/projects/{project_id}/resources'
-        }
-        return self._run_pagination_request(request_params)
-
     def create_project(self,
                        name: str,
                        description: str,
                        resources_ids: list[str],
-                       is_active_learning: bool = False) -> dict:
+                       is_active_learning: bool = False,
+                       two_up_display: bool = False,
+                       ) -> dict:
         """
         Create a new project.
 
         Args:
             name (str): The name of the project.
+            description (str): The description of the project.
+            resources_ids (list[str]): The list of resource ids to be included in the project.
+            is_active_learning (bool): Whether the project is an active learning project or not.
+            two_up_display (bool): allow annotators to display multiple resources for annotation.
 
         Returns:
             dict: The created project.
@@ -976,6 +1097,7 @@ class RootAPIHandler(BaseAPIHandler):
         Raises:
             DatamintException: If the project could not be created.
         """
+
         request_args = {
             'url': self._get_endpoint_url('projects'),
             'method': 'POST',
@@ -989,7 +1111,7 @@ class RootAPIHandler(BaseAPIHandler):
                          "frame_labels": [],
                          "image_labels": [],
                      },
-                     "two_up_display": False,
+                     "two_up_display": two_up_display,
                      "require_review": False,
                      'description': description}
         }
@@ -1012,7 +1134,8 @@ class RootAPIHandler(BaseAPIHandler):
                           'url': url
                           }
         try:
-            print(self._run_request(request_params))
+            resp = self._run_request(request_params)
+            _LOGGER.debug(resp)
         except ResourceNotFoundError as e:
             e.set_params('project', {'project_id': project_id})
             raise e
@@ -1028,6 +1151,9 @@ class RootAPIHandler(BaseAPIHandler):
         Args:
             project_id (str): The project id.
             outpath (str): The path to save the project zip file.
+            all_annotations (bool): Whether to include all annotations in the downloaded dataset, 
+                even those not made by the provided project.
+            include_unannotated (bool): Whether to include unannotated resources in the downloaded dataset.
 
         Example:
             >>> api_handler.download_project('project_id', 'path/to/project.zip')