RDBC-839 EntityToJson major refactor w/o breaking changes

Author: poissoncorp

ravendb/documents/bulk_insert_operation.py

@@ -25,7 +25,7 @@
 from ravendb.http.server_node import ServerNode
 from ravendb.http.raven_command import RavenCommand
 from ravendb.documents.operations.misc import GetOperationStateOperation
-from ravendb.documents.session.entity_to_json import EntityToJson
+from ravendb.documents.session.entity_to_json import EntityToJsonStatic
 from ravendb.documents.session.document_info import DocumentInfo
 from ravendb.json.metadata_as_dictionary import MetadataAsDictionary
 from ravendb.documents.commands.batches import CommandType
@@ -322,7 +322,7 @@ def _write_string_no_escape(self, data: str) -> None:
 
     def _write_document(self, entity: object, metadata: MetadataAsDictionary):
         document_info = DocumentInfo(metadata_instance=metadata)
-        json_dict = EntityToJson.convert_entity_to_json_internal_static(entity, self._conventions, document_info, True)
+        json_dict = EntityToJsonStatic.convert_entity_to_json(entity, self._conventions, document_info)
         self._current_data_buffer += bytearray(json.dumps(json_dict), encoding="utf-8")
 
     def _ensure_ongoing_operation(self) -> None:

ravendb/documents/operations/compare_exchange/compare_exchange.py

@@ -9,7 +9,7 @@
 from ravendb.documents.session.document_session_operations.misc import _update_metadata_modifications
 from ravendb.exceptions.raven_exceptions import RavenException
 from ravendb.json.metadata_as_dictionary import MetadataAsDictionary
-from ravendb.documents.session.entity_to_json import EntityToJson
+from ravendb.documents.session.entity_to_json import EntityToJsonStatic
 from ravendb.tools.utils import Utils
 
 _T = TypeVar("_T")
