canvas 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

canvas_cli/tests.py

@@ -1,8 +1,9 @@
 import os
 import shutil
+from collections.abc import Callable, Generator
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Generator, cast
+from typing import Any, cast
 from unittest.mock import MagicMock, patch
 from urllib.parse import urlparse
 
@@ -20,14 +21,13 @@ runner = CliRunner()
 
 @pytest.fixture(scope="session")
 def plugin_name() -> str:
-    """The plugin name to be used for the canvas cli test"""
+    """The plugin name to be used for the canvas cli test."""
     return f"cli-{datetime.now().timestamp()}".replace(".", "")
 
 
 @pytest.fixture(scope="session")
 def create_or_update_config_auth_file_for_testing(plugin_name: str) -> Generator[None, None, None]:
     """Creates the necessary config file for auth before performing cli tests."""
-
     if not settings.INTEGRATION_TEST_URL:
         raise ImproperlyConfigured("INTEGRATION_TEST_URL is not set")
 
@@ -45,19 +45,27 @@ def create_or_update_config_auth_file_for_testing(plugin_name: str) -> Generator
 
     temp_path = path.parent / "temp_credentials.ini"
 
-    original_content = open(path, "r").read()
-    open(path, "w").writelines(
-        [
-            f"[{host}]\n",
-            f"client_id={client_id}\n",
-            f"client_secret={client_secret}\n",
-        ]
-    )
-    open(temp_path, "a").write(original_content)
+    # Read the original content
+    with open(path) as original_file:
+        original_content = original_file.read()
+
+    # Write new content to the original file
+    with open(path, "w") as original_file:
+        original_file.writelines(
+            [
+                f"[{host}]\n",
+                f"client_id={client_id}\n",
+                f"client_secret={client_secret}\n",
+            ]
+        )
+
+    # Append original content to the temp file
+    with open(temp_path, "a") as temp_file:
+        temp_file.write(original_content)
 
     yield
 
-    with open(temp_path, "r") as temp:
+    with open(temp_path) as temp:
         original_content = temp.read()
         with open(path, "w") as f:
             f.write(original_content)
@@ -66,9 +74,10 @@ def create_or_update_config_auth_file_for_testing(plugin_name: str) -> Generator
 
 @pytest.fixture(autouse=True, scope="session")
 def write_plugin(plugin_name: str) -> Generator[Any, Any, Any]:
+    """Writes a plugin to the file system."""
     runner.invoke(app, "init", input=plugin_name)
-    protocol = open(f"./{plugin_name}/protocols/my_protocol.py", "w")
-    p = """
+
+    protocol_code = """
 from canvas_sdk.events import EventType
 from canvas_sdk.protocols import BaseProtocol
 from logger import log
@@ -81,8 +90,9 @@ class Protocol(BaseProtocol):
         log.info(self.NARRATIVE_STRING)
         return []
 """
-    protocol.write(p)
-    protocol.close()
+
+    with open(f"./{plugin_name}/protocols/my_protocol.py", "w") as protocol:
+        protocol.write(protocol_code)
 
     yield
 
@@ -91,12 +101,12 @@ class Protocol(BaseProtocol):
 
 
 def list_empty_plugins(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 1 - list all plugins"""
+    """Step 1 - list all plugins."""
     return ("list", 0, [], [f"{plugin_name}"])
 
 
 def install_new_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 2 - install a new plugin"""
+    """Step 2 - install a new plugin."""
     return (
         f"install {plugin_name}",
         0,
@@ -111,12 +121,12 @@ def install_new_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]
 
 
 def list_newly_installed_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 3 - list all plugins, including newly installed one"""
+    """Step 3 - list all plugins, including newly installed one."""
     return ("list", 0, [f"{plugin_name}@0.0.1	enabled"], [])
 
 
 def disable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 4 - disable plugin"""
+    """Step 4 - disable plugin."""
     return (
         f"disable {plugin_name}",
         0,
@@ -126,12 +136,12 @@ def disable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
 
 
 def list_disabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 5 - list disabled plugin"""
+    """Step 5 - list disabled plugin."""
     return ("list", 0, [f"{plugin_name}@0.0.1	disabled"], [])
 
 
 def enable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 6 - enable the disabled plugin"""
+    """Step 6 - enable the disabled plugin."""
     return (
         f"enable {plugin_name}",
         0,
@@ -141,7 +151,7 @@ def enable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
 
 
 def uninstall_enabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 7 - try to uninstall the enabled plugin"""
