canvas 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

canvas_cli/utils/context/context.py

@@ -0,0 +1,172 @@
+import functools
+import json
+from pathlib import Path
+from typing import Any, Callable, TypeVar
+
+import typer
+
+from canvas_cli.utils.print import print
+
+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)
+
+    Loading from a file is dynamic. I.e., you only need to create a new property,
+    and mark its setter as persistent if needed.
+    """
+
+    # Path to the config file
+    _config_file_path: Path
+
+    # Dict with the config file values
+    _config_file: dict[str, Any]
+
+    # Base dir for the paths inside the project, not configurable
+    _base_dir = Path(__file__).parent / ".." / ".."
+
+    # Base dir for every template used, not configurable
+    _base_template_dir: Path = _base_dir / "templates"
+
+    # Dir where the plugin templates are located
+    _plugin_template_dir: Path = _base_template_dir / "plugins"
+
+    # Default plugin template name
+    _default_plugin_template_name: str = "default"
+
+    # The default host to use for requests
+    _default_host: str | None = None
+
+    # Print extra output
+    _verbose: bool = False
+
+    # If True no colored output is shown
+    _no_ansi: bool = False
+
+    # When the most recently requested api_token will expire
+    _token_expiration_date: str | None = None
+
+    @staticmethod
+    def persistent(fn: F | None = None, **options: Any) -> Callable[[F], F] | F:
+        """A decorator to store a config value in the file everytime it's changed."""
+
+        def _decorator(fn: F) -> F:
+            @functools.wraps(fn)
+            def wrapper(self: "CLIContext", *args: Any, **kwargs: Any) -> Any:
+                fn(self, *args, **kwargs)
+                value = args[0]
+
+                print.verbose(f"Storing {fn.__name__}={value} in the config file")
+
+                self._config_file[fn.__name__] = value
+                with open(self._config_file_path, "w") as f:
+                    json.dump(self._config_file, f)
+
+            return wrapper
+
+        return _decorator(fn) if fn else _decorator
+
+    @property
+    def plugin_template_dir(self) -> Path:
+        """Default Path to use for Plugin templates."""
+        return self._plugin_template_dir
+
+    @plugin_template_dir.setter
+    @persistent
+    def plugin_template_dir(self, new_plugin_template_dir: Path) -> None:
+        self._plugin_template_dir = new_plugin_template_dir
+
+    @property
+    def default_plugin_template_name(self) -> str:
+        """Default template to be used when creating a Plugin."""
+        return self._default_plugin_template_name
+
+    @default_plugin_template_name.setter
+    @persistent
+    def default_plugin_template_name(self, new_default_plugin_template_name: str) -> None:
+        self._default_plugin_template_name = new_default_plugin_template_name
+
+    @property
+    def default_host(self) -> str | None:
+        """Default host to be used when connecting to instances."""
+        return self._default_host
+
+    @default_host.setter
+    @persistent
+    def default_host(self, new_default_host: str | None) -> None:
+        self._default_host = new_default_host
+
+    @property
+    def verbose(self) -> bool:
+        """Enable extra output."""
+        return self._verbose
+
+    @verbose.setter
+    def verbose(self, new_verbose: bool) -> None:
+        self._verbose = new_verbose
+
+    @property
+    def no_ansi(self) -> bool:
+        """If set removes colorized output."""
+        return self._no_ansi
+
+    @no_ansi.setter
+    def no_ansi(self, new_no_ansi: bool) -> None:
+        self._no_ansi = new_no_ansi
+
+    @property
+    def token_expiration_date(self) -> str | None:
+        """When the most recently requested api_token will expire."""
+        return self._token_expiration_date
+
+    @token_expiration_date.setter
+    @persistent
+    def token_expiration_date(self, new_token_expiration_date: str) -> None:
+        self._token_expiration_date = new_token_expiration_date
+
+    def load_from_file(self, file: Path) -> None:
+        """Load the given config file into a dict. Aborts execution if it can't decode the file.
+
+        Args:
+            file: Path to the JSON config file
+        """
+        try:
+            self._config_file = json.load(file.open("rb"))
+        except json.JSONDecodeError:
+            print.json(
+                "There was a problem loading the config file, please ensure it's valid JSON",
+                success=False,
+                path=str(file),
+            )
+            raise typer.Abort()
+
+        self._config_file_path = file
+
+        # Get all properties from the class that start with a single underscore,
+        # and initialize it with the corresponding key from the config dictionary.
+        # This generator assumes the config-file key and property will have the same name (minus the `_`)
+        properties = [
+            property
+            for property in dir(self)
+            if property not in ("_config_file", "_config_file_path")
+            and not callable(getattr(self, property))
+            and not property.startswith("__")
+            and property.startswith("_")
+        ]
+
+        for property in properties:
+            json_var = property[1:]
+            if config_value := self._config_file.get(json_var):
+                setattr(self, property, config_value)
+
+    def print_config(self) -> None:
+        """Print the currently loaded configuration."""
+        print.json(message=None, config_file=self._config_file, path=str(self._config_file_path))
+
+
+# CLIContext pseudo-singleton instance
+context: CLIContext = CLIContext()

