usdm4-protocol 0.1.0__py3-none-any.whl

usdm4_protocol/__info__.py

@@ -0,0 +1,3 @@
+__package_version__ = "0.1.0"
+__model_version__ = "4.0.0"
+__system_name__ = "USDM4 Protocol Package"

usdm4_protocol/__init__.py

@@ -0,0 +1,104 @@
+from usdm4_protocol.__info__ import (
+    __package_version__ as __package_version__,
+    __model_version__ as __model_version__,
+    __system_name__ as __system_name__,
+)
+from usdm4_protocol.m11 import USDM4M11
+from usdm4_protocol.cpt import USDM4CPT
+from usdm4_protocol.legacy import USDM4Legacy
+from simple_error_log.errors import Errors
+
+
+class USDM4Protocol:
+    """Unified entry point for importing clinical trial protocols into USDM4.
+
+    Supports three protocol formats:
+    - M11 (ICH M11 template, DOCX)
+    - CPT (TransCelerate Common Protocol Template, DOCX)
+    - Legacy (unknown sponsor format, PDF)
+    """
+
+    def __init__(self):
+        self._errors = Errors()
+        self._handler = None
+
+    def from_m11(self, filepath: str, use_ai: bool = False):
+        """Import an M11-formatted protocol (DOCX)."""
+        self._handler = USDM4M11()
+        return self._handler.from_docx(filepath, use_ai=use_ai)
+
+    def from_cpt(self, filepath: str):
+        """Import a CPT-formatted protocol (DOCX)."""
+        self._handler = USDM4CPT()
+        return self._handler.from_docx(filepath)
+
+    def from_pdf(self, filepath: str, pdf_converter: str = "auto"):
+        """Import a legacy PDF protocol.
+
+        Args:
+            filepath: Path to the PDF file.
+            pdf_converter: Which converter to use.
+                - "auto": Use docling if available, otherwise pymupdf.
+                - "docling": Use docling (pip install usdm4_protocol[pdf-docling]).
+                - "pymupdf": Use pymupdf (pip install usdm4_protocol[pdf]).
+        """
+        self._handler = USDM4Legacy()
+        return self._handler.from_pdf(filepath, pdf_converter=pdf_converter)
+
+    def from_file(self, filepath: str, use_ai: bool = False):
+        """Import a protocol, detecting format from the file extension and content.
+
+        For .pdf files, uses the Legacy handler.
+        For .docx files, attempts M11 first (if use_ai is requested or M11 markers
+        are detected), otherwise falls back to CPT.
+        """
+        lower = filepath.lower()
+        if lower.endswith(".pdf"):
+            return self.from_pdf(filepath, pdf_converter="auto")
+        elif lower.endswith(".docx"):
+            if use_ai:
+                return self.from_m11(filepath, use_ai=True)
+            return self.from_cpt(filepath)
+        else:
+            self._errors.error(f"Unsupported file format: {filepath}")
+            return None
+
+    def to_html(self, file_path: str, template: str = "M11") -> str | None:
+        """Export USDM4 data to HTML.
+
+        Args:
+            file_path: Path to USDM4 JSON file.
+            template: Template to use ("M11" or "CPT").
+        """
+        if template.upper() == "M11":
+            handler = USDM4M11()
+            return handler.to_html(file_path)
+        elif template.upper() == "CPT":
+            handler = USDM4CPT()
+            return handler.to_html(file_path)
+        else:
+            self._errors.error(f"Unsupported template: {template}")
+            return None
+
+    def data_views(self, file_path: str) -> dict:
+        """Generate data views from USDM4 data (M11 format)."""
+        handler = USDM4M11()
+        return handler.data_views(file_path)
+
+    @property
+    def source(self) -> dict:
+        if self._handler:
+            return self._handler.source
+        return {}
+
+    @property
+    def source_no_sections(self) -> dict:
+        if self._handler:
+            return self._handler.source_no_sections
+        return {}
+
+    @property
+    def errors(self):
+        if self._handler:
+            return self._handler.errors
+        return self._errors

