dependency inject app configuration

Author: djcopley

pyproject.toml

@@ -57,6 +57,7 @@ dependencies = [
     "pytest-xdist~=3.6",
     "pytest-asyncio~=0.24",
     "pytest-httpx~=0.30",
+    "tomli-w>=1.2.0",
 ]
 
 [[tool.hatch.envs.hatch-test.matrix]]

src/shelloracle/__main__.py

@@ -1,68 +1,4 @@
-import argparse
-import logging
-import sys
-from importlib.metadata import version
-
-from shelloracle import shelloracle
-from shelloracle.config import initialize_config
-from shelloracle.settings import Settings
-from shelloracle.tty_log_handler import TtyLogHandler
-
-logger = logging.getLogger(__name__)
-
-
-def configure_logging():
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-
-    file_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %(message)s")
-    file_handler = logging.FileHandler(Settings.shelloracle_home / "shelloracle.log")
-    file_handler.setLevel(logging.DEBUG)
-    file_handler.setFormatter(file_formatter)
-
-    tty_formatter = logging.Formatter("%(message)s")
-    tty_handler = TtyLogHandler()
-    tty_handler.setLevel(logging.WARNING)
-    tty_handler.setFormatter(tty_formatter)
-
-    root_logger.addHandler(file_handler)
-    root_logger.addHandler(tty_handler)
-
-
-def configure():
-    # nest this import in a function to avoid expensive module loads
-    from shelloracle.bootstrap import bootstrap_shelloracle
-
-    bootstrap_shelloracle()
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--version", action="version", version=f"{__package__} {version(__package__)}")
-
-    subparsers = parser.add_subparsers()
-    configure_subparser = subparsers.add_parser("configure", help=f"install {__package__} keybindings")
-    configure_subparser.set_defaults(action=configure)
-
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    configure_logging()
-
-    if action := getattr(args, "action", None):
-        action()
-        sys.exit(0)
-
-    try:
-        initialize_config()
-    except FileNotFoundError:
-        logger.warning("ShellOracle configuration not found. Run `shor configure` to initialize.")
-        sys.exit(1)
-
-    shelloracle.cli()
-
-
 if __name__ == "__main__":
+    from shelloracle.cli import main
+
     main()

src/shelloracle/bootstrap.py

@@ -12,7 +12,6 @@
 from prompt_toolkit.shortcuts import confirm
 
 from shelloracle.providers import Provider, Setting, get_provider, list_providers
-from shelloracle.settings import Settings
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
@@ -104,7 +103,7 @@ def correct_name_setting():
     yield from correct_name_setting()
 
 
-def write_shelloracle_config(provider: type[Provider], settings: dict[str, Any]) -> None:
+def write_shelloracle_config(provider: type[Provider], settings: dict[str, Any], config_path: Path) -> None:
     config = tomlkit.document()
 
     shor_table = tomlkit.table()
@@ -119,8 +118,7 @@ def write_shelloracle_config(provider: type[Provider], settings: dict[str, Any])
         provider_configuration_table.add(setting, value)
     provider_table.add(provider.name, provider_configuration_table)
 
-    filepath = Settings.shelloracle_home / "config.toml"
-    with filepath.open("w") as config_file:
+    with config_path.open("w") as config_file:
         tomlkit.dump(config, config_file)
 
 
@@ -164,7 +162,7 @@ def user_select_provider() -> type[Provider]:
     return get_provider(provider_name)
 
 
-def bootstrap_shelloracle() -> None:
+def bootstrap_shelloracle(config_path: Path) -> None:
     try:
         provider = user_select_provider()
         settings = user_configure_settings(provider)
@@ -173,5 +171,5 @@ def bootstrap_shelloracle() -> None:
         return
     except KeyboardInterrupt:
         return
-    write_shelloracle_config(provider, settings)
+    write_shelloracle_config(provider, settings, config_path)
     install_keybindings()

src/shelloracle/cli/__init__.py