canvas_cli/utils/context/tests.py

@@ -0,0 +1,130 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+import typer
+
+from canvas_cli.utils.context import CLIContext
+
+
+class CLIContextTestHelper(CLIContext):
+    """CLIContext subclass that defines some properties we can test."""
+
+    _persistent_mock_property: str | None = None
+    _transient_mock_property: bool = False
+
+    @property
+    def persistent_mock_property(self) -> str | None:
+        """Mock persistent property."""
+        return self._persistent_mock_property
+
+    @persistent_mock_property.setter
+    @CLIContext.persistent
+    def persistent_mock_property(self, new_persistent_mock_property: str | None) -> None:
+        self._persistent_mock_property = new_persistent_mock_property
+
+    @property
+    def transient_mock_property(self) -> bool:
+        """Mock transient property."""
+        return self._transient_mock_property
+
+    @transient_mock_property.setter
+    def transient_mock_property(self, new_transient_mock_property: bool) -> None:
+        self._transient_mock_property = new_transient_mock_property
+
+
+@pytest.fixture
+def config_file(tmp_path: Path) -> Path:
+    """Fixture that yields an empty config file and cleans up after itself."""
+    config_file = tmp_path / "mock_config.json"
+    yield config_file
+    os.remove(config_file)
+
+
+@pytest.fixture
+def valid_mock_config_file(config_file: Path) -> Path:
+    """Fixture that yields a valid mock config file."""
+    mock_config = {
+        "persistent_mock_property": "mock-value",
+    }
+    with open(config_file, "w") as f:
+        json.dump(mock_config, f)
+
+    yield config_file
+
+
+@pytest.fixture
+def invalid_json_mock_config_file(config_file: Path) -> Path:
+    """Fixture that yields an invalid config file."""
+    config_file.write_text("Absolutely invalid JSON")
+
+    yield config_file
+
+
+@pytest.fixture
+def invalid_properties_mock_config_file(config_file: Path) -> Path:
+    """Fixture that yields a valid mock config file."""
+    mock_config = {
+        "unknown-property": "mock-value",
+    }
+    with open(config_file, "w") as f:
+        json.dump(mock_config, f)
+
+    yield config_file
+
+
+def test_valid_load_from_file(valid_mock_config_file: Path) -> None:
+    """Test loading a valid config file."""
+    context = CLIContextTestHelper()
+    context.load_from_file(valid_mock_config_file)
+
+    assert context.persistent_mock_property == "mock-value"
+
+
+def test_invalid_load_from_file(invalid_json_mock_config_file: Path) -> None:
+    """Test loading an invalid config file aborts the execution."""
+    context = CLIContextTestHelper()
+
+    with pytest.raises(typer.Abort):
+        context.load_from_file(invalid_json_mock_config_file)
+
+
+def test_load_invalid_property(invalid_properties_mock_config_file: Path) -> None:
+    """Since we dynamically load the properties, this test ensures that unknown properties don't throw exceptions."""
+    context = CLIContextTestHelper()
+
+    context.load_from_file(invalid_properties_mock_config_file)
+
+
+def test_config_persistence(valid_mock_config_file: Path) -> None:
+    """Test marking a property with @persistent stores the value in the config file."""
+    context = CLIContextTestHelper()
+    context.load_from_file(valid_mock_config_file)
+
+    assert context.persistent_mock_property == "mock-value"
+
+    context.persistent_mock_property = "new-value"
+
+    # This won't ever happen but since the values are in memory, we need to create a new context instance,
+    # as if mimicking a new program launch
+    context_b = CLIContextTestHelper()
+    context_b.load_from_file(valid_mock_config_file)
+
+    assert context_b.persistent_mock_property == "new-value"
+
+
+def test_config_transience(valid_mock_config_file: Path) -> None:
+    """Test the properties transient default."""
+    context = CLIContextTestHelper()
+    context.load_from_file(valid_mock_config_file)
+
+    assert context.transient_mock_property is False
+    context.transient_mock_property = True
+
+    # This won't ever happen but since the values are in memory, we need to create a new context instance,
+    # as if mimicking a new program launch
+    context_b = CLIContextTestHelper()
+    context_b.load_from_file(valid_mock_config_file)
+
+    assert context_b.transient_mock_property is False