usdm4_protocol/common/__init__.py

@@ -0,0 +1 @@
+# Common utilities for all packages

usdm4_protocol/common/ai/__init__.py

@@ -0,0 +1 @@
+# AI providers

usdm4_protocol/common/ai/base_ai.py

@@ -0,0 +1,53 @@
+from abc import ABC, abstractmethod
+
+
+class BaseAIProvider(ABC):
+    """Abstract base class for AI providers."""
+
+    @property
+    @abstractmethod
+    def available(self) -> bool:
+        """Check if the AI provider is available."""
+        pass
+
+    @abstractmethod
+    def prompt(self, text: str, system: str = "") -> str:
+        """
+        Send a prompt to the AI model and get a response.
+
+        Args:
+            text: The prompt text
+            system: Optional system message for context
+
+        Returns:
+            The response text from the AI model, or None if unavailable
+        """
+        pass
+
+    @abstractmethod
+    def streaming_prompt(self, text: str, system_message: str = "") -> str:
+        """
+        Send a prompt to the AI model with streaming response.
+
+        Args:
+            text: The prompt text
+            system_message: Optional system message for context
+
+        Returns:
+            The full response text from the AI model, or None if unavailable
+        """
+        pass
+
+    @abstractmethod
+    def extract_json(self, text: str, dict: bool = True) -> dict | list | None:
+        """
+        Extract JSON from AI response text.
+
+        Args:
+            text: The response text containing JSON
+            dict: If True, extract dictionary; if False, extract list
+
+        Returns:
+            Parsed JSON object/list, or None if extraction failed
+        """
+        pass

usdm4_protocol/common/ai/claude_provider.py