@@ -1,24 +1,24 @@
 import logging
 import sys
-from importlib.metadata import version
+from pathlib import Path
 
 import click
 
 from shelloracle import shelloracle
+from shelloracle.cli.application import Application
 from shelloracle.cli.config import config
-from shelloracle.config import initialize_config
-from shelloracle.settings import Settings
+from shelloracle.config import Configuration
 from shelloracle.tty_log_handler import TtyLogHandler
 
 logger = logging.getLogger(__name__)
 
 
-def configure_logging():
+def configure_logging(log_path: Path):
     root_logger = logging.getLogger()
     root_logger.setLevel(logging.DEBUG)
 
     file_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %(message)s")
-    file_handler = logging.FileHandler(Settings.shelloracle_home / "shelloracle.log")
+    file_handler = logging.FileHandler(log_path)
     file_handler.setLevel(logging.DEBUG)
     file_handler.setFormatter(file_formatter)
 
@@ -32,21 +32,25 @@ def configure_logging():
 
 
 @click.group(invoke_without_command=True)
-@click.version_option(version=version("shelloracle"))
+@click.version_option()
 @click.pass_context
 def cli(ctx):
     """ShellOracle command line interface."""
-    configure_logging()
+    app = Application()
+    configure_logging(app.log_path)
+    ctx.obj = app
 
-    # If no subcommand is invoked, run the main CLI
-    if ctx.invoked_subcommand is None:
-        try:
-            initialize_config()
-        except FileNotFoundError:
-            logger.warning("ShellOracle configuration not found. Run `shor config init` to initialize.")
-            sys.exit(1)
+    if ctx.invoked_subcommand is not None:
+        # If no subcommand is invoked, run the main CLI
+        return
 
-        shelloracle.cli()
+    try:
+        app.configuration = Configuration.from_file(app.config_path)
+    except FileNotFoundError:
+        logger.warning("Configuration not found. Run `shor config init` to initialize.")
+        sys.exit(1)
+
+    shelloracle.cli(app)
 
 
 cli.add_command(config)

src/shelloracle/cli/application.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from shelloracle.config import Configuration
+
+shelloracle_home = Path.home() / ".shelloracle"
+shelloracle_home.mkdir(exist_ok=True)
+
+
+class Application:
+    configuration: Configuration
+
+    def __init__(self):
+        self.config_path = shelloracle_home / "config.toml"
+        self.log_path = shelloracle_home / "shelloracle.log"

src/shelloracle/cli/config/init.py

@@ -1,10 +1,13 @@
 import click
 
+from shelloracle.cli import Application
+
 
 @click.command()
-def init():
+@click.pass_obj
+def init(app: Application):
     """Install shelloracle keybindings."""
     # nest this import in a function to avoid expensive module loads
     from shelloracle.bootstrap import bootstrap_shelloracle
 
-    bootstrap_shelloracle()
+    bootstrap_shelloracle(app.config_path)

src/shelloracle/config.py

@@ -7,11 +7,10 @@
 
 from yaspin.spinners import SPINNERS_DATA
 
-from shelloracle.settings import Settings
-
 if TYPE_CHECKING:
     from pathlib import Path
 
+
 if sys.version_info < (3, 11):
     import tomli as tomllib
 else:
@@ -21,15 +20,13 @@
 
 
 class Configuration(Mapping):
-    def __init__(self, filepath: Path) -> None:
+    def __init__(self, config: dict[str, Any]) -> None:
         """ShellOracle application configuration
 
-        :param filepath: Path to the configuration file
+        :param config: configuration dict
         :raises FileNotFoundError: if the configuration file does not exist
         """
-        self.filepath = filepath
-        with filepath.open("rb") as config_file:
-            self._config = tomllib.load(config_file)
+        self._config = config
 
     def __getitem__(self, key: str) -> Any:
         return self._config[key]
@@ -46,6 +43,10 @@ def __str__(self):
     def __repr__(self) -> str:
         return str(self)
 