canvas_cli/utils/print/__init__.py

@@ -0,0 +1,3 @@
+from canvas_cli.utils.print.print import Printer, print
+
+__all__ = ("print", "Printer")

canvas_cli/utils/print/print.py

@@ -0,0 +1,60 @@
+import json
+from builtins import print as builtin_print
+from typing import Any
+
+from requests import Response
+from rich import print as rich_print
+
+
+class Printer:
+    """Class to override Python's default print with json and Requests.response capabilities."""
+
+    def __call__(self, *args: Any) -> None:
+        """Default printing."""
+        self._default_print(*args)
+
+    @staticmethod
+    def response(response: Response, success: bool = True) -> None:
+        """Print a response object by getting its json or text response."""
+        try:
+            message = response.json()
+        except json.JSONDecodeError:
+            message = response.text
+
+        Printer.json(message=message, success=success, status_code=response.status_code)
+
+    @staticmethod
+    def json(message: str | list[str] | dict | None, success: bool = True, **kwargs: Any) -> None:
+        """Print a message in json format regardless of the input."""
+        status = {"success": success}
+        if message:
+            try:
+                json_message = json.loads(message)
+            except (json.JSONDecodeError, TypeError):
+                json_message = message
+
+            status.update({"message": json_message})
+        for key, value in kwargs.items():
+            status.update({key: value})
+
+        Printer._default_print(json.dumps(status))
+
+    @staticmethod
+    def verbose(*args: Any) -> None:
+        """Print text only if `verbose` is set in context."""
+        from canvas_cli.utils.context import context
+
+        if context.verbose:
+            Printer._default_print(*args)
+
+    @staticmethod
+    def _default_print(*args: Any) -> None:
+        from canvas_cli.utils.context import context
+
+        if context.no_ansi:
+            builtin_print(*args)
+        else:
+            rich_print(*args)
+
+
+print = Printer()

canvas_cli/utils/print/tests.py

@@ -0,0 +1,70 @@
+import json
+from unittest.mock import Mock
+
+import pytest
+from requests import Response
+
+from canvas_cli.utils.print import print
+
+
+@pytest.mark.parametrize(
+    "message", ["a simple message", ["an array", "of messages"], {"one": "test"}]
+)
+def test_print_json_outputs_valid_json(
+    message: str | list[str] | dict | None, capfd: pytest.CaptureFixture[str]
+) -> None:
+    """Test the output of print is always valid json."""
+    print.json(message)
+    output, _ = capfd.readouterr()
+    try:
+        json.loads(output)
+    except ValueError as exc:
+        assert False, f"{output} is not valid json: {exc}"
+
+
+def test_print_json_outputs_kwargs(capfd: pytest.CaptureFixture[str]) -> None:
+    """Test the output of print contains all given kwargs."""
+    print.json("A message", status_code=200, a_string="a_value", an_array=[1, 2], a_dict={"one": 2})
+    output, _ = capfd.readouterr()
+    try:
+        json_dict = json.loads(output)
+
+        assert json_dict.get("a_string") == "a_value"
+        assert json_dict.get("an_array") == [1, 2]
+        assert json_dict.get("a_dict") == {"one": 2}
+
+    except ValueError as exc:
+        assert False, f"{output} is not valid json: {exc}"
+
+
+def test_print_overrides_default(capfd: pytest.CaptureFixture[str]) -> None:
+    """Test using `print` defaults to Rich."""
+    message = "Testing print"
+    print(message)
+    output, _ = capfd.readouterr()
+    assert message + "\n" == output
+
+
+def test_print_response_non_json_text(capfd: pytest.CaptureFixture[str]) -> None:
+    """Test print.response with a non-json response."""
+    response = Mock(spec=Response)
+    response.status_code = 200
+    response.text = "testing text"
+    response.json.side_effect = json.JSONDecodeError("", "", 0)
+    print.response(response)
+    output, _ = capfd.readouterr()
+    assert json.loads(output) == json.loads(
+        '{"status_code": 200, "success": true, "message": "testing text"}'
+    )
+
+
+def test_print_response_json_text(capfd: pytest.CaptureFixture[str]) -> None:
+    """Test print.response with a json response."""
+    response = Mock(spec=Response)
+    response.status_code = 201
+    response.json.return_value = {"something": True}
+    print.response(response)
+    output, _ = capfd.readouterr()
+    assert json.loads(output) == json.loads(
+        '{"status_code": 201, "success": true, "message": {"something": true} }'
+    )

