backo 0.3.0__tar.gz → 0.3.3__tar.gz

{backo-0.3.0 → backo-0.3.3}/CHANGELOG.md

@@ -5,9 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.3.3] 2026-09-04
+
+    * fix : Error on release 0.3.1 and 0.3.2
+
+## [0.3.2] 2026-09-04
+    * Doc
+      * Minor documentation fix
+
+## [0.3.1] 2026-09-04
+    * Feat
+      * Adding routes for Total computation in selections (/_selections_total/ path)
+    * Internal
+      * Cross database references
+    * Fix
+      * datetime was stored in DBMongoConnector as a string. -> fixed but need probably a migration
+    * Doc
+      * Minor documentation fix
+  
 ## [0.3.0] 2026-09-01
     * Feat
-      * BREAKING CHANGE : DBHandler refactoring (import and definition of DBConnector)
+      * BREAKING CHANGE : DBHandler refactoring (import and definition of DBConnector, use from backo.db import ...)
       * BREAKING CHANGE : In DBHandler select the field 'total' in response is actually set to 'None'
       * DBValKeyConnector (for Redis)
       * DBSqlite3Connector (for SQLite3)
@@ -21,7 +39,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
       * fix current_user anonymous bug overlap between tests
     * Doc
       * Adding DBHandlers documentation
-    * 
+  
 ## [0.2.1] 2026-06-18
     * Feat
       * openapi information

