Rename Methods

Author: ArneGudermann

src/viur/core/__init__.py

@@ -288,14 +288,14 @@ def setup(modules:  ModuleType | object, render:  ModuleType | object = None, de
     if conf.file_hmac_key is None:
         from viur.core import db
         key = db.Key("viur-conf", "viur-conf")
-        if not (obj := db.Get(key)):  # create a new "viur-conf"?
+        if not (obj := db.get(key)):  # create a new "viur-conf"?
             logging.info("Creating new viur-conf")
             obj = db.Entity(key)
 
         if "hmacKey" not in obj:  # create a new hmacKey
             logging.info("Creating new hmacKey")
             obj["hmacKey"] = utils.string.random(length=20)
-            db.Put(obj)
+            db.put(obj)
 
         conf.file_hmac_key = bytes(obj["hmacKey"], "utf-8")
 

src/viur/core/bones/base.py

@@ -1054,7 +1054,7 @@ def unserialize_compute(self, skel: "SkeletonInstance", name: str) -> bool:
                 from viur.core.skeleton import RefSkel  # noqa: E402 # import works only here because circular imports
 
                 if issubclass(skel.skeletonCls, RefSkel):  # we have a ref skel we must load the complete Entity
-                    db_obj = db.Get(skel["key"])
+                    db_obj = db.get(skel["key"])
                     last_update = db_obj.get(f"_viur_compute_{name}_")
                 else:
                     last_update = skel.dbEntity.get(f"_viur_compute_{name}_")
@@ -1064,15 +1064,15 @@ def unserialize_compute(self, skel: "SkeletonInstance", name: str) -> bool:
                     # if so, recompute and refresh updated value
                     skel.accessedValues[name] = value = self._compute(skel, name)
                     def transact():
-                        db_obj = db.Get(skel["key"])
+                        db_obj = db.get(skel["key"])
                         db_obj[f"_viur_compute_{name}_"] = now
                         db_obj[name] = value
-                        db.Put(db_obj)
+                        db.put(db_obj)
 
                     if db.IsInTransaction():
                         transact()
                     else:
-                        db.RunInTransaction(transact)
+                        db.run_in_transaction(transact)
 
                     return True
 

src/viur/core/bones/file.py

@@ -67,7 +67,7 @@ def ensureDerived(key: db.Key, srcKey, deriveMap: dict[str, t.Any], refreshKey:
                     }
 
     def updateTxn(key, resDict):
-        obj = db.Get(key)
+        obj = db.get(key)
         if not obj:  # File-object got deleted during building of our derives
             return
         obj["derived"] = obj.get("derived") or {}
@@ -77,10 +77,10 @@ def updateTxn(key, resDict):
             obj["derived"]["deriveStatus"][k] = v["version"]
             for fileName, fileDict in v["files"].items():
                 obj["derived"]["files"][fileName] = fileDict
-        db.Put(obj)
+        db.put(obj)
 
     if resDict:  # Write updated results back and queue updateRelationsTask
-        db.RunInTransaction(updateTxn, key, resDict)
+        db.run_in_transaction(updateTxn, key, resDict)
         # Queue that updateRelations call at least 30 seconds into the future, so that other ensureDerived calls from
         # the same FileBone have the chance to finish, otherwise that updateRelations Task will call postSavedHandler
         # on that FileBone again - re-queueing any ensureDerivedCalls that have not finished yet.
@@ -93,7 +93,7 @@ def refreshTxn():
                 skel.refresh()
                 skel.write(update_relations=False)
 
-            db.RunInTransaction(refreshTxn)
+            db.run_in_transaction(refreshTxn)
 
 
 class FileBone(TreeLeafBone):

src/viur/core/bones/key.py

@@ -65,7 +65,7 @@ def singleValueFromClient(self, value, skel=None, bone_name=None, client_data=No
                 return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid, err)]
 
             if self.check:
