refactor: point as one type

drow/annotation.py

@@ -1,6 +1,7 @@
-from typing import TypeVar, TypedDict, NotRequired, Generic, Literal
+from typing import TypeVar, TypedDict, NotRequired, Generic, Literal, TypeAlias
 
 DataType = TypeVar("DataType")
+PointData: TypeAlias = tuple[float, DataType]
 
 
 class BaseResponse(TypedDict):
@@ -32,29 +33,24 @@ class HistogramValue(TypedDict):
     buckets: list[BucketValue]
 
 
-ScalarPointData = tuple[float, str]
-StringPointData = tuple[float, str]
-HistogramPointData = tuple[float, HistogramValue]
-
-
 class BaseVector(TypedDict):
     metric: dict[str, str]
 
 
 class ScalarInstantVector(BaseVector):
-    value: ScalarPointData
+    value: PointData[str]
 
 
 class HistogramInstantVector(BaseVector):
-    histogram: HistogramPointData
+    histogram: PointData[HistogramValue]
 
 
 class ScalarRangeVector(BaseVector):
-    values: list[ScalarPointData]
+    values: list[PointData[str]]
 
 
 class HistogramRangeVector(BaseVector):
-    histograms: list[HistogramPointData]
+    histograms: list[PointData[HistogramValue]]
 
 
 class VectorData(TypedDict):
@@ -69,9 +65,9 @@ class MatrixData(TypedDict):
 
 class ScalarData(TypedDict):
     resultType: Literal["scalar"]
-    result: ScalarPointData
+    result: PointData[str]
 
 
 class StringData(TypedDict):
     resultType: Literal["string"]
-    result: StringPointData
+    result: PointData[str]

drow/model.py

@@ -5,21 +5,15 @@
 
 
 @dataclass(frozen=True)
-class ScalarPoint(Generic[T]):
+class Point(Generic[T]):
     timestamp: float
     value: T
 
 
-@dataclass(frozen=True)
-class StringPoint:
-    timestamp: float
-    value: str
-
-
 @dataclass(frozen=True)
 class InstantSeries(Generic[T]):
     metric: dict[str, str]
-    value: ScalarPoint[T]
+    value: Point[T]
 
 
 @dataclass(frozen=True)
@@ -30,7 +24,7 @@ class InstantVector(Generic[T]):
 @dataclass(frozen=True)
 class RangeSeries(Generic[T]):
     metric: dict[str, str]
-    values: list[ScalarPoint[T]]
+    values: list[Point[T]]
 
 
 @dataclass(frozen=True)

drow/parser.py

@@ -3,11 +3,11 @@
 from .annotation import (
     SuccessResponse, ErrorResponse,
     ScalarInstantVector, ScalarRangeVector,
-    ScalarPointData,
+    PointData,
     VectorData, MatrixData, ScalarData, StringData,
 )
 from .model import (
-    ScalarPoint, StringPoint,
+    Point,
     InstantSeries, RangeSeries,
     InstantVector, Matrix,
 )
@@ -25,7 +25,7 @@
     ErrorResponse,
 ]
 QueryResult: TypeAlias = Union[
-    ScalarPoint[T], StringPoint, InstantVector[T],
+    Point[T], Point[str], InstantVector[T],
 ]
 QueryRangeResponse = Union[
     SuccessResponse[MatrixData],
@@ -107,15 +107,15 @@ def parse_matrix(self, data: MatrixData) -> Matrix[T]:
             self.parse_range_series(i) for i in data["result"]
         ])
 
-    def parse_scalar(self, data: ScalarData) -> ScalarPoint[T]:
+    def parse_scalar(self, data: ScalarData) -> Point[T]:
         return self.parse_scalar_point(data["result"])
 
-    def parse_scalar_point(self, data: ScalarPointData) -> ScalarPoint[T]:
+    def parse_scalar_point(self, data: PointData[str]) -> Point[T]:
         t, v = data
-        return ScalarPoint(t, self.parse_value(v))
+        return Point(t, self.parse_value(v))
 
-    def parse_string(self, data: StringData) -> StringPoint:
-        return StringPoint(*data["result"])
+    def parse_string(self, data: StringData) -> Point[str]:
+        return Point(*data["result"])
 
     def parse_query_value_response(self, resp: QueryResponse) -> T:
         if resp["status"] == "error":

tests/test_parser.py

@@ -5,7 +5,7 @@
     VectorData, MatrixData, ScalarData, StringData,
 )
 from drow.model import (
-    ScalarPoint, StringPoint,
+    Point,
     InstantVector, Matrix,
 )
 from drow.parser import (
@@ -103,7 +103,7 @@ def test_success_scalar(self) -> None:
             "data": {"resultType": "scalar", "result": (1739529069.829, "5")},
         }
         parsed = parser.parse_query_response(resp)
-        assert isinstance(parsed, ScalarPoint)
+        assert isinstance(parsed, Point)
         self.assertEqual(parsed.value, "5")
 
     def test_success_string(self) -> None:
@@ -114,7 +114,7 @@ def test_success_string(self) -> None:
             },
         }
         parsed = parser.parse_query_response(resp)
-        assert isinstance(parsed, StringPoint)
+        assert isinstance(parsed, Point)
         self.assertEqual(parsed.value, "foo")
 
     def test_error(self) -> None: