RDBC-642 Code format

Author: poissoncorp

ravendb/documents/session/entity_to_json.py

@@ -7,7 +7,9 @@
 from ravendb.documents.session.document_info import DocumentInfo
 from ravendb.documents.session.event_args import (
     BeforeConversionToDocumentEventArgs,
-    AfterConversionToDocumentEventArgs, BeforeConversionToEntityEventArgs, AfterConversionToEntityEventArgs,
+    AfterConversionToDocumentEventArgs,
+    BeforeConversionToEntityEventArgs,
+    AfterConversionToEntityEventArgs,
 )
 from ravendb.exceptions import exceptions
 from ravendb.exceptions.exceptions import InvalidOperationException
@@ -71,9 +73,7 @@ def _convert_entity_to_json_internal(
         return json_node
 
     # todo: refactor this method, make it more useful/simple and less ugly (like this return...[0])
-    def convert_to_entity(
-        self, entity_type: Type[_T], key: str, document: dict, track_entity: bool
-    ) -> _T:
+    def convert_to_entity(self, entity_type: Type[_T], key: str, document: dict, track_entity: bool) -> _T:
         conventions = self._session.conventions
         return self.convert_to_entity_static(document, entity_type, conventions, self._session)
 
@@ -148,18 +148,25 @@ def convert_to_entity_by_key_static(
 
     @staticmethod
     def convert_to_entity_static(
-        document: dict, object_type: [_T], conventions: "DocumentConventions", session_hook: Optional["InMemoryDocumentSessionOperations"] = None
+        document: dict,
+        object_type: [_T],
+        conventions: "DocumentConventions",
+        session_hook: Optional["InMemoryDocumentSessionOperations"] = None,
     ) -> _T:
         metadata = document.pop("@metadata")
         document_deepcopy = deepcopy(document)
         type_from_metadata = conventions.try_get_type_from_metadata(metadata)
         is_inherit = False
         key = metadata.get(constants.Documents.Metadata.ID, None)
         if session_hook:
-            session_hook.before_conversion_to_entity_invoke(BeforeConversionToEntityEventArgs(session_hook,key,object_type,document_deepcopy))
+            session_hook.before_conversion_to_entity_invoke(
+                BeforeConversionToEntityEventArgs(session_hook, key, object_type, document_deepcopy)
+            )
 
         if object_type == dict or type_from_metadata == "builtins.dict":
-            session_hook.after_conversion_to_entity_invoke(AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, document_deepcopy))
+            session_hook.after_conversion_to_entity_invoke(
+                AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, document_deepcopy)
+            )
             return document_deepcopy
 
         if type_from_metadata is None:
@@ -169,7 +176,8 @@ def convert_to_entity_static(
                 dyn = _DynamicStructure(**document_deepcopy)
                 if session_hook:
                     session_hook.after_conversion_to_entity_invoke(
-                       AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy,dyn))
+                        AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, dyn)
+                    )
                 return dyn
         else:
             object_from_metadata = Utils.import_class(type_from_metadata)
@@ -205,7 +213,8 @@ def convert_to_entity_static(
             entity.Id = metadata.get("@id", None)
         if session_hook:
             session_hook.after_conversion_to_entity_invoke(
-                AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, entity))
+                AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, entity)
+            )
         return entity
 
     def remove_from_missing(self, entity):

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_12748.py

@@ -273,7 +273,9 @@ def test_can_correctly_aggregate_ranges(self):
             self.assertIsNone(range2.min_)
 
             range1 = list(filter(lambda x: x.range_ == "total < 100" and x.name == "quantity", facet_result.values))[0]
-            range2 = list(filter(lambda x: x.range_ == "total >= 1500" and x.name == "quantity", facet_result.values))[0]
+            range2 = list(filter(lambda x: x.range_ == "total >= 1500" and x.name == "quantity", facet_result.values))[
+                0
+            ]
 
             self.assertEqual(2, range1.count_)
             self.assertEqual(1, range2.count_)
@@ -286,23 +288,22 @@ def test_can_correctly_aggregate_ranges(self):
             self.assertIsNone(range1.min_)
             self.assertIsNone(range2.min_)
 
-
         with self.store.open_session() as session:
             range = RangeBuilder.for_path("total")
             r = (
                 session.query_index("Orders/All", Order)
-                    .aggregate_by(
+                .aggregate_by(
                     lambda f: f.by_ranges(
                         range.is_less_than(100),
                         range.is_greater_than_or_equal_to(100).is_less_than(500),
                         range.is_greater_than_or_equal_to(500).is_less_than(1500),
                         range.is_greater_than_or_equal_to(1500),
                     )
-                        .sum_on("total", "T1")
-                        .average_on("total", "T1")
-                        .sum_on("quantity", "Q1")
+                    .sum_on("total", "T1")
+                    .average_on("total", "T1")
+                    .sum_on("quantity", "Q1")
                 )
-                    .execute()
+                .execute()
             )
 
             facet_result = r.get("total")
@@ -340,19 +341,19 @@ def test_can_correctly_aggregate_ranges(self):
             range = RangeBuilder.for_path("total")
             r = (
                 session.query_index("Orders/All", Order)
-                    .aggregate_by(
+                .aggregate_by(
                     lambda f: f.by_ranges(
                         range.is_less_than(100),
                         range.is_greater_than_or_equal_to(100).is_less_than(500),
                         range.is_greater_than_or_equal_to(500).is_less_than(1500),
                         range.is_greater_than_or_equal_to(1500),
                     )
-                        .sum_on("total", "T1")
-                        .sum_on("total", "T2")
-                        .average_on("total", "T2")
-                        .sum_on("quantity", "Q1")
+                    .sum_on("total", "T1")
+                    .sum_on("total", "T2")
+                    .average_on("total", "T2")
+                    .sum_on("quantity", "Q1")
                 )
-                    .execute()
+                .execute()
             )
 
             facet_result = r.get("total")
@@ -371,26 +372,23 @@ def test_can_correctly_aggregate_ranges(self):
             self.assertIsNone(range1.min_)
             self.assertIsNone(range2.min_)
 
-
             range1 = list(filter(lambda x: x.range_ == "total < 100" and x.name == "T2", facet_result.values))[0]
             range2 = list(filter(lambda x: x.range_ == "total >= 1500" and x.name == "T2", facet_result.values))[0]
 
             self.assertEqual(2, range1.count_)
             self.assertEqual(1, range2.count_)
             self.assertEqual(12, range1.sum_)
             self.assertEqual(3333, range2.sum_)
-            self.assertEqual(6,range1.average_)
-            self.assertEqual(3333,range2.average_)
+            self.assertEqual(6, range1.average_)
+            self.assertEqual(3333, range2.average_)
             self.assertIsNone(range1.max_)
             self.assertIsNone(range2.max_)
             self.assertIsNone(range1.min_)
             self.assertIsNone(range2.min_)
 
-
             range1 = list(filter(lambda x: x.range_ == "total < 100" and x.name == "Q1", facet_result.values))[0]
             range2 = list(filter(lambda x: x.range_ == "total >= 1500" and x.name == "Q1", facet_result.values))[0]
 
-
             self.assertEqual(2, range1.count_)
             self.assertEqual(1, range2.count_)
             self.assertEqual(8, range1.sum_)