destiny_sdk 0.5.0__tar.gz → 0.5.1__tar.gz

{destiny_sdk-0.5.0 → destiny_sdk-0.5.1}/.gitignore

@@ -15,6 +15,7 @@ downloads/
 eggs/
 .eggs/
 lib/
+!/ui/lib/
 lib64/
 parts/
 sdist/
@@ -186,6 +187,9 @@ cython_debug/
 # Mac Finder config
 .DS_Store
 
+# Include everything in ui (has its own .gitignore)
+!/ui/
+
 # delete-me working files
 tmp-scripts.sh
 infra/app/*.py

{destiny_sdk-0.5.0 → destiny_sdk-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: destiny_sdk
-Version: 0.5.0
+Version: 0.5.1
 Summary: A software development kit (sdk) to support interaction with the DESTINY repository
 Author-email: Adam Hamilton <adam@futureevidence.org>, Andrew Harvey <andrew@futureevidence.org>, Daniel Breves <daniel@futureevidence.org>, Jack Walmisley <jack@futureevidence.org>
 License-Expression: Apache-2.0

{destiny_sdk-0.5.0 → destiny_sdk-0.5.1}/pyproject.toml

@@ -33,7 +33,7 @@ license = "Apache-2.0"
 name = "destiny_sdk"
 readme = "README.md"
 requires-python = "~=3.12"
-version = "0.5.0"
+version = "0.5.1"
 
 [tool.pytest.ini_options]
 addopts = ["--color=yes", "--import-mode=importlib", "--verbose"]

destiny_sdk-0.5.1/src/destiny_sdk/identifiers.py

@@ -0,0 +1,192 @@
+"""Identifier classes for the Destiny SDK."""
+
+import uuid
+from enum import StrEnum, auto
+from typing import Annotated, Literal, Self
+
+from pydantic import UUID4, BaseModel, Field, TypeAdapter, field_validator
+
+
+class ExternalIdentifierType(StrEnum):
+    """
+    The type of identifier used to identify a reference.
+
+    This is used to identify the type of identifier used in the `ExternalIdentifier`
+    class.
+    """
+
+    DOI = auto()
+    """A DOI (Digital Object Identifier) which is a unique identifier for a document."""
+    PM_ID = auto()
+    """A PubMed ID which is a unique identifier for a document in PubMed."""
+    OPEN_ALEX = auto()
+    """An OpenAlex ID which is a unique identifier for a document in OpenAlex."""
+    OTHER = auto()
+    """Any other identifier not defined. This should be used sparingly."""
+
+
+class DOIIdentifier(BaseModel):
+    """An external identifier representing a DOI."""
+
+    identifier: str = Field(
+        description="The DOI of the reference.",
+        pattern=r"^10\.\d{4,9}/[-._;()/:a-zA-Z0-9%<>\[\]+&]+$",
+    )
+    identifier_type: Literal[ExternalIdentifierType.DOI] = Field(
+        ExternalIdentifierType.DOI, description="The type of identifier used."
+    )
+
+    @field_validator("identifier", mode="before")
+    @classmethod
+    def remove_doi_url(cls, value: str) -> str:
+        """Remove the URL part of the DOI if it exists."""
+        return (
+            value.removeprefix("http://doi.org/")
+            .removeprefix("https://doi.org/")
+            .strip()
+        )
+
+
+class PubMedIdentifier(BaseModel):
+    """An external identifier representing a PubMed ID."""
+
+    identifier: int = Field(description="The PubMed ID of the reference.")
+    identifier_type: Literal[ExternalIdentifierType.PM_ID] = Field(
+        ExternalIdentifierType.PM_ID, description="The type of identifier used."
+    )
+
+
+class OpenAlexIdentifier(BaseModel):
+    """An external identifier representing an OpenAlex ID."""
+
+    identifier: str = Field(
+        description="The OpenAlex ID of the reference.", pattern=r"^W\d+$"
+    )
+    identifier_type: Literal[ExternalIdentifierType.OPEN_ALEX] = Field(
+        ExternalIdentifierType.OPEN_ALEX, description="The type of identifier used."
+    )
+
+    @field_validator("identifier", mode="before")
+    @classmethod
+    def remove_open_alex_url(cls, value: str) -> str:
+        """Remove the OpenAlex URL if it exists."""
+        return (
+            value.removeprefix("http://openalex.org/")
+            .removeprefix("https://openalex.org/")
+            .strip()
+        )
+
+
+class OtherIdentifier(BaseModel):
+    """An external identifier not otherwise defined by the repository."""
+
+    identifier: str = Field(description="The identifier of the reference.")
+    identifier_type: Literal[ExternalIdentifierType.OTHER] = Field(
+        ExternalIdentifierType.OTHER, description="The type of identifier used."
+    )
+    other_identifier_name: str = Field(
+        description="The name of the undocumented identifier type."
+    )
+
+
+#: Union type for all external identifiers.
+ExternalIdentifier = Annotated[
+    DOIIdentifier | PubMedIdentifier | OpenAlexIdentifier | OtherIdentifier,
+    Field(discriminator="identifier_type"),
+]
+
+ExternalIdentifierAdapter: TypeAdapter[ExternalIdentifier] = TypeAdapter(
+    ExternalIdentifier
+)
+
+
+class LinkedExternalIdentifier(BaseModel):
+    """An external identifier which identifies a reference."""
+
+    identifier: ExternalIdentifier = Field(
+        description="The identifier of the reference.",
+        discriminator="identifier_type",
+    )
+    reference_id: UUID4 = Field(
+        description="The ID of the reference this identifier identifies."
+    )
+
+
+class IdentifierLookup(BaseModel):
+    """An external identifier lookup."""
+
+    identifier: str = Field(description="The identifier value.")
+    identifier_type: ExternalIdentifierType | None = Field(
+        description="The type of identifier used. If not provided, it is assumed to"
+        " be a DESTINY identifier.",
+    )
+    other_identifier_name: str | None = Field(
+        default=None,
+        description="The name of the undocumented identifier type.",
+    )
+
+    def serialize(self) -> str:
+        """Serialize the identifier lookup to a string."""
+        if self.identifier_type is None:
+            return self.identifier
+        if self.identifier_type == ExternalIdentifierType.OTHER:
+            return f"other:{self.other_identifier_name}:{self.identifier}"
+        return f"{self.identifier_type.value.lower()}:{self.identifier}"
+
+    @classmethod
+    def parse(cls, identifier_lookup_string: str, delimiter: str = ":") -> Self:
+        """Parse an identifier string into an IdentifierLookup."""
+        if delimiter not in identifier_lookup_string:
+            try:
+                UUID4(identifier_lookup_string)
+            except ValueError as exc:
+                msg = (
+                    f"Invalid identifier lookup string: {identifier_lookup_string}. "
+                    "Must be UUIDv4 if no identifier type is specified."
+                )
+                raise ValueError(msg) from exc
+            return cls(
+                identifier=identifier_lookup_string,
+                identifier_type=None,
+            )
+        identifier_type, identifier = identifier_lookup_string.split(delimiter, 1)
+        if identifier_type == ExternalIdentifierType.OTHER:
+            if delimiter not in identifier:
+                msg = (
+                    f"Invalid identifier lookup string: {identifier_lookup_string}. "
+                    "Other identifier type must include other identifier name."
+                )
+                raise ValueError(msg)
+            other_identifier_type, identifier = identifier.split(delimiter, 1)
+            return cls(
+                identifier=identifier,
+                identifier_type=ExternalIdentifierType.OTHER,
+                other_identifier_name=other_identifier_type,
+            )
+        if identifier_type not in ExternalIdentifierType:
+            msg = (
+                f"Invalid identifier lookup string: {identifier_lookup_string}. "
+                f"Unknown identifier type: {identifier_type}."
+            )
+            raise ValueError(msg)
+        return cls(
+            identifier=identifier,
+            identifier_type=ExternalIdentifierType(identifier_type),
+        )
+
+    @classmethod
+    def from_identifier(cls, identifier: ExternalIdentifier | UUID4) -> Self:
+        """Create an IdentifierLookup from an ExternalIdentifier or UUID4."""
+        if isinstance(identifier, uuid.UUID):
+            return cls(identifier=str(identifier), identifier_type=None)
+        return cls(
+            identifier=str(identifier.identifier),
+            identifier_type=identifier.identifier_type,
+            other_identifier_name=getattr(identifier, "other_identifier_name", None),
+        )
+
+    def to_identifier(self) -> ExternalIdentifier | UUID4:
+        """Convert into an ExternalIdentifier or UUID4 if it has no identifier_type."""
+        if self.identifier_type is None:
+            return UUID4(self.identifier)
+        return ExternalIdentifierAdapter.validate_python(self.model_dump())

destiny_sdk-0.5.1/tests/unit/test_identifiers.py

@@ -0,0 +1,320 @@
+import uuid
+
+import destiny_sdk
+import pytest
+from pydantic import ValidationError
+
+
+def test_valid_doi():
+    obj = destiny_sdk.identifiers.DOIIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+        identifier="10.1000/xyz123",
+    )
+    assert obj.identifier == "10.1000/xyz123"
+
+
+def test_invalid_doi():
+    with pytest.raises(ValidationError, match="String should match pattern"):
+        destiny_sdk.identifiers.DOIIdentifier(
+            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+            identifier="invalid_doi",
+        )
+
+
+def test_doi_url_removed():
+    """Test that a DOI with a URL is fixed to just the DOI part."""
+    obj = destiny_sdk.identifiers.DOIIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+        identifier="http://doi.org/10.1000/xyz123",
+    )
+    assert obj.identifier == "10.1000/xyz123"
+
+
+def test_valid_pmid():
+    identifier = 123456
+
+    obj = destiny_sdk.identifiers.PubMedIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
+        identifier=identifier,
+    )
+    assert obj.identifier == identifier
+
+
+def test_invalid_pmid():
+    with pytest.raises(ValidationError, match="Input should be a valid integer"):
+        destiny_sdk.identifiers.PubMedIdentifier(
+            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
+            identifier="abc123",
+        )
+
+
+def test_valid_open_alex():
+    valid_open_alex = "W123456789"
+    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+        identifier=valid_open_alex,
+    )
+    assert obj.identifier == valid_open_alex
+
+
+def test_open_alex_url_removed():
+    identitier = "W123456789"
+    valid_openalex_with_url_https = f"https://openalex.org/{identitier}"
+
+    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+        identifier=valid_openalex_with_url_https,
+    )
+
+    assert obj.identifier == identitier
+
+    valid_openalex_with_url_http = f"http://openalex.org/{identitier}"
+
+    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+        identifier=valid_openalex_with_url_http,
+    )
+
+    assert obj.identifier == identitier
+
+
+def test_invalid_open_alex():
+    with pytest.raises(ValidationError, match="String should match pattern"):
+        destiny_sdk.identifiers.OpenAlexIdentifier(
+            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+            identifier="invalid-openalex",
+        )
+
+
+def test_valid_other_identifier():
+    obj = destiny_sdk.identifiers.OtherIdentifier(
+        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
+        identifier="custom_identifier",
+        other_identifier_name="custom_type",
+    )
+    assert obj.other_identifier_name == "custom_type"
+
+
+def test_invalid_other_identifier_missing_name():
+    with pytest.raises(
+        ValidationError,
+        match="Field required",
+    ):
+        destiny_sdk.identifiers.OtherIdentifier(
+            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
+            identifier="custom_identifier",
+        )
+
+
+# IdentifierLookup Tests
+
+
+class TestIdentifierLookupSerialization:
+    """Test serialization of IdentifierLookup objects."""
+
+    @pytest.mark.parametrize(
+        ("identifier_type", "identifier", "other_name", "expected"),
+        [
+            # UUID (no type)
+            (
+                None,
+                "550e8400-e29b-41d4-a716-446655440000",
+                None,
+                "550e8400-e29b-41d4-a716-446655440000",
+            ),
+            # Standard identifier types
+            (
+                destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+                "10.1000/xyz123",
+                None,
+                "doi:10.1000/xyz123",
+            ),
+            (
+                destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
+                "12345",
+                None,
+                "pm_id:12345",
+            ),
+            (
+                destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+                "W123456789",
+                None,
+                "open_alex:W123456789",
+            ),
+            # Other identifier type
+            (
+                destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
+                "custom123",
+                "arxiv",
+                "other:arxiv:custom123",
+            ),
+        ],
+    )
+    def test_serialize(self, identifier_type, identifier, other_name, expected):
+        lookup = destiny_sdk.identifiers.IdentifierLookup(
+            identifier=identifier,
+            identifier_type=identifier_type,
+            other_identifier_name=other_name,
+        )
+        assert lookup.serialize() == expected
+
+    def test_serialize_custom_delimiter(self):
+        lookup = destiny_sdk.identifiers.IdentifierLookup(
+            identifier="10.1000/xyz123",
+            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+        )
+        # Default delimiter should still work
+        assert lookup.serialize() == "doi:10.1000/xyz123"
+
+
+class TestIdentifierLookup:
+    """Test parsing of identifier lookup strings."""
+
+    @pytest.mark.parametrize(
+        (
+            "input_identifier",
+            "expected_lookup",
+            "expected_serialization",
+        ),
+        [
+            # UUID (no type)
+            (
+                uuid.UUID("550e8400-e29b-41d4-a716-446655440000"),
+                destiny_sdk.identifiers.IdentifierLookup(
+                    identifier="550e8400-e29b-41d4-a716-446655440000",
+                    identifier_type=None,
+                ),
+                "550e8400-e29b-41d4-a716-446655440000",
+            ),
+            # DOI identifier
+            (
+                destiny_sdk.identifiers.DOIIdentifier(
+                    identifier="10.1000/xyz123",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+                ),
+                destiny_sdk.identifiers.IdentifierLookup(
+                    identifier="10.1000/xyz123",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
+                ),
+                "doi:10.1000/xyz123",
+            ),
+            # PubMed identifier
+            (
+                destiny_sdk.identifiers.PubMedIdentifier(
+                    identifier=12345,
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
+                ),
+                destiny_sdk.identifiers.IdentifierLookup(
+                    identifier="12345",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
+                ),
+                "pm_id:12345",
+            ),
+            # OpenAlex identifier
+            (
+                destiny_sdk.identifiers.OpenAlexIdentifier(
+                    identifier="W123456789",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+                ),
+                destiny_sdk.identifiers.IdentifierLookup(
+                    identifier="W123456789",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
+                ),
+                "open_alex:W123456789",
+            ),
+            # Other identifier type
+            (
+                destiny_sdk.identifiers.OtherIdentifier(
+                    identifier="custom123",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
+                    other_identifier_name="arxiv",
+                ),
+                destiny_sdk.identifiers.IdentifierLookup(
+                    identifier="custom123",
+                    identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
+                    other_identifier_name="arxiv",
+                ),
+                "other:arxiv:custom123",
+            ),
+        ],
+    )
+    def test_full_round_trip(
+        self, input_identifier, expected_lookup, expected_serialization
+    ):
+        # Step 1: Convert input identifier to IdentifierLookup using from_identifier
+        lookup = destiny_sdk.identifiers.IdentifierLookup.from_identifier(
+            input_identifier
+        )
+
+        # Step 2: Compare to expected IdentifierLookup
+        assert lookup.identifier == expected_lookup.identifier
+        assert lookup.identifier_type == expected_lookup.identifier_type
+        assert lookup.other_identifier_name == expected_lookup.other_identifier_name
+
+        # Step 3: Serialize the IdentifierLookup
+        serialized = lookup.serialize()
+
+        # Step 4: Check the serialization matches expected
+        assert serialized == expected_serialization
+
+        # Step 5: Parse it back
+        parsed = destiny_sdk.identifiers.IdentifierLookup.parse(serialized)
+
+        # Step 6: Assert parsed is the same as the lookup
+        assert parsed.identifier == lookup.identifier
+        assert parsed.identifier_type == lookup.identifier_type
+        assert parsed.other_identifier_name == lookup.other_identifier_name
+
+        # Step 7: Convert back to identifier using to_identifier
+        result_identifier = parsed.to_identifier()
+
+        # Step 8: Assert result is the same as input
+        if isinstance(input_identifier, uuid.UUID):
+            assert isinstance(result_identifier, uuid.UUID)
+            assert str(result_identifier) == str(input_identifier)
+        else:
+            assert isinstance(result_identifier, type(input_identifier))
+            assert result_identifier.identifier == input_identifier.identifier
+            assert result_identifier.identifier_type == input_identifier.identifier_type
+            if hasattr(input_identifier, "other_identifier_name"):
+                assert (
+                    result_identifier.other_identifier_name
+                    == input_identifier.other_identifier_name
+                )
+
+    def test_parse_invalid_uuid(self):
+        with pytest.raises(
+            ValueError, match="Must be UUIDv4 if no identifier type is specified"
+        ):
+            destiny_sdk.identifiers.IdentifierLookup.parse("not-a-uuid")
+
+    def test_parse_unknown_identifier_type(self):
+        with pytest.raises(ValueError, match="Unknown identifier type: unknown"):
+            destiny_sdk.identifiers.IdentifierLookup.parse("unknown:12345")
+
+    def test_parse_other_missing_name(self):
+        with pytest.raises(
+            ValueError,
+            match="Other identifier type must include other identifier name",
+        ):
+            destiny_sdk.identifiers.IdentifierLookup.parse("other:12345")
+
+    def test_parse_custom_delimiter(self):
+        lookup = destiny_sdk.identifiers.IdentifierLookup.parse(
+            "doi|10.1000/xyz123", delimiter="|"
+        )
+        assert lookup.identifier == "10.1000/xyz123"
+        assert (
+            lookup.identifier_type == destiny_sdk.identifiers.ExternalIdentifierType.DOI
+        )
+
+    def test_parse_with_colon(self):
+        lookup = destiny_sdk.identifiers.IdentifierLookup.parse(
+            "other:foobar:a:b:c", delimiter=":"
+        )
+        assert lookup.identifier == "a:b:c"
+        assert (
+            lookup.identifier_type
+            == destiny_sdk.identifiers.ExternalIdentifierType.OTHER
+        )
+        assert lookup.other_identifier_name == "foobar"

{destiny_sdk-0.5.0 → destiny_sdk-0.5.1}/uv.lock

@@ -63,7 +63,7 @@ wheels = [
 
 [[package]]
 name = "destiny-sdk"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "cachetools" },

destiny_sdk-0.5.0/src/destiny_sdk/identifiers.py

@@ -1,107 +0,0 @@
-"""Identifier classes for the Destiny SDK."""
-
-from enum import StrEnum, auto
-from typing import Annotated, Literal
-
-from pydantic import UUID4, BaseModel, Field, field_validator
-
-
-class ExternalIdentifierType(StrEnum):
-    """
-    The type of identifier used to identify a reference.
-
-    This is used to identify the type of identifier used in the `ExternalIdentifier`
-    class.
-    """
-
-    DOI = auto()
-    """A DOI (Digital Object Identifier) which is a unique identifier for a document."""
-    PM_ID = auto()
-    """A PubMed ID which is a unique identifier for a document in PubMed."""
-    OPEN_ALEX = auto()
-    """An OpenAlex ID which is a unique identifier for a document in OpenAlex."""
-    OTHER = auto()
-    """Any other identifier not defined. This should be used sparingly."""
-
-
-class DOIIdentifier(BaseModel):
-    """An external identifier representing a DOI."""
-
-    identifier: str = Field(
-        description="The DOI of the reference.",
-        pattern=r"^10\.\d{4,9}/[-._;()/:a-zA-Z0-9%<>\[\]+&]+$",
-    )
-    identifier_type: Literal[ExternalIdentifierType.DOI] = Field(
-        ExternalIdentifierType.DOI, description="The type of identifier used."
-    )
-
-    @field_validator("identifier", mode="before")
-    @classmethod
-    def remove_doi_url(cls, value: str) -> str:
-        """Remove the URL part of the DOI if it exists."""
-        return (
-            value.removeprefix("http://doi.org/")
-            .removeprefix("https://doi.org/")
-            .strip()
-        )
-
-
-class PubMedIdentifier(BaseModel):
-    """An external identifier representing a PubMed ID."""
-
-    identifier: int = Field(description="The PubMed ID of the reference.")
-    identifier_type: Literal[ExternalIdentifierType.PM_ID] = Field(
-        ExternalIdentifierType.PM_ID, description="The type of identifier used."
-    )
-
-
-class OpenAlexIdentifier(BaseModel):
-    """An external identifier representing an OpenAlex ID."""
-
-    identifier: str = Field(
-        description="The OpenAlex ID of the reference.", pattern=r"^W\d+$"
-    )
-    identifier_type: Literal[ExternalIdentifierType.OPEN_ALEX] = Field(
-        ExternalIdentifierType.OPEN_ALEX, description="The type of identifier used."
-    )
-
-    @field_validator("identifier", mode="before")
-    @classmethod
-    def remove_open_alex_url(cls, value: str) -> str:
-        """Remove the OpenAlex URL if it exists."""
-        return (
-            value.removeprefix("http://openalex.org/")
-            .removeprefix("https://openalex.org/")
-            .strip()
-        )
-
-
-class OtherIdentifier(BaseModel):
-    """An external identifier not otherwise defined by the repository."""
-
-    identifier: str = Field(description="The identifier of the reference.")
-    identifier_type: Literal[ExternalIdentifierType.OTHER] = Field(
-        ExternalIdentifierType.OTHER, description="The type of identifier used."
-    )
-    other_identifier_name: str = Field(
-        description="The name of the undocumented identifier type."
-    )
-
-
-#: Union type for all external identifiers.
-ExternalIdentifier = Annotated[
-    DOIIdentifier | PubMedIdentifier | OpenAlexIdentifier | OtherIdentifier,
-    Field(discriminator="identifier_type"),
-]
-
-
-class LinkedExternalIdentifier(BaseModel):
-    """An external identifier which identifies a reference."""
-
-    identifier: ExternalIdentifier = Field(
-        description="The identifier of the reference.",
-        discriminator="identifier_type",
-    )
-    reference_id: UUID4 = Field(
-        description="The ID of the reference this identifier identifies."
-    )

destiny_sdk-0.5.0/tests/unit/test_identifiers.py

@@ -1,104 +0,0 @@
-import destiny_sdk
-import pytest
-from pydantic import ValidationError
-
-
-def test_valid_doi():
-    obj = destiny_sdk.identifiers.DOIIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
-        identifier="10.1000/xyz123",
-    )
-    assert obj.identifier == "10.1000/xyz123"
-
-
-def test_invalid_doi():
-    with pytest.raises(ValidationError, match="String should match pattern"):
-        destiny_sdk.identifiers.DOIIdentifier(
-            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
-            identifier="invalid_doi",
-        )
-
-
-def test_doi_url_removed():
-    """Test that a DOI with a URL is fixed to just the DOI part."""
-    obj = destiny_sdk.identifiers.DOIIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.DOI,
-        identifier="http://doi.org/10.1000/xyz123",
-    )
-    assert obj.identifier == "10.1000/xyz123"
-
-
-def test_valid_pmid():
-    identifier = 123456
-
-    obj = destiny_sdk.identifiers.PubMedIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
-        identifier=identifier,
-    )
-    assert obj.identifier == identifier
-
-
-def test_invalid_pmid():
-    with pytest.raises(ValidationError, match="Input should be a valid integer"):
-        destiny_sdk.identifiers.PubMedIdentifier(
-            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.PM_ID,
-            identifier="abc123",
-        )
-
-
-def test_valid_open_alex():
-    valid_open_alex = "W123456789"
-    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
-        identifier=valid_open_alex,
-    )
-    assert obj.identifier == valid_open_alex
-
-
-def test_open_alex_url_removed():
-    identitier = "W123456789"
-    valid_openalex_with_url_https = f"https://openalex.org/{identitier}"
-
-    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
-        identifier=valid_openalex_with_url_https,
-    )
-
-    assert obj.identifier == identitier
-
-    valid_openalex_with_url_http = f"http://openalex.org/{identitier}"
-
-    obj = destiny_sdk.identifiers.OpenAlexIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
-        identifier=valid_openalex_with_url_http,
-    )
-
-    assert obj.identifier == identitier
-
-
-def test_invalid_open_alex():
-    with pytest.raises(ValidationError, match="String should match pattern"):
-        destiny_sdk.identifiers.OpenAlexIdentifier(
-            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OPEN_ALEX,
-            identifier="invalid-openalex",
-        )
-
-
-def test_valid_other_identifier():
-    obj = destiny_sdk.identifiers.OtherIdentifier(
-        identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
-        identifier="custom_identifier",
-        other_identifier_name="custom_type",
-    )
-    assert obj.other_identifier_name == "custom_type"
-
-
-def test_invalid_other_identifier_missing_name():
-    with pytest.raises(
-        ValidationError,
-        match="Field required",
-    ):
-        destiny_sdk.identifiers.OtherIdentifier(
-            identifier_type=destiny_sdk.identifiers.ExternalIdentifierType.OTHER,
-            identifier="custom_identifier",
-        )