File size: 4,127 Bytes
04f192c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
# SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project.
#
# SPDX-License-Identifier: Apache-2.0

import abc
import enum
import functools
from typing import ClassVar, Type, cast, override

import pydantic

__all__ = ["Request", "Response", "ResponseWithDescribeInfo", "FromTo"]


@functools.total_ordering
class Verbosity(enum.Enum):
    """Enum for verbosity levels."""

    LOW = enum.auto()
    NORMAL = enum.auto()
    HIGH = enum.auto()

    def __lt__(self, other):
        if self.__class__ is other.__class__:
            return self.value < other.value
        return NotImplemented


class Response(pydantic.BaseModel, abc.ABC):
    @abc.abstractmethod
    def _describe(self, *, level: int, verbosity: Verbosity) -> list[str]: ...

    def describe(self, *, level: int = 1, verbosity: Verbosity = Verbosity.NORMAL) -> str:
        return "\n".join(self._describe(level=level, verbosity=verbosity))

    def describe_with(self, *, level: int | None = None, verbosity: Verbosity | None = None) -> "Response":
        if level is None and verbosity is None:
            return self

        return ResponseWithDescribeInfo(self, level=level, verbosity=verbosity)

    def __str__(self) -> str:
        return self.describe()


class ResponseWithDescribeInfo[T: Response](Response, abc.ABC):
    def __init__(self, response: T, *, level: int | None = None, verbosity: Verbosity | None = None):
        self.response = response
        self.level = level
        self.verbosity = verbosity

    @override
    def _describe(self, *, level: int, verbosity: Verbosity) -> list[str]:
        return self.response._describe(level=level, verbosity=verbosity)

    @override
    def describe(self, *, level: int | None = None, verbosity: Verbosity | None = None) -> str:
        match (level, verbosity):
            case (None, None):
                _level = self.level
                _verbosity = self.verbosity
            case (_, None):
                _level = level
                _verbosity = self.verbosity
            case (None, _):
                _level = self.level
                _verbosity = verbosity
            case _:
                _level = level
                _verbosity = verbosity

        match (_level, _verbosity):
            case (None, None):
                return super().describe()
            case (_, None):
                return super().describe(level=_level)
            case (None, _):
                return super().describe(verbosity=_verbosity)
            case _:
                return super().describe(level=_level, verbosity=_verbosity)

    @override
    def describe_with(self, *, level: int | None = None, verbosity: Verbosity | None = None) -> Response:
        match (level, verbosity):
            case (None, None):
                return self
            case (_, None):
                return ResponseWithDescribeInfo(self.response, level=level, verbosity=self.verbosity)
            case (None, _):
                return ResponseWithDescribeInfo(self.response, level=self.level, verbosity=verbosity)
            case _:
                return ResponseWithDescribeInfo(self.response, level=level, verbosity=verbosity)


class Request[R: Response](pydantic.BaseModel):
    _event: ClassVar[str | None]
    _response_type: ClassVar[Type[Response] | None]
    _timeout: ClassVar[float | None]

    def __init_subclass__(
        cls, *, event: str | None = None, response_type: Type[R] | None = None, timeout: float | None = None, **kwargs
    ):
        super().__init_subclass__(**kwargs)
        cls._event = event
        cls._response_type = response_type  # TODO: automatic get from R
        cls._timeout = timeout

    @property
    def event(self) -> str:
        assert self._event is not None
        return self._event

    @property
    def response_type(self) -> Type[R]:
        assert self._response_type is not None
        return cast(Type[R], self._response_type)


class FromTo[T](pydantic.BaseModel):
    from_: T = pydantic.Field(alias="from")
    to: T

    def __str__(self) -> str:
        return f"{self.from_} -> {self.to}"