canvas_cli/utils/urls/__init__.py

@@ -0,0 +1,3 @@
+from canvas_cli.utils.urls.urls import CoreEndpoint
+
+__all__ = ("CoreEndpoint",)

canvas_cli/utils/urls/tests.py

@@ -0,0 +1,12 @@
+import pytest
+
+from canvas_cli.utils.urls import CoreEndpoint
+
+
+@pytest.mark.parametrize("path", ["a-path", "/a-path", "/a-path/", "a-path/"])
+def test_endpoint_builder(path: str) -> None:
+    """Test that the endpoint is always generated with a trailing `/`."""
+    assert (
+        CoreEndpoint.LOG.build("https://test-host.com", path)
+        == "https://test-host.com/core/api/v1/logging/a-path/"
+    )

canvas_cli/utils/urls/urls.py

@@ -0,0 +1,27 @@
+from urllib.parse import urljoin
+
+
+class EndpointBuilderMixin:
+    """Class that adds a url builder method."""
+
+    _base_url: str = "core/api/v1"
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    def build(self, host: str, *paths: str) -> str:
+        """Builds a url from a host and a sequence of paths.
+        Assumes this is injected into an enum subclass.
+        """
+        join = "/".join([self._base_url, self.value, "/".join(paths or [])])
+        join = join if join.endswith("/") else join + "/"
+        return urljoin(host, join)
+
+
+class CoreEndpoint:
+    """Class that defines and is able to build endpoints for the /core/ path."""
+
+    _base_url: str = "core/api/v1"
+
+    PLUGIN = EndpointBuilderMixin("plugins")
+    LOG = EndpointBuilderMixin("logging")

canvas_cli/utils/validators/__init__.py

@@ -0,0 +1,3 @@
+from canvas_cli.utils.validators.validators import validate_manifest_file
+
+__all__ = ("validate_manifest_file",)

canvas_cli/utils/validators/manifest_schema.py

@@ -0,0 +1,80 @@
+manifest_schema = {
+    "type": "object",
+    "properties": {
+        "sdk_version": {"type": "string"},
+        "plugin_version": {"type": "string"},
+        "name": {"type": "string"},
+        "description": {"type": "string"},
+        "secrets": {"type": "array", "items": {"type": "string"}},
+        "components": {
+            "type": "object",
+            "properties": {
+                "commands": {"$ref": "#/$defs/component"},
+                "protocols": {"$ref": "#/$defs/component"},
+                "content": {"$ref": "#/$defs/component"},
+                "effects": {"$ref": "#/$defs/component"},
+                "views": {"$ref": "#/$defs/component"},
+            },
+            "additionalProperties": False,
+            "minProperties": 1,
+        },
+        "tags": {
+            "type": "object",
+            "properties": {
+                "patient_sourcing_and_intake": {
+                    "type": "array",
+                    "items": {"enum": ["symptom_triage", "coverage_capture"]},
+                },
+                "interaction_modes_and_utilization": {
+                    "type": "array",
+                    "items": {"enum": ["supply_policies", "demand_policies", "auto_followup"]},
+                },
+                "diagnostic_range_and_inputs": {"type": "array", "items": {"enum": []}},
+                "pricing_and_payments": {"type": "array", "items": {"enum": []}},
+                "care_team_composition": {"type": "array", "items": {"enum": []}},
+                "interventions_and_safety": {"type": "array", "items": {"enum": []}},
+                "content": {"type": "array", "items": {"enum": ["patient_intake"]}},
+            },
+            "additionalProperties": False,
+        },
+        "references": {"type": "array", "items": {"type": "string"}},
+        "license": {"type": "string"},
+        "diagram": {"type": ["boolean", "string"]},
+        "readme": {"type": ["boolean", "string"]},
+    },
+    "required": [
+        "sdk_version",
+        "plugin_version",
+        "name",
+        "description",
+        "components",
+        "tags",
+        "license",
+        "readme",
+    ],
+    "additionalProperties": False,
+    "$defs": {
+        "component": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "class": {"type": "string"},
+                    "description": {"type": "string"},
+                    "data_access": {
+                        "type": "object",
+                        "properties": {
+                            "event": {"type": "string"},
+                            "read": {"type": "array", "items": {"type": "string"}},
+                            "write": {"type": "array", "items": {"type": "string"}},
+                        },
+                        "required": ["event", "read", "write"],
+                        "additionalProperties": False,
+                    },
+                },
+                "required": ["class", "description", "data_access"],
+                "additionalProperties": False,
+            },
+        }
+    },
+}

