RDBC-642 Various tests

Author: poissoncorp

ravendb/documents/indexes/definitions.py

@@ -59,12 +59,11 @@ def __str__(self):
 
 
 class FieldStorage(Enum):
-    YES = " Yes"
+    YES = "Yes"
     NO = "No"
 
 
 class FieldIndexing(Enum):
-    YES = " Yes"
     NO = "No"
     SEARCH = "Search"
     EXACT = "Exact"
@@ -87,7 +86,7 @@ def __str__(self):
 
 
 class FieldTermVector(Enum):
-    YES = " Yes"
+    YES = "Yes"
     NO = "No"
     WITH_POSITIONS = "WithPositions"
     WITH_OFFSETS = "WithOffsets"
@@ -158,7 +157,7 @@ def to_json(self):
             "Storage": self.storage,
             "Indexing": self.indexing,
             "TermVector": self.term_vector,
-            "Spatial": self.spatial,
+            "Spatial": self.spatial.to_json() if self.spatial else None,
             "Analyzer": self.analyzer,
             "Suggestions": self.suggestions,
         }

ravendb/documents/indexes/index_creation.py

@@ -4,6 +4,7 @@
 
 from ravendb import constants
 from ravendb.documents.conventions import DocumentConventions
+from ravendb.documents.indexes.spatial.configuration import SpatialOptionsFactory
 from ravendb.documents.store.definition import DocumentStore, DocumentStoreBase
 from ravendb.documents.indexes.definitions import (
     IndexDefinition,
@@ -105,9 +106,8 @@ def is_map_reduce(self) -> bool:
     def _index(self, field: str, indexing: FieldIndexing) -> None:
         self._indexes_strings[field] = indexing
 
-    # todo: def _spatial(self, field:str, indexing:Callable[[SpatialOptionsFactory],SpatialOptions]) -> None
-    def _spatial(self, field: str, indexing: Callable) -> None:
-        pass
+    def _spatial(self, field: str, indexing: Callable[[SpatialOptionsFactory], SpatialOptions]) -> None:
+        self._spatial_options_strings[field] = indexing(SpatialOptionsFactory())
 
     def _store_all_fields(self, storage: FieldStorage) -> None:
         self._stores_strings[constants.Documents.Indexing.Fields.ALL_FIELDS] = storage

ravendb/documents/indexes/spatial/configuration.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from __future__ import annotations
 from enum import Enum
 from typing import Union, List, Dict
 
@@ -56,6 +57,18 @@ def __init__(
         self.max_y = max_y
         self.units = units
 
+    def to_json(self) -> Dict:
+        return {
+            "Type": self.type.value,
+            "Strategy": self.strategy.value,
+            "MaxTreeLevel": self.max_tree_level,
+            "MinX": self.min_x,
+            "MaxX": self.max_x,
+            "MinY": self.min_y,
+            "MaxY": self.max_y,
+            "Units": self.units,
+        }
+
     @classmethod
     def from_copy(cls, options: SpatialOptions) -> SpatialOptions:
         return cls(
@@ -126,3 +139,99 @@ def __init__(
     @classmethod
     def from_json(cls, json_dict: Dict) -> AutoSpatialOptions:
         return cls.from_copy(SpatialOptions.from_copy(json_dict.get("Options")))
+
+
+class SpatialOptionsFactory:
+    class GeographySpatialOptionsFactory:
+        def default_option(self, circle_radius_units: SpatialUnits = SpatialUnits.KILOMETERS) -> SpatialOptions:
+            return self.geohash_prefix_tree_index(0, circle_radius_units)
+
+        def bounding_box_index(self, circle_radius_units: SpatialUnits = SpatialUnits.KILOMETERS) -> SpatialOptions:
+            ops = SpatialOptions()
+            ops.type = SpatialFieldType.GEOGRAPHY
+            ops.strategy = SpatialSearchStrategy.BOUNDING_BOX
+            ops.units = circle_radius_units
+            return ops
+
+        def geohash_prefix_tree_index(
+            self, max_tree_level: int, circle_radius_units: SpatialUnits = SpatialUnits.KILOMETERS
+        ) -> SpatialOptions:
+            if max_tree_level == 0:
+                max_tree_level = SpatialOptions.DEFAULT_GEOHASH_LEVEL
+
+            opts = SpatialOptions()
+            opts.type = SpatialFieldType.GEOGRAPHY
+            opts.max_tree_level = max_tree_level
+            opts.strategy = SpatialSearchStrategy.GEOHASH_PREFIX_TREE
+            opts.units = circle_radius_units
+            return opts
+
+        def quad_prefix_tree_level(
+            self, max_tree_level: int, circle_radius_units: SpatialUnits = SpatialUnits.KILOMETERS
+        ) -> SpatialOptions:
+            if max_tree_level == 0:
+                max_tree_level = SpatialOptions.DEFAULT_QUAD_TREE_LEVEL
+
+            opts = SpatialOptions()
+            opts.type = SpatialFieldType.GEOGRAPHY
+            opts.max_tree_level = max_tree_level
+            opts.strategy = SpatialSearchStrategy.QUAD_PREFIX_TREE
+            opts.units = circle_radius_units
+            return opts
+
+    class CartesianSpatialOptionsFactory:
+        def bounding_box_index(self) -> SpatialOptions:
+            opts = SpatialOptions()
+            opts.type = SpatialFieldType.CARTESIAN
+            opts.strategy = SpatialSearchStrategy.BOUNDING_BOX
+            return opts
+
+        def quad_prefix_tree_index(
+            self, max_tree_level: int, bounds: SpatialOptionsFactory.SpatialBounds
+        ) -> SpatialOptions:
+            if max_tree_level == 0:
+                raise ValueError("maxTreeLevel")
+
+            opts = SpatialOptions()
+            opts.type = SpatialFieldType.CARTESIAN
+            opts.max_tree_level = max_tree_level
+            opts.strategy = SpatialSearchStrategy.QUAD_PREFIX_TREE
+            opts.min_x = bounds.min_x
+            opts.max_x = bounds.max_x
+            opts.min_y = bounds.min_y
+            opts.max_y = bounds.max_y
+
+            return opts
+
+    def geography(self) -> GeographySpatialOptionsFactory:
+        return SpatialOptionsFactory.GeographySpatialOptionsFactory()
+
+    def cartesian(self) -> CartesianSpatialOptionsFactory:
+        return SpatialOptionsFactory.CartesianSpatialOptionsFactory()
+
+    class SpatialBounds:
+        def __init__(self, min_x: float, min_y: float, max_x: float, max_y: float):
+            self.min_x = min_x
+            self.min_y = min_y
+            self.max_x = max_x
+            self.max_y = max_y
+
+        def __hash__(self):
+            hash((self.max_x, self.min_x, self.max_y, self.min_y))
+
+        def __eq__(self, other: object):
+            if self == other:
+                return True
+            if other == None:
+                return False
+            if self.__class__ != other.__class__:
+                return False
+            other: SpatialOptionsFactory.SpatialBounds
+            return all(
+                [
+                    self.max_x == other.max_x,
+                    self.max_y == other.max_y,
+                    self.min_x == other.min_x,
+                    self.min_y == other.min_y,
+                ]
+            )

ravendb/documents/queries/explanation.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Dict, List
 
 from ravendb.documents.queries.query import QueryResult
@@ -14,3 +15,10 @@ def update(self, query_result: QueryResult) -> None:
 class ExplanationOptions:
     def __init__(self, group_key: str = None):
         self.group_key = group_key
+
+    @classmethod
+    def from_json(cls, json_dict: Dict) -> ExplanationOptions:
+        return cls(json_dict["groupKey"])
+
+    def to_json(self) -> Dict:
+        return {"groupKey": self.group_key}

ravendb/documents/session/entity_to_json.py

@@ -7,7 +7,7 @@
 from ravendb.documents.session.document_info import DocumentInfo
 from ravendb.documents.session.event_args import (
     BeforeConversionToDocumentEventArgs,
-    AfterConversionToDocumentEventArgs,
+    AfterConversionToDocumentEventArgs, BeforeConversionToEntityEventArgs, AfterConversionToEntityEventArgs,
 )
 from ravendb.exceptions import exceptions
 from ravendb.exceptions.exceptions import InvalidOperationException
@@ -72,10 +72,10 @@ def _convert_entity_to_json_internal(
 
     # 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, nested_object_types=None
+        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, nested_object_types)
+        return self.convert_to_entity_static(document, entity_type, conventions, self._session)
 
     @staticmethod
     def populate_entity_static(entity, document: dict) -> None:
@@ -148,25 +148,28 @@ def convert_to_entity_by_key_static(
 
     @staticmethod
     def convert_to_entity_static(
-        document: dict, object_type: [_T], conventions: "DocumentConventions", nested_object_types=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
-        # todo: events
-        # events.before_conversion_to_entity(document, metadata, type_from_metadata)
+        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))
 
         if object_type == dict or type_from_metadata == "builtins.dict":
-            # events.after_conversion_to_entity(document, document, metadata)
+            session_hook.after_conversion_to_entity_invoke(AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, document_deepcopy))
             return document_deepcopy
 
         if type_from_metadata is None:
             if object_type is not None:
                 metadata["Raven-Python-Type"] = "{0}.{1}".format(object_type.__module__, object_type.__name__)
             else:  # no type defined on document or during load, return a dict
                 dyn = _DynamicStructure(**document_deepcopy)
-                # events.after_conversion_to_entity(dyn, document, metadata)
+                if session_hook:
+                    session_hook.after_conversion_to_entity_invoke(
+                       AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy,dyn))
                 return dyn
         else:
             object_from_metadata = Utils.import_class(type_from_metadata)
@@ -187,8 +190,9 @@ def convert_to_entity_static(
         if "from_json" in object_type.__dict__ and inspect.ismethod(object_type.from_json):
             entity = object_type.from_json(document_deepcopy)
 
-        elif nested_object_types is None and is_inherit:
+        elif is_inherit:
             entity = Utils.convert_json_dict_to_object(document_deepcopy, object_type)
+
         else:
             entity = _DynamicStructure(**document_deepcopy)
             entity.__class__ = object_type
@@ -197,33 +201,11 @@ def convert_to_entity_static(
             except TypeError as e:
                 raise InvalidOperationException("Probably projection error", e)
 
-            if nested_object_types:
-                for key in nested_object_types:
-                    attr = getattr(entity, key)
-                    if attr:
-                        try:
-                            if isinstance(attr, list):
-                                nested_list = []
-                                for attribute in attr:
-                                    nested_list.append(Utils.initialize_object(attribute, nested_object_types[key]))
-                                setattr(entity, key, nested_list)
-                            elif nested_object_types[key] is datetime:
-                                setattr(entity, key, Utils.string_to_datetime(attr))
-                            elif nested_object_types[key] is timedelta:
-                                setattr(entity, key, Utils.string_to_timedelta(attr))
-                            else:
-                                setattr(
-                                    entity,
-                                    key,
-                                    Utils.initialize_object(attr, nested_object_types[key]),
-                                )
-                        except TypeError as e:
-                            print(e)
-                            pass
-
         if "Id" in entity.__dict__:
             entity.Id = metadata.get("@id", None)
-        # events.after_conversion_to_entity(entity, document, metadata)
+        if session_hook:
+            session_hook.after_conversion_to_entity_invoke(
+                AfterConversionToEntityEventArgs(session_hook, key, document_deepcopy, entity))
         return entity
 
     def remove_from_missing(self, entity):

ravendb/documents/session/in_memory_document_session_operations.py

@@ -1635,7 +1635,7 @@ def hash_code(self) -> int:
     def __deserialize_from_transformer(
         self, object_type: Type[_T], key: Union[None, str], document: dict, track_entity: bool
     ) -> _T:
-        return self.entity_to_json.convert_to_entity(object_type, key, document, track_entity, None)
+        return self.entity_to_json.convert_to_entity(object_type, key, document, track_entity)
 
     def check_if_id_already_included(self, ids: List[str], includes: Union[List[List], List[str]]) -> bool:
         if includes and not isinstance(includes[0], str):

ravendb/documents/session/query.py

@@ -851,6 +851,10 @@ def _generate_index_query(self, query: str) -> IndexQuery:
         index_query.query_parameters = self._query_parameters
         index_query.disable_caching = self._disable_caching
         index_query.projection_behavior = self._projection_behavior
+
+        if self._page_size is not None:
+            index_query.page_size = self._page_size
+
         return index_query
 
     def _search(self, field_name: str, search_terms: str, operator: SearchOperator) -> None:
@@ -901,11 +905,11 @@ def __build_with(self, query_text: List[str]) -> None:
             query_text.append(os.linesep)
 
     def __build_pagination(self, query_text: List[str]) -> None:
-        if self._start is not None and self._start > 0 or self._page_size is not None:
+        if (self._start is not None and self._start > 0) or self._page_size is not None:
             query_text.append(" limit $")
-            query_text.append(self.__add_query_parameter(self._start))
+            query_text.append(self.__add_query_parameter(self._start or 0))
             query_text.append(", $")
-            query_text.append(self.__add_query_parameter(self._page_size))
+            query_text.append(self.__add_query_parameter(self._page_size or 0))
 
     def __build_include(self, query_text: List[str]) -> None:
         if (
@@ -1709,7 +1713,7 @@ def order_by_score_descending(self) -> DocumentQuery[_T]:
         return self
 
     def include_explanations(
-        self, options: Optional[ExplanationOptions], explanations_callback: Callable[[Explanations], None]
+        self, options: Optional[ExplanationOptions] = None, explanations_callback: Callable[[Explanations], None] = None
     ) -> DocumentQuery[_T]:
         self._include_explanations(options, explanations_callback)
         return self

ravendb/infrastructure/faceted.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+import datetime
+from enum import Enum
+from typing import Dict
+
+
+class Currency(Enum):
+    EUR = "EUR"
+    PLN = "PLN"
+    NIS = "NIS"
+
+
+class Order:
+    def __init__(
+        self,
+        product: str = None,
+        total: float = None,
+        currency: Currency = None,
+        quantity: int = None,
+        region: int = None,
+        at: datetime.datetime = None,
+        tax: float = None,
+    ):
+        self.product = product
+        self.total = total
+        self.currency = currency
+        self.quantity = quantity
+        self.region = region
+        self.at = at
+        self.tax = tax
+
+    @classmethod
+    def from_json(cls, json_dict: Dict) -> Order:
+        return cls(
+            json_dict["product"],
+            json_dict["total"],
+            Currency(json_dict["currency"]),
+            json_dict["quantity"],
+            json_dict["region"],
+            datetime.datetime.fromisoformat(json_dict["at"]) if "at" in json_dict else None,
+            json_dict["tax"],
+        )
+
+    def to_json(self) -> Dict:
+        return {
+            "product": self.product,
+            "total": self.total,
+            "currency": self.currency.value,
+            "quantity": self.quantity,
+            "region": self.region,
+            "at": self.at.isoformat() if self.at else None,
+            "tax": self.tax,
+        }