Merge pull request #203 from poissoncorp/RDBC-780

RDBC-780 Python client - commands

Author: ml054

ravendb/documents/commands/explain.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+from typing import Dict, Any, TYPE_CHECKING, Optional, List
+
+import requests
+from ravendb import RavenCommand, IndexQuery, ServerNode
+from ravendb.extensions.json_extensions import JsonExtensions
+
+if TYPE_CHECKING:
+    from ravendb.documents.conventions import DocumentConventions
+
+
+class ExplainQueryResult:
+    def __init__(self, index: str, reason: str):
+        self.index = index
+        self.reason = reason
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> ExplainQueryResult:
+        return cls(json_dict["Index"], json_dict["Reason"])
+
+
+class ExplainQueryCommand(RavenCommand[List[ExplainQueryResult]]):
+    def __init__(self, conventions: DocumentConventions, index_query: IndexQuery):
+        super().__init__(list)
+        if conventions is None:
+            raise ValueError("Conventions cannot be None")
+        if index_query is None:
+            raise ValueError("Index query cannot be None")
+
+        self._conventions = conventions
+        self._index_query = index_query
+
+    def create_request(self, node: ServerNode) -> requests.Request:
+        path = f"{node.url}/databases/{node.database}/queries?debug=explain"
+        return requests.Request(
+            "POST", path, data=JsonExtensions.write_index_query(self._conventions, self._index_query)
+        )
+
+    def set_response(self, response: Optional[str], from_cache: bool) -> None:
+        if response is None:
+            return
+
+        json_node = json.loads(response)
+        results = json_node.get("Results", None)
+        if results is None:
+            self._throw_invalid_response()
+            return
+
+        self.result = [ExplainQueryResult.from_json(res) for res in results]
+
+    def is_read_request(self) -> bool:
+        return True

ravendb/documents/indexes/analysis/definitions.py

@@ -1,7 +1,14 @@
-from typing import Optional
+from typing import Optional, Any, Dict
 
 
 class AnalyzerDefinition:
     def __init__(self, name: Optional[str] = None, code: Optional[str] = None):
         self.name = name
         self.code = code
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> "AnalyzerDefinition":
+        return cls(json_dict["Name"], json_dict["Code"])
+
+    def to_json(self) -> Dict[str, Any]:
+        return {"Name": self.name, "Code": self.code}

ravendb/documents/indexes/definitions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import datetime
+import enum
 import re
 from enum import Enum
 from abc import ABC
@@ -641,3 +642,10 @@ def _strip_comments(map_str: str) -> str:
     @staticmethod
     def _unify_white_space(map_str: str) -> str:
         return re.sub("\\s+", " ", map_str)
+
+
+class IndexRunningStatus(enum.Enum):
+    RUNNING = "Running"
+    PAUSED = "Paused"
+    DISABLED = "Disabled"
+    PENDING = "Pending"