{backo-0.3.0 → backo-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backo
-Version: 0.3.0
+Version: 0.3.3
 Summary: Back office low code
 Project-URL: GitHub, https://github.com/backo-stricto/backo
 Project-URL: Homepage, https://github.com/backo-stricto/backo
@@ -69,7 +69,13 @@ It aims at providing a simple and efficient way to create a backend application
 ## Installation
 
 ```bash
+
+# basic
 pip install backo
+
+# With mongo
+pip install backo[mongo]
+
 ```
 
 ## Quickstart
@@ -1014,6 +1020,13 @@ is used to call an action.
 | <kbd>GET</kbd>  | \<my-app-name\>/\<collection name\>/_selections/\<selection_name\> | do the selection                     |
 | <kbd>POST</kbd> | \<my-app-name\>/\<collection name\>/_selections/\<selection_name\> | do the selection with complex filter |
 
+And for counting the total of objects
+
+| Method          | Route                                                              | Description                          |
+| --------------- | ------------------------------------------------------------------ | ------------------------------------ |
+| <kbd>GET</kbd>  | \<my-app-name\>/\<collection name\>/_selections_total/\<selection_name\> | get the total for the selection |
+| <kbd>POST</kbd> | \<my-app-name\>/\<collection name\>/_selections_total/\<selection_name\> | get the total for the selection with complex filter |
+
 #### example
 
 ```bash
@@ -1022,8 +1035,12 @@ curl -X GET 'http://localhost/media_library/coll/books/_selections/borrowed'
      ["666", "Docker as BDSM toy", "Wallrich"], 
      ["1234", "Milf forever", "Epstein"]
     ],
-    "total": 2, "_skip": 0, "_page": 10}'
-curl -X GET 'http://localhost/media_library/coll/books/_selections/borrowed?title.$reg=Dock'
+    "total": None, "_skip": 0, "_page": 10}'
+curl -X GET 'http://localhost/media_library/coll/books/_selections_total/borrowed' 
+  '2'
+
+curl -X GET 'http://localhost/media_library/coll/books/_selections_total/borrowed?title.$reg=Dock'
+  '1'
 ```
 
 

{backo-0.3.0 → backo-0.3.3}/README.md

@@ -21,7 +21,13 @@ It aims at providing a simple and efficient way to create a backend application
 ## Installation
 
 ```bash
+
+# basic
 pip install backo
+
+# With mongo
+pip install backo[mongo]
+
 ```
 
 ## Quickstart
@@ -966,6 +972,13 @@ is used to call an action.
 | <kbd>GET</kbd>  | \<my-app-name\>/\<collection name\>/_selections/\<selection_name\> | do the selection                     |
 | <kbd>POST</kbd> | \<my-app-name\>/\<collection name\>/_selections/\<selection_name\> | do the selection with complex filter |
 
+And for counting the total of objects
+
+| Method          | Route                                                              | Description                          |
+| --------------- | ------------------------------------------------------------------ | ------------------------------------ |
+| <kbd>GET</kbd>  | \<my-app-name\>/\<collection name\>/_selections_total/\<selection_name\> | get the total for the selection |
+| <kbd>POST</kbd> | \<my-app-name\>/\<collection name\>/_selections_total/\<selection_name\> | get the total for the selection with complex filter |
+
 #### example
 
 ```bash
@@ -974,8 +987,12 @@ curl -X GET 'http://localhost/media_library/coll/books/_selections/borrowed'
      ["666", "Docker as BDSM toy", "Wallrich"], 
      ["1234", "Milf forever", "Epstein"]
     ],
-    "total": 2, "_skip": 0, "_page": 10}'
-curl -X GET 'http://localhost/media_library/coll/books/_selections/borrowed?title.$reg=Dock'
+    "total": None, "_skip": 0, "_page": 10}'
+curl -X GET 'http://localhost/media_library/coll/books/_selections_total/borrowed' 
+  '2'
+
+curl -X GET 'http://localhost/media_library/coll/books/_selections_total/borrowed?title.$reg=Dock'
+  '1'
 ```
 
 

{backo-0.3.0 → backo-0.3.3}/backo/collection.py

@@ -170,7 +170,7 @@ class Collection:
 
         self._selections = {}
 
-        db_handler.set_model(self.get_meta())
+        db_handler.set_model(self.model.get_schema())
 
         # Adding the "_all" selection
         can_read = self._permissions.get("read", True)
@@ -347,7 +347,7 @@ class Collection:
 
         """
 
-        if selection_name in self._actions:
+        if selection_name in self._selections:
             raise SSyntaxError(
                 'Collection {0} register_selection : selection "{1}" already registered',
                 self.name,
@@ -714,6 +714,15 @@ class Collection:
             collection_blueprint.view_functions[f"{self.name}.do_selection"] = (
                 self.do_selection
             )
+            log.info(
+                "Add route GET selections count /_selections_count/<string:_selection_name>"
+            )
+            collection_blueprint.add_url_rule(
+                "/_selections_total/<string:_selection_name>",
+                "do_count",
+                methods=["GET"],
+            )
+            collection_blueprint.view_functions[f"{self.name}.do_count"] = self.do_count
             log.info("Add route POST selections /_selections/<string:_selection_name>")
             collection_blueprint.add_url_rule(
                 "/_selections/<string:_selection_name>",
@@ -723,6 +732,17 @@ class Collection:
             collection_blueprint.view_functions[f"{self.name}.do_post_selection"] = (
                 self.do_post_selection
             )
+            log.info(
+                "Add route POST selections count /_selections_count/<string:_selection_name>"
+            )
+            collection_blueprint.add_url_rule(
+                "/_selections_total/<string:_selection_name>",
+                "do_post_count",
+                methods=["POST"],
+            )
+            collection_blueprint.view_functions[f"{self.name}.do_post_count"] = (
+                self.do_post_count
+            )
             self._openapi.add_selections(
                 f"/{self.name}/_selections",
                 self.name,
@@ -892,6 +912,30 @@ class Collection:
 
         return (json.dumps(result, cls=StrictoEncoder), 200)
 
+    @error_to_http_handler
+    def do_count(self, _selection_name: str):
+        """
+        Do a count of total objects on a SFilter
+        This route works with the selection route
+
+        :param _selection_name: The name of the selection
+        :type _selection_name: str
+        :raises Error: _description_
+        :return: _description_
+        :rtype: _type_
+        """
+
+        if _selection_name not in self._selections:
+            raise SSyntaxError(
+                "Collection {0} has no selection {0}", self.name, _selection_name
+            )
+
+        match_filter: SFilter = multidict_to_sfilter(request.args)
+        count = self._selections[_selection_name].count(match_filter)
+
+        log.debug(f"count in {self.name}/{_selection_name} {match_filter} -> {count}")
+        return (count, 200)
+
     @check_content_type
     @error_to_http_handler
     def do_post_selection(self, _selection_name: str):
@@ -925,6 +969,33 @@ class Collection:
 
         return (json.dumps(result, cls=StrictoEncoder), 200)
 
+    @check_content_type
+    @error_to_http_handler
+    def do_post_count(self, _selection_name: str):
+        """Do a count on a selection with filter given in post
+
+        :param _selection_name: The name of the selection
+        :type _selection_name: str
+        :raises Error: _description_
+        :return: _description_
+        :rtype: _type_
+        """
+
+        if _selection_name not in self._selections:
+            raise SSyntaxError(
+                "Collection {0} has no selection {0}", self.name, _selection_name
+            )
+
+        request_content = request_to_object(request)
+        log.debug(f"http post selection {_selection_name} content {request_content}")
+
+        match_filter: SFilter = dict_to_sfilter(request_content)
+        count = self._selections[_selection_name].select(match_filter)
+
+        log.debug(f"count in {self.name}/{_selection_name} {match_filter} -> {count}")
+
+        return (count, 200)
+
     @check_content_type
     @error_to_http_handler
     def http_create(self):

{backo-0.3.0 → backo-0.3.3}/backo/db/backo_redirect.py

@@ -59,7 +59,7 @@ class DBBackoRedirectConnector(
 
     def select(
         self,
-        select_filter: SFilter,
+        select_filter: SFilter = None,
         projection: list[str] = None,
         page_size=0,
         num_of_element_to_skip=0,

{backo-0.3.0 → backo-0.3.3}/backo/db/generic/db_handler.py

@@ -43,40 +43,100 @@ class DBHandler(ABC):  # pylint: disable=too-many-instance-attributes
         self._table_name = None
         self.model = None
         self.filter: Filter = None
-        self.transformers: dict[str, dict[str, Transformer]] = {}
-        self.type_transformers: dict[str, Transformer] = {}
+
+        self.transformers_per_db_path: dict[str, tuple[list[str], Transformer]] = {}
+        self.transformers_per_key_path: dict[str, tuple[list[str], Transformer]] = {}
+
+        self._temp_transformers: list[Transformer] = []
+        self._temp_type_transformers: list[Transformer] = []
 
         options = Kparse(kwargs, KPARSE_MODEL)
 
         self.restriction_filter = options.get("restriction")
 
-    def set_model(self, scheme: dict) -> None:
+    def set_model(self, model: dict) -> None:
         """
         Register the model (backo meta() into the connector)
 
-        :param scheme: backo meta data
-        :type scheme: dict
+        :param model: Item model
+        :type model: dict
         """
-        self.model = scheme["item"]
+        self.model = model
         if self.filter:
-            self.filter.set_model(scheme)
-
-    def register_transformer(
-        self, transformer: Transformer, table_name: str = None
+            self.filter.set_model(model)
+
+        # Re-arange transformer according to the model
+        for transformer in self._temp_transformers:
+            self._reorder_transformers_per_key(transformer)
+        self._temp_transformers.clear()
+
+        # Re-arange type transformer according to the model
+        for transformer in self._temp_type_transformers:
+            self._reorder_type_transformers_per_key(transformer, [], model)
+        self._temp_type_transformers.clear()
+
+    def _reorder_transformers_per_key(self, transformer: Transformer) -> None:
+        # Add the transformer indexed by key_path
+        key_path_string = None
+        if transformer.key_path:
+            key_path_string = "_".join(transformer.key_path)
+        if key_path_string:
+            self.transformers_per_key_path[key_path_string] = (
+                transformer.key_path,
+                transformer,
+            )
+
+        # Add the transformer indexed by db_path
+        db_path_string = transformer.get_db_path()
+        if db_path_string:
+            self.transformers_per_db_path["_".join(db_path_string)] = (
+                db_path_string,
+                transformer,
+            )
+
+    def _reorder_type_transformers_per_key(
+        self, transformer: Transformer, key_path: list[str], model: dict
     ) -> None:
+
+        if key_path and transformer.backo_type in model["types"]:
+            self.transformers_per_key_path["_".join(key_path)] = (key_path, transformer)
+            db_path = transformer.get_db_path(key_path)
+            if db_path:
+                self.transformers_per_db_path["_".join(db_path)] = (
+                    db_path,
+                    transformer,
+                )
+
+        if "sub_scheme" in model:
+            for k, v in model["sub_scheme"].items():
+                new_key_path = key_path.copy()
+                new_key_path.append(k)
+                self._reorder_type_transformers_per_key(transformer, new_key_path, v)
+            return
+
+        # A list
+        if "sub_type" in model:
+            sub_model = model["sub_type"]
+            new_key_path = key_path.copy()
+            new_key_path.append("_")
+            self._reorder_type_transformers_per_key(
+                transformer, new_key_path, sub_model
+            )
+            return
+
+    def register_transformer(self, transformer: Transformer) -> None:
         """
         Register a :py:class:`Transformer`
 
         :param transformer: the transformer to register
         :type transformer: :py:class:`Transformer`
-        :param table_name: The table_name, defaults to None
-        :type table_name: str, optional
         """
-        t_name = self._table_name if table_name is None else table_name
-
-        if t_name not in self.transformers:
-            self.transformers[t_name] = {}
-        self.transformers[t_name]["_".join(transformer.key_path)] = transformer
+        # Already a model : store the transformer by key
+        if self.model:
+            self._reorder_transformers_per_key(transformer)
+            return
+        # Keep it temporary waiting for model to store transformer
+        self._temp_transformers.append(transformer)
 
     def register_type_transformer(self, transformer: Transformer) -> None:
         """
@@ -85,66 +145,65 @@ class DBHandler(ABC):  # pylint: disable=too-many-instance-attributes
         :param transformer: the transformer
         :type transformer: Transformer
         """
-        self.type_transformers[transformer.backo_type] = transformer
+
+        if self.model:
+            self._reorder_type_transformers_per_key(transformer, [], self.model)
+            return
+        # Keep it temporary waiting for model to store transformer
+        self._temp_type_transformers.append(transformer)
 
     def _transform_on_load(self, loaded_object: dict):
-        for transformers in self.transformers.values():
-            for transformer in transformers.values():
+
+        for db_path, transformer in self.transformers_per_db_path.values():
+            if transformer.path_exists_in_object(db_path, loaded_object):
                 try:
-                    db_path = transformer.get_db_path()
-                    if transformer.path_exists_in_object(db_path, loaded_object):
-                        transformer.on_load(loaded_object, db_path)
+                    transformer.on_load(loaded_object, db_path)
                 except Exception as e:
                     raise DBError("Transformer on load error") from e
 
     def _transform_on_create(self, obj: dict):
-        for transformers in self.transformers.values():
-            for transformer in transformers.values():
+
+        for key_path, transformer in self.transformers_per_key_path.values():
+            if transformer.path_exists_in_object(key_path, obj):
                 try:
-                    if transformer.path_exists_in_object(transformer.key_path, obj):
-                        transformer.on_create(obj, transformer.key_path)
+                    transformer.on_create(obj, key_path)
                 except Exception as e:
-                    raise DBError("Transformer on create error") from e
+                    raise DBError("Transformer on_create error") from e
 
     def _transform_on_save(self, obj: dict):
-        for transformers in self.transformers.values():
-            for transformer in transformers.values():
+
+        for key_path, transformer in self.transformers_per_key_path.values():
+            if transformer.path_exists_in_object(key_path, obj):
                 try:
-                    if transformer.path_exists_in_object(transformer.key_path, obj):
-                        transformer.on_save(obj, transformer.key_path)
+                    transformer.on_save(obj, key_path)
                 except Exception as e:
-                    raise DBError("Transformer on save error") from e
+                    raise DBError("Transformer on_save error") from e
 
-    def get_transformer(
-        self, key_path: list[str], table_name: str = None, backo_types: list[str] = None
+    def get_transformer_by_key(
+        self, key_path: list[str] = None, db_path: list[str] = None
     ) -> Transformer:
         """
-        Get a transformer for this key_path and the table or type
-
-        :param key_path: the key in the object (like [ 'address', 'street' ])
-        :type key_path: list[str]
-        :param table_name: the table_name, defaults to None
-        :type table_name: str, optional
-        :param backo_types: types of the key, defaults to None
-        :type backo_types: list[str], optional
-        :return: _description_A transformer or None
+        Get a transformer by key_path or by _db_path
+
+        :param key_path: _description_, defaults to None
+        :type key_path: list[str], optional
+        :param db_path: _description_, defaults to None
+        :type db_path: list[str], optional
+        :return: _description_
         :rtype: Transformer
         """
-
-        if backo_types:
-            for backo_type in backo_types:
-                if backo_type in self.type_transformers:
-                    return self.type_transformers[backo_type]
-
-        t_name = self._table_name if table_name is None else table_name
-        if t_name not in self.transformers:
+        # print(f'get_trans_by_key {key_path} {db_path} {self.transformers_per_key_path}')
+        if key_path:
+            key_path_string = "_".join(key_path)
+            if key_path_string in self.transformers_per_key_path:
+                return self.transformers_per_key_path[key_path_string][1]
             return None
-        t_path = self.transformers[t_name]
+        if db_path:
+            db_path_string = "_".join(db_path)
+            if db_path_string in self.transformers_per_db_path:
+                return self.transformers_per_db_path[db_path_string][1]
 
-        key = "_".join(key_path)
-        if key not in t_path:
-            return None
-        return t_path[key]
+        return None
 
     def check_structure(self, _update_directly=False) -> tuple[bool, str]:
         """
@@ -253,7 +312,7 @@ class DBHandler(ABC):  # pylint: disable=too-many-instance-attributes
     @abstractmethod
     def select(  # pylint: disable=unused-argument
         self,
-        select_filter: SFilter,
+        select_filter: SFilter = None,
         projection: list[str] = None,
         page_size: int = 0,
         num_of_element_to_skip: int = 0,

{backo-0.3.0 → backo-0.3.3}/backo/db/generic/filter.py

@@ -20,15 +20,15 @@ class Filter:
         self.model = None
         self.get_transformer = get_transformer
 
-    def set_model(self, scheme: dict) -> None:
+    def set_model(self, model: dict) -> None:
         """
         Set the model (meta() to the filter), to adapt
         the filtering on types of objects
 
-        :param scheme: scheme
-        :type scheme: dict
+        :param model: scheme
+        :type model: dict
         """
-        self.model = scheme["item"]
+        self.model = model
 
     def _get_model_by_path(self, path: str, key_path: list[str], model: dict) -> dict:
         """

{backo-0.3.0 → backo-0.3.3}/backo/db/generic/transformer.py

@@ -3,7 +3,7 @@ Attribut transformer
 """
 
 import uuid
-
+from typing import Any
 from jsonpath import patch, findall
 
 
@@ -58,15 +58,15 @@ class Transformer:
         jpath = f"$.{'.'.join(searching_path)}"
         return bool(findall(jpath, obj))
 
-    def on_load(self, _loaded_object: dict, _key_path: list[str]):
+    def on_load(self, _loaded_object: dict, _db_path: list[str]):
         """
         Called when the object is read from the DB.
         You can do some changement into the object (delete keys, modifications, ...)
 
         :param _loaded_object: the lodaded object
         :type _loaded_object: dict
-        :param _key_path: a key path as list
-        :type _key_path: list[str]
+        :param _db_path: a key path as list
+        :type _db_path: list[str]
         """
         return
 
@@ -94,14 +94,37 @@ class Transformer:
         """
         return
 
-    def get_db_path(self) -> list[str]:
+    def get_db_path(self, _key_path: list[str] = None) -> list[str]:
         """
-        Return the db_path (by default = sekf.key_path )
+        Return the db_path (by default = sekf.key_path or the _key_path given in case of a Type Transformer )
 
         :return: the key path associated to this transformer
         :rtype: list[str]
         """
-        return self.key_path
+        return self.key_path if self.key_path else _key_path
+
+    def get_db_model(self, model: dict, _key_path: list[str] = None) -> list[str]:
+        """
+        Return an adaptation of the model to the Ddatabase
+
+        :return: A modified
+        :rtype: dict
+        """
+        return model
+
+    def transform_value_to_db(self, v: Any) -> Any:
+        """
+        Transform its value on save, create, filter
+
+        """
+        return v
+
+    def transform_value_from_db(self, v: Any) -> Any:
+        """
+        Transform its value on load
+
+        """
+        return v
 
     def must_be_store_in_db(self) -> bool:
         """
@@ -188,7 +211,7 @@ class RenameTransformer(Transformer):
             obj,
         )
 
-    def get_db_path(self) -> list[str]:
+    def get_db_path(self, _key_path: list[str] = None) -> list[str]:
         """
         Return the key_path
 
@@ -236,7 +259,7 @@ class IgnoreTransformer(Transformer):
         """
         patch.apply([{"op": "remove", "path": self.db_path_string}], loaded_object)
 
-    def get_db_path(self) -> list[str]:
+    def get_db_path(self, _key_path: list[str] = None) -> list[str]:
         """
         Return the key_path
 

{backo-0.3.0 → backo-0.3.3}/backo/db/memory.py

@@ -89,7 +89,7 @@ class DBMemoryConnector(DBHandler):
             raise NotFoundError('_id "{0}" not found in "{1}"', _id, self._name)
 
         d = copy.deepcopy(o)
-        d[_id] = _id
+        d["_id"] = _id
 
         # Do all transformations on the object
         self._transform_on_save(d)
@@ -100,7 +100,7 @@ class DBMemoryConnector(DBHandler):
 
     def select(  # pylint: disable=unused-argument
         self,
-        select_filter: SFilter,
+        select_filter: SFilter = None,
         projection: list[str] = None,
         page_size: int = 0,
         num_of_element_to_skip: int = 0,