+    """Step 7 - try to uninstall the enabled plugin."""
     return (
         f"uninstall {plugin_name}",
         1,
@@ -154,7 +164,7 @@ def uninstall_enabled_plugin(plugin_name: str) -> tuple[str, int, list[str], lis
 
 
 def uninstall_disabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 8 - disable and then uninstall the plugin"""
+    """Step 8 - disable and then uninstall the plugin."""
     runner.invoke(app, f"disable {plugin_name}")
 
     return (
@@ -192,7 +202,7 @@ def test_canvas_list_install_disable_enable_uninstall(
     create_or_update_config_auth_file_for_testing: None,
     step: Callable,
 ) -> None:
-    """Tests that the Canvas CLI can list, install, disable, enable, and uninstall a plugin"""
+    """Tests that the Canvas CLI can list, install, disable, enable, and uninstall a plugin."""
     mock_get_password.return_value = None
     mock_set_password.return_value = None
 

canvas_cli/utils/context/context.py

@@ -1,7 +1,8 @@
 import functools
 import json
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import typer
 
@@ -12,6 +13,7 @@ F = TypeVar("F", bound=Callable)
 
 class CLIContext:
     """Class that handles configuration across the CLI.
+
     Includes methods for:
     * Loading a JSON file with configuration keys into memory.
     * Making a property transient (default, value is not persisted) or persistent (via decorators)
@@ -118,7 +120,7 @@ class CLIContext:
                 success=False,
                 path=str(file),
             )
-            raise typer.Abort()
+            raise typer.Abort() from None
 
         self._config_file_path = file
 

canvas_cli/utils/context/tests.py

@@ -1,7 +1,7 @@
 import json
 import os
+from collections.abc import Generator
 from pathlib import Path
-from typing import Generator
 
 import pytest
 import typer

canvas_cli/utils/print/tests.py

@@ -18,7 +18,7 @@ def test_print_json_outputs_valid_json(message: Any, capfd: pytest.CaptureFixtur
     try:
         json.loads(output)
     except ValueError as exc:
-        assert False, f"{output} is not valid json: {exc}"
+        assert AssertionError(f"{output} is not valid json: {exc}")
 
 
 def test_print_json_outputs_kwargs(capfd: pytest.CaptureFixture[str]) -> None:
@@ -33,7 +33,7 @@ def test_print_json_outputs_kwargs(capfd: pytest.CaptureFixture[str]) -> None:
         assert json_dict.get("a_dict") == {"one": 2}
 
     except ValueError as exc:
-        assert False, f"{output} is not valid json: {exc}"
+        assert AssertionError(f"{output} is not valid json: {exc}")
 
 
 def test_print_overrides_default(capfd: pytest.CaptureFixture[str]) -> None:

canvas_cli/utils/validators/tests.py

@@ -5,6 +5,7 @@ from canvas_cli.utils.validators import validate_manifest_file
 
 @pytest.fixture
 def protocol_manifest_example() -> dict:
+    """Return a valid protocol manifest example."""
     return {
         "sdk_version": "0.3.1",
         "plugin_version": "1.0.1",
@@ -32,5 +33,5 @@ def protocol_manifest_example() -> dict:
 
 
 def test_manifest_file_schema(protocol_manifest_example: dict) -> None:
-    """Test that no exception raised when a valid manifest file is validated"""
+    """Test that no exception raised when a valid manifest file is validated."""
     validate_manifest_file(protocol_manifest_example)

canvas_sdk/base.py

@@ -24,7 +24,7 @@ class Model(BaseModel):
     )
 
     def _get_effect_method_required_fields(self, method: Any) -> tuple:
-        return getattr(self.Meta, f"{method}_required_fields", tuple())
+        return getattr(self.Meta, f"{method}_required_fields", ())
 
     def _create_error_detail(self, type: str, message: str, value: Any) -> InitErrorDetails:
         return InitErrorDetails({"type": PydanticCustomError(type, message), "input": value})

canvas_sdk/commands/base.py

@@ -2,11 +2,11 @@ import json
 import re
 from enum import EnumType
 from types import NoneType, UnionType
-from typing import Any, Literal, Tuple, Union, cast, get_args, get_origin
+from typing import Union, get_args, get_origin
 
 from canvas_sdk.base import Model
 from canvas_sdk.commands.constants import Coding
-from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.effects import Effect
 from canvas_sdk.effects.protocol_card import Recommendation
 
 
@@ -26,9 +26,7 @@ class _BaseCommand(Model):
     command_uuid: str | None = None
 
     def _get_effect_method_required_fields(self, method: str) -> tuple:
-        base_required_fields: tuple = getattr(
-            _BaseCommand.Meta, f"{method}_required_fields", tuple()
-        )
+        base_required_fields: tuple = getattr(_BaseCommand.Meta, f"{method}_required_fields", ())
         command_required_fields = super()._get_effect_method_required_fields(method)
         return tuple(set(base_required_fields) | set(command_required_fields))
 
@@ -72,7 +70,7 @@ class _BaseCommand(Model):
         """The schema of the command."""
         base_properties = {"note_uuid", "command_uuid"}
         schema = cls.model_json_schema()
-        required_fields: tuple = getattr(cls.Meta, "commit_required_fields", tuple())
+        required_fields: tuple = getattr(cls.Meta, "commit_required_fields", ())
         return {
             definition.get("commands_api_name", name): {
                 "required": name in required_fields,

canvas_sdk/commands/commands/prescribe.py

@@ -1,7 +1,5 @@
-from dataclasses import dataclass
 from decimal import Decimal
 from enum import Enum
-from typing import TypeVar
 
 from pydantic import Field, conlist
 
@@ -29,7 +27,9 @@ class PrescribeCommand(_BaseCommand):
         NOT_ALLOWED = "not_allowed"
 
     fdb_code: str | None = Field(default=None, json_schema_extra={"commands_api_name": "prescribe"})
-    icd10_codes: conlist(str, max_length=2) = Field([], json_schema_extra={"commands_api_name": "indications"})  # type: ignore[valid-type]
+    icd10_codes: conlist(str, max_length=2) = Field(  # type: ignore[valid-type]
+        [], json_schema_extra={"commands_api_name": "indications"}
+    )
     sig: str = ""
     days_supply: int | None = None
     quantity_to_dispense: Decimal | float | int | None = None

canvas_sdk/commands/commands/reason_for_visit.py

@@ -24,7 +24,7 @@ class ReasonForVisitCommand(_BaseCommand):
         if self.structured and not self.coding:
             errors.append(
                 self._create_error_detail(
-                    "value", f"Structured RFV should have a coding.", self.coding
+                    "value", "Structured RFV should have a coding.", self.coding
                 )
             )
         return errors

canvas_sdk/commands/commands/task.py

@@ -1,7 +1,8 @@
 from datetime import date
-from enum import Enum, StrEnum
+from enum import StrEnum
+from typing import NotRequired
 
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import TypedDict
 
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
 

canvas_sdk/commands/commands/vitals.py

@@ -1,5 +1,4 @@
 from enum import Enum
-from typing import Optional
 
 from pydantic import conint, constr
 

canvas_sdk/commands/constants.py

@@ -1,4 +1,6 @@
-from typing_extensions import NotRequired, TypedDict
+from typing import NotRequired
+
+from typing_extensions import TypedDict
 
 
 class Coding(TypedDict):

canvas_sdk/commands/tests/protocol/tests.py

@@ -1,5 +1,5 @@
+from collections.abc import Generator
 from datetime import datetime
-from typing import Any, Generator
 
 import pytest
 
@@ -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(scope="session")
 def plugin_name() -> str:
+    """The plugin name to be used."""
     return f"commands{datetime.now().timestamp()}".replace(".", "")
 
 
@@ -35,6 +38,7 @@ def plugin_name() -> str:
 def write_and_install_protocol_and_clean_up(
     plugin_name: str, token: MaskedValue, new_note: dict
 ) -> Generator[None, None, None]:
+    """Write the protocol code, install the plugin, and clean up after the test."""
     write_protocol_code(new_note["externallyExposableId"], plugin_name, COMMANDS)
     install_plugin(plugin_name, token)
 
@@ -47,6 +51,7 @@ def write_and_install_protocol_and_clean_up(
 def test_protocol_that_inserts_every_command(
     write_and_install_protocol_and_clean_up: None, token: MaskedValue, new_note: dict
 ) -> None:
+    """Test that the protocol inserts every command."""
     trigger_plugin_event(token)
 
     commands_in_body = get_original_note_body_commands(new_note["id"], token)

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")