+    @property
+    def raw_config(self) -> dict[str, Any]:
+        return self._config
+
     @property
     def provider(self) -> str:
         return self["shelloracle"]["provider"]
@@ -60,31 +61,8 @@ def spinner_style(self) -> str | None:
             return None
         return style
 
-
-_config: Configuration | None = None
-
-
-def initialize_config() -> None:
-    """Initialize the configuration file
-
-    :raises RuntimeError: if the config is already initialized
-    :raises FileNotFoundError: if the config file is not found
-    """
-    global _config  # noqa: PLW0603
-    if _config:
-        msg = "Configuration already initialized"
-        raise RuntimeError(msg)
-    filepath = Settings.shelloracle_home / "config.toml"
-    _config = Configuration(filepath)
-
-
-def get_config() -> Configuration:
-    """Returns the global configuration object.
-
-    :return: the global configuration
-    :raises RuntimeError: if the configuration is not initialized
-    """
-    if _config is None:
-        msg = "Configuration not initialized"
-        raise RuntimeError(msg)
-    return _config
+    @classmethod
+    def from_file(cls, filepath: Path):
+        with filepath.open("rb") as config_file:
+            config = tomllib.load(config_file)
+        return cls(config)

src/shelloracle/providers/__init__.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Generic, Protocol, TypeVar, runtime_checkable
-
-from shelloracle.config import get_config
+from typing import TYPE_CHECKING, Generic, Protocol, TypeVar
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
 
