das-cli 1.0.15__py3-none-any.whl → 1.2.0__py3-none-any.whl

das/cli.py

@@ -551,6 +551,41 @@ def create_entry(das_ctx, attribute, file_path=None, data=None):
     except Exception as e:
         click.secho(f"Error: {e}", fg="red")
 
+@entry.command("upload-digital-object")
+@click.option('--entry-code', required=True, help='Entry code to attach the digital object to')
+@click.option('--type', 'digital_object_type', required=True, help='Digital object type name (e.g., Dataset, File, Image)')
+@click.option('--description', 'file_description', default='', help='Description for the uploaded file')
+@click.argument('file_path', required=True)
+@pass_das_context
+def upload_digital_object(das_ctx, entry_code, digital_object_type, file_description, file_path):
+    """Upload a file as a digital object and link it to an entry.
+
+    Examples:
+
+    \b
+    # Upload a dataset file and link to an entry
+    das entry upload-digital-object --entry-code ENT001 --type Dataset --description "CTD raw" c:\\data\\ctd.zip
+    """
+    try:
+        # Ensure services are initialized
+        das_ctx.get_client()
+
+        # Perform upload and link
+        digital_object_id = das_ctx.digital_objects_manager.upload_digital_object(
+            entry_code=entry_code,
+            file_description=file_description,
+            digital_object_type=digital_object_type,
+            file_path=file_path,
+        )
+
+        if digital_object_id:
+            click.secho("✓ Digital object uploaded and linked successfully!", fg="green")
+            click.echo(f"Digital Object ID: {digital_object_id}")
+        else:
+            click.secho("Upload completed but no ID was returned.", fg="yellow")
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red")
+
 @entry.command("get")
 @click.option('--code', default=None, help='Entry code')
 @click.option('--id', type=int, default=None, help='Entry ID')