@@ -0,0 +1,175 @@
+import json
+from simple_error_log.errors import Errors
+from simple_error_log.error_location import KlassMethodLocation
+from usdm4_protocol.common.ai.base_ai import BaseAIProvider
+
+try:
+    from anthropic import Anthropic
+    from d4k_ms_base.service_environment import ServiceEnvironment
+
+    ANTHROPIC_AVAILABLE = True
+except ImportError:
+    ANTHROPIC_AVAILABLE = False
+
+
+class ClaudeProvider(BaseAIProvider):
+    """Claude AI provider using Anthropic API."""
+
+    MODULE = "usdm4_protocol.common.ai.claude_provider.ClaudeProvider"
+    DEFAULT_MODEL = "claude-haiku-4-5-20251001"
+    MODEL_PRICING = {DEFAULT_MODEL: {"input": 15.0, "output": 75.0}}
+
+    def __init__(self, errors: Errors, model: str = None):
+        """
+        Initialize the Claude provider.
+
+        Args:
+            errors: Error logging object
+            model: Model name (defaults to haiku)
+        """
+        self._errors = errors
+        self._model = model or self.DEFAULT_MODEL
+        self._client = None
+        self._available = False
+
+        if not ANTHROPIC_AVAILABLE:
+            errors.warning(
+                "Anthropic package not installed. Install with 'pip install anthropic d4k_ms_base'",
+                KlassMethodLocation(self.MODULE, "__init__"),
+            )
+            return
+
+        try:
+            api_key = ServiceEnvironment().get("ANTHROPIC_API_KEY")
+            if not api_key:
+                errors.error(
+                    "Anthropic API key environment variable is not set",
+                    KlassMethodLocation(self.MODULE, "__init__"),
+                )
+            else:
+                self._client = Anthropic(api_key=api_key)
+                self._available = True
+        except Exception as e:
+            errors.exception(
+                "Failed to initialize Anthropic client",
+                e,
+                KlassMethodLocation(self.MODULE, "__init__"),
+            )
+
+    @property
+    def available(self) -> bool:
+        """Check if the Claude provider is available."""
+        return self._available
+
+    def prompt(self, text: str, system: str = "") -> str:
+        """Send a prompt to Claude and get a response."""
+        if not self._client:
+            self._errors.error(
+                "No client object found",
+                KlassMethodLocation(self.MODULE, "prompt"),
+            )
+            return None
+
+        try:
+            message = self._client.messages.create(
+                max_tokens=1024,
+                system=system if system else "",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": text,
+                    }
+                ],
+                model=self._model,
+            )
+            return message.content[0].text
+        except Exception as e:
+            self._errors.exception(
+                "Error executing prompt",
+                e,
+                KlassMethodLocation(self.MODULE, "prompt"),
+            )
+            return None
+
+    def streaming_prompt(self, text: str, system_message: str = "") -> str:
+        """Send a prompt to Claude with streaming response."""
+        if not self._client:
+            self._errors.error(
+                "No client object found",
+                KlassMethodLocation(self.MODULE, "streaming_prompt"),
+            )
+            return None
+
+        try:
+            with self._client.messages.stream(
+                model=self._model,
+                max_tokens=16384,
+                temperature=0,
+                system=system_message if system_message else "",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": text,
+                    }
+                ],
+            ) as stream:
+                return self._streaming_response(stream)
+        except Exception as e:
+            self._errors.exception(
+                "Error executing streaming prompt",
+                e,
+                KlassMethodLocation(self.MODULE, "streaming_prompt"),
+            )
+            return None
+
+    def extract_json(self, text: str, dict: bool = True) -> dict | list | None:
+        """Extract JSON from response text."""
+        if not text:
+            self._errors.error(
+                "Error decoding Claude response - empty text",
+                KlassMethodLocation(self.MODULE, "extract_json"),
+            )
+            return None
+
+        try:
+            result = text.replace("\n", "")
+            if dict:
+                s_index = result.find("{")
+                e_index = result.rfind("}")
+            else:
+                s_index = result.find("[")
+                e_index = result.rfind("]")
+
+            if s_index >= 0 and e_index >= 0 and e_index > s_index:
+                result = result[s_index : e_index + 1]
+                return json.loads(result)
+            else:
+                self._errors.error(
+                    "Error decoding Claude response - no JSON found",
+                    KlassMethodLocation(self.MODULE, "extract_json"),
+                )
+                return None
+        except Exception as e:
+            self._errors.exception(
+                "Error decoding Claude JSON",
+                e,
+                KlassMethodLocation(self.MODULE, "extract_json"),
+            )
+            return None
+
+    def _streaming_response(self, stream) -> str:
+        """Process streamed response from Claude."""
+        full_response = ""
+        try:
+            for chunk in stream:
+                if hasattr(chunk, "delta") and hasattr(chunk.delta, "text"):
+                    content = chunk.delta.text
+                    full_response += content
+        except Exception as e:
+            self._errors.exception(
+                "Error decoding Claude stream",
+                e,
+                KlassMethodLocation(self.MODULE, "_streaming_response"),
+            )
+            return None
+        return full_response

usdm4_protocol/common/ai/fallback_provider.py

@@ -0,0 +1,34 @@
+from simple_error_log.errors import Errors
+from usdm4_protocol.common.ai.base_ai import BaseAIProvider
+
+
+class FallbackProvider(BaseAIProvider):
+    """Fallback provider that returns None for all operations."""
+
+    MODULE = "usdm4_protocol.common.ai.fallback_provider.FallbackProvider"
+
+    def __init__(self, errors: Errors):
+        """
+        Initialize the fallback provider.
+
+        Args:
+            errors: Error logging object
+        """
+        self._errors = errors
+
+    @property
+    def available(self) -> bool:
+        """Fallback provider is never available."""
+        return False
+
+    def prompt(self, text: str, system: str = "") -> None:
+        """Fallback always returns None."""
+        return None
+
+    def streaming_prompt(self, text: str, system_message: str = "") -> None:
+        """Fallback always returns None."""
+        return None
+
+    def extract_json(self, text: str, dict: bool = True) -> None:
+        """Fallback always returns None."""
+        return None