-                if db.Get(key) is None:
+                if db.get(key) is None:
                     return self.getEmptyValue(), [
                         ReadFromClientError(
                             ReadFromClientErrorSeverity.Invalid,

src/viur/core/bones/relational.py

@@ -136,7 +136,7 @@ class RelationalBone(BaseBone):
             - RelationalConsistency.PreventDeletion
                 Will prevent deleting the referenced entity as long as it's selected in this bone (calling
                 skel.delete() on the referenced entity will raise errors.Locked). It's still (technically)
-                possible to remove the underlying datastore entity using db.Delete manually, but this *must not*
+                possible to remove the underlying datastore entity using db.delete manually, but this *must not*
                 be used on a skeleton object as it will leave a whole bunch of references in a stale state.
 
             - RelationalConsistency.SetNull
@@ -228,7 +228,7 @@ def __init__(
                     :param RelationalConsistency.PreventDeletion:
                         Will prevent deleting the referenced entity as long as it's
                         selected in this bone (calling skel.delete() on the referenced entity will raise errors.Locked).
-                        It's still (technically) possible to remove the underlying datastore entity using db.Delete
+                        It's still (technically) possible to remove the underlying datastore entity using db.delete
                         manually, but this *must not* be used on a skeleton object as it will leave a whole bunch of
                         references in a stale state.
 
@@ -521,10 +521,10 @@ def postSavedHandler(self, skel, boneName, key) -> None:
         for dbObj in dbVals.iter():
             try:
                 if not dbObj["dest"].key in [x["dest"]["key"] for x in values]:  # Relation has been removed
-                    db.Delete(dbObj.key)
+                    db.delete(dbObj.key)
                     continue
             except:  # This entry is corrupt
-                db.Delete(dbObj.key)
+                db.delete(dbObj.key)
             else:  # Relation: Updated
                 data = [x for x in values if x["dest"]["key"] == dbObj["dest"].key][0]
                 # Write our (updated) values in
@@ -539,7 +539,7 @@ def postSavedHandler(self, skel, boneName, key) -> None:
                 dbObj["viur_relational_consistency"] = self.consistency.value
                 dbObj["viur_foreign_keys"] = list(self.refKeys)
                 dbObj["viurTags"] = srcEntity.get("viurTags")  # Copy tags over so we can still use our searchengine
-                db.Put(dbObj)
+                db.put(dbObj)
                 values.remove(data)
         # Add any new Relation
         for val in values:
@@ -557,7 +557,7 @@ def postSavedHandler(self, skel, boneName, key) -> None:
             dbObj["viur_relational_updateLevel"] = self.updateLevel.value
             dbObj["viur_relational_consistency"] = self.consistency.value
             dbObj["viur_foreign_keys"] = list(self._ref_keys)
-            db.Put(dbObj)
+            db.put(dbObj)
 
     def postDeletedHandler(self, skel: "SkeletonInstance", boneName: str, key: db.Key) -> None:
         """
@@ -575,7 +575,7 @@ def postDeletedHandler(self, skel: "SkeletonInstance", boneName: str, key: db.Ke
         query.filter("viur_dest_kind =", self.kind)
         query.filter("viur_src_property =", boneName)
         query.filter("src.__key__ =", key)
-        db.Delete([entity for entity in query.run()])
+        db.delete([entity for entity in query.run()])
 
     def isInvalid(self, key) -> None:
         """
@@ -613,7 +613,7 @@ def restoreSkels(key, usingData, index=None):
             errors = []
             try:
                 dbKey = db.keyHelper(key, self.kind)
-                entry = db.Get(dbKey)
+                entry = db.get(dbKey)
                 assert entry
             except:  # Invalid key or something like that
                 logging.info(f"Invalid reference key >{key}< detected on bone '{bone_name}'")
@@ -1091,7 +1091,7 @@ def relskels_from_keys(self, key_rel_list: list[tuple[db.Key, dict | None]]) ->
         :return: A dictionary containing a reference skeleton and optional relation data.
         """
 
-        if not all(db_objs := db.Get([db.keyHelper(value[0], self.kind) for value in key_rel_list])):
+        if not all(db_objs := db.get([db.keyHelper(value[0], self.kind) for value in key_rel_list])):
             return []  # return emtpy data when not all data is found
         res_rel_skels = []
         for (key, rel), db_obj in zip(key_rel_list, db_objs):

src/viur/core/bones/uid.py

@@ -12,12 +12,12 @@ def generate_number(db_key: db.Key) -> int:
     def transact(_key: db.Key):
         for i in range(3):
             try:
-                if db_obj := db.Get(_key):
+                if db_obj := db.get(_key):
                     db_obj["count"] += 1
                 else:
                     db_obj = db.Entity(_key)
                     db_obj["count"] = 0
-                db.Put(db_obj)
+                db.put(db_obj)
                 break
             except db.CollisionError:  # recall the function
                 time.sleep(i + 1)
@@ -28,7 +28,7 @@ def transact(_key: db.Key):
     if db.IsInTransaction():
         return transact(db_key)
     else:
-        return db.RunInTransaction(transact, db_key)
+        return db.run_in_transaction(transact, db_key)
 
 
 def generate_uid(skel, bone):

src/viur/core/cache.py

@@ -17,7 +17,7 @@
     http Header    along with their requests. Entities in this cache will expire if
         - Their TTL is exceeded
         - They're explicitly removed from the cache by calling :meth:`viur.core.cache.flushCache` using their path
-        - A Datastore entity that has been accessed using db.Get() from within the cached function has been modified
+        - A Datastore entity that has been accessed using db.get() from within the cached function has been modified
         - The wrapped function has run a query over a kind in which an entity has been added/edited/deleted
 
     ..Warning: As this cache is intended to be used with exposed functions, it will not only store the result of the
@@ -142,7 +142,7 @@ def wrapF(self, *args, **kwargs) -> str | bytes:
             # Something is wrong (possibly the parameter-count)
             # Let's call f, but we knew already that this will clash
             return f(self, *args, **kwargs)
-        dbRes = db.Get(db.Key(viurCacheName, key))
+        dbRes = db.get(db.Key(viurCacheName, key))
         if dbRes is not None:
             if (
                     not maxCacheTime or dbRes["creationtime"] > utils.utcNow()
@@ -165,7 +165,7 @@ def wrapF(self, *args, **kwargs) -> str | bytes:
         dbEntity["content-type"] = currReq.response.headers['Content-Type']
         dbEntity["accessedEntries"] = list(accessedEntries)
         dbEntity.exclude_from_indexes = {"data", "content-type"}  # save two DB-writes.
-        db.Put(dbEntity)
+        db.put(dbEntity)
         logging.debug("This request was a cache-miss. Cache has been updated.")
         return res
 
@@ -234,31 +234,31 @@ def flushCache(prefix: str = None, key: db.Key | None = None, kind:  str | None
     if prefix is not None:
         items = db.Query(viurCacheName).filter("path =", prefix.rstrip("*")).iter()
         for item in items:
-            db.Delete(item)
+            db.delete(item)
         if prefix.endswith("*"):
             items = db.Query(viurCacheName) \
                 .filter("path >", prefix.rstrip("*")) \
                 .filter("path <", prefix.rstrip("*") + u"\ufffd") \
                 .iter()
             for item in items:
-                db.Delete(item)
+                db.delete(item)
         logging.debug(f"Flushing cache succeeded. Everything matching {prefix=} is gone.")
     if key is not None:
         items = db.Query(viurCacheName).filter("accessedEntries =", key).iter()
         for item in items:
             logging.info(f"""Deleted cache entry {item["path"]!r}""")
-            db.Delete(item.key)
+            db.delete(item.key)
         if not isinstance(key, db.Key):
             key = db.Key.from_legacy_urlsafe(key)  # hopefully is a string
         items = db.Query(viurCacheName).filter("accessedEntries =", key.kind).iter()
         for item in items:
             logging.info(f"""Deleted cache entry {item["path"]!r}""")
-            db.Delete(item.key)
+            db.delete(item.key)
     if kind is not None:
         items = db.Query(viurCacheName).filter("accessedEntries =", kind).iter()
         for item in items:
             logging.info(f"""Deleted cache entry {item["path"]!r}""")
-            db.Delete(item.key)
+            db.delete(item.key)
 
 
 __all__ = ["enableCache", "flushCache"]

src/viur/core/db/query.py

@@ -380,6 +380,7 @@ def limit(self, limit: int) -> t.Self:
         :param limit: The maximum number of entities.
         :returns: Returns the query itself for chaining.
         """
+        # TODO Add a check for the limit (<=100) ?
         if isinstance(self.queries, QueryDefinition):
             self.queries.limit = limit
         elif isinstance(self.queries, list):
@@ -657,14 +658,14 @@ def fetch(self, limit: int = -1) -> "SkelList['SkeletonInstance']" | None:
             logging.error(("Limit", limit))
             raise NotImplementedError(
                 "This query is not limited! You must specify an upper bound using limit() between 1 and 100")
-        dbRes = self.run(limit)
-        if dbRes is None:
+
+        if not (db_res := self.run(limit)):
             return None
         res = SkelList(self.srcSkel)
-        for e in dbRes:
-            skelInstance = SkeletonInstance(self.srcSkel.skeletonCls, bone_map=self.srcSkel.boneMap)
-            skelInstance.dbEntity = e
-            res.append(skelInstance)
+        for e in db_res:
+            skel_instance = SkeletonInstance(self.srcSkel.skeletonCls, bone_map=self.srcSkel.boneMap)
+            skel_instance.dbEntity = e
+            res.append(skel_instance)
         res.getCursor = lambda: self.getCursor()
         res.get_orders = lambda: self.get_orders()
         return res
@@ -688,8 +689,7 @@ def iter(self) -> t.Iterator[Entity]:
         elif isinstance(self.queries, list):
             raise ValueError("No iter on Multiqueries")
         while True:
-            qryRes = self._run_single_filter_query(self.queries, 20)
-            yield from qryRes
+            yield from self._run_single_filter_query(self.queries, 100)
             if not self.queries.currentCursor:  # We reached the end of that query
                 break
             self.queries.startCursor = self.queries.currentCursor
@@ -718,8 +718,8 @@ def getSkel(self) -> t.Optional["SkeletonInstance"]:
         """
         if self.srcSkel is None:
             raise NotImplementedError("This query has not been created using skel.all()")
-        res = self.getEntry()
-        if res is None:
+
+        if not (res:= self.getEntry()):
             return None
         self.srcSkel.setEntity(res)
         return self.srcSkel

src/viur/core/db/utils.py

@@ -2,7 +2,7 @@
 from deprecated.sphinx import deprecated
 import typing as t
 
-from .transport import Get, Put, RunInTransaction
+from .transport import get, put, run_in_transaction
 from .types import Entity, Key, currentDbAccessLog, currentTransaction
 
 
@@ -110,7 +110,7 @@ def GetOrInsert(key: Key, **kwargs) -> Entity:
     """
     Either creates a new entity with the given key, or returns the existing one.
 
-    Its guaranteed that there is no race-condition here; it will never overwrite an
+    Its guaranteed that there is no race-condition here; it will never overwrite a
     previously created entity. Extra keyword arguments passed to this function will be
     used to populate the entity if it has to be created; otherwise they are ignored.
 
@@ -119,17 +119,17 @@ def GetOrInsert(key: Key, **kwargs) -> Entity:
     """
 
     def txn(key, kwargs):
-        obj = Get(key)
+        obj = get(key)
         if not obj:
             obj = Entity(key)
             for k, v in kwargs.items():
                 obj[k] = v
-            Put(obj)
+            put(obj)
         return obj
 
-    if IsInTransaction():
+    if is_in_transaction():
         return txn(key, kwargs)
-    return RunInTransaction(txn, key, kwargs)
+    return run_in_transaction(txn, key, kwargs)
 
 
 def encodeKey(key: Key) -> str:
@@ -153,7 +153,7 @@ def acquireTransactionSuccessMarker() -> str:
     if "viurTxnMarkerSet" not in txn:
         e = Entity(Key("viur-transactionmarker", marker))
         e["creationdate"] = datetime.datetime.utcnow()
-        Put(e)
+        put(e)
         txn["viurTxnMarkerSet"] = True
     return marker