ravendb/documents/indexes/stats.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+from datetime import datetime
+from typing import Dict, Any
+
+from ravendb.documents.indexes.definitions import (
+    IndexState,
+    IndexPriority,
+    IndexLockMode,
+    IndexType,
+    IndexSourceType,
+    IndexRunningStatus,
+)
+from ravendb.tools.utils import Utils
+
+
+class IndexStats:
+    def __init__(
+        self,
+        name: str = None,
+        map_attempts: int = None,
+        map_successes: int = None,
+        map_errors: int = None,
+        map_reference_attempts: int = None,
+        map_reference_successes: int = None,
+        map_reference_errors: int = None,
+        reduce_attempts: int = None,
+        reduce_successes: int = None,
+        reduce_errors: int = None,
+        reduce_output_collection: str = None,
+        reduce_output_reference_pattern: str = None,
+        pattern_references_collection_name: str = None,
+        mapped_per_second_rate: float = None,
+        reduced_per_second_rate: float = None,
+        max_number_of_outputs_per_document: int = None,
+        collections: Dict[str, CollectionStats] = None,
+        last_querying_time: datetime = None,
+        state: IndexState = None,
+        priority: IndexPriority = None,
+        created_timestamp: datetime = None,
+        last_indexing_time: datetime = None,
+        stale: bool = None,
+        lock_mode: IndexLockMode = None,
+        type: IndexType = None,
+        status: IndexRunningStatus = None,
+        entries_count: int = None,
+        errors_count: int = None,
+        source_type: IndexSourceType = None,
+        is_test_index: bool = None,
+    ):
+        self.name = name
+        self.map_attempts = map_attempts
+        self.map_successes = map_successes
+        self.map_errors = map_errors
+        self.map_reference_attempts = map_reference_attempts
+        self.map_reference_successes = map_reference_successes
+        self.map_reference_errors = map_reference_errors
+        self.reduce_attempts = reduce_attempts
+        self.reduce_successes = reduce_successes
+        self.reduce_errors = reduce_errors
+        self.reduce_output_collection = reduce_output_collection
+        self.reduce_output_reference_pattern = reduce_output_reference_pattern
+        self.pattern_references_collection_name = pattern_references_collection_name
+        self.mapped_per_second_rate = mapped_per_second_rate
+        self.reduced_per_second_rate = reduced_per_second_rate
+        self.max_number_of_outputs_per_document = max_number_of_outputs_per_document
+        self.collections = collections
+        self.last_querying_time = last_querying_time
+        self.state = state
+        self.priority = priority
+        self.created_timestamp = created_timestamp
+        self.last_indexing_time = last_indexing_time
+        self.stale = stale
+        self.lock_mode = lock_mode
+        self.type = type
+        self.status = status
+        self.entries_count = entries_count
+        self.errors_count = errors_count
+        self.source_type = source_type
+        self.is_test_index = is_test_index
+
+    class CollectionStats:
+        def __init__(
+            self,
+            last_processed_document_etag: int = None,
+            last_processed_tombstone_etag: int = None,
+            document_lag: int = None,
+            tombstone_lag: int = None,
+        ):
+            self.last_processed_document_etag = last_processed_document_etag
+            self.last_processed_tombstone_etag = last_processed_tombstone_etag
+            self.document_lag = document_lag
+            self.tombstone_lag = tombstone_lag
+
+        @classmethod
+        def from_json(cls, json_dict: Dict[str, Any]) -> "IndexStats.CollectionStats":
+            return cls(
+                json_dict["LastProcessedDocumentEtag"],
+                json_dict["LastProcessedTombstoneEtag"],
+                json_dict["DocumentLag"],
+                json_dict["TombstoneLag"],
+            )
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> IndexStats:
+        return cls(
+            json_dict["Name"],
+            json_dict["MapAttempts"],
+            json_dict["MapSuccesses"],
+            json_dict["MapErrors"],
+            json_dict["MapReferenceAttempts"],
+            json_dict["MapReferenceSuccesses"],
+            json_dict["MapReferenceErrors"],
+            json_dict["ReduceAttempts"],
+            json_dict["ReduceSuccesses"],
+            json_dict["ReduceErrors"],
+            json_dict["ReduceOutputCollection"],
+            json_dict["ReduceOutputReferencePattern"],
+            json_dict["PatternReferencesCollectionName"],
+            json_dict["MappedPerSecondRate"],
+            json_dict["ReducedPerSecondRate"],
+            json_dict["MaxNumberOfOutputsPerDocument"],
+            {key: cls.CollectionStats.from_json(value) for key, value in json_dict["Collections"].items()},
+            Utils.string_to_datetime(json_dict["LastQueryingTime"]),
+            IndexState(json_dict["State"]),
+            IndexPriority(json_dict["Priority"]),
+            Utils.string_to_datetime(json_dict["CreatedTimestamp"]),
+            Utils.string_to_datetime(json_dict["LastIndexingTime"]),
+            json_dict["IsStale"],
+            IndexLockMode(json_dict["LockMode"]),
+            IndexType(json_dict["Type"]),
+            IndexRunningStatus(json_dict["Status"]),
+            json_dict["EntriesCount"],
+            json_dict["ErrorsCount"],
+            IndexSourceType(json_dict["SourceType"]),
+            json_dict.get("IsTestIndex", None),
+        )