Fix pytest

Fix pytest

Fix pytest

Fix pytest

Fix pytest

Fix pytest

Fix pytest

Fix pytest

Author: BenjaminCharmes

pydatalab/schemas/cell.json

@@ -174,7 +174,7 @@ class ServerConfig(BaseSettings):
 
     REMOTE_FILESYSTEMS: list[RemoteFilesystem] = Field(
         [],
-        descripton="A list of dictionaries describing remote filesystems to be accessible from the server.",
+        description="A list of dictionaries describing remote filesystems to be accessible from the server.",
     )
 
     REMOTE_CACHE_MAX_AGE: int = Field(
@@ -346,6 +346,15 @@ def make_missing_log_directory(cls, v):
             raise RuntimeError(f"Unable to create log file at {v}") from exc
         return v
 
+    def update(self, values: dict):
+        """Update the configuration with new values, following Pydantic v1 behavior."""
+        for key, value in values.items():
+            key_upper = key.upper()
+            if hasattr(self, key_upper):
+                setattr(self, key_upper, value)
+            else:
+                setattr(self, key_upper, value)
+
 
 CONFIG: ServerConfig = ServerConfig()
 """The global server configuration object.

pydatalab/schemas/equipment.json

@@ -94,25 +94,33 @@ def _check_secret_and_warn(secret: str, error: str, environ: bool = False) -> bo
         "No GitHub OAuth client secret provided, GitHub login will not work",
     ):
         FEATURE_FLAGS.auth_mechanisms.github = True
+    else:
+        FEATURE_FLAGS.auth_mechanisms.github = False
     if _check_secret_and_warn(
         "ORCID_OAUTH_CLIENT_SECRET",
         "No ORCID OAuth client secret provided, ORCID login will not work",
     ) and _check_secret_and_warn(
         "ORCID_OAUTH_CLIENT_ID", "No ORCID OAuth client ID provided, ORCID login will not work"
     ):
         FEATURE_FLAGS.auth_mechanisms.orcid = True
+    else:
+        FEATURE_FLAGS.auth_mechanisms.orcid = False
     if _check_secret_and_warn(
         "OPENAI_API_KEY",
         "No OpenAI API key provided, OpenAI-based ChatBlock will not work",
         environ=True,
     ):
         FEATURE_FLAGS.ai_integrations.openai = True
+    else:
+        FEATURE_FLAGS.ai_integrations.openai = False
     if _check_secret_and_warn(
         "ANTHROPIC_API_KEY",
         "No Anthropic API key provided, Claude-based ChatBlock will not work",
         environ=True,
     ):
         FEATURE_FLAGS.ai_integrations.anthropic = True
+    else:
+        FEATURE_FLAGS.ai_integrations.anthropic = False
 
     if CONFIG.DEBUG:
         LOGGER.warning("Running with debug logs enabled")

pydatalab/schemas/sample.json

@@ -2,11 +2,11 @@
 from typing import Literal
 
 from pydantic import (
+    Field,
     field_validator,
     model_validator,
 )
 
-from pydatalab.models.entries import EntryReference
 from pydatalab.models.items import Item
 from pydatalab.models.utils import Constituent
 
@@ -33,31 +33,33 @@ class Cell(Item):
 
     type: Literal["cells"] = "cells"
 
-    cell_format: CellFormat | None
+    cell_format: CellFormat | None = None
     """The form factor of the cell, e.g., coin, pouch, in situ or otherwise."""
 
-    cell_format_description: str | None
+    cell_format_description: str | None = None
     """Additional human-readable description of the cell form factor, e.g., 18650, AMPIX, CAMPIX"""
 
-    cell_preparation_description: str | None
+    cell_preparation_description: str | None = None
+    """Description of how the cell was prepared."""
 
-    characteristic_mass: float | None
+    characteristic_mass: float | None = None
     """The characteristic mass of the cell in milligrams. Can be used to normalize capacities."""
 
-    characteristic_chemical_formula: str | None
+    characteristic_chemical_formula: str | None = None
     """The chemical formula of the active material. Can be used to calculated molar mass in g/mol for normalizing capacities."""
 
-    characteristic_molar_mass: float | None
+    characteristic_molar_mass: float | None = None
     """The molar mass of the active material, in g/mol. Will be inferred from the chemical formula, or can be supplied if it cannot be supplied"""
 
-    positive_electrode: list[CellComponent] = []
-
-    negative_electrode: list[CellComponent] = []
-
-    electrolyte: list[CellComponent] = []
+    positive_electrode: list[CellComponent] = Field(default_factory=list)
+    negative_electrode: list[CellComponent] = Field(default_factory=list)
+    electrolyte: list[CellComponent] = Field(default_factory=list)
 
     active_ion_charge: float = 1
 
+    active_ion: str | None = None
+    """The active ion species."""
+
     @field_validator("characteristic_molar_mass", mode="before")
     @classmethod
     def set_molar_mass(cls, v, info):
@@ -75,33 +77,68 @@ def set_molar_mass(cls, v, info):
     @model_validator(mode="before")
     @classmethod
     def add_missing_electrode_relationships(cls, values):
-        """Add any missing sample synthesis constituents to parent relationships"""
-        from pydatalab.models.relationships import RelationshipType, TypedRelationship
+        """Add any missing electrode constituents to parent relationships"""
+        from pydatalab.models.relationships import RelationshipType
 
         existing_parthood_relationship_ids = set()
         if values.get("relationships") is not None:
-            existing_parthood_relationship_ids = {
-                relationship.refcode or relationship.item_id
-                for relationship in values["relationships"]
-                if relationship.relation == RelationshipType.PARTHOOD
-            }
+            for relationship in values["relationships"]:
+                if isinstance(relationship, dict):
+                    relation = relationship.get("relation")
+                    if relation == RelationshipType.PARTHOOD or relation == "is_part_of":
+                        ref_id = relationship.get("refcode") or relationship.get("item_id")
+                        if ref_id:
+                            existing_parthood_relationship_ids.add(ref_id)
+                else:
+                    if (
+                        hasattr(relationship, "relation")
+                        and relationship.relation == RelationshipType.PARTHOOD
+                    ):
+                        ref_id = getattr(relationship, "refcode", None) or getattr(
+                            relationship, "item_id", None
+                        )
+                        if ref_id:
+                            existing_parthood_relationship_ids.add(ref_id)
         else:
             values["relationships"] = []
 
         for component in ("positive_electrode", "negative_electrode", "electrolyte"):
             for constituent in values.get(component, []):
-                if (
-                    isinstance(constituent.item, EntryReference)
-                    and (constituent.item.refcode or constituent.item.item_id)
-                    not in existing_parthood_relationship_ids
-                ):
-                    relationship = TypedRelationship(
-                        relation=RelationshipType.PARTHOOD,
-                        refcode=constituent.item.refcode,
-                        item_id=constituent.item.item_id,
-                        type=constituent.item.type,
-                        description="Is a constituent of",
-                    )
-                    values["relationships"].append(relationship)
+                if isinstance(constituent, dict):
+                    item_data = constituent.get("item")
+                else:
+                    item_data = getattr(constituent, "item", None)
+
+                if item_data is None:
+                    continue
+
+                if isinstance(item_data, dict):
+                    item_id = item_data.get("item_id")
+                    refcode = item_data.get("refcode")
+                    item_type = item_data.get("type")
+
+                    if not item_id and not refcode:
+                        continue
+
+                    constituent_id = refcode or item_id
+                else:
+                    item_id = getattr(item_data, "item_id", None)
+                    refcode = getattr(item_data, "refcode", None)
+                    item_type = getattr(item_data, "type", None)
+
+                    if not item_id and not refcode:
+                        continue
+
+                    constituent_id = refcode or item_id
+
+                if constituent_id and constituent_id not in existing_parthood_relationship_ids:
+                    relationship_dict = {
+                        "relation": RelationshipType.PARTHOOD,
+                        "refcode": refcode,
+                        "item_id": item_id,
+                        "type": item_type,
+                        "description": "Is a constituent of",
+                    }
+                    values["relationships"].append(relationship_dict)
 
         return values

pydatalab/schemas/startingmaterial.json

@@ -16,10 +16,10 @@ class Collection(Entry, HasOwner, HasBlocks):
     collection_id: HumanReadableIdentifier = Field(None)
     """A short human-readable/usable name for the collection."""
 
-    title: str | None
+    title: str | None = None
     """A descriptive title for the collection."""
 
-    description: str | None
+    description: str | None = None
     """A description of the collection, either in plain-text or a markup language."""
 
     num_items: int | None = Field(None)

pydatalab/src/pydatalab/config.py

@@ -19,18 +19,18 @@ class Entry(BaseModel, abc.ABC):
     type: str
     """The resource type of the entry."""
 
-    immutable_id: PyObjectId = Field(
+    immutable_id: PyObjectId | None = Field(
         None,
         title="Immutable ID",
         alias="_id",
-        format="uuid",
+        json_schema_extra={"format": "uuid"},
     )
     """The immutable database ID of the entry."""
 
     last_modified: IsoformatDateTime | None = None
     """The timestamp at which the entry was last modified."""
 
-    relationships: list[TypedRelationship] | None = None
+    relationships: list[TypedRelationship] = Field(default_factory=list)
     """A list of related entries and their types."""
 
     @model_validator(mode="before")
@@ -44,6 +44,13 @@ def check_id_names(cls, values):
 
         return values
 
+    @model_validator(mode="after")
+    def validate_relationships(self):
+        """Ensure relationships is always a list."""
+        if self.relationships is None:
+            self.relationships = []
+        return self
+
     def to_reference(self, additional_fields: list[str] | None = None) -> "EntryReference":
         """Populate an EntryReference model from this entry, selecting additional fields to inline.
 

pydatalab/src/pydatalab/main.py

@@ -8,14 +8,14 @@ class Equipment(Item):
 
     type: Literal["equipment"] = "equipment"
 
-    serial_numbers: str | None
+    serial_numbers: str | None = None
     """A string describing one or more serial numbers for the instrument."""
 
-    manufacturer: str | None
+    manufacturer: str | None = None
     """The manufacturer of this piece of equipment"""
 
-    location: str | None
+    location: str | None = None
     """Place where the equipment is located"""
 
-    contact: str | None
+    contact: str | None = None
     """Contact information for equipment (e.g., email address or phone number)."""