import re from typing import Any, Optional, List, Dict from pydantic import BaseModel, Field, field_validator from typing_extensions import Annotated class SpreadsheetModel(BaseModel): dewarname: str = Field(..., alias='dewarname') puckname: str = Field(..., alias='puckname') pucktype: Optional[str] = Field(None, alias="pucktype") crystalname: Annotated[ str, Field(..., max_length=64, title="Crystal Name", description="max_length imposed by MTZ file header format https://www.ccp4.ac.uk/html/mtzformat.html", alias='crystalname' ), ] positioninpuck: int # Only accept positive integers between 1 and 16 priority: Optional[int] comments: Optional[str] directory: Optional[str] proteinname: Optional[str] = "" # Alphanumeric validation oscillation: Optional[float] = None # Only accept positive float exposure: Optional[float] = None # Only accept positive floats between 0 and 1 totalrange: Optional[int] = None # Only accept positive integers between 0 and 360 transmission: Optional[int] = None # Only accept positive integers between 0 and 100 targetresolution: Optional[float] = None # Only accept positive float aperture: Optional[str] = None # Optional string field datacollectiontype: Optional[str] = None # Only accept "standard", other types might be added later processingpipeline: Optional[str] = "" # Only accept "gopy", "autoproc", "xia2dials" spacegroupnumber: Optional[int] = None # Only accept positive integers between 1 and 230 cellparameters: Optional[str] = None # Must be a set of six positive floats or integers rescutkey: Optional[str] = None # Only accept "is" or "cchalf" rescutvalue: Optional[float] = None # Must be a positive float if rescutkey is provided userresolution: Optional[float] = None pdbid: Optional[str] = "" # Accepts either the format of the protein data bank code or {provided} autoprocfull: Optional[bool] = None procfull: Optional[bool] = None adpenabled: Optional[bool] = None noano: Optional[bool] = None ffcscampaign: Optional[bool] = None trustedhigh: Optional[float] = None # Should be a float between 0 and 2.0 autoprocextraparams: Optional[str] = None # Optional string field chiphiangles: Optional[float] = None # Optional float field between 0 and 30 dose: Optional[float] = None # Optional float field # Add pucktype validation @field_validator('pucktype', mode="before") @classmethod def validate_pucktype(cls, v): if v != "unipuck": raise ValueError(f"'{v}' is not valid. Pucktype must be 'unipuck'.") return v # Validators @field_validator('dewarname', 'puckname', mode="before") @classmethod def dewarname_puckname_characters(cls, v): if v: v = str(v).strip().replace(" ", "_").upper() if re.search("\n", v): assert v.isalnum(), "is not valid. newline character detected." v = re.sub(r"\.0$", "", v) return v raise ValueError("Value must be provided for dewarname and puckname.") @field_validator('crystalname', mode="before") @classmethod def parameter_characters(cls, v): v = str(v).replace(" ", "_") if re.search("\n", v): assert v.isalnum(), "is not valid. newline character detected." characters = re.sub("[._+-]", "", v) assert characters.isalnum(), f" '{v}' is not valid. Only alphanumeric and . _ + - characters allowed." return v @field_validator('directory', mode="before") @classmethod def directory_characters(cls, v): if v: v = str(v).strip("/").replace(" ", "_") if re.search("\n", v): raise ValueError(f" '{v}' is not valid. newline character detected.") valid_macros = ["{date}", "{prefix}", "{sgpuck}", "{puck}", "{beamline}", "{sgprefix}", "{sgpriority}", "{sgposition}", "{protein}", "{method}"] pattern = re.compile("|".join(re.escape(macro) for macro in valid_macros)) v = pattern.sub('macro', v) allowed_chars = "[a-z0-9_.+-]" directory_re = re.compile(f"^(({allowed_chars}*|{allowed_chars}+)*/*)*$", re.IGNORECASE) if not directory_re.match(v): raise ValueError(f" '{v}' is not valid. Value must be a valid path or macro.") return v @field_validator('positioninpuck', mode="before") @classmethod def positioninpuck_possible(cls, v): if not isinstance(v, int) or v < 1 or v > 16: raise ValueError(f" '{v}' is not valid. Value must be an integer between 1 and 16.") return v @field_validator('priority', mode="before") @classmethod def priority_positive(cls, v): if v is not None: try: v = int(v) if v <= 0: raise ValueError(f" '{v}' is not valid. Value must be a positive integer.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a positive integer.") from e return v @field_validator('aperture', mode="before") @classmethod def aperture_selection(cls, v): if v is not None: try: v = int(float(v)) if v not in {1, 2, 3}: raise ValueError(f" '{v}' is not valid. Value must be 1, 2, or 3.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be 1, 2, or 3.") from e return v @field_validator('oscillation', 'targetresolution', mode="before") @classmethod def positive_float_validator(cls, v): if v is not None: try: v = float(v) if v <= 0: raise ValueError(f" '{v}' is not valid. Value must be a positive float.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a positive float.") from e return v @field_validator('exposure', mode="before") @classmethod def exposure_in_range(cls, v): if v is not None: try: v = float(v) if not (0 <= v <= 1): raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 1.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 1.") from e return v @field_validator('totalrange', mode="before") @classmethod def totalrange_in_range(cls, v): if v is not None: try: v = int(v) if not (0 <= v <= 360): raise ValueError(f" '{v}' is not valid. Value must be an integer between 0 and 360.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be an integer between 0 and 360.") from e return v @field_validator('transmission', mode="before") @classmethod def transmission_fraction(cls, v): if v is not None: try: v = int(v) if not (0 <= v <= 100): raise ValueError(f" '{v}' is not valid. Value must be an integer between 0 and 100.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be an integer between 0 and 100.") from e return v @field_validator('datacollectiontype', mode="before") @classmethod def datacollectiontype_allowed(cls, v): allowed = {"standard"} # Other types of data collection might be added later if v and v.lower() not in allowed: raise ValueError(f" '{v}' is not valid. Value must be one of {allowed}.") return v @field_validator('processingpipeline', mode="before") @classmethod def processingpipeline_allowed(cls, v): allowed = {"gopy", "autoproc", "xia2dials"} if v and v.lower() not in allowed: raise ValueError(f" '{v}' is not valid. Value must be one of {allowed}.") return v @field_validator('spacegroupnumber', mode="before") @classmethod def spacegroupnumber_allowed(cls, v): if v is not None: try: v = int(v) if not (1 <= v <= 230): raise ValueError(f" '{v}' is not valid. Value must be an integer between 1 and 230.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be an integer between 1 and 230.") from e return v @field_validator('cellparameters', mode="before") @classmethod def cellparameters_format(cls, v): if v: values = [float(i) for i in v.split(",")] if len(values) != 6 or any(val <= 0 for val in values): raise ValueError(f" '{v}' is not valid. Value must be a set of six positive floats or integers.") return v @field_validator('rescutkey', 'rescutvalue', mode="before") @classmethod def rescutkey_value_pair(cls, values): rescutkey = values.get('rescutkey') rescutvalue = values.get('rescutvalue') if rescutkey and rescutvalue: if rescutkey not in {"is", "cchalf"}: raise ValueError("Rescutkey must be either 'is' or 'cchalf'") if not isinstance(rescutvalue, float) or rescutvalue <= 0: raise ValueError("Rescutvalue must be a positive float if rescutkey is provided") return values @field_validator('trustedhigh', mode="before") @classmethod def trustedhigh_allowed(cls, v): if v is not None: try: v = float(v) if not (0 <= v <= 2.0): raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 2.0.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 2.0.") from e return v @field_validator('chiphiangles', mode="before") @classmethod def chiphiangles_allowed(cls, v): if v is not None: try: v = float(v) if not (0 <= v <= 30): raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 30.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a float between 0 and 30.") from e return v @field_validator('dose', mode="before") @classmethod def dose_positive(cls, v): if v is not None: try: v = float(v) if v <= 0: raise ValueError(f" '{v}' is not valid. Value must be a positive float.") except (ValueError, TypeError) as e: raise ValueError(f" '{v}' is not valid. Value must be a positive float.") from e return v class TELLModel(SpreadsheetModel): input_order: int samplemountcount: int = 0 samplestatus: str = "not present" puckaddress: str = "---" username: str puck_number: int prefix: Optional[str] folder: Optional[str] class SpreadsheetResponse(BaseModel): data: List[SpreadsheetModel] # Validated data rows as SpreadsheetModel instances errors: List[Dict[str, Any]] # Errors encountered during validation raw_data: List[Dict[str, Any]] # Raw data extracted from the spreadsheet dewars_count: int dewars: List[str] pucks_count: int pucks: List[str] samples_count: int samples: List[str] headers: Optional[List[str]] = None # Add headers if needed __all__ = ['SpreadsheetModel', 'SpreadsheetResponse']