canvas_cli/utils/validators/tests.py

@@ -0,0 +1,36 @@
+import pytest
+
+from canvas_cli.utils.validators import validate_manifest_file
+
+
+@pytest.fixture
+def protocol_manifest_example() -> dict:
+    return {
+        "sdk_version": "0.3.1",
+        "plugin_version": "1.0.1",
+        "name": "Prompt to prescribe when assessing condition",
+        "description": "To assist in ....",
+        "components": {
+            "protocols": [
+                {
+                    "class": "prompt_to_prescribe.protocols.prompt_when_assessing.PromptWhenAssessing",
+                    "description": "probably the same as the plugin's description",
+                    "data_access": {
+                        "event": "",
+                        "read": ["conditions"],
+                        "write": ["commands"],
+                    },
+                }
+            ]
+        },
+        "tags": {"patient_sourcing_and_intake": ["symptom_triage"]},
+        "references": [],
+        "license": "",
+        "diagram": False,
+        "readme": "README.MD",
+    }
+
+
+def test_manifest_file_schema(protocol_manifest_example: dict) -> None:
+    """Test that no exception raised when a valid manifest file is validated"""
+    validate_manifest_file(protocol_manifest_example)

canvas_cli/utils/validators/validators.py

@@ -0,0 +1,40 @@
+from jsonschema import validators
+
+from canvas_cli.utils.context import context
+from canvas_cli.utils.print import print
+from canvas_cli.utils.validators.manifest_schema import manifest_schema
+
+
+def get_default_host(host: str | None) -> str | None:
+    """Return context's default host if the host param is null."""
+    return host or context.default_host  # type: ignore
+
+
+def validate_manifest_file(manifest_json: dict) -> None:
+    """Validates a Canvas Manifest json against the manifest schema."""
+    validator = validators.validator_for(manifest_schema)(manifest_schema)
+    tag_warnings = []
+    tag_value_warnings = []
+    other_warnings = []
+    for error in validator.iter_errors(manifest_json):
+        if error.path and len(error.path) and error.path[0] == "tags":
+            if error.validator == "enum":
+                tag_value_warnings.append(error)
+            elif error.validator == "additionalProperties":
+                tag_warnings.append(error)
+            else:
+                other_warnings.append(error)
+        else:
+            raise error
+
+    if tag_warnings:
+        print("Warning: there are unrecognized tags in the manifest file:")
+        for tag_warning in tag_warnings:
+            print(f"\t- {tag_warning.message}")
+    if tag_value_warnings:
+        print("Warning: there are unrecognized tag values in the manifest file:")
+        for tag_value_warning in tag_value_warnings:
+            tag_category = tag_value_warning.path[1]
+            print(
+                f"\t- Please choose a valid tag value for '{tag_category}'. {tag_value_warning.message}."
+            )

canvas_sdk/commands/__init__.py

@@ -0,0 +1,27 @@
+from canvas_sdk.commands.commands.assess import AssessCommand
+from canvas_sdk.commands.commands.diagnose import DiagnoseCommand
+from canvas_sdk.commands.commands.goal import GoalCommand
+from canvas_sdk.commands.commands.history_present_illness import (
+    HistoryOfPresentIllnessCommand,
+)
+from canvas_sdk.commands.commands.medication_statement import MedicationStatementCommand
+from canvas_sdk.commands.commands.plan import PlanCommand
+from canvas_sdk.commands.commands.prescribe import PrescribeCommand
+from canvas_sdk.commands.commands.questionnaire import QuestionnaireCommand
+from canvas_sdk.commands.commands.reason_for_visit import ReasonForVisitCommand
+from canvas_sdk.commands.commands.stop_medication import StopMedicationCommand
+from canvas_sdk.commands.commands.update_goal import UpdateGoalCommand
+
+__all__ = (
+    "AssessCommand",
+    "DiagnoseCommand",
+    "GoalCommand",
+    "HistoryOfPresentIllnessCommand",
+    "MedicationStatementCommand",
+    "PlanCommand",
+    "PrescribeCommand",
+    "QuestionnaireCommand",
+    "ReasonForVisitCommand",
+    "StopMedicationCommand",
+    "UpdateGoalCommand",
+)