+    from shelloracle.config import Configuration
+
 system_prompt = (
     "Based on the following user description, generate a corresponding shell command. Focus solely "
     "on interpreting the requirements and translating them into a single, executable Bash command. "
@@ -22,7 +22,6 @@ class ProviderError(Exception):
     """LLM providers raise this error to gracefully indicate something has gone wrong."""
 
 
-@runtime_checkable
 class Provider(Protocol):
     """
     LLM Provider Protocol
@@ -31,6 +30,10 @@ class Provider(Protocol):
     """
 
     name: str
+    config: Configuration
+
+    def __init__(self, config: Configuration) -> None:
+        self.config = config
 
     @abstractmethod
     def generate(self, prompt: str) -> AsyncIterator[str]:
@@ -64,9 +67,8 @@ def __get__(self, instance: Provider, owner: type[Provider]) -> T:
             # inspect.get_members from determining the object type
             msg = "Settings must be accessed through a provider instance."
             raise AttributeError(msg)
-        config = get_config()
         try:
-            return config["provider"][owner.name][self.name]
+            return instance.config["provider"][owner.name][self.name]
         except KeyError:
             if self.default is None:
                 raise

src/shelloracle/providers/deepseek.py

@@ -11,7 +11,8 @@ class Deepseek(Provider):
     api_key = Setting(default="")
     model = Setting(default="deepseek-chat")
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         if not self.api_key:
             msg = "No API key provided"
             raise ProviderError(msg)

src/shelloracle/providers/google.py

@@ -11,7 +11,8 @@ class Google(Provider):
     api_key = Setting(default="")
     model = Setting(default="gemini-2.0-flash")  # Assuming a default model name
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         if not self.api_key:
             msg = "No API key provided"
             raise ProviderError(msg)

src/shelloracle/providers/localai.py

@@ -16,7 +16,8 @@ class LocalAI(Provider):
     def endpoint(self) -> str:
         return f"http://{self.host}:{self.port}"
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         # Use a placeholder API key so the client will work
         self.client = AsyncOpenAI(api_key="sk-xxx", base_url=self.endpoint)
 

src/shelloracle/providers/openai.py

@@ -11,7 +11,8 @@ class OpenAI(Provider):
     api_key = Setting(default="")
     model = Setting(default="gpt-3.5-turbo")
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         if not self.api_key:
             msg = "No API key provided"
             raise ProviderError(msg)

src/shelloracle/providers/openai_compat.py

@@ -12,7 +12,8 @@ class OpenAICompat(Provider):
     api_key = Setting(default="")
     model = Setting(default="")
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         if not self.api_key:
             msg = "No API key provided. Use a dummy placeholder if no key is required"
             raise ProviderError(msg)

src/shelloracle/providers/xai.py

@@ -11,7 +11,8 @@ class XAI(Provider):
     api_key = Setting(default="")
     model = Setting(default="grok-beta")
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         if not self.api_key:
             msg = "No API key provided"
             raise ProviderError(msg)

src/shelloracle/settings.py

@@ -14,12 +14,13 @@
 from yaspin import yaspin
 from yaspin.spinners import Spinners
 
-from shelloracle.config import get_config
 from shelloracle.providers import get_provider
 
 if TYPE_CHECKING:
     from yaspin.core import Yaspin
 
+    from shelloracle.cli import Application
+
 logger = logging.getLogger(__name__)
 
 
@@ -47,19 +48,19 @@ def get_query_from_pipe() -> str | None:
     return lines[0].rstrip()
 
 
-def spinner() -> Yaspin:
+def spinner(style: str | None) -> Yaspin:
     """Get the correct spinner based on the user's configuration
 
+    :param style: The spinner style
     :returns: yaspin object
     """
-    config = get_config()
-    if not config.spinner_style:
-        return yaspin()
-    style = getattr(Spinners, config.spinner_style)
-    return yaspin(style)
+    if style:
+        style = getattr(Spinners, style)
+        return yaspin(style)
+    return yaspin()
 
 
-async def shelloracle() -> None:
+async def shelloracle(app: Application) -> None:
     """ShellOracle program entrypoint
 
     If there is a query from the input pipe, it processes the query to generate a response.
@@ -76,11 +77,10 @@ async def shelloracle() -> None:
         prompt = await prompt_user(default_prompt)
     logger.info("user prompt: %s", prompt)
 
-    config = get_config()
-    provider = get_provider(config.provider)()
+    provider = get_provider(app.configuration.provider)(app.configuration)
 
     shell_command = ""
-    with create_app_session_from_tty(), patch_stdout(raw=True), spinner() as sp:
+    with create_app_session_from_tty(), patch_stdout(raw=True), spinner(app.configuration.spinner_style) as sp:
         async for token in provider.generate(prompt):
             # some models may erroneously return a newline, which causes issues with the status spinner
             shell_command += token.replace("\n", "")
@@ -89,13 +89,13 @@ async def shelloracle() -> None:
     sys.stdout.write(shell_command)
 
 
-def cli() -> None:
+def cli(app: Application) -> None:
     """Run the ShellOracle command line interface
 
     :returns: None
     """
     try:
-        asyncio.run(shelloracle())
+        asyncio.run(shelloracle(app))
     except (KeyboardInterrupt, asyncio.exceptions.CancelledError):
         return
     except Exception:

src/shelloracle/shelloracle.py

@@ -1,25 +1,8 @@
 import pytest
-import tomlkit
 
-from shelloracle.config import Configuration
-
-
-@pytest.fixture(autouse=True)
-def tmp_shelloracle_home(monkeypatch, tmp_path):
-    monkeypatch.setattr("shelloracle.settings.Settings.shelloracle_home", tmp_path)
-    return tmp_path
+from shelloracle.cli import Application
 
 
 @pytest.fixture
-def set_config(monkeypatch, tmp_shelloracle_home):
-    config_path = tmp_shelloracle_home / "config.toml"
-
-    def _set_config(config: dict) -> None:
-        with config_path.open("w") as f:
-            tomlkit.dump(config, f)
-        configuration = Configuration(config_path)
-        monkeypatch.setattr("shelloracle.config._config", configuration)
-
-    yield _set_config
-
-    config_path.unlink()
+def global_app():
+    return Application()

tests/conftest.py

@@ -1,11 +1,12 @@
 import pytest
 
+from shelloracle.config import Configuration
 from shelloracle.providers.deepseek import Deepseek
 
 
 class TestOpenAI:
     @pytest.fixture
-    def deepseek_config(self, set_config):
+    def deepseek_config(self):
         config = {
             "shelloracle": {"provider": "Deepseek"},
             "provider": {
@@ -15,11 +16,11 @@ def deepseek_config(self, set_config):
                 }
             },
         }
-        set_config(config)
+        return Configuration(config)
 
     @pytest.fixture
     def deepseek_instance(self, deepseek_config):
-        return Deepseek()
+        return Deepseek(deepseek_config)
 
     def test_name(self):
         assert Deepseek.name == "Deepseek"

tests/providers/test_deepseek.py

@@ -5,16 +5,15 @@
 
 class TestOpenAI:
     @pytest.fixture
-    def localai_config(self, set_config):
-        config = {
+    def localai_config(self):
+        return {
             "shelloracle": {"provider": "LocalAI"},
             "provider": {"LocalAI": {"host": "localhost", "port": 8080, "model": "mistral-openorca"}},
         }
-        set_config(config)
 
     @pytest.fixture
     def localai_instance(self, localai_config):
-        return LocalAI()
+        return LocalAI(localai_config)
 
     def test_name(self):
         assert LocalAI.name == "LocalAI"

tests/providers/test_localai.py

@@ -1,21 +1,22 @@
 import pytest
 from pytest_httpx import IteratorStream
 
+from shelloracle.config import Configuration
 from shelloracle.providers.ollama import Ollama
 
 
 class TestOllama:
     @pytest.fixture
-    def ollama_config(self, set_config):
+    def ollama_config(self):
         config = {
             "shelloracle": {"provider": "Ollama"},
             "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
         }
-        set_config(config)
+        return Configuration(config)
 
     @pytest.fixture
     def ollama_instance(self, ollama_config):
-        return Ollama()
+        return Ollama(ollama_config)
 
     def test_name(self):
         assert Ollama.name == "Ollama"

tests/providers/test_ollama.py

@@ -1,22 +1,23 @@
 import pytest
 
+from shelloracle.config import Configuration
 from shelloracle.providers.openai import OpenAI
 
 
 class TestOpenAI:
     @pytest.fixture
-    def openai_config(self, set_config):
+    def openai_config(self):
         config = {
             "shelloracle": {"provider": "OpenAI"},
             "provider": {
                 "OpenAI": {"api_key": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "model": "gpt-3.5-turbo"}
             },
         }
-        set_config(config)
+        return Configuration(config)
 
     @pytest.fixture
     def openai_instance(self, openai_config):
-        return OpenAI()
+        return OpenAI(openai_config)
 
     def test_name(self):
         assert OpenAI.name == "OpenAI"

tests/providers/test_openai.py

@@ -1,11 +1,12 @@
 import pytest
 
+from shelloracle.config import Configuration
 from shelloracle.providers.xai import XAI
 
 
 class TestOpenAI:
     @pytest.fixture
-    def xai_config(self, set_config):
+    def xai_config(self):
         config = {
             "shelloracle": {"provider": "XAI"},
             "provider": {
@@ -15,11 +16,11 @@ def xai_config(self, set_config):
                 }
             },
         }
-        set_config(config)
+        return Configuration(config)
 
     @pytest.fixture
     def xai_instance(self, xai_config):
-        return XAI()
+        return XAI(xai_config)
 
     def test_name(self):
         assert XAI.name == "XAI"

tests/providers/test_xai.py

@@ -1,63 +1,59 @@
 from __future__ import annotations
 
 import pytest
+import tomli_w
 
-from shelloracle.config import get_config, initialize_config
+from shelloracle.config import Configuration
 
 
 class TestConfiguration:
     @pytest.fixture
-    def default_config(self, set_config):
-        config = {
-            "shelloracle": {"provider": "Ollama", "spinner_style": "earth"},
-            "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
-        }
-        set_config(config)
-        return config
-
-    def test_initialize_config(self, default_config):
-        with pytest.raises(RuntimeError):
-            initialize_config()
-
-    def test_from_file(self, default_config):
-        assert get_config() == default_config
+    def default_config(self):
+        return Configuration(
+            {
+                "shelloracle": {"provider": "Ollama", "spinner_style": "earth"},
+                "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
+            }
+        )
+
+    def test_from_file(self, default_config, tmp_path):
+        config_path = tmp_path / "config.toml"
+        with config_path.open("wb") as f:
+            tomli_w.dump(default_config.raw_config, f)
+        assert Configuration.from_file(config_path) == default_config
 
     def test_getitem(self, default_config):
         for key in default_config:
-            assert default_config[key] == get_config()[key]
+            assert default_config[key] == default_config.raw_config[key]
 
     def test_len(self, default_config):
-        assert len(default_config) == len(get_config())
+        assert len(default_config) == len(default_config.raw_config)
 
     def test_iter(self, default_config):
-        assert list(iter(default_config)) == list(iter(get_config()))
-
-    def test_str(self, default_config):
-        assert str(get_config()) == f"Configuration({default_config})"
-
-    def test_repr(self, default_config):
-        assert repr(default_config) == str(default_config)
+        assert list(iter(default_config)) == list(iter(default_config.raw_config))
 
     def test_provider(self, default_config):
-        assert get_config().provider == "Ollama"
+        assert default_config.provider == "Ollama"
 
     def test_spinner_style(self, default_config):
-        assert get_config().spinner_style == "earth"
-
-    def test_no_spinner_style(self, caplog, set_config):
-        config_dict = {
-            "shelloracle": {"provider": "Ollama"},
-            "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
-        }
-        set_config(config_dict)
-        assert get_config().spinner_style is None
+        assert default_config.spinner_style == "earth"
+
+    def test_no_spinner_style(self, caplog):
+        config = Configuration(
+            {
+                "shelloracle": {"provider": "Ollama"},
+                "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
+            }
+        )
+        assert config.spinner_style is None
         assert "invalid spinner style" not in caplog.text
 
-    def test_invalid_spinner_style(self, caplog, set_config):
-        config_dict = {
-            "shelloracle": {"provider": "Ollama", "spinner_style": "invalid"},
-            "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
-        }
-        set_config(config_dict)
-        assert get_config().spinner_style is None
+    def test_invalid_spinner_style(self, caplog):
+        config = Configuration(
+            {
+                "shelloracle": {"provider": "Ollama", "spinner_style": "invalid"},
+                "provider": {"Ollama": {"host": "localhost", "port": 11434, "model": "dolphin-mistral"}},
+            }
+        )
+        assert config.spinner_style is None
         assert "invalid spinner style" in caplog.text

tests/test_config.py

@@ -17,24 +17,15 @@ def mock_yaspin(monkeypatch):
     return mock
 
 
-@pytest.fixture
-def mock_config(monkeypatch):
-    config = MagicMock()
-    monkeypatch.setattr("shelloracle.config._config", config)
-    return config
-
-
 @pytest.mark.parametrize(("spinner_style", "expected"), [(None, call()), ("earth", call(Spinners.earth))])
-def test_spinner(spinner_style, expected, mock_config, mock_yaspin):
-    mock_config.spinner_style = spinner_style
-    spinner()
+def test_spinner(spinner_style, expected, mock_yaspin):
+    spinner(spinner_style)
     assert mock_yaspin.call_args == expected
 
 
-def test_spinner_fail(mock_yaspin, mock_config):
-    mock_config.spinner_style = "not a spinner style"
+def test_spinner_fail(mock_yaspin):
     with pytest.raises(AttributeError):
-        spinner()
+        spinner("not a spinner style")
 
 
 @pytest.mark.parametrize(