@@ -148,7 +148,7 @@ def get_command(
             if not self.__value:
                 return None
 
-            entity = EntityToJson.convert_entity_to_json_internal_static(self.__value.value, conventions, None, False)
+            entity = EntityToJsonStatic.convert_entity_to_json(self.__value.value, conventions, None, False)
 
             entity_json = entity if isinstance(entity, dict) else None
             metadata = (
@@ -229,7 +229,7 @@ def update_value(self, value: CompareExchangeValue):
             self.__value.index = self._index
 
             if self.__value.value is not None:
-                EntityToJson.populate_entity_static(self.__value.value, value.value)
+                EntityToJsonStatic.populate_entity(self.__value.value, value.value)
 
     @staticmethod
     def prepare_metadata_for_put(

ravendb/documents/operations/compare_exchange/operations.py

@@ -19,7 +19,7 @@
 from ravendb.http.server_node import ServerNode
 from ravendb.http.topology import RaftCommand
 from ravendb.json.metadata_as_dictionary import MetadataAsDictionary
-from ravendb.documents.session.entity_to_json import EntityToJson
+from ravendb.documents.session.entity_to_json import EntityToJsonStatic
 from ravendb.tools.utils import Utils
 from ravendb.util.util import RaftIdGenerator
 
@@ -65,14 +65,14 @@ def parse_from_string(
 
 class PutCompareExchangeValueOperation(IOperation[CompareExchangeResult], Generic[_T]):
     def __init__(self, key: str, value: _T, index: int, metadata: MetadataAsDictionary = None):
-        self.__key = key
-        self.__value = value
-        self.__index = index
-        self.__metadata = metadata
+        self._key = key
+        self._value = value
+        self._index = index
+        self._metadata = metadata
 
     def get_command(self, store: DocumentStore, conventions: DocumentConventions, cache: HttpCache) -> RavenCommand[_T]:
         return self.__PutCompareExchangeValueCommand(
-            self.__key, self.__value, self.__index, self.__metadata, conventions
+            self._key, self._value, self._index, self._metadata, conventions
         )
 
     class __PutCompareExchangeValueCommand(RavenCommand[_T], RaftCommand, Generic[_T]):
@@ -87,43 +87,43 @@ def __init__(
 
             super().__init__(CompareExchangeResult[_T])
 
-            self.__key = key
-            self.__value = value
-            self.__index = index
-            self.__metadata = metadata
-            self.__conventions = conventions or DocumentConventions()
+            self._key = key
+            self._value = value
+            self._index = index
+            self._metadata = metadata
+            self._conventions = conventions or DocumentConventions()
 
         def is_read_request(self) -> bool:
             return False
 
         def create_request(self, node: ServerNode) -> requests.Request:
-            url = f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self.__key)}&index={self.__index}"
-            tuple = {constants.CompareExchange.OBJECT_FIELD_NAME: self.__value}
-            json_dict = EntityToJson.convert_entity_to_json_internal_static(tuple, self.__conventions, None, False)
-            if self.__metadata:
+            url = f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self._key)}&index={self._index}"
+            object_and_value = {constants.CompareExchange.OBJECT_FIELD_NAME: self._value}
+            json_dict = EntityToJsonStatic.convert_entity_to_json(object_and_value, self._conventions, None, False)
+            if self._metadata:
                 metadata = CompareExchangeSessionValue.prepare_metadata_for_put(
-                    self.__key, self.__metadata, self.__conventions
+                    self._key, self._metadata, self._conventions
                 )
                 json_dict[constants.Documents.Metadata.KEY] = metadata
 
             return requests.Request("PUT", url, data=json_dict)
 
         def set_response(self, response: str, from_cache: bool) -> None:
-            self.result = CompareExchangeResult.parse_from_string(type(self.__value), response, self.__conventions)
+            self.result = CompareExchangeResult.parse_from_string(type(self._value), response, self._conventions)
 
         def get_raft_unique_request_id(self) -> str:
             return RaftIdGenerator.new_id()
 
 
 class GetCompareExchangeValueOperation(IOperation[CompareExchangeValue[_T]], Generic[_T]):
     def __init__(self, key: str, object_type: Type[_T], materialize_metadata: bool = True):
-        self.__key = key
-        self.__object_type = object_type
-        self.__materialize_metadata = materialize_metadata
+        self._key = key
+        self._object_type = object_type
+        self._materialize_metadata = materialize_metadata
 
     def get_command(self, store: DocumentStore, conventions: DocumentConventions, cache: HttpCache) -> RavenCommand[_T]:
         return self.GetCompareExchangeValueCommand(
-            self.__key, self.__object_type, self.__materialize_metadata, conventions
+            self._key, self._object_type, self._materialize_metadata, conventions
         )
 
     class GetCompareExchangeValueCommand(RavenCommand[CompareExchangeValue[_T]]):
@@ -133,55 +133,55 @@ def __init__(
             if not key:
                 raise ValueError("The key argument must have value")
             super().__init__(CompareExchangeValue[_T])
-            self.__key = key
-            self.__object_type = object_type
-            self.__materialize_metadata = materialize_metadata
-            self.__conventions = conventions
+            self._key = key
+            self._object_type = object_type
+            self._materialize_metadata = materialize_metadata
+            self._conventions = conventions
 
         def is_read_request(self) -> bool:
             return True
 
         def create_request(self, node: ServerNode) -> requests.Request:
-            url = f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self.__key)}"
+            url = f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self._key)}"
             return requests.Request("GET", url)
 
         def set_response(self, response: str, from_cache: bool) -> None:
             self.result = CompareExchangeValueResultParser.get_value(
-                self.__object_type, response, self.__materialize_metadata, self.__conventions
+                self._object_type, response, self._materialize_metadata, self._conventions
             )
 
 
 class DeleteCompareExchangeValueOperation(IOperation[CompareExchangeResult[_T]], Generic[_T]):
     def __init__(self, object_type: type, key: str, index: int):
-        self.__key = key
-        self.__object_type = object_type
-        self.__index = index
+        self._key = key
+        self._object_type = object_type
+        self._index = index
 
     def get_command(self, store: DocumentStore, conventions: DocumentConventions, cache: HttpCache) -> RavenCommand[_T]:
-        return self.RemoveCompareExchangeCommand[_T](self.__object_type, self.__key, self.__index, conventions)
+        return self.RemoveCompareExchangeCommand[_T](self._object_type, self._key, self._index, conventions)
 
     class RemoveCompareExchangeCommand(RavenCommand[CompareExchangeResult[_T]], RaftCommand, Generic[_T]):
         def __init__(self, object_type: type, key: str, index: int, conventions: DocumentConventions):
             if not key:
                 raise ValueError("The key must have value")
 
             super().__init__(CompareExchangeResult[_T])
