powerrules 0.1.0b0__tar.gz

powerrules-0.1.0b0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 LeoTN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

powerrules-0.1.0b0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: powerrules
+Version: 0.1.0b0
+Summary: A rule-based computer power state management tool
+License: MIT
+License-File: LICENSE
+Author: LeoTN
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: psutil (>=7.0,<8.0)
+Requires-Dist: pydantic (>=2.0,<3.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: typer (>=0.27.1,<0.28.0)
+Description-Content-Type: text/markdown
+
+# PowerRules
+A rule-based computer power state management tool
+

powerrules-0.1.0b0/README.md

@@ -0,0 +1,2 @@
+# PowerRules
+A rule-based computer power state management tool

powerrules-0.1.0b0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "powerrules"
+version = "0.1.0b0"
+description = "A rule-based computer power state management tool"
+authors = ["LeoTN"]
+readme = "README.md"
+license = "MIT"
+packages = [{ include = "powerrules", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+pyyaml = "^6.0"
+pydantic = "^2.0"
+typer = "^0.27.1"
+psutil = "^7.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0"
+
+[tool.poetry.scripts]
+pwru = "powerrules.cli.app:app"
+
+[build-system]
+requires = ["poetry-core>=2.0.0"]
+build-backend = "poetry.core.masonry.api"

powerrules-0.1.0b0/src/powerrules/__main__.py

@@ -0,0 +1,4 @@
+from powerrules.cli.app import app
+
+if __name__ == "__main__":
+    app()

powerrules-0.1.0b0/src/powerrules/actions/base.py

@@ -0,0 +1,11 @@
+from typing import Protocol
+
+
+class Action(Protocol):
+    def execute(self) -> None:
+        """Execute the action.
+
+        Raises:
+            ActionExecutionError: If the action cannot be executed.
+        """
+        ...

powerrules-0.1.0b0/src/powerrules/actions/power.py

@@ -0,0 +1,70 @@
+from powerrules.engine.exceptions import ActionExecutionError
+from powerrules.providers.power import PowerProvider
+
+
+class ShutdownAction:
+    def __init__(self, power_provider: PowerProvider):
+        self.power_provider = power_provider
+
+    def execute(self) -> None:
+        """Shut down the computer.
+
+        Raises:
+            ActionExecutionError: If the computer cannot be shut down.
+        """
+        try:
+            self.power_provider.shutdown()
+        except Exception as e:
+            raise ActionExecutionError("Failed to shut down the computer") from e
+
+
+class SleepAction:
+    def __init__(self, power_provider: PowerProvider):
+        self.power_provider = power_provider
+
+    def execute(self) -> None:
+        """Put the computer into sleep mode.
+
+        Raises:
+            ActionExecutionError: If the computer cannot be put into sleep mode.
+        """
+        try:
+            self.power_provider.sleep()
+        except Exception as e:
+            raise ActionExecutionError(
+                "Failed to put the computer into sleep mode"
+            ) from e
+
+
+class HibernateAction:
+    def __init__(self, power_provider: PowerProvider):
+        self.power_provider = power_provider
+
+    def execute(self) -> None:
+        """Put the computer into hibernation.
+
+        Raises:
+            ActionExecutionError: If the computer cannot be put into hibernation.
+        """
+        try:
+            self.power_provider.hibernate()
+        except Exception as e:
+            raise ActionExecutionError(
+                "Failed to put the computer into hibernation"
+            ) from e
+
+
+class RebootAction:
+    def __init__(self, power_provider: PowerProvider):
+        self.power_provider = power_provider
+
+    def execute(self) -> None:
+        """Reboot the computer.
+
+        Raises:
+            ActionExecutionError: If the computer cannot be rebooted.
+        """
+        try:
+            self.power_provider.reboot()
+        except Exception as e:
+            raise ActionExecutionError("Failed to reboot the computer") from e

powerrules-0.1.0b0/src/powerrules/application/runtime.py

@@ -0,0 +1,100 @@
+import time
+from pathlib import Path
+
+from powerrules.config.builder import ConfigurationBuilder
+from powerrules.config.loader import ConfigurationLoader
+from powerrules.engine.models import Rule, RuleEvaluationResult
+from powerrules.engine.rule_engine import RuleEngine
+from powerrules.platform.windows.power import WindowsPowerProvider
+from powerrules.platform.windows.process import WindowsProcessProvider
+from powerrules.providers.clock import SystemClockProvider
+
+
+class PowerRulesRuntime:
+    """Coordinate PowerRules configuration loading and rule evaluation and action execution."""
+
+    def run_once(self, configuration_path: Path) -> RuleEvaluationResult:
+        """Load and evaluate the configured policy once.
+
+        The policy is loaded only for this evaluation.
+
+        Args:
+            configuration_path: Path to the PowerRules policy file.
+
+        Returns:
+            The result of the rule evaluation.
+        """
+        rule_engine = self._build_rule_engine(configuration_path)
+
+        return rule_engine.evaluate()
+
+    def run_continuously(
+        self,
+        configuration_path: Path,
+        evaluation_interval: float = 10.0,
+        stop_on_match: bool = False,
+    ) -> None:
+        """Load a policy once and continuously evaluate it.
+
+        The policy is loaded only once when the method starts.
+        Changes to the policy file are ignored until the process is restarted.
+
+        Args:
+            configuration_path: Path to the PowerRules policy file.
+            evaluation_interval: Delay between evaluations in seconds.
+            stop_on_match: Stop the evaluation when a rule matches.
+
+        Raises:
+            ValueError: If the evaluation interval is less than or equal to zero.
+            ConditionEvaluationError: If a condition cannot be evaluated.
+            ActionExecutionError: If a matching action cannot be executed.
+        """
+        if evaluation_interval <= 0:
+            raise ValueError("Evaluation interval must be greater than zero")
+
+        rule_engine = self._build_rule_engine(configuration_path)
+        last_matched_rule: Rule | None = None
+
+        while True:
+            matched_rule = rule_engine.find_match()
+
+            if matched_rule is None:
+                last_matched_rule = None
+
+            elif matched_rule is not last_matched_rule:
+                matched_rule.action.execute()
+                last_matched_rule = matched_rule
+
+                if stop_on_match:
+                    break
+
+            time.sleep(evaluation_interval)
+
+    @staticmethod
+    def _build_rule_engine(configuration_path: Path) -> RuleEngine:
+        """Build a rule engine from a policy file.
+
+        The policy is loaded and built exactly once per invocation.
+
+        Args:
+            configuration_path: Path to the PowerRules policy file.
+
+        Returns:
+            A configured rule engine.
+        """
+        configuration = ConfigurationLoader().load(configuration_path)
+
+        clock_provider = SystemClockProvider()
+        process_provider = WindowsProcessProvider()
+        power_provider = WindowsPowerProvider()
+
+        rule_set = ConfigurationBuilder(
+            # Information about the current date and time
+            clock_provider=clock_provider,
+            # Information about running processes
+            process_provider=process_provider,
+            # Basically an API to interact with the power state of the OS
+            power_provider=power_provider,
+        ).build(configuration)
+
+        return RuleEngine(rule_set.rules)

powerrules-0.1.0b0/src/powerrules/cli/app.py

@@ -0,0 +1,114 @@
+from importlib.metadata import version
+from pathlib import Path
+
+import typer
+
+from powerrules.application.runtime import PowerRulesRuntime
+from powerrules.cli.errors import cli_command
+from powerrules.config.loader import ConfigurationLoader
+
+# Main application
+app = typer.Typer(
+    name="pwru",
+    help="A rule-based computer power state management tool.",
+    no_args_is_help=True,
+)
+
+# Policy subcommand
+policy_app = typer.Typer(
+    name="policy",
+    help="Manage PowerRules policies.",
+    no_args_is_help=True,
+)
+
+app.add_typer(policy_app, name="policy")
+
+
+def version_callback(value: bool) -> None:
+    """Display the installed PowerRules version."""
+    if value:
+        typer.echo(f"PowerRules {version('powerrules')}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Display the installed PowerRules version.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """A rule-based computer power state management tool."""
+
+
+@policy_app.command("validate")
+@cli_command
+def validate(
+    policy: Path = typer.Option(
+        Path("powerrules.yaml"),
+        "--policy",
+        "-p",
+        help="Path to the PowerRules policy file.",
+    ),
+) -> None:
+    """Validate a PowerRules policy file."""
+    ConfigurationLoader().load(policy)
+
+    typer.echo("[INFO] Policy is valid")
+
+
+@policy_app.command("show")
+@cli_command
+def show(
+    policy: Path = typer.Option(
+        Path("powerrules.yaml"),
+        "--policy",
+        "-p",
+        help="Path to the PowerRules policy file.",
+    ),
+) -> None:
+    """Display the configured rules of a PowerRules policy."""
+    policy_configuration = ConfigurationLoader().load(policy)
+
+    for index, rule in enumerate(policy_configuration.rules, start=1):
+        status = "enabled" if rule.enabled else "disabled"
+        typer.echo(f"{index}. {rule.name} [{status}]")
+
+
+@policy_app.command("run")
+@cli_command
+def run(
+    once: bool = typer.Option(
+        False,
+        "--once",
+        help="Evaluate the policy once and then exit.",
+    ),
+    stop_on_match: bool = typer.Option(
+        False,
+        "--stop-on-match",
+        help="Stop the continuous evaluation after the first rule match.",
+    ),
+    policy: Path = typer.Option(
+        Path("powerrules.yaml"),
+        "--policy",
+        "-p",
+        help="Path to the PowerRules policy file.",
+    ),
+) -> None:
+    """Evaluate a PowerRules policy continuously or once."""
+    runtime = PowerRulesRuntime()
+
+    if once:
+        result = runtime.run_once(configuration_path=policy)
+
+        if result.matched_rule is None:
+            typer.echo("[INFO] No rule matched")
+        else:
+            typer.echo(f"[INFO] Rule '{result.matched_rule.name}' matched")
+
+        return
+
+    runtime.run_continuously(configuration_path=policy, stop_on_match=stop_on_match)

powerrules-0.1.0b0/src/powerrules/cli/errors.py

@@ -0,0 +1,113 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, NoReturn, TypeVar
+
+import typer
+import yaml
+from pydantic import ValidationError
+
+from powerrules.engine.exceptions import (
+    ActionExecutionError,
+    ConditionEvaluationError,
+)
+
+EXIT_RUNTIME_ERROR = 1
+EXIT_POLICY_ERROR = 2
+
+ReturnType = TypeVar("ReturnType")
+
+
+def handle_cli_error(error: Exception) -> NoReturn:
+    """Handle a command execution error.
+
+    Args:
+        error: Exception raised during command execution.
+
+    Raises:
+        typer.Exit: Always raised after displaying the error.
+    """
+    # The policy file type is currently the only type being used in CLI commands
+    if isinstance(error, FileNotFoundError):
+        typer.echo(
+            f"[ERROR] Policy file not found: {error.filename}",
+            err=True,
+        )
+        raise typer.Exit(code=EXIT_POLICY_ERROR)
+
+    if isinstance(error, yaml.YAMLError):
+        typer.echo(
+            "[ERROR] Failed to parse policy file",
+            err=True,
+        )
+        raise typer.Exit(code=EXIT_POLICY_ERROR)
+
+    if isinstance(error, ValidationError):
+        typer.echo(
+            "[ERROR] Policy validation failed",
+            err=True,
+        )
+
+        # Output the cryptic Pydantic errors anyway. This should be reworked in the future for a nicer output
+        for validation_error in error.errors():
+            location = ".".join(str(item) for item in validation_error["loc"])
+            message = validation_error["msg"]
+
+            typer.echo(
+                f"[ERROR] {location}: {message}",
+                err=True,
+            )
+
+        raise typer.Exit(code=EXIT_POLICY_ERROR)
+
+    # The existing error messages for conditions and actions
+    if isinstance(error, ConditionEvaluationError):
+        typer.echo(
+            f"[ERROR] Failed to evaluate condition: {error}",
+            err=True,
+        )
+        raise typer.Exit(code=EXIT_RUNTIME_ERROR)
+
+    if isinstance(error, ActionExecutionError):
+        typer.echo(
+            f"[ERROR] Failed to execute action: {error}",
+            err=True,
+        )
+        raise typer.Exit(code=EXIT_RUNTIME_ERROR)
+
+    if isinstance(error, ValueError):
+        typer.echo(
+            f"[ERROR] {error}",
+            err=True,
+        )
+        raise typer.Exit(code=EXIT_RUNTIME_ERROR)
+
+    typer.echo(
+        f"[ERROR] Unexpected error: {error}",
+        err=True,
+    )
+    raise typer.Exit(code=EXIT_RUNTIME_ERROR)
+
+
+def cli_command(
+    function: Callable[..., ReturnType],
+) -> Callable[..., ReturnType]:
+    """Wrap a CLI command with centralized error handling.
+
+    Args:
+        function: CLI command function.
+
+    Returns:
+        Wrapped CLI command function.
+    """
+
+    @wraps(function)
+    def wrapper(*args: Any, **kwargs: Any) -> ReturnType:
+        try:
+            return function(*args, **kwargs)
+        except typer.Exit:
+            raise
+        except Exception as e:
+            # Handle errors which result from CLI commands. This avoids tracebacks and instead shows a readable error message
+            handle_cli_error(e)
+
+    return wrapper

powerrules-0.1.0b0/src/powerrules/conditions/base.py

@@ -0,0 +1,14 @@
+from typing import Protocol
+
+
+class Condition(Protocol):
+    def evaluate(self) -> bool:
+        """Evaluate the condition.
+
+        Returns:
+            True if the condition matches, otherwise False.
+
+        Raises:
+            ConditionEvaluationError: If the condition cannot be evaluated.
+        """
+        ...

powerrules-0.1.0b0/src/powerrules/conditions/datetime.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from datetime import time
+from enum import StrEnum
+
+from powerrules.providers.clock import ClockProvider
+
+
+class Weekday(StrEnum):
+    """Represent all weekdays."""
+
+    MONDAY = "Monday"
+    TUESDAY = "Tuesday"
+    WEDNESDAY = "Wednesday"
+    THURSDAY = "Thursday"
+    FRIDAY = "Friday"
+    SATURDAY = "Saturday"
+    SUNDAY = "Sunday"
+
+
+@dataclass(frozen=True)
+class TimeRange:
+    """Represents a range of time within a day."""
+
+    start: time
+    end: time
+
+    def contains(self, current_time: time) -> bool:
+        """Return whether the given time is within the range.
+
+        The start time is inclusive and the end time is exclusive (6:00 is in the range 23:00-7:00, but 7:00 is not).
+
+        Ranges crossing midnight are supported.
+
+        Args:
+            current_time: Time to check.
+
+        Returns:
+            True if the time is within the range, otherwise False.
+        """
+        # The range does not cross midnight
+        if self.start <= self.end:
+            # Does the current_time fall within the range?
+            return self.start <= current_time < self.end
+
+        # The range crosses midnight (e.g., 23:00-7:00)
+        # Does the current_time fall within the range?
+        return current_time >= self.start or current_time < self.end
+
+
+class DateTimeCondition:
+    def __init__(
+        self,
+        clock_provider: ClockProvider,
+        *,
+        time_range: TimeRange | None = None,
+        weekdays: frozenset[Weekday] | None = None,
+    ):
+        self.clock_provider = clock_provider
+        self.time_range = time_range
+        self.weekdays = weekdays
+
+    def evaluate(self) -> bool:
+        """Evaluate the configured date and time condition.
+
+        Returns:
+            True if the current date and time matches the condition,
+            otherwise False.
+        """
+        current_datetime = self.clock_provider.now()
+
+        if self.time_range is not None:
+            return self.time_range.contains(current_datetime.time())
+
+        if self.weekdays is not None:
+            current_weekday = (
+                Weekday.MONDAY,
+                Weekday.TUESDAY,
+                Weekday.WEDNESDAY,
+                Weekday.THURSDAY,
+                Weekday.FRIDAY,
+                Weekday.SATURDAY,
+                Weekday.SUNDAY,
+            )[current_datetime.weekday()]
+            return current_weekday in self.weekdays
+
+        return False

powerrules-0.1.0b0/src/powerrules/conditions/operators.py

@@ -0,0 +1,51 @@
+from collections.abc import Sequence
+
+from powerrules.conditions.base import Condition
+
+
+class AndCondition:
+    def __init__(self, conditions: Sequence[Condition]):
+        self.conditions = tuple(conditions)
+
+    def evaluate(self) -> bool:
+        """Evaluate all conditions using logical AND.
+
+        Returns:
+            True if all conditions match, otherwise False.
+
+        Raises:
+            ConditionEvaluationError: If a condition cannot be evaluated.
+        """
+        return all(condition.evaluate() for condition in self.conditions)
+
+
+class OrCondition:
+    def __init__(self, conditions: Sequence[Condition]):
+        self.conditions = tuple(conditions)
+
+    def evaluate(self) -> bool:
+        """Evaluate all conditions using logical OR.
+
+        Returns:
+            True if at least one condition matches, otherwise False.
+
+        Raises:
+            ConditionEvaluationError: If a condition cannot be evaluated.
+        """
+        return any(condition.evaluate() for condition in self.conditions)
+
+
+class NotCondition:
+    def __init__(self, condition: Condition):
+        self.condition = condition
+
+    def evaluate(self) -> bool:
+        """Evaluate the condition using logical NOT.
+
+        Returns:
+            True if the condition does not match, otherwise False.
+
+        Raises:
+            ConditionEvaluationError: If the condition cannot be evaluated.
+        """
+        return not self.condition.evaluate()

powerrules-0.1.0b0/src/powerrules/conditions/process.py

@@ -0,0 +1,33 @@
+from powerrules.engine.exceptions import ConditionEvaluationError
+from powerrules.providers.process import ProcessProvider
+
+
+class ProcessCondition:
+    def __init__(
+        self,
+        process_name: str,
+        expected_running: bool,
+        # Basically a wrapper object to interact with the OS to provide information about the running processes
+        process_provider: ProcessProvider,
+    ):
+        self.process_name = process_name
+        self.expected_running = expected_running
+        self.process_provider = process_provider
+
+    def evaluate(self) -> bool:
+        """Evaluate whether the configured process is in the expected state.
+
+        Returns:
+            True if the process state matches the expected state.
+
+        Raises:
+            ConditionEvaluationError: If the process state cannot be determined.
+        """
+        try:
+            is_running = self.process_provider.is_running(self.process_name)
+        except Exception as e:
+            raise ConditionEvaluationError(
+                f"Failed to determine whether process '{self.process_name}' is running."
+            ) from e
+
+        return is_running == self.expected_running

powerrules-0.1.0b0/src/powerrules/config/builder.py

@@ -0,0 +1,179 @@
+from powerrules.actions.base import Action
+from powerrules.actions.power import (
+    HibernateAction,
+    RebootAction,
+    ShutdownAction,
+    SleepAction,
+)
+from powerrules.conditions.base import Condition
+from powerrules.conditions.datetime import DateTimeCondition, TimeRange
+from powerrules.conditions.operators import AndCondition, NotCondition, OrCondition
+from powerrules.conditions.process import ProcessCondition
+from powerrules.config.models import (
+    ActionConfiguration,
+    ConditionConfiguration,
+    DateTimeConditionConfiguration,
+    ProcessConditionConfiguration,
+    RuleConfiguration,
+    RuleSetConfiguration,
+)
+from powerrules.engine.exceptions import ConfigurationError
+from powerrules.engine.models import Rule, RuleSet
+from powerrules.providers.clock import ClockProvider
+from powerrules.providers.power import PowerProvider
+from powerrules.providers.process import ProcessProvider
+
+
+class ConfigurationBuilder:
+    def __init__(
+        self,
+        clock_provider: ClockProvider,
+        process_provider: ProcessProvider,
+        power_provider: PowerProvider,
+    ):
+        self.clock_provider = clock_provider
+        self.process_provider = process_provider
+        self.power_provider = power_provider
+
+    def build(self, configuration: RuleSetConfiguration) -> RuleSet:
+        """Build a rule set from the validated configuration. This allows the rule engine to process the rules.
+
+        NOTE: The builder dos NOT validate the configuration. This needs to be done in advance.
+
+        Args:
+            configuration: Validated (with Pydantic) PowerRules configuration.
+
+        Returns:
+            The executable rule set.
+        """
+        rules = tuple(
+            self._build_rule(rule_configuration)
+            for rule_configuration in configuration.rules
+        )
+
+        return RuleSet(rules=rules)
+
+    def _build_rule(self, rule_configuration: RuleConfiguration) -> Rule:
+        """Build a domain rule  (which can be processed by the rule engine) from its configuration.
+
+        Args:
+            rule_configuration: Configuration of the rule.
+
+        Returns:
+            The executable rule.
+        """
+        return Rule(
+            name=rule_configuration.name,
+            enabled=rule_configuration.enabled,
+            condition=self._build_condition(rule_configuration.conditions),
+            action=self._build_action(rule_configuration.action),
+        )
+
+    def _build_condition(
+        self,
+        condition_configuration: ConditionConfiguration,
+    ) -> Condition:
+        """Build a condition from its configuration.
+
+        Args:
+            condition_configuration: Configuration of the condition.
+
+        Returns:
+            The executable condition.
+        """
+        if condition_configuration.and_conditions is not None:
+            return AndCondition(
+                conditions=tuple(
+                    self._build_condition(condition)
+                    for condition in condition_configuration.and_conditions
+                )
+            )
+
+        if condition_configuration.or_conditions is not None:
+            return OrCondition(
+                conditions=tuple(
+                    self._build_condition(condition)
+                    for condition in condition_configuration.or_conditions
+                )
+            )
+
+        if condition_configuration.not_condition is not None:
+            return NotCondition(
+                condition=self._build_condition(condition_configuration.not_condition)
+            )
+
+        if condition_configuration.process is not None:
+            return self._build_process_condition(condition_configuration.process)
+
+        if condition_configuration.datetime is not None:
+            return self._build_datetime_condition(condition_configuration.datetime)
+
+        raise ConfigurationError("Condition configuration does not contain a condition")
+
+    def _build_process_condition(
+        self,
+        configuration: ProcessConditionConfiguration,
+    ) -> ProcessCondition:
+        """Build a process condition.
+
+        Args:
+            configuration: Process condition configuration.
+
+        Returns:
+            The executable process condition.
+        """
+        return ProcessCondition(
+            process_name=configuration.name,
+            expected_running=configuration.running,
+            process_provider=self.process_provider,
+        )
+
+    def _build_datetime_condition(
+        self,
+        configuration: DateTimeConditionConfiguration,
+    ) -> DateTimeCondition:
+        """Build a datetime condition from its configuration.
+
+        Args:
+            configuration: DateTime condition configuration.
+
+        Returns:
+            The executable datetime condition.
+        """
+        if configuration.between is not None:
+            return DateTimeCondition(
+                clock_provider=self.clock_provider,
+                time_range=TimeRange(
+                    start=configuration.between.start,
+                    end=configuration.between.end,
+                ),
+            )
+
+        if configuration.weekday is not None:
+            return DateTimeCondition(
+                clock_provider=self.clock_provider,
+                weekdays=frozenset(configuration.weekday),
+            )
+
+        raise RuntimeError("Invalid datetime condition configuration")
+
+    def _build_action(self, configuration: ActionConfiguration) -> Action:
+        """Build an action from its configuration.
+
+        Args:
+            configuration: Action configuration.
+
+        Returns:
+            The executable action.
+        """
+        match configuration.type:
+            case "shutdown":
+                return ShutdownAction(self.power_provider)
+            case "sleep":
+                return SleepAction(self.power_provider)
+            case "hibernate":
+                return HibernateAction(self.power_provider)
+            case "reboot":
+                return RebootAction(self.power_provider)
+
+        raise ConfigurationError(f"Unsupported action type '{configuration.type}'")

powerrules-0.1.0b0/src/powerrules/config/loader.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+import yaml
+
+from powerrules.config.models import RuleSetConfiguration
+
+
+class ConfigurationLoader:
+    """Load and validate PowerRules configuration files."""
+
+    def load(self, path: Path) -> RuleSetConfiguration:
+        """Load and validate a PowerRules configuration file.
+
+        Args:
+            path: Path to the YAML configuration file.
+
+        Returns:
+            Validated PowerRules configuration.
+
+        Raises:
+            OSError: If the configuration file cannot be read.
+            yaml.YAMLError: If the YAML cannot be parsed.
+            ValidationError: If the configuration is invalid.
+        """
+        with path.open("r", encoding="utf-8") as file:
+            data = yaml.safe_load(file)
+
+        return RuleSetConfiguration.model_validate(data)

powerrules-0.1.0b0/src/powerrules/config/models.py

@@ -0,0 +1,212 @@
+from datetime import time
+from typing import Literal
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    field_validator,
+    model_validator,
+)
+
+from powerrules.conditions.datetime import Weekday
+
+
+class ProcessConditionConfiguration(BaseModel):
+    """Configuration for a process condition."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    running: StrictBool
+
+
+class TimeRangeConfiguration(BaseModel):
+    """Configuration for a datetime range."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    start: time
+    end: time
+
+    @field_validator("start", "end", mode="before")
+    @classmethod
+    def validate_time(cls, value: object) -> time:
+        """Validate and parse a configured time value.
+
+        Args:
+            value: Value to validate and parse.
+
+        Returns:
+            Parsed time value.
+        """
+        return _parse_time(value)
+
+
+class DateTimeConditionConfiguration(BaseModel):
+    """Configuration for a datetime condition."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    between: TimeRangeConfiguration | None = None
+    weekday: list[Weekday] | None = None
+
+    @model_validator(mode="after")
+    def validate_variant(self) -> "DateTimeConditionConfiguration":
+        """Validate that exactly one datetime variant is configured.
+
+        Returns:
+            The validated configuration.
+
+        Raises:
+            ValueError: If zero or multiple variants are configured.
+        """
+        configured_variants = sum(
+            value is not None
+            for value in (
+                self.between,
+                self.weekday,
+            )
+        )
+
+        if configured_variants != 1:
+            raise ValueError(
+                "A datetime condition must define exactly one of 'between' or 'weekday'"
+            )
+
+        return self
+
+
+class ConditionConfiguration(BaseModel):
+    """Configuration for a condition tree."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_by_name=True,
+    )
+
+    and_conditions: list["ConditionConfiguration"] | None = Field(
+        default=None,
+        validation_alias="and",
+        serialization_alias="and",
+    )
+    or_conditions: list["ConditionConfiguration"] | None = Field(
+        default=None,
+        validation_alias="or",
+        serialization_alias="or",
+    )
+    not_condition: "ConditionConfiguration | None" = Field(
+        default=None,
+        validation_alias="not",
+        serialization_alias="not",
+    )
+    process: ProcessConditionConfiguration | None = None
+    datetime: DateTimeConditionConfiguration | None = None
+
+    @model_validator(mode="after")
+    def validate_variant(self) -> "ConditionConfiguration":
+        configured_variants = sum(
+            value is not None
+            for value in (
+                self.and_conditions,
+                self.or_conditions,
+                self.not_condition,
+                self.process,
+                self.datetime,
+            )
+        )
+
+        if configured_variants != 1:
+            raise ValueError(
+                "A condition must define exactly one of 'and', 'or', 'not', 'process', or 'datetime'"
+            )
+
+        if self.and_conditions is not None and len(self.and_conditions) < 2:
+            raise ValueError("An 'and' condition must contain at least two conditions")
+
+        if self.or_conditions is not None and len(self.or_conditions) < 2:
+            raise ValueError("An 'or' condition must contain at least two conditions")
+
+        return self
+
+
+class ActionConfiguration(BaseModel):
+    """Configuration for an action."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal[
+        "shutdown",
+        "sleep",
+        "hibernate",
+        "reboot",
+    ]
+
+
+class RuleConfiguration(BaseModel):
+    """Configuration for a single rule."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    enabled: StrictBool = True
+    conditions: ConditionConfiguration
+    action: ActionConfiguration
+
+
+class RuleSetConfiguration(BaseModel):
+    """PowerRules YAML configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    rules: list[RuleConfiguration]
+
+
+def _parse_time(value: object) -> time:
+    """Parse a supported time configuration value.
+
+    Supported formats are H, HH, H:MM, HH:MM, H:MM:SS, and HH:MM:SS.
+
+    Args:
+        value: Value to parse.
+
+    Returns:
+        Parsed time value.
+
+    Raises:
+        ValueError: If the value is not a supported time format.
+    """
+    if isinstance(value, time):
+        return value
+
+    if not isinstance(value, str):
+        raise ValueError("Time value must be a string")
+
+    parts = value.split(":")
+
+    if not 1 <= len(parts) <= 3:
+        raise ValueError(f"Invalid time format '{value}', expected H, H:MM, or H:MM:SS")
+
+    if not all(part.isdigit() for part in parts):
+        raise ValueError(f"Invalid time format '{value}', expected H, H:MM, or H:MM:SS")
+
+    hour = parts[0]
+
+    if not 1 <= len(hour) <= 2:
+        raise ValueError(f"Invalid hour format '{hour}', expected H or HH")
+
+    if len(parts) > 1 and len(parts[1]) != 2:
+        raise ValueError(f"Invalid minute format '{parts[1]}', expected MM")
+
+    if len(parts) > 2 and len(parts[2]) != 2:
+        raise ValueError(f"Invalid second format '{parts[2]}', expected SS")
+
+    try:
+        return time(
+            hour=int(hour),
+            minute=int(parts[1]) if len(parts) > 1 else 0,
+            second=int(parts[2]) if len(parts) > 2 else 0,
+        )
+    except ValueError as e:
+        raise ValueError(f"Invalid time value '{value}'") from e

powerrules-0.1.0b0/src/powerrules/engine/exceptions.py

@@ -0,0 +1,14 @@
+class PowerRulesError(Exception):
+    """Base exception for PowerRules errors."""
+
+
+class ConditionEvaluationError(PowerRulesError):
+    """Raised when a condition cannot be evaluated."""
+
+
+class ActionExecutionError(PowerRulesError):
+    """Raised when an action cannot be executed."""
+
+
+class ConfigurationError(PowerRulesError):
+    """Raised when a configuration cannot be converted into a rule set."""

powerrules-0.1.0b0/src/powerrules/engine/models.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+from powerrules.actions.base import Action
+from powerrules.conditions.base import Condition
+
+
+@dataclass(frozen=True)
+class Rule:
+    """A rule consisting of a condition and an action."""
+
+    name: str
+    condition: Condition
+    action: Action
+    enabled: bool = True
+
+
+@dataclass(frozen=True)
+class RuleSet:
+    """Represent an ordered set of PowerRules rules."""
+
+    rules: tuple[Rule, ...]
+
+
+@dataclass(frozen=True)
+class RuleEvaluationResult:
+    """Represent the result of evaluating the rule set."""
+
+    matched_rule: Rule | None

powerrules-0.1.0b0/src/powerrules/engine/rule_engine.py

@@ -0,0 +1,46 @@
+from collections.abc import Sequence
+
+from powerrules.engine.models import Rule, RuleEvaluationResult
+
+
+class RuleEngine:
+    def __init__(self, rules: Sequence[Rule]):
+        self.rules = tuple(rules)
+
+    def find_match(self) -> Rule | None:
+        """Find the first enabled rule whose condition matches.
+
+        Returns:
+            The first matching rule, or None if no rule matches.
+
+        Raises:
+            ConditionEvaluationError: If a condition cannot be evaluated.
+        """
+        for rule in self.rules:
+            if not rule.enabled:
+                continue
+
+            if rule.condition.evaluate():
+                return rule
+
+        return None
+
+    def evaluate(self) -> RuleEvaluationResult:
+        """Evaluate rules and execute the first matching action.
+
+        Returns:
+            The result of the rule evaluation.
+
+        Raises:
+            ConditionEvaluationError: If a condition cannot be evaluated.
+            ActionExecutionError: If a matching action cannot be executed.
+        """
+        matched_rule = self.find_match()
+
+        if matched_rule is None:
+            return RuleEvaluationResult(matched_rule=None)
+
+        # Execute the action, e.g. reboot or shutdown etc.
+        matched_rule.action.execute()
+
+        return RuleEvaluationResult(matched_rule=matched_rule)

powerrules-0.1.0b0/src/powerrules/platform/windows/power.py

@@ -0,0 +1,51 @@
+import ctypes
+import subprocess
+
+
+class WindowsPowerProvider:
+    """Provide power management operations on Windows."""
+
+    def shutdown(self) -> None:
+        """Shut down the computer."""
+        subprocess.run(
+            ["shutdown.exe", "/s", "/t", "0"],
+            check=True,
+        )
+
+    def sleep(self) -> None:
+        """Put the computer into sleep mode."""
+        self._set_suspend_state(hibernate=False)
+
+    def hibernate(self) -> None:
+        """Put the computer into hibernation."""
+        self._set_suspend_state(hibernate=True)
+
+    def reboot(self) -> None:
+        """Reboot the computer."""
+        subprocess.run(
+            ["shutdown.exe", "/r", "/t", "0"],
+            check=True,
+        )
+
+    @staticmethod
+    def _set_suspend_state(hibernate: bool) -> None:
+        """Set the Windows suspend state.
+
+        Args:
+            hibernate: True to hibernate, False to enter sleep mode.
+
+        Raises:
+            OSError: If Windows cannot change the system power state.
+        """
+        result = ctypes.windll.powrprof.SetSuspendState(
+            hibernate,
+            False,
+            False,
+        )
+
+        if not result:
+            error_code = ctypes.get_last_error()
+            raise OSError(
+                error_code,
+                f"Failed to change the Windows power state, error code {error_code}",
+            )

powerrules-0.1.0b0/src/powerrules/platform/windows/process.py

@@ -0,0 +1,20 @@
+import psutil
+
+
+class WindowsProcessProvider:
+    """Provide process information on Windows."""
+
+    def is_running(self, process_name: str) -> bool:
+        """Return whether a process with the given name is running.
+
+        Args:
+            process_name: Name of the process to search for.
+
+        Returns:
+            True if at least one matching process is running, otherwise False.
+        """
+        for process in psutil.process_iter(["name"]):
+            if process.info["name"] == process_name:
+                return True
+
+        return False

powerrules-0.1.0b0/src/powerrules/providers/clock.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+from typing import Protocol
+
+
+class ClockProvider(Protocol):
+    def now(self) -> datetime:
+        """Return the current date and time."""
+        ...
+
+
+class SystemClockProvider:
+    def now(self) -> datetime:
+        """Return the current system date and time."""
+        return datetime.now()

powerrules-0.1.0b0/src/powerrules/providers/power.py

@@ -0,0 +1,19 @@
+from typing import Protocol
+
+
+class PowerProvider(Protocol):
+    def shutdown(self) -> None:
+        """Shut down the computer."""
+        ...
+
+    def sleep(self) -> None:
+        """Put the computer into sleep mode."""
+        ...
+
+    def hibernate(self) -> None:
+        """Put the computer into hibernation."""
+        ...
+
+    def reboot(self) -> None:
+        """Reboot the computer."""
+        ...

powerrules-0.1.0b0/src/powerrules/providers/process.py

@@ -0,0 +1,7 @@
+from typing import Protocol
+
+
+class ProcessProvider(Protocol):
+    def is_running(self, process_name: str) -> bool:
+        """Return whether a process with the given name is running."""
+        ...