canvas 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

canvas_sdk/commands/tests/schema/tests.py

@@ -18,16 +18,19 @@ from canvas_sdk.commands.tests.test_utils import (
 
 @pytest.fixture(scope="session")
 def token() -> MaskedValue:
+    """Get a valid token."""
     return get_token()
 
 
 @pytest.fixture(scope="session")
 def new_note(token: MaskedValue) -> dict:
+    """Create a new note."""
     return create_new_note(token)
 
 
 @pytest.fixture
 def command_type_map() -> dict[str, type]:
+    """Map of command field types to their corresponding Python types."""
     return {
         "AutocompleteField": str,
         "MultiLineTextField": str,
@@ -51,6 +54,7 @@ def test_command_schema_matches_command_api(
     new_note: dict,
     Command: _BaseCommand,
 ) -> None:
+    """Test that the command schema matches the command API."""
     # first create the command in the new note
     data = {"noteKey": new_note["externallyExposableId"], "schemaKey": Command.Meta.key}
     headers = {"Authorization": f"Bearer {token.value}"}
@@ -90,7 +94,7 @@ def test_command_schema_matches_command_api(
             # this condition initially created for Prescribe.indications,
             # but could apply to other AutocompleteField fields that are lists
             # making the assumption here that if the field ends in 's' (like indications), it is a list
-            assert get_origin(expected_type) == list
+            assert get_origin(expected_type) is list
 
         else:
             assert expected_type == actual_type

canvas_sdk/commands/tests/test_utils.py

@@ -35,6 +35,8 @@ runner = CliRunner()
 
 
 class MaskedValue:
+    """A class to mask sensitive values in tests."""
+
     def __init__(self, value: str) -> None:
         self.value = value
 
@@ -46,6 +48,7 @@ class MaskedValue:
 
 
 def get_field_type_unformatted(field_props: dict[str, Any]) -> str:
+    """Get the unformatted field type from the field properties."""
     if t := field_props.get("type"):
         return field_props.get("format") or t
 
@@ -56,14 +59,17 @@ def get_field_type_unformatted(field_props: dict[str, Any]) -> str:
 
 
 def get_field_type(field_props: dict) -> str:
+    """Get the field type from the field properties."""
     return get_field_type_unformatted(field_props).replace("-", "").replace("array", "list")
 
 
 def random_string() -> str:
+    """Generate a random string."""
     return "".join(random.choices(string.ascii_uppercase + string.digits, k=7))
 
 
 def fake(field_props: dict, Command: type[_BaseCommand]) -> Any:
+    """Generate a fake value for a field."""
     t = get_field_type(field_props)
     match t:
         case "string":
@@ -89,13 +95,14 @@ def fake(field_props: dict, Command: type[_BaseCommand]) -> Any:
         case "ClinicalQuantity":
             return ClinicalQuantity(representative_ndc="ndc", ncpdp_quantity_qualifier_code="code")
     if t[0].isupper():
-        return random.choice([e for e in getattr(Command, t)])
+        return random.choice(list(getattr(Command, t)))
 
 
 def raises_wrong_type_error(
     Command: type[_BaseCommand],
     field: str,
 ) -> None:
+    """Test that the correct error is raised when the wrong type is passed to a field."""
     field_props = Command.model_json_schema()["properties"][field]
     field_type = get_field_type(field_props)
     wrong_field_type = "integer" if field_type == "string" else "string"
@@ -119,8 +126,8 @@ def raises_wrong_type_error(
         "dictionary" if field_type == "Coding" or field_type == "ClinicalQuantity" else field_type
     )
     if field_type == "number":
-        assert f"Input should be an instance of Decimal" in err_msg1
-        assert f"Input should be an instance of Decimal" in err_msg2
+        assert "Input should be an instance of Decimal" in err_msg1
+        assert "Input should be an instance of Decimal" in err_msg2
     elif field_type[0].isupper():
         assert f"Input should be an instance of {Command.__name__}.{field_type}" in err_msg1
         assert f"Input should be an instance of {Command.__name__}.{field_type}" in err_msg2
@@ -133,6 +140,7 @@ def raises_none_error_for_effect_method(
     Command: type[_BaseCommand],
     method: str,
 ) -> None:
+    """Test that the correct error is raised when a required field is None for an effect method."""
     cmd_name = Command.__name__
     cmd_name_article = "an" if cmd_name.startswith(("A", "E", "I", "O", "U")) else "a"
 
@@ -155,6 +163,7 @@ def raises_none_error_for_effect_method(
 def write_protocol_code(
     note_uuid: str, plugin_name: str, commands: list[type[_BaseCommand]]
 ) -> None:
+    """Test that the protocol code is written correctly."""
     imports = ", ".join([c.__name__ for c in commands])
     effects = ", ".join([f"{c.__name__}(note_uuid='{note_uuid}').originate()" for c in commands])
 
@@ -171,21 +180,23 @@ class Protocol(BaseProtocol):
     with chdir(Path("./custom-plugins")):
         runner.invoke(app, "init", input=plugin_name)
 
-    protocol = open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w")
-    protocol.write(protocol_code)
-    protocol.close()
+    with open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w") as protocol:
+        protocol.write(protocol_code)
 
 
 def install_plugin(plugin_name: str, token: MaskedValue) -> None:
-    requests.post(
-        plugin_url(cast(str, settings.INTEGRATION_TEST_URL)),
-        data={"is_enabled": True},
-        files={"package": open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb")},
-        headers={"Authorization": f"Bearer {token.value}"},
-    )
+    """Install a plugin."""
+    with open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb") as package:
+        requests.post(
+            plugin_url(cast(str, settings.INTEGRATION_TEST_URL)),
+            data={"is_enabled": True},
+            files={"package": package},
+            headers={"Authorization": f"Bearer {token.value}"},
+        )
 
 
 def trigger_plugin_event(token: MaskedValue) -> None:
+    """Trigger a plugin event."""
     requests.post(
         f"{settings.INTEGRATION_TEST_URL}/api/Note/",
         headers={
@@ -204,6 +215,7 @@ def trigger_plugin_event(token: MaskedValue) -> None:
 
 
 def get_original_note_body_commands(new_note_id: int, token: MaskedValue) -> list[str]:
+    """Get the commands from the original note body."""
     original_note = requests.get(
         f"{settings.INTEGRATION_TEST_URL}/api/Note/{new_note_id}",
         headers={
@@ -225,6 +237,7 @@ def get_original_note_body_commands(new_note_id: int, token: MaskedValue) -> lis
 
 
 def clean_up_files_and_plugins(plugin_name: str, token: MaskedValue) -> None:
+    """Clean up the files and plugins."""
     # clean up
     if Path(f"./custom-plugins/{plugin_name}").exists():
         shutil.rmtree(Path(f"./custom-plugins/{plugin_name}"))
@@ -261,6 +274,7 @@ COMMANDS: list[type[_BaseCommand]] = [
 
 
 def create_new_note(token: MaskedValue) -> dict:
+    """Create a new note."""
     headers = {
         "Authorization": f"Bearer {token.value}",
         "Content-Type": "application/json",
@@ -279,6 +293,7 @@ def create_new_note(token: MaskedValue) -> dict:
 
 
 def get_token() -> MaskedValue:
+    """Get a valid token."""
     return MaskedValue(
         requests.post(
             f"{settings.INTEGRATION_TEST_URL}/auth/token/",

canvas_sdk/commands/tests/unit/tests.py

@@ -82,6 +82,7 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     Command: type[_BaseCommand],
     fields_to_test: tuple[str],
 ) -> None:
+    """Test that Command raises a generic error when a kwarg is given an incorrect type."""
     for field in fields_to_test:
         raises_wrong_type_error(Command, field)
 
@@ -184,6 +185,7 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     err_msg: str,
     valid_kwargs: dict,
 ) -> None:
+    """Test that Command raises a specific error when a kwarg is given an incorrect type."""
     with pytest.raises(ValidationError) as e1:
         cmd = Command(**err_kwargs)
         cmd.originate()
@@ -258,6 +260,7 @@ def test_command_allows_kwarg_with_correct_type(
     Command: type[_BaseCommand],
     fields_to_test: tuple[str],
 ) -> None:
+    """Test that Command allows a kwarg with the correct type."""
     schema = Command.model_json_schema()
 
     for field in fields_to_test:

canvas_sdk/effects/__init__.py

@@ -1 +1,3 @@
 from canvas_generated.messages.effects_pb2 import Effect, EffectType
+
+__all__ = ("Effect", "EffectType")

canvas_sdk/effects/banner_alert/__init__.py

@@ -1,2 +1,4 @@
 from canvas_sdk.effects.banner_alert.add_banner_alert import AddBannerAlert
 from canvas_sdk.effects.banner_alert.remove_banner_alert import RemoveBannerAlert
+
+__all__ = ("AddBannerAlert", "RemoveBannerAlert")

canvas_sdk/effects/banner_alert/tests.py

@@ -1,8 +1,9 @@
 import shutil
+from collections.abc import Generator
 from contextlib import chdir
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Generator
+from typing import Any
 
 import pytest
 import requests
@@ -21,6 +22,7 @@ runner = CliRunner()
 
 @pytest.fixture(scope="session")
 def token() -> MaskedValue:
+    """Get a valid token."""
     return MaskedValue(
         requests.post(
             f"{settings.INTEGRATION_TEST_URL}/auth/token/",
@@ -36,6 +38,7 @@ def token() -> MaskedValue:
 
 @pytest.fixture(scope="session")
 def first_patient_id(token: MaskedValue) -> dict:
+    """Get the first patient id."""
     headers = {
         "Authorization": f"Bearer {token.value}",
         "Content-Type": "application/json",
@@ -47,6 +50,7 @@ def first_patient_id(token: MaskedValue) -> dict:
 
 @pytest.fixture(scope="session")
 def plugin_name() -> str:
+    """Get the plugin name to be used."""
     return f"addbanneralert{datetime.now().timestamp()}".replace(".", "")
 
 
@@ -54,7 +58,7 @@ def plugin_name() -> str:
 def write_and_install_protocol_and_clean_up(
     first_patient_id: str, plugin_name: str, token: MaskedValue
 ) -> Generator[Any, Any, Any]:
-
+    """Write the protocol code, install the plugin, and clean up after the test."""
     if not settings.INTEGRATION_TEST_URL:
         raise ImproperlyConfigured("INTEGRATION_TEST_URL is not set")
 
@@ -62,9 +66,8 @@ def write_and_install_protocol_and_clean_up(
     with chdir(Path("./custom-plugins")):
         runner.invoke(app, "init", input=plugin_name)
 
-    protocol = open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w")
-    protocol.write(
-        f"""from canvas_sdk.effects.banner_alert import AddBannerAlert
+    protocol_code = f"""
+from canvas_sdk.effects.banner_alert import AddBannerAlert
 from canvas_sdk.events import EventType
 from canvas_sdk.protocols import BaseProtocol
 
@@ -81,16 +84,18 @@ class Protocol(BaseProtocol):
             ).apply()
         ]
 """
-    )
-    protocol.close()
 
-    # install the plugin
-    requests.post(
-        plugin_url(settings.INTEGRATION_TEST_URL),
-        data={"is_enabled": True},
-        files={"package": open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb")},
-        headers={"Authorization": f"Bearer {token.value}"},
-    )
+    with open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w") as protocol:
+        protocol.write(protocol_code)
+
+    with open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb") as package:
+        # install the plugin
+        requests.post(
+            plugin_url(settings.INTEGRATION_TEST_URL),
+            data={"is_enabled": True},
+            files={"package": package},
+            headers={"Authorization": f"Bearer {token.value}"},
+        )
 
     yield
 
@@ -132,6 +137,7 @@ def test_protocol_that_adds_banner_alert(
     plugin_name: str,
     first_patient_id: str,
 ) -> None:
+    """Test that the protocol adds a banner alert."""
     # trigger the event
     requests.post(
         f"{settings.INTEGRATION_TEST_URL}/api/Note/",
@@ -206,6 +212,7 @@ def test_protocol_that_adds_banner_alert(
 def test_banner_alert_apply_method_succeeds_with_all_required_fields(
     Effect: type[AddBannerAlert] | type[RemoveBannerAlert], params: dict, expected_payload: str
 ) -> None:
+    """Test that the apply method succeeds with all required fields."""
     b = Effect()
     for k, v in params.items():
         setattr(b, k, v)
@@ -240,6 +247,7 @@ def test_banner_alert_apply_method_succeeds_with_all_required_fields(
 def test_banner_alert_apply_method_raises_error_without_required_fields(
     Effect: type[AddBannerAlert] | type[RemoveBannerAlert], expected_err_msgs: str
 ) -> None:
+    """Test that the apply method raises an error when missing required fields."""
     b = Effect()
     with pytest.raises(ValidationError) as e:
         b.apply()

canvas_sdk/effects/protocol_card/__init__.py

@@ -1 +1,3 @@
 from canvas_sdk.effects.protocol_card.protocol_card import ProtocolCard, Recommendation
+
+__all__ = ("ProtocolCard", "Recommendation")

canvas_sdk/effects/protocol_card/tests.py

@@ -21,6 +21,7 @@ from canvas_sdk.effects.protocol_card import ProtocolCard, Recommendation
 
 
 def test_apply_method_succeeds_with_patient_id_and_key() -> None:
+    """Test that the apply method succeeds with all required fields."""
     p = ProtocolCard(patient_id="uuid", key="something-unique")
     applied = p.apply()
     assert (
@@ -30,6 +31,7 @@ def test_apply_method_succeeds_with_patient_id_and_key() -> None:
 
 
 def test_apply_method_raises_error_without_patient_id_and_key() -> None:
+    """Test that the apply method raises an error when missing required fields."""
     p = ProtocolCard()
 
     with pytest.raises(ValidationError) as e:
@@ -109,6 +111,7 @@ def test_apply_method_raises_error_without_patient_id_and_key() -> None:
 def test_add_recommendations(
     init_params: dict[Any, Any], rec1_params: dict[Any, Any], rec2_params: dict[Any, Any]
 ) -> None:
+    """Test that the add_recommendation method adds recommendations to the ProtocolCard."""
     p = ProtocolCard(**init_params)
     p.add_recommendation(**rec1_params)
     p.recommendations.append(Recommendation(**rec2_params))
@@ -117,17 +120,17 @@ def test_add_recommendations(
         "narrative": init_params["narrative"],
         "recommendations": [
             {
-                "title": rec1_params.get("title", None),
-                "button": rec1_params.get("button", None),
-                "href": rec1_params.get("href", None),
+                "title": rec1_params.get("title"),
+                "button": rec1_params.get("button"),
+                "href": rec1_params.get("href"),
                 "command": {"type": rec1_params["command"]} if "command" in rec1_params else {},
                 "context": rec1_params.get("context", {}),
                 "key": 0,
             },
             {
-                "title": rec2_params.get("title", None),
-                "button": rec2_params.get("button", None),
-                "href": rec2_params.get("href", None),
+                "title": rec2_params.get("title"),
+                "button": rec2_params.get("button"),
+                "href": rec2_params.get("href"),
                 "command": {"type": rec2_params["command"]} if "command" in rec2_params else {},
                 "context": rec2_params.get("context", {}),
                 "key": 1,
@@ -158,6 +161,7 @@ def test_add_recommendations(
 def test_add_recommendations_from_commands(
     Command: type[_BaseCommand], init_params: dict[str, str]
 ) -> None:
+    """Test that the add_recommendation method adds recommendations from commands to the ProtocolCard."""
     cmd = Command(**init_params)
     p = ProtocolCard(patient_id="uuid", key="commands")
     p.recommendations.append(cmd.recommend())

canvas_sdk/events/__init__.py

@@ -1 +1,3 @@
 from canvas_generated.messages.events_pb2 import Event, EventResponse, EventType
+
+__all__ = ("Event", "EventResponse", "EventType")

canvas_sdk/handlers/__init__.py

@@ -1 +1,3 @@
 from canvas_sdk.handlers.base import BaseHandler
+
+__all__ = ("BaseHandler",)

canvas_sdk/protocols/__init__.py

@@ -1,2 +1,4 @@
 from canvas_sdk.protocols.base import BaseProtocol
 from canvas_sdk.protocols.clinical_quality_measure import ClinicalQualityMeasure
+
+__all__ = ("BaseProtocol", "ClinicalQualityMeasure")

canvas_sdk/protocols/base.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from canvas_sdk.handlers.base import BaseHandler
 
 

canvas_sdk/protocols/clinical_quality_measure.py

@@ -88,7 +88,8 @@ class ClinicalQualityMeasure(BaseProtocol):
                 case EventType.CONDITION_CREATED | EventType.CONDITION_UPDATED:
                     self._patient_id = patient_id(Condition)
                 case (
-                    EventType.MEDICATION_LIST_ITEM_CREATED | EventType.MEDICATION_LIST_ITEM_UPDATED
+                    EventType.MEDICATION_LIST_ITEM_CREATED
+                    | EventType.MEDICATION_LIST_ITEM_UPDATED
                 ):
                     self._patient_id = patient_id(Medication)
                 case _:

canvas_sdk/utils/http.py

@@ -1,6 +1,7 @@
 import time
+from collections.abc import Callable, Mapping
 from functools import wraps
-from typing import Any, Callable, Mapping, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import requests
 import statsd

canvas_sdk/utils/tests.py

@@ -5,6 +5,7 @@ from canvas_sdk.utils import Http
 
 @patch("requests.Session.get")
 def test_http_get(mock_get: MagicMock) -> None:
+    """Test that the Http.get method calls requests.get with the correct arguments."""
     http = Http()
     http.get("https://www.canvasmedical.com/", headers={"Authorization": "Bearer as;ldkfjdkj"})
     mock_get.assert_called_once_with(
@@ -14,6 +15,7 @@ def test_http_get(mock_get: MagicMock) -> None:
 
 @patch("requests.Session.post")
 def test_http_post(mock_post: MagicMock) -> None:
+    """Test that the Http.post method calls requests.post with the correct arguments."""
     http = Http()
     http.post(
         "https://www.canvasmedical.com/",
@@ -31,6 +33,7 @@ def test_http_post(mock_post: MagicMock) -> None:
 
 @patch("requests.Session.put")
 def test_http_put(mock_put: MagicMock) -> None:
+    """Test that the Http.put method calls requests.put with the correct arguments."""
     http = Http()
     http.put(
         "https://www.canvasmedical.com/",
@@ -48,6 +51,7 @@ def test_http_put(mock_put: MagicMock) -> None:
 
 @patch("requests.Session.patch")
 def test_http_patch(mock_patch: MagicMock) -> None:
+    """Test that the Http.patch method calls requests.patch with the correct arguments."""
     http = Http()
     http.patch(
         "https://www.canvasmedical.com/",

canvas_sdk/v1/data/__init__.py

@@ -4,3 +4,16 @@ from .medication import Medication, MedicationCoding
 from .patient import Patient
 from .staff import Staff
 from .task import Task, TaskComment, TaskLabel
+
+__all__ = (
+    "BillingLineItem",
+    "Condition",
+    "ConditionCoding",
+    "Medication",
+    "MedicationCoding",
+    "Patient",
+    "Staff",
+    "Task",
+    "TaskComment",
+    "TaskLabel",
+)

canvas_sdk/v1/data/allergy_intolerance.py

@@ -1,4 +1,3 @@
-from django.contrib.postgres.fields import ArrayField
 from django.db import models
 
 from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet

canvas_sdk/v1/data/base.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 from collections.abc import Container
-from typing import TYPE_CHECKING, Any, Protocol, Self, Type, cast
+from typing import TYPE_CHECKING, Any, Protocol, Self, cast
 
 from django.db import models
 from django.db.models import Q
@@ -50,7 +50,7 @@ class ValueSetLookupQuerySetProtocol(QuerySetProtocol):
 
     @staticmethod
     @abstractmethod
-    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+    def codings(value_set: type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
         """A protocol method for defining codings."""
         raise NotImplementedError
 
@@ -64,7 +64,7 @@ class ValueSetLookupQuerySetProtocol(QuerySetProtocol):
 class ValueSetLookupQuerySetMixin(ValueSetLookupQuerySetProtocol):
     """A QuerySet mixin that can filter objects based on a ValueSet."""
 
-    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet[Any]:
+    def find(self, value_set: type["ValueSet"]) -> models.QuerySet[Any]:
         """
         Filters conditions, medications, etc. to those found in the inherited ValueSet class that is passed.
 
@@ -84,7 +84,7 @@ class ValueSetLookupQuerySetMixin(ValueSetLookupQuerySetProtocol):
         return self.filter(q_filter).distinct()
 
     @staticmethod
-    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+    def codings(value_set: type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
         """Provide a sequence of tuples where each tuple is a code system URL and a set of codes."""
         values_dict = cast(dict, value_set.values)
         return cast(
@@ -113,7 +113,7 @@ class ValueSetLookupByNameQuerySetMixin(ValueSetLookupQuerySetMixin):
     """
 
     @staticmethod
-    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+    def codings(value_set: type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
         """
         Provide a sequence of tuples where each tuple is a code system name and a set of codes.
         """

canvas_sdk/v1/data/billing.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Type
+from typing import TYPE_CHECKING
 
 from django.db import models
 
@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 class BillingLineItemQuerySet(ValueSetTimeframeLookupQuerySet):
     """A class that adds functionality to filter BillingLineItem objects."""
 
-    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
+    def find(self, value_set: type["ValueSet"]) -> models.QuerySet:
         """
         This method is overridden to use for BillingLineItem CPT codes.
         The codes are saved as string values in the BillingLineItem.cpt field,

canvas_sdk/v1/data/common.py

@@ -1,4 +1,3 @@
-from django.contrib.postgres.fields import ArrayField
 from django.db import models
 
 

canvas_sdk/v1/data/patient.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Self
+from typing import Self
 
 import arrow
 from django.db import models

canvas_sdk/v1/data/questionnaire.py

@@ -153,7 +153,8 @@ class Interview(models.Model):
     note_id = models.BigIntegerField()
     appointment_id = models.BigIntegerField()
     questionnaires = models.ManyToManyField(  # type: ignore[var-annotated]
-        Questionnaire, through="canvas_sdk.InterviewQuestionnaireMap"  # type: ignore[misc]
+        Questionnaire,
+        through="canvas_sdk.InterviewQuestionnaireMap",  # type: ignore[misc]
     )
     progress_status = models.CharField()
     created = models.DateTimeField()

canvas_sdk/value_set/custom.py

@@ -115,7 +115,6 @@ class Antiarrhythmics(ValueSet):
         "230155",
         "237183",
         "243776",
-        "243776",
         "248491",
         "248829",
         "250272",
@@ -129,9 +128,6 @@ class Antiarrhythmics(ValueSet):
         "265785",
         "274471",
         "278255",
-        "278255",
-        "278255",
-        "278255",
         "280333",
         "281153",
         "283306",
@@ -139,8 +135,6 @@ class Antiarrhythmics(ValueSet):
         "291187",
         "296991",
         "444249",
-        "444249",
-        "444944",
         "444944",
         "449494",
         "449496",
@@ -157,12 +151,10 @@ class Antiarrhythmics(ValueSet):
         "454207",
         "454371",
         "545231",
-        "545231",
         "545232",
         "545233",
         "545238",
         "545239",
-        "545239",
         "558741",
         "558745",
         "559416",
@@ -177,8 +169,6 @@ class Antiarrhythmics(ValueSet):
         "565069",
         "573523",
         "583982",
-        "583982",
-        "583985",
         "583985",
         "590326",
         "590375",

canvas_sdk/value_set/tests/test_value_sets.py

@@ -8,12 +8,14 @@ from canvas_sdk.value_set.value_set import CombinedValueSet
 
 
 def test_value_set_class_values_property() -> None:
+    """Test that the value_set returns the correct values."""
     value_set = DisordersOfTheImmuneSystem
     assert value_set.values["ICD10CM"] == DisordersOfTheImmuneSystem.ICD10CM
     assert value_set.values["SNOMEDCT"] == DisordersOfTheImmuneSystem.SNOMEDCT
 
 
 def test_value_set_class_pipe_operator_with_two_value_sets() -> None:
+    """Test that the pipe operator returns the correct values."""
     combined_value_set: CombinedValueSet = (
         DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
     )
@@ -30,6 +32,7 @@ def test_value_set_class_pipe_operator_with_two_value_sets() -> None:
 
 
 def test_value_set_class_pipe_operator_with_three_value_sets() -> None:
+    """Test that the pipe operator returns the correct values with multiple operands."""
     combined_value_set: CombinedValueSet = (
         DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination | Rhabdomyolysis
     )
@@ -46,6 +49,7 @@ def test_value_set_class_pipe_operator_with_three_value_sets() -> None:
 
 
 def test_value_set_class_pipe_operator_with_two_combined_value_sets() -> None:
+    """Test that the pipe operator returns the correct values with two combined value_sets."""
     combined_value_set_1: CombinedValueSet = (
         DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
     )