-            self.__object_type = object_type
-            self.__key = key
-            self.__index = index
-            self.__conventions = conventions
+            self._object_type = object_type
+            self._key = key
+            self._index = index
+            self._conventions = conventions
 
         def is_read_request(self) -> bool:
             return True
 
         def create_request(self, node: ServerNode) -> requests.Request:
             return requests.Request(
                 "DELETE",
-                f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self.__key)}&index={self.__index}",
+                f"{node.url}/databases/{node.database}/cmpxchg?key={Utils.quote_key(self._key)}&index={self._index}",
             )
 
         def set_response(self, response: str, from_cache: bool) -> None:
-            self.result = CompareExchangeResult.parse_from_string(self.__object_type, response, self.__conventions)
+            self.result = CompareExchangeResult.parse_from_string(self._object_type, response, self._conventions)
 
         def get_raft_unique_request_id(self) -> str:
             return RaftIdGenerator.new_id()
@@ -226,34 +226,34 @@ def __init__(
             conventions: DocumentConventions,
         ):
             super().__init__(dict)
-            self.__operation = operation
-            self.__materialize_metadata = materialize_metadata
-            self.__conventions = conventions
+            self._operation = operation
+            self._materialize_metadata = materialize_metadata
+            self._conventions = conventions
 
         def is_read_request(self) -> bool:
             return True
 
         def create_request(self, node: ServerNode) -> requests.Request:
             path_builder = [node.url, "/databases/", node.database, "/cmpxchg?"]
 
-            if self.__operation._keys:
-                for key in self.__operation._keys:
+            if self._operation._keys:
+                for key in self._operation._keys:
                     path_builder.append("&key=")
                     path_builder.append(Utils.quote_key(key))
             else:
-                if self.__operation._start_with:
+                if self._operation._start_with:
                     path_builder.append("&startsWith=")
-                    path_builder.append(Utils.quote_key(self.__operation._start_with))
-                if self.__operation._start:
+                    path_builder.append(Utils.quote_key(self._operation._start_with))
+                if self._operation._start:
                     path_builder.append("&start=")
-                    path_builder.append(Utils.quote_key(self.__operation._start))
-                if self.__operation._page_size:
+                    path_builder.append(Utils.quote_key(self._operation._start))
+                if self._operation._page_size:
                     path_builder.append("&pageSize=")
-                    path_builder.append(Utils.quote_key(self.__operation._page_size))
+                    path_builder.append(Utils.quote_key(self._operation._page_size))
 
             return requests.Request("GET", "".join(path_builder))
 
         def set_response(self, response: str, from_cache: bool) -> None:
             self.result = CompareExchangeValueResultParser.get_values(
-                self.__operation._object_type, response, self.__materialize_metadata, self.__conventions
+                self._operation._object_type, response, self._materialize_metadata, self._conventions
             )

ravendb/documents/operations/executor.py

@@ -3,7 +3,7 @@
 import http
 from typing import Union, Optional, TYPE_CHECKING, TypeVar
 
-from ravendb.documents.session.entity_to_json import EntityToJson
+from ravendb.documents.session.entity_to_json import EntityToJsonStatic
 from ravendb.documents.operations.patch import PatchOperation, PatchStatus
 from ravendb.documents.operations.definitions import (
     IOperation,
@@ -90,7 +90,7 @@ def send_patch_operation_with_entity_class(
 
         try:
             result.status = command.result.status
-            result.document = EntityToJson.convert_to_entity_static(
+            result.document = EntityToJsonStatic.convert_to_entity(
                 command.result.modified_document, entity_class, self._request_executor.conventions
             )
             return result

ravendb/documents/operations/revisions.py

@@ -12,7 +12,7 @@
 from ravendb.http.raven_command import RavenCommand
 from ravendb.util.util import RaftIdGenerator
 from ravendb.http.topology import RaftCommand
-from ravendb.documents.session.entity_to_json import EntityToJson
+from ravendb.documents.session.entity_to_json import EntityToJsonStatic
 from ravendb.documents.conventions import DocumentConventions
 
 
@@ -167,7 +167,7 @@ def set_response(self, response: Optional[str], from_cache: bool) -> None:
                 if not revision:
                     continue
 
-                entity = EntityToJson.convert_to_entity_static(
+                entity = EntityToJsonStatic.convert_to_entity(
                     revision, self._object_type, DocumentConventions.default_conventions()
                 )
                 results.append(entity)