0.2.2 - fix typos

Fix: Correct typos in the docstrings.

Author: cainmagi

Changelog.md

@@ -4,6 +4,12 @@
 
 ## CHANGELOG
 
+### 0.2.2 @ 12/31/2024
+
+#### :wrench: Fix
+
+1. Fix: Correct typos in the docstrings.
+
 ### 0.2.1 @ 12/17/2024
 
 #### :wrench: Fix

flask_sqlalchemy_compat/auto.py

@@ -205,9 +205,9 @@ def get_flask_sqlalchemy(
         `flask_sqlalchemy.SQLAlchemy` if the package is available.
 
         If the package is not available, will attempt to return a
-        `SQLAlchemyProxy[flask_sqlalchemy_lite.SQLAlchemy]` instance. However, this
-        returned value is still notated by `flask_sqlalchemy.SQLAlchemy`, which
-        indicates that users should use `flask_sqlalchemy` to develop their
+        `SQLAlchemyProxy[flask_sqlalchemy_lite.SQLAlchemy, _ModelLite]` instance.
+        However, this returned value is still notated by `flask_sqlalchemy.SQLAlchemy`,
+        which indicates that users should use `flask_sqlalchemy` to develop their
         codes, while making this returned value as a falling back option.
     """
     if app is not None and not isinstance(app, Flask):

flask_sqlalchemy_compat/backdict.py

@@ -130,7 +130,7 @@ class BackDict(UserDict[K, V]):
        first. If it is not found, will return the value in `back_dict` domain. Since
        the modifications of the dictionary will only take effects on the `data` domain,
        this second-level domain will not change.
-    3. The second-level dictionary can have different keyword types. compared to the
+    3. The second-level dictionary can have different keyword types compared to the
        `data` domain. Users need to provide a `key_mapper` and its inverse operator
        `key_back_mapper` to support this feature.
     """
@@ -287,16 +287,16 @@ def copy(self) -> Self:
         return res
 
     def keys(self):
-        """`BackDict(...).keys()` -> a set-like object providing a view on
+        """`BackDict(...).keys()` is a set-like object providing a view on
         `BackDict`'s keys."""
         return collections.abc.KeysView(self.__view)
 
     def items(self):
-        """`BackDict(...).items()` -> a set-like object providing a view on
+        """`BackDict(...).items()` is a set-like object providing a view on
         `BackDict`'s items."""
         return collections.abc.ItemsView(self.__view)
 
     def values(self):
-        """`BackDict(...).values()` -> an object providing a view on `BackDict`'s
+        """`BackDict(...).values()` is an object providing a view on `BackDict`'s
         values."""
         return collections.abc.ValuesView(self.__view)

flask_sqlalchemy_compat/backends.py

@@ -16,7 +16,7 @@
 Description
 -----------
 The backends of the `flask_sqlalchemy_compat` package. These backends are modules
-conditionally loaded. In other words, if the model is intalled, will load the module.
+conditionally loaded. In other words, if the module is intalled, will load the module.
 Otherwise, load a placeholder of the corresponding module.
 
 The backends include:
@@ -89,8 +89,11 @@ class ModulePlaceholder(ModuleType):
 
     def __init__(self, name: str, doc: Optional[str] = None) -> None:
         """Initialization.
-        Arguments:
-            name: The module name. It will be passed to ModuleType.
+
+        Arguments
+        ---------
+        name: `str`
+            The module name. It will be passed to `ModuleType`.
         """
         name = str(name)
         if doc is None:
@@ -185,7 +188,7 @@ def is_module_invalid(module: ModuleType) -> TypeGuard[ModulePlaceholder]:
 class BackendProxy(Generic[M1, M2]):
     """A proxy class that is used for maintaining the dynamically loaded modules.
 
-    The properties of this module are editable, thus allowing the modules to be
+    The properties of this instance are editable, thus allowing the modules to be
     dynamically changed if necessary.
     """
 

flask_sqlalchemy_compat/flask_sa_api.py

@@ -78,7 +78,7 @@ class SQLAlchemyProxy(Generic[_SQLAlchemyLiteDB_co, _ModelLite_co]):
     `flask_sqlalchemy_lite.SQLAlchemy`, it can mimic the usage of
     `flask_sqlalchemy.SQLAlchemy`.
 
-    Note that not all the functionalities of `flask_sqlalchemy_lite.SQLAlchemy` can
+    Note that not all the functionalities of this proxy can
     be exactly the same as the those of `flask_sqlalchemy.SQLAlchemy`. In specific,
     this proxy will do the following things:
 
@@ -138,14 +138,16 @@ def __init__(
 
     @property
     def db(self) -> _SQLAlchemyLiteDB_co:
-        """Property: The `db` instance provided by the Flask SQLAlchemy extension."""
+        """Property: The `db` instance provided by the Flask SQLAlchemy Lite
+        extension."""
         return self.__db
 
     @property
     def Model(self) -> Type[_ModelLite_co]:
         """Property: The `Model` type. It can be used as the base class of the
-        SQLAlchemy models. This value is `model_class` passed to the initialization
-        of this wrapper.
+        SQLAlchemy models. This value is identical to `model_class` passed to the
+        initialization of this wrapper. But note that `model_class` is already
+        modified for supporting extra functionalities.
         """
         return self.__model_class
 
@@ -192,7 +194,7 @@ def Query(self) -> Type[sa_orm.Query]:
 
     @property
     def session(self) -> sa_orm.scoped_session[sa_orm.Session]:
-        """The same as `self.db.session`.
+        """The usages are similar to those of `self.db.session`.
 
         The default session for the current application context. It will be
         closed when the context ends."""

flask_sqlalchemy_compat/flask_sa_lite_api.py

@@ -79,12 +79,12 @@ class SQLAlchemyLiteProxy(Generic[_SQLAlchemyDB_co]):
     the `flask_sqlalchemy.SQLAlchemy`, it can mimic the usage of
     `flask_sqlalchemy_lite.SQLAlchemy`.
 
-    Note that not all the functionalities of `flask_sqlalchemy.SQLAlchemy` can be
+    Note that not all the functionalities of this proxy can be
     exactly the same as the those of `flask_sqlalchemy_lite.SQLAlchemy`. In specific,
     this proxy will do the following things:
 
     * Provide a regular session like that of `flask_sqlalchemy_lite.SQLAlchemy`. This
-      regular session is managed by this proxy class.
+      regular session is managed by the instance of this proxy class.
     * Provide other basic methods in `flask_sqlalchemy_lite.SQLAlchemy`. The usages
       would be equivalent but the implmentation is based on `flask_sqlalchemy`.
     * Any functionality that cannot be used will raise a `NotImplementedError`.

flask_sqlalchemy_compat/protocols.py

@@ -213,12 +213,12 @@ def Query(self) -> Callable[..., sa_orm.Query]:
 
     @property
     def Table(self) -> Callable[..., sa.Table]:
-        """The default query class used by `Model.query` and `lazy="dynamic"`
-        relationships."""
+        """The default data table class that does not require user-specified
+        metadata."""
         ...
 
     @property
     def Model(self) -> Callable[..., ModelProtocol]:
-        """The default query class used by `Model.query` and `lazy="dynamic"`
-        relationships."""
+        """The default object relationship mapping (ORM) model class that has
+        extensive functionalies."""
         ...

flask_sqlalchemy_compat/utilities.py

@@ -15,7 +15,7 @@
 
 Description
 -----------
-The extra functionalities used for hooking the original SQLAlchemy extensions. The
+The extra functionalities used for hooking the original `SQLAlchemy` extensions. The
 extensions need to be hooked because some extra functionalities may need to be
 provided.
 """
@@ -272,9 +272,9 @@ def clone_method(
     -------
     #1: `((self: S, **P) -> T) -> ((self: S, **P) -> T)`
         A wrapper that forward a function as it is directly but the signature of the
-        function will be consistent with the argument `method`.
+        function will be consistent with the argument `func_o`.
 
-        The input signature will be copied from `method`. But the output value will
+        The input signature will be copied from `func_o`. But the output value will
         be determined by the wrapped method.
     """
 
@@ -317,10 +317,10 @@ def clone_function(
     -------
     #1: `((**P) -> T) -> ((**P) -> T)`
         A wrapper that forward a function as it is directly but the signature of the
-        function will be consistent with the argument `method`.
+        function will be consistent with the argument `func_o`.
 
-        The input signature will be copied from `method`. But the output value will
-        be determined by the wrapped method.
+        The input signature will be copied from `func_o`. But the output value will
+        be determined by the wrapped function.
     """
 
     def wrapper(func: Callable[P, T]) -> Callable[P, T]:

flask_sqlalchemy_compat/version.py

@@ -20,4 +20,4 @@
 
 __all__ = ("__version__",)
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"