usdm4_protocol/common/assemble/__init__.py

@@ -0,0 +1 @@
+# Assembly utilities

usdm4_protocol/common/assemble/assemble_usdm.py

@@ -0,0 +1,52 @@
+from usdm4 import USDM4
+from simple_error_log.errors import Errors
+from simple_error_log.error_location import KlassMethodLocation
+from usdm4.assembler.assembler import Assembler
+from usdm4.api.wrapper import Wrapper
+from usdm4_protocol.__info__ import (
+    __package_version__ as system_version,
+    __system_name__ as system_name,
+)
+
+
+class AssembleUSDM:
+    """Unified USDM assembler for all source formats."""
+
+    MODULE = "usdm4_protocol.common.assemble.assemble_usdm.AssembleUSDM"
+
+    def __init__(self, source_data: dict, errors: Errors):
+        """
+        Initialize the USDM assembler.
+
+        Args:
+            source_data: Source data dictionary to be assembled into USDM4
+            errors: Error logging object
+        """
+        self._source_data = source_data
+        self._errors = errors
+        self._usdm4 = USDM4()
+        self._assembler: Assembler = self._usdm4.assembler(self._errors)
+
+    def process(self) -> Wrapper:
+        """
+        Process the source data and assemble into USDM4.
+
+        Returns:
+            USDM4 wrapper object or empty dict if assembly fails
+        """
+        try:
+            self._assembler.execute(self._source_data)
+            return self._assembler.wrapper(system_name, system_version)
+        except Exception as e:
+            location = KlassMethodLocation(self.MODULE, "process")
+            self._errors.exception(
+                "Exception raised assembling USDM",
+                e,
+                location,
+            )
+            return {}
+
+    @property
+    def source(self):
+        """Get the source data."""
+        return self._source_data

usdm4_protocol/common/base_import.py

@@ -0,0 +1,60 @@
+import copy
+from abc import ABC, abstractmethod
+from simple_error_log.errors import Errors
+from simple_error_log.error_location import KlassMethodLocation
+from usdm4_protocol.common.assemble.assemble_usdm import AssembleUSDM
+
+
+class BaseImport(ABC):
+    """Base class for format-specific import handlers.
+
+    Provides the shared Load -> Extract -> Assemble -> Wrapper pipeline and
+    common properties (source, source_no_sections, extra). Subclasses must
+    implement _load() and _extract() to supply format-specific behaviour.
+    """
+
+    MODULE = "usdm4_protocol.common.base_import.BaseImport"
+
+    def __init__(self, file_path: str, errors: Errors):
+        self._file_path = file_path
+        self._errors = errors
+        self._study = None
+
+    def process(self):
+        try:
+            loaded = self._load()
+            self._study = self._extract(loaded)
+            assembler = AssembleUSDM(self._study, self._errors)
+            wrapper = assembler.process()
+            return wrapper
+        except Exception as e:
+            location = KlassMethodLocation(self.MODULE, "process")
+            self._errors.exception(
+                f"Exception raised processing '{self._file_path}'",
+                e,
+                location,
+            )
+            return None
+
+    @abstractmethod
+    def _load(self):
+        """Load the source file. Returns format-specific data."""
+
+    @abstractmethod
+    def _extract(self, loaded) -> dict:
+        """Extract study data from the loaded source. Returns study dict."""
+
+    @property
+    def source(self) -> dict:
+        return self._study
+
+    @property
+    def source_no_sections(self) -> dict:
+        the_copy = copy.deepcopy(self._study)
+        the_copy["document"]["sections"] = []
+        return the_copy
+
+    @property
+    def extra(self) -> dict:
+        """Override in subclasses that need extra metadata."""
+        return {}

usdm4_protocol/common/extract/__init__.py

@@ -0,0 +1 @@
+# Extract utilities