@@ -957,6 +992,38 @@ def create_download_request(das_ctx, name, entry, file, from_file, output_format
     except Exception as e:
         click.secho(f"Error: {e}", fg="red")
 
+@download.command("files")
+@click.argument('request_id', required=True)
+@click.option('--out', 'output_path', required=False, default='.', help='Output file path or directory (defaults to current directory)')
+@click.option('--force', is_flag=True, help='Overwrite existing file if present')
+@pass_das_context
+def download_files(das_ctx, request_id, output_path, force):
+    """
+    Download the completed bundle for a download request and save it to disk.
+
+    Examples:
+
+    \b
+    # Save into current directory with server-provided filename
+    das download files 6b0e68e6-00cd-43a7-9c51-d56c9c091123
+
+    \b
+    # Save to a specific folder
+    das download files 6b0e68e6-00cd-43a7-9c51-d56c9c091123 --out C:\\Downloads
+
+    \b
+    # Save to an explicit filename, overwriting if exists
+    das download files 6b0e68e6-00cd-43a7-9c51-d56c9c091123 --out C:\\Downloads\\bundle.zip --force
+    """
+    try:
+        das_ctx.get_client()
+        saved_path = das_ctx.download_manager.save_download(request_id=request_id, output_path=output_path, overwrite=force)
+        click.secho(f"✓ Download saved to: {saved_path}", fg="green")
+    except FileExistsError as e:
+        click.secho(str(e), fg="yellow")
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red")
+
 @download.command("delete-request")
 @click.argument('request_id', required=True)
 @pass_das_context

das/common/api.py

@@ -27,6 +27,26 @@ def get_data(url, headers=None, params=None):
         print(f"Error fetching API data: {e}")
         return {"error": str(e)}
 
+def get_binary_response(url, headers=None, params=None, stream=True):
+    """
+    Perform a GET request expected to return binary content.
+
+    Returns the raw requests.Response so callers can inspect headers
+    and stream content to disk.
+    """
+    try:
+        response = requests.get(
+            url,
+            headers=headers,
+            params=params,
+            verify=load_verify_ssl(),
+            stream=stream,
+        )
+        response.raise_for_status()
+        return response
+    except requests.RequestException as e:
+        return {"error": str(e)}
+
 def post_data(url, headers=None, data=None):
     """
     Send data to a REST API endpoint.

das/managers/digital_objects_manager.py

@@ -1,16 +1,24 @@
+import os
+import sys
 from das.common.config import load_api_url
+from das.services.search import SearchService
 from das.services.entries import EntriesService
 from das.services.digital_objects import DigitalObjectsService
 
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
 class DigitalObjectsManager:
+    """Manager for digital objects."""
+    
     def __init__(self):
         base_url = load_api_url()
         if base_url is None or base_url == "":
             raise ValueError(f"Base URL is required - {self.__class__.__name__}")
 
+        self.__attribute_id_digital_object_type = 5;
         self.digital_objects_service = DigitalObjectsService(base_url)
         self.entry_service = EntriesService(base_url)
+        self.search_service = SearchService(base_url)
 
     def link_existing_digital_objects(
         self, entry_code: str, digital_object_code_list: list[str], is_unlink: bool = False
@@ -43,4 +51,34 @@ class DigitalObjectsManager:
 
         return result
 
+    def upload_digital_object(self, entry_code: str, file_description: str, digital_object_type: str, file_path: str):
+        """Upload a digital object to the digital object service."""
+        response = self.search_service.search_entries(
+            queryString=f"displayname({digital_object_type})",
+            attributeId=self.__attribute_id_digital_object_type,
+            maxResultCount=1,
+            skipCount=0
+            )
 
+        entry_response = self.entry_service.get_entry(entry_code)
+        if entry_response is None:
+            raise ValueError(f"Entry with code '{entry_code}' not found")
+
+        if response.get('totalCount', 0) == 0:
+            raise ValueError(f"Digital object type '{digital_object_type}' not found")
+        
+        digital_object_type_id = response.get('items', [])[0].get('entry').get('id')
+        digital_object_id = self.digital_objects_service.upload_digital_object(file_description, digital_object_type_id, file_path)
+        
+        self.digital_objects_service.link_existing_digital_objects(
+            attribute_id=entry_response.get('attributeId'), 
+            entry_id=entry_response.get('entry').get('id'), 
+            digital_object_id_list=[digital_object_id]
+        )
+
+        return digital_object_id
+
+
+if __name__ == "__main__":
+    digital_objects_manager = DigitalObjectsManager()
+    digital_objects_manager.upload_digital_object(entry_code="zb.b.f7", file_description="test", digital_object_type="Dataset", file_path="my_new_file.txt")

das/managers/download_manager.py

@@ -90,4 +90,46 @@ class DownloadManager:
 
     def get_my_requests(self):
         """Get all download requests for the current user."""
-        return self.download_request_service.get_my_requests()
+        return self.download_request_service.get_my_requests()
+
+    def download_files(self, request_id: str):
+        """Return streaming response for files of a download request."""
+        return self.download_request_service.download_files(request_id)
+
+    def save_download(self, request_id: str, output_path: str, overwrite: bool = False) -> str:
+        """
+        Download and save the request bundle to disk.
+
+        Returns the path to the saved file.
+        """
+        import os
+
+        resp = self.download_files(request_id)
+        # If an error structure was returned from lower layer
+        if isinstance(resp, dict) and resp.get('error'):
+            raise ValueError(resp['error'])
+
+        # Determine filename from headers if available
+        filename = f"download_{request_id}.zip"
+        try:
+            cd = resp.headers.get('Content-Disposition') if hasattr(resp, 'headers') else None
+            if cd and 'filename=' in cd:
+                filename = cd.split('filename=')[-1].strip('"')
+        except Exception:
+            pass
+
+        # If output_path is a directory, join with filename
+        target_path = output_path
+        if os.path.isdir(output_path) or output_path.endswith(os.path.sep):
+            target_path = os.path.join(output_path, filename)
+
+        if os.path.exists(target_path) and not overwrite:
+            raise FileExistsError(f"File already exists: {target_path}. Use overwrite to replace.")
+
+        # Stream to disk
+        with open(target_path, 'wb') as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        return target_path

das/managers/search_manager.py

@@ -3,7 +3,6 @@ from das.services.attributes import AttributesService
 from das.services.entry_fields import EntryFieldsService
 from das.services.search import SearchService
 
-
 class SearchManager:
     def __init__(self):        
         base_url = load_api_url()

das/services/digital_objects.py

@@ -1,10 +1,22 @@
+import os
+import sys
+from math import ceil
+from os.path import exists
+import json
+from base64 import b64encode
 from das.common.api import post_data
-from das.common.config import load_token
-
+from das.common.config import load_token, load_verify_ssl
+from pathlib import Path
+import math
+import uuid
+import requests
 
+CHUNK_SIZE = 1000000 # 1MB
 class DigitalObjectsService:
     def __init__(self, base_url):
         self.base_url = f"{base_url}/api/services/app/DigitalObject"
+        # Common possible upload endpoints observed across deployments
+        self.upload_digital_object_url = f"{base_url}/File/UploadDigitalObject"
 
     def link_existing_digital_objects(self, attribute_id: int, entry_id: str, digital_object_id_list: list[str], is_unlink: bool = False):
         """Link existing digital objects to an entry."""
@@ -39,6 +51,92 @@ class DigitalObjectsService:
         )
 
         return response.get("success")
+
+    # This is our chunk reader. This is what gets the next chunk of data ready to send.
+    def __read_in_chunks(self, file_object, chunk_size):
+        while True:
+            data = file_object.read(chunk_size)
+            if not data:
+                break
+            yield data
+
+
+    def upload_digital_object(self,  file_description: str, digital_object_type_id: str, file_path: str):
+
+        if not exists(file_path):
+            raise ValueError(f"File '{file_path}' does not exist")
+
+        head, tail = os.path.split(file_path)
+
+        metadata = {
+            "fileName": tail,
+            "fileSize": os.path.getsize(file_path),
+            "description": file_description,
+            "digitalObjectTypeId": digital_object_type_id,
+            "id": str(uuid.uuid4()).lower(),
+            "description": file_description,
+            "totalCount": ceil(os.path.getsize(file_path) / CHUNK_SIZE),
+            "index": 0,
+        }
+
+        binary_file = open(file_path, "rb")
+        index = 0
+        offset = 0
+        digital_object_id = None        
+        headers = {}
+
+        try:
+            for chunk in self.__read_in_chunks(binary_file, CHUNK_SIZE):
+                offset = index + len(chunk)
+                headers['Content-Range'] = 'bytes %s-%s/%s' % (index, offset - 1, metadata.get('fileSize'))
+                index = offset   
+                json_metadata = json.dumps(metadata)
+                base654_bytes = b64encode(json_metadata.encode('utf-8')).decode('ascii')
+                headers['metadata'] = base654_bytes               
+
+                r = self.upload_file(chunk, metadata, headers)
+
+                if r.get('result', None) is None:                    
+                    continue
+
+                digital_object_id = r.get('result').get('id')
+                metadata['index'] = index + 1
+                
+            binary_file.close()               
+
+        except Exception as e:
+            raise ValueError(f"Error uploading file '{file_path}': {str(e)}")
+        finally:
+            binary_file.close()
+
+            return digital_object_id
+
+        
+
+    def upload_file(self, file, body, headers):
+        """Upload a file to the digital object service."""
+        token = load_token()
+        headers.update({
+            "Accept": "application/json",
+            "Authorization": f"Bearer {token}",
+            # Do NOT set Content-Type here when sending files; requests will set proper multipart boundary
+        })
+
+        files = {
+            "file": ("chunk", file, "application/octet-stream"),
+        }
+
+        try:
+            response = requests.post(self.upload_digital_object_url, headers=headers, files=files, verify=load_verify_ssl())
+            response.raise_for_status()
+            if response.status_code == 200:
+                return response.json()
+            else:
+                raise ValueError(f"Error uploading file: {response.status_code} - {response.text}")
+        except requests.RequestException as e:
+            raise ValueError(f"Error uploading file: {str(e)}")
+
+
     
 
 

das/services/downloads.py

@@ -1,10 +1,11 @@
-from das.common.api import post_data, get_data
+from das.common.api import post_data, get_data, get_binary_response
 from das.common.config import load_token
 
 
 class DownloadRequestService:
     def __init__(self, base_url):
         self.base_url = f"{base_url}/api/services/app/DownloadRequest"
+        self.download_files_url = f"{base_url}/File/DownloadRequestSet"
 
     def create(self, request_data: list[dict]):
         """Create a new download request."""
@@ -81,4 +82,20 @@ class DownloadRequestService:
         error_msg = None
         if isinstance(response, dict):
             error_msg = response.get('error') or response.get('message')
-        raise ValueError(error_msg or 'Failed to fetch download requests')
+        raise ValueError(error_msg or 'Failed to fetch download requests')
+
+    def download_files(self, request_id: str):
+        """Return a streaming HTTP response for the download bundle of a request."""
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+            
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+
+        url = f"{self.download_files_url}?requestId={request_id}"
+
+        response = get_binary_response(url, headers=headers, params=None, stream=True)
+        return response

{das_cli-1.0.15.dist-info → das_cli-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: das-cli
-Version: 1.0.15
+Version: 1.2.0
 Summary: DAS api client.
 Author: Royal Netherlands Institute for Sea Research
 License-Expression: MIT
@@ -166,6 +166,13 @@ das entry update --attribute <AttributeName> [--code CODE] <file_path>
 #   das entry update --attribute core --data [{ 'Code': 'ENT001' }, { 'Code': 'ENT002' }]
 ```
 
+#### Upload and link a digital object
+
+```bash
+# Upload a file as a digital object and link it to an entry
+das entry upload-digital-object --entry-code ENT001 --type Dataset --description "CTD raw" c:\data\ctd.zip
+```
+
 #### Link or unlink digital objects
 
 ```bash

{das_cli-1.0.15.dist-info → das_cli-1.2.0.dist-info}/RECORD

@@ -1,32 +1,32 @@
 das/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 das/app.py,sha256=kKxN4Vn84SA5Ph3zY13avMG2vrUp-ffpdDkhwYR9Bho,1475
-das/cli.py,sha256=3BujNatTZXqXGoDNleG8ru4GT_KkUDRQujesAyGRP0w,46971
+das/cli.py,sha256=f09aWaCW26vU3lBJjdidg6YtevxylWgHR8blu6CBd_k,49834
 das/ai/plugins/dasai.py,sha256=R0X0Vey_GOAtWoqcloB-NATZFtXB_l5b9dfPXocNIbI,2165
 das/ai/plugins/entries/entries_plugin.py,sha256=Dhv6PrguQj5mzxBW6DlCzkmwucszazLQfzwlp9EhIGk,608
 das/authentication/auth.py,sha256=DTtH66Ft6nuuMe7EYvrr3GqGVEGGxE7GmD2fO7vRv4s,1501
 das/authentication/secure_input.py,sha256=P-NpbFeHrp2uIOMqip55cGn_NqqpswhnknAF1t7c2_U,1911
-das/common/api.py,sha256=9kuM8Gcw29uiYbqw9fPK4w5gTpWv9baxjK9NvHNeb5E,3905
+das/common/api.py,sha256=GNY1nF5B8JgFDAGifC2jR2ZTtKt4GLd7W20ARky4wcY,4501
 das/common/config.py,sha256=VQi_tJ7hvIa--gvx9VCBkfVI9p0ptOvifIu08tc8kEs,6127
 das/common/entry_fields_constants.py,sha256=5Yh4Ujt70HEF-FsnwVBPBm3DB3HHzQWSWR-9Upt7C5I,93
 das/common/enums.py,sha256=jS0frv6717duG_wZNockXMTZ-VfsGu_f8_-lgYGnrcY,1745
 das/common/file_utils.py,sha256=-zePjYsj8iRpQssVQMHDK3Mh5q8FooKJCUCKCXKS6_Y,7006
 das/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-das/managers/digital_objects_manager.py,sha256=i6wDx589dEQ58X_pZGON808GkWinymV3PZAZ4TVx1P0,1825
-das/managers/download_manager.py,sha256=NqaLhmjw-4nZq8SVdN0g5MAnbMPEnu-A3A4oXxQ-IZQ,3776
+das/managers/digital_objects_manager.py,sha256=v7VAYfKoDpmWJGVgpVoSyk6hqGMiQJeOX5rgm65xE5U,3677
+das/managers/download_manager.py,sha256=bZuRX5yoKC_n00Tbjn_aRHgHLeq6SjI0TqDqgjttOQU,5431
 das/managers/entries_manager.py,sha256=Kc_PN71Bp7VICrxoP9MiDCrUzR7OdUXfX5puDDxtm08,19015
-das/managers/search_manager.py,sha256=kad6-3H-LsYlUVPE7yKEaCuKLpN2w2-eE3Baskg-R-0,4265
+das/managers/search_manager.py,sha256=vXf0JmK5oW-xEGUdDnppfc1-6HdH1hfiZR7L2bCz9u0,4263
 das/services/attributes.py,sha256=78E9f1wNZYxG9Hg5HfX_h1CFmACaMjwD2Y6Ilb7PJGY,2616
 das/services/cache.py,sha256=g-vY51gqGV_1Vpza476PkMqGpuDNo1NbTwQWIIsvO0s,1932
-das/services/digital_objects.py,sha256=_1X1PqQ2X0_0--tO4YRuNXQEiZIyKSPEYSwROliTc8o,1394
-das/services/downloads.py,sha256=YBDFPmjAQHUK0OUdFprW1Ox81nzpKaJE9xQBJyyEz4Q,3060
+das/services/digital_objects.py,sha256=ww1KHVLNmm_ffzgqP4Jt4wCbHMVfhD2FJWahlSPFaes,4935
+das/services/downloads.py,sha256=cn2eoiKEDRcINlzoLgw6mpN3VVLBBiccdFyuCO7TB2I,3709
 das/services/entries.py,sha256=Uspl7LZcNWEnr7ct5_Kn31jMjrkSKV7UXzrN6nb3HF0,4966
 das/services/entry_fields.py,sha256=x2wUDkKNduj9pf4s56hRo0UW-eBhipkU9gFMEjFw5DA,1290
 das/services/hangfire.py,sha256=hidmVP9yb4znzBaJJRyKawYx7oYaBv5OVL-t0BhvN_A,818
 das/services/search.py,sha256=3X_KPb9fs024FhxoTr4j-xY5ymm5rvvzlekxuh8tLdg,1374
 das/services/users.py,sha256=iNijO2UPIEtcpPy8Tkemdxxym9rYLCUyckQHIQj68W0,795
-das_cli-1.0.15.dist-info/licenses/LICENSE,sha256=4EDhysVgQWBlzo0rdUl_k89s-iVfgCcSa1gUx1TM1vA,1124
-das_cli-1.0.15.dist-info/METADATA,sha256=2blsy-4LbMkhGV7T9iipiPDSIk6eSBfQxCrBe_qJkZM,11150
-das_cli-1.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-das_cli-1.0.15.dist-info/entry_points.txt,sha256=ZrdMae7NcvogQhzM1zun8E8n_QwYq-LpZvoJCr2_I4g,36
-das_cli-1.0.15.dist-info/top_level.txt,sha256=OJsPEeJyJ2rJlpEn2DTPgbMSvYG-6FeD13_m5qLpw3E,4
-das_cli-1.0.15.dist-info/RECORD,,
+das_cli-1.2.0.dist-info/licenses/LICENSE,sha256=4EDhysVgQWBlzo0rdUl_k89s-iVfgCcSa1gUx1TM1vA,1124
+das_cli-1.2.0.dist-info/METADATA,sha256=mxD9Zy0gUaaqTq4bMkIbqHt594Fs4S3Oi-zVxaLXDIc,11375
+das_cli-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+das_cli-1.2.0.dist-info/entry_points.txt,sha256=ZrdMae7NcvogQhzM1zun8E8n_QwYq-LpZvoJCr2_I4g,36
+das_cli-1.2.0.dist-info/top_level.txt,sha256=OJsPEeJyJ2rJlpEn2DTPgbMSvYG-6FeD13_m5qLpw3E,4
+das_cli-1.2.0.dist-info/RECORD,,