pma-python 2.0.0.184__tar.gz → 2.0.0.186__tar.gz

{pma_python-2.0.0.184 → pma_python-2.0.0.186}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pma_python
-Version: 2.0.0.184
+Version: 2.0.0.186
 Summary: Universal viewing of digital microscopy, whole slide imaging and digital pathology data
 Home-page: https://github.com/pathomation/pma_python
 Author: Pathomation

{pma_python-2.0.0.184 → pma_python-2.0.0.186}/pma_python/core.py

@@ -14,6 +14,7 @@ import os
 import datetime
 import io
 import re
+import traceback
 import pandas as pd
 import requests
 from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor
@@ -1901,29 +1902,303 @@ def get_annotation_distance(slideRef, layerID, annotationID, sessionID=None, ver
 # **************************************#
 #           === Uploader ===            #
 # **************************************#
-FOUR_GB = 4 * 1024 * 1024 * 1024
-FIVE_GB = 5 * 1024 * 1024 * 1024
+def _normalize_upload_directory(upload_directory: str) -> str:
+    if upload_directory is None:
+        raise ValueError("target_folder cannot be empty")
+    normalized = upload_directory.strip()
+    if normalized == "/":
+        return ""
+    normalized = normalized.lstrip("/")
+    return normalized.rstrip("/")
+
+
+def _join_virtual_path(parent: str, child: str) -> str:
+    parent = (parent or "").strip("/")
+    child = (child or "").lstrip("/")
+    return f"{parent}/{child}" if parent else child
+
+
+def _normalize_upload_type(upload_type):
+    if isinstance(upload_type, str):
+        return upload_type.strip().lower()
+    return upload_type
+
+
+def _is_upload_type(upload_type, *candidates) -> bool:
+    normalized = _normalize_upload_type(upload_type)
+    for candidate in candidates:
+        if isinstance(candidate, str):
+            if normalized == candidate.lower():
+                return True
+        elif normalized == candidate:
+            return True
+    return False
+
+
+def _companion_folders(slide_path: str) -> list[str]:
+    """
+    Folders that hold the image data of a multi-file slide, by vendor naming convention:
+    - "<name>/"   e.g. 3DHistech MRXS
+    - "_<name>_/" e.g. Olympus/Evident VSI
+    """
+    directory = os.path.dirname(slide_path)
+    stem = os.path.splitext(os.path.basename(slide_path))[0]
+    return [os.path.join(directory, stem), os.path.join(directory, f"_{stem}_")]
+
+
+def _pma_start_files_for_slide(slide_path: str) -> list[str]:
+    """
+    Ask PMA.start which local files belong to this slide (it knows every multi-file format).
+    Best effort: returns [] when PMA.start is not running or cannot answer.
+    """
+    try:
+        return list(get_files_for_slide(slide_path, _pma_pmacoreliteSessionID) or [])
+    except Exception:
+        if pma._pma_debug == True:
+            print("PMA.start could not enumerate the files for", slide_path)
+        return []
+
+
+def _collect_slide_package_files(slide_path: str):
+    """
+    All local files that make up a slide: the main file first, then its image data files.
+    Files are found both by vendor folder conventions (see _companion_folders) and by asking
+    PMA.start, so a multi-file slide is never uploaded without its image data.
+    Relative paths are relative to the folder that contains the main file.
+    """
+    if not os.path.isfile(slide_path):
+        raise ValueError(f"File not found: {slide_path}")
+
+    slide_path = os.path.abspath(slide_path)
+    base_dir = os.path.dirname(slide_path)
+    main_name = os.path.basename(slide_path)
+
+    def key(path):
+        return os.path.normcase(os.path.abspath(path))
+
+    extra = {}
+
+    def add(path):
+        path = os.path.abspath(path)
+        if key(path) == key(slide_path) or not os.path.isfile(path):
+            return
+        rel = os.path.relpath(path, base_dir)
+        if rel.startswith(os.pardir) or os.path.isabs(rel):
+            # never upload files from outside the slide's own folder
+            return
+        extra.setdefault(key(path), (path, rel.replace("\\", "/")))
+
+    for folder in _companion_folders(slide_path):
+        if os.path.isdir(folder):
+            for root, dirnames, filenames in os.walk(folder):
+                dirnames.sort()
+                for filename in sorted(filenames):
+                    add(os.path.join(root, filename))
+
+    for path in _pma_start_files_for_slide(slide_path):
+        add(path)
+
+    package_files = [{
+        "local_path": slide_path,
+        "relative_path": main_name,
+        "is_main": True,
+        "size": os.stat(slide_path).st_size
+    }]
+    for path, rel in sorted(extra.values(), key=lambda item: item[1].lower()):
+        package_files.append({
+            "local_path": path,
+            "relative_path": rel,
+            "is_main": False,
+            "size": os.stat(path).st_size
+        })
+
+    return package_files
+
+
+def _build_upload_urls(server_url: str, session_id: str, upload_id: int, package_files) -> list[str]:
+    base = server_url if server_url.endswith("/") else server_url + "/"
+    encoded_session = pma._pma_q(session_id)
+    urls = []
+    for file in package_files:
+        encoded_path = pma._pma_q(file["relative_path"])
+        urls.append(f"{base}transfer/Upload/{upload_id}?sessionId={encoded_session}&path={encoded_path}")
+    return urls
+
 
 def _get_slide_package_size(slide_path: str) -> tuple[int, int]:
     """Return total bytes and maximum single-file bytes for a slide package."""
-    total_size = 0
-    max_size = 0
+    files = _collect_slide_package_files(slide_path)
+    total_size = sum(file["size"] for file in files)
+    max_size = max(file["size"] for file in files) if files else 0
+    return total_size, max_size
 
-    files = [slide_path]
-    slide_name_no_ext = os.path.splitext(os.path.basename(slide_path))[0]
-    slide_dir = os.path.join(os.path.dirname(slide_path), slide_name_no_ext)
 
-    if os.path.isdir(slide_dir):
-        for root, _, filenames in os.walk(slide_dir):
-            for filename in filenames:
-                files.append(os.path.join(root, filename))
+async def _poll_image_info(
+        slide_ref: str,
+        session_id: str,
+        verify=True,
+        max_attempts: int = 5,
+        interval_seconds: float = 1.0,
+) -> bool:
+    for attempt in range(max_attempts):
+        try:
+            await asyncio.to_thread(
+                get_slide_info,
+                slide_ref,
+                sessionID=session_id,
+                verify=verify
+            )
+            return True
+        except Exception:
+            if attempt >= max_attempts - 1:
+                return False
+            await asyncio.sleep((attempt + 1) * interval_seconds)
 
-    for filepath in files:
-        size = os.stat(filepath).st_size
-        total_size += size
-        max_size = max(max_size, size)
+    return False
+
+
+async def _upload_package_files(
+        *,
+        client: PmaCoreClient,
+        session_id: str,
+        upload_directory: str,
+        package_files,
+        progress_callback=None,
+        verify=True,
+) -> tuple[bool, str | None]:
+    try:
+        header = UploadHeaderModel(
+            path=upload_directory,
+            files=[
+                UploadFileModel(
+                    isMain=file["is_main"],
+                    length=file["size"],
+                    path=file["relative_path"]
+                )
+                for file in package_files
+            ]
+        )
+
+        resp = await client.upload_header(header, session_id)
+
+        is_azure = _is_upload_type(resp.upload_type, 2, "azure")
+        is_amazon = _is_upload_type(resp.upload_type, 1, "amazons3")
+
+        def _normalize_relative_path(path: str) -> str:
+            return (path or "").replace("\\", "/").lstrip("/")
+
+        multipart_by_path = {
+            _normalize_relative_path(mf.file_path): mf
+            for mf in (resp.multipart_files or [])
+        }
+
+        # Keep aggregate progress in bytes across all files (same semantics as the rest of this SDK).
+        total_bytes = sum(file["size"] for file in package_files)
+        uploaded_size = [0] * len(package_files)
+
+        def update_progress(index: int, loaded: int):
+            capped = min(max(loaded, 0), package_files[index]["size"])
+            uploaded_size[index] = capped
+            if callable(progress_callback) and total_bytes > 0:
+                progress_callback(sum(uploaded_size), total_bytes)
+
+        if callable(progress_callback):
+            progress_callback(0, total_bytes)
+
+        has_direct_urls = bool(resp.urls)
+        direct_urls = list(resp.urls or [])
+        fallback_urls = _build_upload_urls(client.server_url, session_id, resp.id, package_files)
+
+        for index, file in enumerate(package_files):
+            direct_url = direct_urls[index] if index < len(direct_urls) else None
+            relative_path = _normalize_relative_path(file["relative_path"])
+            multipart_file = multipart_by_path.get(relative_path)
+
+            def per_file_progress(sent: int, _total: int, idx=index):
+                update_progress(idx, sent)
+
+            with open(file["local_path"], "rb") as stream:
+                if is_amazon and multipart_file is not None:
+                    remote_file_path = _join_virtual_path(upload_directory, multipart_file.file_path)
+                    await client.upload_multipart_file_to_s3(
+                        multipart_file,
+                        remote_file_path,
+                        stream,
+                        session_id,
+                        progress_callback=per_file_progress
+                    )
+                elif is_azure:
+                    if not direct_url:
+                        return False, f"No upload URL provided for file {file['relative_path']}"
+                    await client.upload_file(
+                        resp.id,
+                        resp.upload_type,
+                        direct_url,
+                        file["relative_path"],
+                        stream,
+                        session_id,
+                        total_bytes=file["size"],
+                        progress_callback=per_file_progress,
+                        method="PUT",
+                        verify=verify
+                    )
+                else:
+                    upload_url = direct_url or (fallback_urls[index] if index < len(fallback_urls) else None)
+                    method = "PUT" if bool(direct_url) else "POST"
+                    if not upload_url:
+                        return False, f"No upload URL provided for file {file['relative_path']}"
+                    await client.upload_file(
+                        resp.id,
+                        resp.upload_type,
+                        upload_url,
+                        file["relative_path"],
+                        stream,
+                        session_id,
+                        total_bytes=file["size"],
+                        progress_callback=per_file_progress,
+                        method=method,
+                        verify=verify
+                    )
+
+            update_progress(index, file["size"])
+
+        finalize_url = f"{client.server_url}transfer/Upload/{resp.id}"
+        finalize_response = await asyncio.to_thread(
+            requests.get,
+            finalize_url,
+            params={"sessionId": session_id},
+            verify=verify
+        )
+
+        if finalize_response.status_code < 200 or finalize_response.status_code >= 300:
+            try:
+                payload = finalize_response.json()
+                error_message = payload.get("Message") or payload.get("ExceptionMessage")
+            except Exception:
+                error_message = finalize_response.text
+            return False, f"Upload finalize failed: {error_message}"
+
+        main_slide_path = _join_virtual_path(upload_directory, package_files[0]["relative_path"])
+        image_ready = await _poll_image_info(
+            main_slide_path,
+            session_id,
+            verify=verify,
+            max_attempts=5,
+            interval_seconds=1.0
+        )
+
+        if not image_ready:
+            return False, "Slide upload completed, but unable to fetch image information."
+
+        if callable(progress_callback):
+            progress_callback(total_bytes, total_bytes)
+
+        return True, None
+    except Exception as e:
+        if os.getenv("PMA_UPLOAD_DEBUG_TRACE", "").lower() in ("1", "true", "yes"):
+            return False, f"{e}\n{traceback.format_exc()}"
+        return False, str(e)
 
-    return total_size, max_size
 
 async def upload(
         *,
@@ -1939,7 +2214,7 @@ async def upload(
     Automatically:
     - calculates full slide size (file + folder + nested files)
     - detects server upload type
-    - routes upload to legacy transfer or large file uploader
+    - routes according to server upload strategy
     """
 
     if not os.path.isfile(slide_path):
@@ -1959,18 +2234,18 @@ async def upload(
 
     try:
         client = PmaCoreClient(pma_core_url)
+        package_files = _collect_slide_package_files(slide_path)
 
-        file_size = os.stat(slide_path).st_size
-        file_name = os.path.basename(slide_path)
-
+        normalized_upload_directory = _normalize_upload_directory(upload_directory)
         header = UploadHeaderModel(
-            path=upload_directory,
+            path=normalized_upload_directory,
             files=[
                 UploadFileModel(
-                    isMain=True,
-                    length=file_size,
-                    path=file_name
+                    isMain=file["is_main"],
+                    length=file["size"],
+                    path=file["relative_path"]
                 )
+                for file in package_files
             ]
         )
 
@@ -1983,7 +2258,7 @@ async def upload(
         # ================================
 
         # UploadType 0 → always small uploader
-        if resp.upload_type == 0:
+        if _is_upload_type(resp.upload_type, 0, "filesystem"):
             print("UploadType 0 → forcing SMALL uploader")
 
             return upload_legacy(
@@ -1993,33 +2268,21 @@ async def upload(
                 progress_callback=progress_callback
             )
 
-        # Otherwise choose based on total package size or safe single-request cap
-        if total_size < FOUR_GB and max_file_size < FIVE_GB:
-            print("Using SMALL file uploader")
-
-            return upload_legacy(
-                session_id=session_id,
-                slide_path=slide_path,
-                upload_directory=upload_directory,
-                progress_callback=progress_callback
-            )
-
-        else:
-            print("Using LARGE file uploader")
-
-            return await upload_file_over_5gb(
-                pma_core_url=pma_core_url,
-                session_id=session_id,
-                slide_path=slide_path,
-                upload_directory=upload_directory,
-                progress_callback=progress_callback
-            )
+        # For cloud uploads, follow server strategy (S3 multipart, Azure blocks, or direct URLs).
+        print("Using SERVER-DRIVEN uploader")
+        return await upload_file_on_cloud(
+            pma_core_url=pma_core_url,
+            session_id=session_id,
+            slide_path=slide_path,
+            upload_directory=upload_directory,
+            progress_callback=progress_callback
+        )
 
     except Exception as e:
         return False, str(e)
 
 # **************************************#
-#   === Small Files < 5bg Uploader  === #
+#   ===     Filesystem Uploader    ===  #
 # **************************************#
 def upload_legacy(slide_path, upload_directory, session_id, progress_callback=None, verify=True):
     """
@@ -2157,15 +2420,16 @@ def upload_legacy(slide_path, upload_directory, session_id, progress_callback=No
 
 
 # **************************************#
-#   === Large Files > 5gb Uploader === #
+#   ===       Cloud Uploader       ===  #
 # **************************************#
-async def upload_file_over_5gb(
+async def upload_file_on_cloud(
         *,
         pma_core_url: str,
         session_id: str,
         slide_path: str,
         upload_directory: str,
         progress_callback=None,
+        verify=True,
 ):
     """
     Asynchronous large-file upload implementation using PmaCoreClient.
@@ -2176,90 +2440,22 @@ async def upload_file_over_5gb(
     - global progress tracking across all uploaded files
     """
 
-    # ===== GETTING ALL FILES =====
-    all_files = []
-
-    all_files.append(slide_path)
-
-    vsi_name_no_ext = os.path.splitext(os.path.basename(slide_path))[0]
-    local_stack_root = os.path.join(os.path.dirname(slide_path), vsi_name_no_ext)
-
-    # stack files
-    if os.path.isdir(local_stack_root):
-        for root, _, files in os.walk(local_stack_root):
-            for f in files:
-                all_files.append(os.path.join(root, f))
-
-    # ===== general size =====
-    total_bytes = sum(os.stat(f).st_size for f in all_files)
-
-    # ===== GLOBAL TRACKER =====
-    class GlobalProgressTracker:
-        def __init__(self, total_bytes, callback):
-            self.total_bytes = total_bytes
-            self.callback = callback
-            self.sent_total = 0
-
-        def add(self, delta):
-            self.sent_total += delta
-            if self.callback and self.total_bytes > 0:
-                self.callback(self.sent_total, self.total_bytes)
-
-    tracker = GlobalProgressTracker(total_bytes, progress_callback)
-
-    # ===== FILE CALLBACK WRAPPER =====
-    def make_file_cb():
-        last_sent = 0
-
-        def _cb(sent, total):
-            nonlocal last_sent
-            delta = sent - last_sent
-            last_sent = sent
-            tracker.add(delta)
+    if not os.path.isfile(slide_path):
+        return False, f"File not found: {slide_path}"
 
-        return _cb
+    normalized_upload_directory = _normalize_upload_directory(upload_directory)
+    package_files = _collect_slide_package_files(slide_path)
 
-    ok, err = await large_files_upload_package(
-        pma_core_url=pma_core_url,
+    client = PmaCoreClient(pma_core_url)
+    return await _upload_package_files(
+        client=client,
         session_id=session_id,
-        slide_path=slide_path,
-        upload_directory=upload_directory,
-        progress_callback=make_file_cb()
+        upload_directory=normalized_upload_directory,
+        package_files=package_files,
+        progress_callback=progress_callback,
+        verify=verify,
     )
 
-    if not ok:
-        return False, f"Upload failed: {err}"
-
-    # ===== STACK =====
-    if os.path.isdir(local_stack_root):
-
-        for root, _, files in os.walk(local_stack_root):
-
-            for file_name in files:
-
-                local_file = os.path.join(root, file_name)
-
-                rel_inside_stack = os.path.relpath(
-                    local_file,
-                    local_stack_root
-                ).replace("\\", "/")
-
-                remote_dir = f"{upload_directory}/{vsi_name_no_ext}/{os.path.dirname(rel_inside_stack)}"
-                remote_dir = remote_dir.rstrip("/")
-
-                ok, err = await large_files_upload_package(
-                    pma_core_url=pma_core_url,
-                    session_id=session_id,
-                    slide_path=local_file,
-                    upload_directory=remote_dir,
-                    progress_callback=make_file_cb()
-                )
-
-                if not ok:
-                    return False, f"Stack upload failed: {local_file} -> {err}"
-
-    return True, None
-
 
 async def large_files_upload_package(
         *,
@@ -2268,93 +2464,37 @@ async def large_files_upload_package(
         slide_path: str,
         upload_directory: str,
         progress_callback=None,
+        verify=True,
 ) -> tuple[bool, str | None]:
     """
-    Low-level async upload routine for a single file.
+    Low-level async upload wrapper for a single file.
 
     Performs:
     - upload header request
     - multipart or direct upload
-    - upload completion polling
+    - upload finalization + image info polling
     """
 
-    try:
-        client = PmaCoreClient(pma_core_url)
-        print("trust_env:", client.session.trust_env)
-
-        if not os.path.isfile(slide_path):
-            return False, f"File not found: {slide_path}"
-
-        file_size = os.stat(slide_path).st_size
-        file_name = os.path.basename(slide_path)
-
-        # ===== HEADER =====
-        header = UploadHeaderModel(
-            path=upload_directory,
-            files=[
-                UploadFileModel(
-                    isMain=True,
-                    length=file_size,
-                    path=file_name
-                )
-            ]
-        )
-
-        # ===== SEND HEADER =====
-        resp = await client.upload_header(header, session_id)
-
-        # print("UploadType:", resp.upload_type)
-        print("MultipartFiles:", resp.multipart_files)
-        print("Urls:", resp.urls)
-
-        # ===== MULTIPART ONLY IF SERVER SENT PARTS =====
-        if resp.multipart_files and len(resp.multipart_files) > 0:
-
-            mp = resp.multipart_files[0]
-
-            full_virtual_path = (
-                    header.path.rstrip("/") + "/" + mp.file_path.lstrip("/")
-            )
-
-            with open(slide_path, "rb") as stream:
-                await client.upload_multipart_file_to_s3(
-                    mp,
-                    full_virtual_path,
-                    stream,
-                    session_id,
-                    progress_callback=progress_callback
-                )
-
-        # ===== SINGLE PUT / AZURE / FILESYSTEM =====
-        else:
-
-            upload_url = resp.urls[0] if resp.urls else None
-
-            with open(slide_path, "rb") as stream:
-                await client.upload_file(
-                    resp.id,
-                    resp.upload_type,
-                    upload_url,
-                    file_name,
-                    stream,
-                    session_id,
-                    total_bytes=file_size,
-                    progress_callback=progress_callback
-                )
-
-        # ===== STATUS =====
-        for _ in range(12):
-            st = await client.get_upload_status(resp.id, session_id)
-
-            if '"Complete": true' in st or '"Complete" : true' in st:
-                return True, None
-
-            await asyncio.sleep(10)
-
-        return False, "Upload not completed"
+    if not os.path.isfile(slide_path):
+        return False, f"File not found: {slide_path}"
 
-    except Exception as e:
-        return False, str(e)
+    normalized_upload_directory = _normalize_upload_directory(upload_directory)
+    single_file = [{
+        "local_path": slide_path,
+        "relative_path": os.path.basename(slide_path),
+        "is_main": True,
+        "size": os.stat(slide_path).st_size
+    }]
+
+    client = PmaCoreClient(pma_core_url)
+    return await _upload_package_files(
+        client=client,
+        session_id=session_id,
+        upload_directory=normalized_upload_directory,
+        package_files=single_file,
+        progress_callback=progress_callback,
+        verify=verify,
+    )
 
 
 # callback for large files upload

{pma_python-2.0.0.184 → pma_python-2.0.0.186}/pma_python/pma_core_client.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 
 import requests
@@ -17,6 +19,9 @@ class TLS12HttpAdapter(HTTPAdapter):
         ctx = ssl.create_default_context()
         ctx.minimum_version = ssl.TLSVersion.TLSv1_2
         ctx.maximum_version = ssl.TLSVersion.TLSv1_2
+        # Requests may switch cert requirements to CERT_NONE when verify=False.
+        # Keep check_hostname disabled on the context to avoid SSL runtime errors.
+        ctx.check_hostname = False
 
         self.poolmanager = PoolManager(
             num_pools=connections,
@@ -26,6 +31,13 @@ class TLS12HttpAdapter(HTTPAdapter):
             **pool_kwargs
         )
 
+    def cert_verify(self, conn, url, verify, cert):
+        super().cert_verify(conn, url, verify, cert)
+        # urllib3 expects assert_hostname to be False/None/string, not bool True.
+        # False disables hostname checks (verify=False); None means default behavior.
+        if hasattr(conn, "assert_hostname"):
+            conn.assert_hostname = False if not verify else None
+
 class _ProgressStream:
     def __init__(self, raw, total_bytes: int, callback: UploadProgressCallback | None):
         self.raw = raw
@@ -48,6 +60,12 @@ class _ProgressStream:
     def tell(self):
         return self.raw.tell()
 
+    def __len__(self):
+        return self.total_bytes
+
+    def close(self):
+        return self.raw.close()
+
 
 # Model classes
 class UploadFileModel:
@@ -200,12 +218,17 @@ class PmaCoreClient:
         response.raise_for_status()
         return UploadResponse(**response.json())
 
-    async def upload_file(self, upload_id: int, upload_type: Optional[str], upload_url: str,
+    async def upload_file(self, upload_id: int, upload_type: Optional[str], upload_url: Optional[str],
                           relative_path: str, stream: IO, session_id: str,
                           total_bytes: int | None = None,
-                          progress_callback: UploadProgressCallback | None = None):
-
-        if upload_type == "Azure" or upload_type == 2:
+                          progress_callback: UploadProgressCallback | None = None,
+                          method: str = "PUT",
+                          verify: bool = True):
+
+        normalized_upload_type = str(upload_type).lower() if upload_type is not None else ""
+        if normalized_upload_type in ("azure", "2"):
+            if not upload_url:
+                raise ValueError("Azure upload requires an upload URL")
             await self.upload_file_to_azure(
                 upload_url,
                 stream,
@@ -221,32 +244,29 @@ class PmaCoreClient:
             wrapped = _ProgressStream(stream, total_bytes, progress_callback)
 
         if upload_to_presigned:
-            data = wrapped.read()
-            print("========== DEBUG PRESIGNED ==========")
-            print("upload_url RAW =", upload_url)
-            print("type(upload_url) =", type(upload_url))
-            print("====================================")
-
-            headers = {
-                "Content-Length": str(len(data))
-            }
-
-            import urllib3
-
-            http = urllib3.PoolManager()
-
-            response = await asyncio.to_thread(
-                http.request,
-                "PUT",
-                upload_url,
-                body=data,
-                headers=headers,
-                preload_content=False
-            )
-
-            if response.status >= 300:
-                raise Exception(f"S3 upload failed: {response.status}")
+            resolved_method = (method or "PUT").upper()
+            headers = {}
+            if total_bytes is not None:
+                headers["Content-Length"] = str(total_bytes)
+
+            if resolved_method == "POST":
+                files = {"file": (relative_path.split("/")[-1], wrapped, "application/octet-stream")}
+                response = await asyncio.to_thread(
+                    self.session.post,
+                    upload_url,
+                    files=files,
+                    verify=verify
+                )
+            else:
+                response = await asyncio.to_thread(
+                    self.session.put,
+                    upload_url,
+                    data=wrapped,
+                    headers=headers,
+                    verify=verify
+                )
 
+            response.raise_for_status()
             return
 
         url = f"{self.server_url}transfer/Upload/{upload_id}"
@@ -254,10 +274,11 @@ class PmaCoreClient:
 
         files = {"file": (relative_path.split("/")[-1], wrapped, "application/octet-stream")}
         response = await asyncio.to_thread(
-            requests.post,
+            self.session.post,
             url,
             params=params,
-            files=files
+            files=files,
+            verify=verify
         )
         response.raise_for_status()
 
@@ -340,7 +361,7 @@ class PmaCoreClient:
             total_bytes: int | None = None,
             progress_callback: UploadProgressCallback | None = None,
     ):
-        block_size = 4 * 1024 * 1024
+        block_size = 1024 * 1024 * 1024
         block_id = 0
         sent_total = 0
         safe_base = upload_url.replace(" ", "%20")
@@ -439,8 +460,18 @@ class PmaCoreClient:
 
             response.raise_for_status()
 
-            etag = response.headers.get("ETag", "") or ""
-            etag = etag.strip().strip('"')
+            raw_etag = response.headers.get("ETag")
+            if raw_etag is None:
+                raise ValueError(
+                    f"Multipart part upload succeeded but no ETag header was returned for part {part.PartNumber}."
+                )
+
+            # Some proxies/S3-compatible layers may surface non-string header values.
+            etag = str(raw_etag).strip().strip('"')
+            if not etag:
+                raise ValueError(
+                    f"Multipart part upload succeeded but ETag value was empty for part {part.PartNumber}."
+                )
 
             part_etags.append(
                 PartETagModel(

pma_python-2.0.0.186/pma_python/version.py

@@ -0,0 +1 @@
+__version__ = '2.0.0.186'

{pma_python-2.0.0.184 → pma_python-2.0.0.186}/pma_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pma_python
-Version: 2.0.0.184
+Version: 2.0.0.186
 Summary: Universal viewing of digital microscopy, whole slide imaging and digital pathology data
 Home-page: https://github.com/pathomation/pma_python
 Author: Pathomation

{pma_python-2.0.0.184 → pma_python-2.0.0.186}/pma_python.egg-info/SOURCES.txt

@@ -13,4 +13,5 @@ pma_python.egg-info/SOURCES.txt
 pma_python.egg-info/dependency_links.txt
 pma_python.egg-info/not-zip-safe
 pma_python.egg-info/requires.txt
-pma_python.egg-info/top_level.txt
+pma_python.egg-info/top_level.txt
+tests/test_slide_package.py

pma_python-2.0.0.186/tests/test_slide_package.py

@@ -0,0 +1,143 @@
+"""Tests for _collect_slide_package_files: multi-file slides must be uploaded with their image data."""
+import asyncio
+import os
+import shutil
+import tempfile
+import unittest
+from unittest import mock
+
+from pma_python import core
+
+REAL_PMA_START_HELPER = core._pma_start_files_for_slide
+
+
+def write(path, size):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "wb") as f:
+        f.write(b"x" * size)
+    return path
+
+
+class CollectSlidePackageFiles(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.mkdtemp()
+        # by default PMA.start is not running
+        p = mock.patch.object(core, "_pma_start_files_for_slide", return_value=[])
+        p.start()
+        self.addCleanup(p.stop)
+
+    def tearDown(self):
+        shutil.rmtree(self.dir, ignore_errors=True)
+
+    def rel(self, files):
+        return [f["relative_path"] for f in files]
+
+    def test_olympus_vsi_underscore_folder(self):
+        vsi = write(os.path.join(self.dir, "VL1_Name, A_1AH&E.vsi"), 100)
+        write(os.path.join(self.dir, "_VL1_Name, A_1AH&E_", "stack1", "frame_t.ets"), 5000)
+        write(os.path.join(self.dir, "_VL1_Name, A_1AH&E_", "stack10001", "frame_t.ets"), 300)
+        files = core._collect_slide_package_files(vsi)
+        self.assertEqual(self.rel(files), [
+            "VL1_Name, A_1AH&E.vsi",
+            "_VL1_Name, A_1AH&E_/stack1/frame_t.ets",
+            "_VL1_Name, A_1AH&E_/stack10001/frame_t.ets",
+        ])
+        self.assertTrue(files[0]["is_main"])
+        self.assertFalse(any(f["is_main"] for f in files[1:]))
+        self.assertEqual(core._get_slide_package_size(vsi), (5400, 5000))
+
+    def test_mrxs_same_name_folder(self):
+        mrxs = write(os.path.join(self.dir, "slide.mrxs"), 10)
+        write(os.path.join(self.dir, "slide", "Data0000.dat"), 700)
+        write(os.path.join(self.dir, "slide", "Slidedat.ini"), 20)
+        self.assertEqual(self.rel(core._collect_slide_package_files(mrxs)),
+                         ["slide.mrxs", "slide/Data0000.dat", "slide/Slidedat.ini"])
+
+    def test_single_file_slide(self):
+        svs = write(os.path.join(self.dir, "single.svs"), 42)
+        write(os.path.join(self.dir, "other.svs"), 42)          # unrelated neighbour
+        files = core._collect_slide_package_files(svs)
+        self.assertEqual(self.rel(files), ["single.svs"])
+        self.assertEqual(core._get_slide_package_size(svs), (42, 42))
+
+    def test_pma_start_list_is_merged_without_duplicates(self):
+        vsi = write(os.path.join(self.dir, "a.vsi"), 1)
+        ets = write(os.path.join(self.dir, "_a_", "stack1", "frame_t.ets"), 9)
+        extra = write(os.path.join(self.dir, "a_extra", "x.bin"), 3)   # a convention we do not know
+        outside = write(os.path.join(tempfile.mkdtemp(), "elsewhere.bin"), 3)
+        with mock.patch.object(core, "_pma_start_files_for_slide", return_value=[vsi, ets, extra, outside]):
+            files = core._collect_slide_package_files(vsi)
+        self.assertEqual(self.rel(files), ["a.vsi", "_a_/stack1/frame_t.ets", "a_extra/x.bin"])
+        shutil.rmtree(os.path.dirname(outside), ignore_errors=True)
+
+    def test_pma_start_unavailable_is_not_fatal(self):
+        vsi = write(os.path.join(self.dir, "b.vsi"), 1)
+        write(os.path.join(self.dir, "_b_", "stack1", "frame_t.ets"), 9)
+        with mock.patch.object(core, "get_files_for_slide", side_effect=ConnectionError("PMA.start down")), \
+             mock.patch.object(core, "_pma_start_files_for_slide", side_effect=REAL_PMA_START_HELPER):
+            files = core._collect_slide_package_files(vsi)
+        self.assertEqual(self.rel(files), ["b.vsi", "_b_/stack1/frame_t.ets"])
+
+    def test_missing_file(self):
+        with self.assertRaises(ValueError):
+            core._collect_slide_package_files(os.path.join(self.dir, "nope.vsi"))
+
+
+class RealPmaStartHelper(unittest.TestCase):
+    def test_returns_empty_list_when_pma_start_errors(self):
+        with mock.patch.object(core, "get_files_for_slide", side_effect=ConnectionError("down")):
+            self.assertEqual(core._pma_start_files_for_slide("C:/x.vsi"), [])
+
+    def test_returns_paths_from_pma_start(self):
+        with mock.patch.object(core, "get_files_for_slide", return_value={"C:/x.vsi": {}, "C:/_x_/s/f.ets": {}}):
+            self.assertEqual(sorted(core._pma_start_files_for_slide("C:/x.vsi")), ["C:/_x_/s/f.ets", "C:/x.vsi"])
+
+
+class CloudUploadSendsWholeSlide(unittest.TestCase):
+    """End to end through upload_file_on_cloud with a fake server: every file must be announced and sent."""
+
+    def test_vsi_upload_sends_image_data(self):
+        d = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, d, True)
+        vsi = write(os.path.join(d, "VL9_X, Y_1AH&E.vsi"), 100)
+        write(os.path.join(d, "_VL9_X, Y_1AH&E_", "stack1", "frame_t.ets"), 5000)
+
+        sent = []
+
+        class FakeResp:
+            id, upload_type, urls, multipart_files = 7, 2, ["u1", "u2"], []
+
+        class FakeClient:
+            server_url = "https://pma.example/"
+
+            def __init__(self, url):
+                pass
+
+            async def upload_header(self, header, session_id):
+                self.header = header
+                sent.append(("header", [(f.path, f.length, f.isMain) for f in header.files]))
+                return FakeResp()
+
+            async def upload_file(self, upload_id, upload_type, url, rel, stream, session_id, **kw):
+                sent.append(("file", rel, len(stream.read())))
+
+        class Ok:
+            status_code = 200
+
+        with mock.patch.object(core, "PmaCoreClient", FakeClient), \
+             mock.patch.object(core, "_pma_start_files_for_slide", return_value=[]), \
+             mock.patch.object(core.requests, "get", return_value=Ok()), \
+             mock.patch.object(core, "get_slide_info", return_value={}):
+            ok, err = asyncio.run(core.upload_file_on_cloud(
+                pma_core_url="https://pma.example/", session_id="S", slide_path=vsi,
+                upload_directory="Slides/Received"))
+
+        self.assertTrue(ok, err)
+        self.assertEqual(sent[0], ("header", [("VL9_X, Y_1AH&E.vsi", 100, True),
+                                              ("_VL9_X, Y_1AH&E_/stack1/frame_t.ets", 5000, False)]))
+        self.assertEqual(sent[1:], [("file", "VL9_X, Y_1AH&E.vsi", 100),
+                                    ("file", "_VL9_X, Y_1AH&E_/stack1/frame_t.ets", 5000)])
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

pma_python-2.0.0.184/pma_python/version.py

@@ -1 +0,0 @@
-__version__ = '2.0.0.184'