db-attribute 2.1__tar.gz → 2.1.1__tar.gz

{db_attribute-2.1 → db_attribute-2.1.1.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: db_attribute
-Version: 2.1
+Version: 2.1.1.0
 Summary: DataBase attribute package
 Home-page: https://github.com/shutkanos/Db-Attribute
 Author: Shutkanos
 Author-email: Shutkanos <Shutkanos836926@mail.ru>
 License: MIT
 Project-URL: Homepage, https://github.com/shutkanos/Db-Attribute
-Project-URL: Documentation, https://github.com/shutkanos/Db-Attribute/readme.md
+Project-URL: Documentation, https://github.com/shutkanos/Db-Attribute#readme.md
 Project-URL: Repository, https://github.com/shutkanos/Db-Attribute
 Keywords: db,database,attribute,db_attribute,db attribute,DbAttribute,database attribute
 Classifier: Development Status :: 4 - Beta
@@ -26,22 +26,49 @@ Dynamic: license-file
 DbAttribute - Database Attribute
 =========================
 
-This module allows you to save attributes of objects not in RAM, but in a database. the closest analogue is <a href='https://github.com/sqlalchemy/sqlalchemy'>SQLAlchemy</a>. Unlike SQLAlchemy, this module maximizes automatism, allowing the developer to focus on other details without worrying about working with the database.
+DbAttribute is an ORM library designed to simplify database interactions. Core capabilities:
 
+* Automatic state synchronization
+Object attribute changes are automatically tracked and persisted to the database without requiring explicit commit calls.
+<br><br>
+* Direct object manipulation
+Supports both value assignment (obj.attr = value) and in-place modification of container types:
+
+```python
+obj.books.append("New Book")
+obj.settings["theme"] = "dark"
+```
+
+* Expressive query syntax
+Filtering uses Python operators with natural syntax:
+
+```python
+# Find users older than 18 named John
+User.get((User.age > 18) & (User.name == "John"))
+
+# Get all users named Bob
+[user for user in User if user.name == "Bob"]
+```
+The library provides tools for declarative model definition, relationship management, and database operation optimization through configurable synchronization modes.
+
+# Table of contents
+
+* [Table of contents](#table-of-contents)
 * [Supported types](#supported-types)
 * [Install](#install)
-* [How it used](#how-it-used)
+* [How to use it](#how-to-use-it)
     * [Create class](#create-class)
         * [Options](#options)
     * [Work with obj](#work-with-obj)
-        * [Create new obj / add obj do db](#create-new-obj--add-obj-do-db)
-        * [Found / get obj](#found--get-obj)
+        * [Create new object](#create-new-object)
+        * [Finding objects](#finding-objects)
         * [Iterations](#iterations)
         * [Change attribute of obj](#change-attribute-of-obj)
         * [Dump mode](#dump-mode)
     * [Types](#types)
         * [Db attribute](#db-attribute)
         * [Db classes](#db-classes)
+        * [Custom Db Classes](#custom-db-classes) 
         * [Json type](#json-type)
 * [Speed Test](#speed-test)
     * [Get attr](#get-attr)
@@ -50,28 +77,34 @@ This module allows you to save attributes of objects not in RAM, but in a databa
 
 # Supported types
 
-This module supported standart types: `int`, `float`, `str`, `bool`, `None`, `tuple`, `list`, `set`, `dict`, `datetime`.
+This module supports standard types: `int`, `float`, `str`, `bool`, `None`, `tuple`, `list`, `set`, `dict`, `datetime`.
 
-If developer needs other data types, he will need to write an adapter class.
+If a developer needs other data types, they will need to write an adapter class.
 
 # Install
 
-Installation from source (requires git):
+The package can be obtained from PyPI and installed in a single step:
 
 ```
-$ pip install git+https://github.com/shutkanos/Db-Attribute.git
+pip install db_attribute
 ```
 
-# How it used
+It can also be obtained from source (requires git):
+
+```
+pip install git+https://github.com/shutkanos/Db-Attribute.git
+```
+
+# How to use it
 
 ## Create class
 
-For create any classes (Tables):
+To create any class (Table):
 
 * Set metaclass `DbAttributeMetaclass`
 * Inheritance the `DbAttribute` (optional, since it inherits automatically when using a metaclass)
 * Set dbworkobj for connect to database
-* Create any fields / Annotations / DbFields for database
+* Define fields using annotations or DbField for database columns
 
 ```python
 from db_attribute import DbAttribute, DbAttributeMetaclass, db_work, connector
@@ -86,10 +119,10 @@ class User(DbAttribute, metaclass=DbAttributeMetaclass, __dbworkobj__=db_work_ob
     ban = DbField(default=False) # Ok
     other_int_information = 100 # Need annotation or DbField - not error, but not saved
     list_of_books = DbField(default_factory=lambda: ['name of first book']) # Ok
-    sittings: dict = DbField(default_factory=lambda: {}) # Ok
+    settings: dict = DbField(default_factory=dict) # Ok
 ```
 
-Each class object has its own `id`. It is inherited from DbAttribute and stored in __dict__
+Each instance has a unique `id` identifier. It is inherited from DbAttribute and stored in `__dict__`
 
 ### Options
 
@@ -111,7 +144,9 @@ class User(DbAttribute, metaclass=DbAttributeMetaclass):
 ```python
 class BaseMeta:
     __dbworkobj__ = dbworkobj
-class User(DbAttribute, metaclass=DbAttributeMetaclass):
+class Class_A(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+class Class_B(DbAttribute, metaclass=DbAttributeMetaclass):
     Meta = BaseMeta
 ```
 
@@ -123,9 +158,9 @@ All options:
 
 ## Work with obj
 
-### Create new obj / add obj do db
+### Create new object
 
-For create obj use id (optional) and other fields (optional),
+To create an object, use an id (optional) and other fields (optional),
 
 ```python
 obj = User(id=3) # other field set to defaults value
@@ -142,7 +177,7 @@ obj = User(name='Alica')
 print(obj) # User(id=5, name='Alica')
 ```
 
-If Developer need recreated obj, he can call DbAttribute cls with id.
+If a developer needs to recreate an object, he can call DbAttribute cls with id.
 
 ```python
 obj = User(name='Ben', age=10, id=3) #insert obj to db
@@ -161,33 +196,35 @@ obj = User(id=3)
 print(obj) #User(id=3, name='Anna', age=15)
 ```
 
-### Found / get obj
+### Finding objects
 
-if the developer needs to find an object, he can use the 'get' method.
+If a developer needs to find an object, they can use the 'get' method.
 
-if the 'get' method finds multiple search results, it selects the smallest id.
-if the 'get' method does not find any search results, it returns None.
+The `get()` method returns:
+- Single object if found
+- Object with smallest ID if multiple matches exist
+- `None` if no matches found
 
 ```python
 #create objs
-obj = User(name='Bob', age=3, id=1)
-obj = User(name='Bob', age=2, id=2)
+obj = User(name='Bob', age=2, id=1)
+obj = User(name='Bob', age=3, id=2)
 obj = User(name='Anna', age=2, id=3)
 #finds objs
-print(User.get((User.age == 3) & (User.name == 'Bob'))) #User(id=1, name=Bob, age=3)
-print(User.get(User.name == 'Anna'))                    #User(id=3, name=Anna, age=2)
-print(User.get(User.name == 'Bob'))                     #User(id=1, name=Bob, age=3)
+print(User.get((User.age == 3) & (User.name == 'Bob'))) #User(id=2, name='Bob', age=3)
+print(User.get(User.name == 'Anna'))                    #User(id=3, name='Anna', age=2)
+print(User.get(User.name == 'Bob'))                     #User(id=1, name='Bob', age=2)
 print(User.get(User.name == 'Other name'))              #None
 ```
 
 To check the correctness of writing a logical expression, you can:
 
 ```python
-print(User.name == 'Anna')                      #(User.name = Anna)
-print((User.age == 3) & (User.name == 'Bob'))   #((User.age = 3) and (User.name = Bob))
+print(User.name == 'Anna')                      #(User.name = 'Anna')
+print((User.age == 3) & (User.name == 'Bob'))   #((User.age = 3) and (User.name = 'Bob'))
 ```
 
-Use '&', '|' instead of the 'and', 'or' operators. The 'and' and 'or' operators are not supported
+Use '&' and '|' instead of the 'and' and 'or' operators. The 'and' and 'or' operators are not supported
 
 ### Iterations
 
@@ -195,17 +232,18 @@ If a developer needs to iterate through all the elements of a class, they can us
 
 ```python
 print(list(User))
-#[User(id=1, name=Bob, age=3), User(id=2, name=Bob, age=2), User(id=3, name=Anna, age=2)]
+#[User(id=1, name='Bob', age=3), User(id=2, name='Bob', age=2), User(id=3, name='Anna', age=2)]
 
-print([i.name for i in User])
-#['Bob', 'Bob', 'Anna']
+print([i for i in User if i.age < 3])
+#[User(id=2, name='Bob', age=2), User(id=3, name='Anna', age=2)]
 
 for i in User:
     print(i)
-#User(id=1, name=Bob, age=3)
-#User(id=2, name=Bob, age=2)
-#User(id=3, name=Anna, age=2)
+#User(id=1, name='Bob', age=3)
+#User(id=2, name='Bob', age=2)
+#User(id=3, name='Anna', age=2)
 ```
+⚠️ Iterations loads all objects - not recommended for large tables
 
 ### Change attribute of obj
 
@@ -222,7 +260,7 @@ print(obj) #User(id=1, name='Anna', list_of_books=['Any name of book'])
 
 ### Dump mode
 
-If in any function you will work with obj, you can activate manual_dump_mode (auto_dump_mode is default),
+If in any function you will work with obj, you can activate manual_dump_mode (auto_dump_mode is the default),
 
 * `auto_dump_mode`: attributes don't save in self.__dict__, all changes automatic dump in db.
 * `manual_dump_mode`: attributes save in self.__dict__, and won't dump in db until self.db_attribute_set_dump_mode is called. this helps to quickly perform operations on containers db attributes
@@ -239,7 +277,7 @@ user.set_manual_dump_mode()
 print(user.__dict__)
 # {'id': 1, '_any_db_data1': 531, '_any_db_data2': 'string'}
 ```
-Or set dump mod for individual attributes
+Or set dump mode for individual attributes
 
 ```python
 user = User(id=1, any_db_data1=531, any_db_data2='string')
@@ -257,7 +295,7 @@ for i in range(10 ** 5):
     user.list_of_books.append(i)
 user.set_auto_dump_mode()
 ```
-If Developer need dump attributes to db with manual_dump_mode, you can use DbAttribute.db_attribute_dump
+If a developer needs to dump attributes to db with manual_dump_mode, you can use DbAttribute.db_attribute_dump
 
 ```python
 user = User(id=1, list_of_books=[])
@@ -274,7 +312,7 @@ user.set_auto_dump_mode()
 
 ### Db attribute
 
-Developer can set the Db attribute class as data type for another Db attribute class
+A developer can set the Db attribute class as data type for another Db attribute class
 
 ```python
 from db_attribute.db_types import TableType
@@ -287,24 +325,45 @@ class Class_B(DbAttribute, metaclass=DbAttributeMetaclass):
     Meta = BaseMeta
     obj_a: Class_A
 ```
-For create obj:
+To create an object:
 ```python
 obj_a = Class_A(id=15, name='Anna', obj_b=1)
 obj_b = Class_B(id=1, name='Bob', obj_a=15)
-print(obj_b) #Class_B(id=1, name=Bob, obj_a=Class_A(id=15, name=Anna, obj_b=Class_B(id=1, ...)))
+print(obj_b) #Class_B(id=1, name='Bob', obj_a=Class_A(id=15, name='Anna', obj_b=Class_B(id=1, ...)))
 #or
 obj_a = Class_A(id=15, name='Anna', obj_b=obj_b)
-print(obj_a) #Class_A(id=15, name=Anna, obj_b=Class_B(id=1, name=Bob, obj_a=Class_A(id=15, ...)))
+print(obj_a) #Class_A(id=15, name='Anna', obj_b=Class_B(id=1, name='Bob', obj_a=Class_A(id=15, ...)))
 ```
 For found obj:
 ```python
 Class_A(id=15, name='Anna', obj_b=1)
 obj = Class_B(id=1, name='Bob', obj_a=15)
 obj = Class_A.get(Class_A.obj_b == obj)
-print(obj) #Class_A(id=15, name=Anna, obj_b=Class_B(id=1, name=Bob, obj_a=Class_A(id=15, ...)))
+print(obj) #Class_A(id=15, name='Anna', obj_b=Class_B(id=1, name='Bob', obj_a=Class_A(id=15, ...)))
 #And Found with use id of obj:
 obj = Class_A.get(Class_A.obj_b == 1)
-print(obj) #Class_A(id=15, name=Anna, obj_b=Class_B(id=1, name=Bob, obj_a=Class_A(id=15, ...)))
+print(obj) #Class_A(id=15, name='Anna', obj_b=Class_B(id=1, name='Bob', obj_a=Class_A(id=15, ...)))
+```
+One-to-Many relationship:
+```python
+from db_attribute.db_types import DbField
+
+class Author(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+    name: str = ""
+    books: list = DbField(default_factory=list)
+
+class Book(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+    title: str = ""
+    author: Author
+
+author = Author(name="George Orwell")
+book = Book(title="1984", author=author)
+author.books.append(book)
+
+print(author) #Author(id=1, name='George Orwell', books=[Book(id=1, title='1984', author=Author(id=1, ...))])
+print(book) #Book(id=1, title='1984', author=Author(id=1, name='George Orwell', books=[Book(id=1, ...)]))
 ```
 
 ### Db classes
@@ -328,9 +387,67 @@ print(obj.list_of_books.dumps())
 #{"t": "DbList", "d": [{"t": "DbDatetime", "d": "2024-01-01T00:00:00"}, {"t": "DbDatetime", "d": "2027-07-07T00:00:00"}]}
 ```
 
+### Custom Db Classes
+
+And to create a custom 'Db class', you need to
+* Create regular class
+* Inherit from DbClass (DbClass - first. It is important) and your regular class for custom Db class
+* Set a Decorator with or without the necessary parameters
+* Set at least the `__convert_to_db__` module, according to the documentation
+* add additional modules.
+
+```python
+from db_attribute import db_class
+
+# for exemple you have your class:
+
+class UserDataClass:
+    def __init__(self, value = None):
+        self.value = value
+    def __repr__(self):
+        return f'UserDataClass(value={self.value})'
+
+@db_class.DbClassDecorator
+class DbUserDataClass(db_class.DbClass, UserDataClass):
+    def __init__(self, value=None, **kwargs):
+        # This is not a mandatory method
+        super().__init__(_call_init=False, **kwargs) # But this call is mandatory
+        self.__dict__['value'] = value
+        # Here we set the value of a variable using __dict__.
+        # This is not necessary, but it speeds up the work with the class.
+
+    @classmethod
+    def __convert_to_db__(cls, obj: UserDataClass, **kwargs):
+        """Methode for convert obj to dbclass - need @classmethod and kwargs"""
+        # This is a mandatory method
+        # Call with _user_db=True
+        # Example:
+        # print(type(DbUserDataClass(value=10)))                #UserDataClass
+        # print(type(DbUserDataClass(value=10, _use_db=True)))  #DbUserDataClass
+        return cls(_use_db=True, value=obj.value, **kwargs)
+
+    def __convert_from_db__(self):
+        """Reverse convert"""
+        # This is not a mandatory method.
+        return self._standart_class(value=self.value)
+```
+
+For example:
+
+```python
+class User(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+    data: UserDataClass
+
+user = User(id=1, data=UserDataClass(10))
+print(user.data) # UserDataClass(value=10)
+user.data.value = 5
+print(user.data) # UserDataClass(value=5)
+```
+
 ### Json type
 
-Db attribute support `tuple`, `list`, `dict`, other collections, but this types slow, because uses Db classes (see [speed test](#speed-test)).
+DbAttribute supports `tuple`, `list`, `dict`, other collections, but these types are slow, because uses Db classes (see [speed test](#speed-test)).
 
 To solve this problem, use a Json convertation
 
@@ -339,24 +456,24 @@ from db_attribute.db_types import JsonType, DbField
 
 class User(DbAttribute, metaclass=DbAttributeMetaclass):
     Meta = BaseMeta
-    sittings: JsonType = DbField(default_factory=lambda: {})
+    settings: JsonType = DbField(default_factory=lambda: {})
 
-obj = User(1, sittings={1: 2, 3: [4, 5]})
-print(obj.sittings)  # {'1': 2, '3': [4, 5]}
-print(type(obj.sittings))  # dict
+obj = User(1, settings={1: 2, 3: [4, 5]})
+print(obj.settings)  # {'1': 2, '3': [4, 5]}
+print(type(obj.settings))  # dict
 ```
 
 * If Developer change obj with JsonType, this obj don't dump to db, you need set the new obj 
-* The json support only `dict`, `list`, `str`, `int`, `float`, `True`, `False`, `None`
+* JsonType only supports: `dict`, `list`, `str`, `int`, `float`, `bool`, `None`
 
 ```python
-obj = User(1, sittings={1: 2, 3: [4, 5]})
-del obj.sittings['3'] # not changed
-obj.sittings['1'] = 3 # not changed
-obj.sittings |= {4: 5} # not changed
-print(obj.sittings) #{'1': 2, '3': [4, 5]}
-obj.sittings = {1: 3} # changed
-print(obj.sittings) #{'1': 3}
+obj = User(1, settings={1: 2, 3: [4, 5]})
+del obj.settings['3'] # not changed
+obj.settings['1'] = 3 # not changed
+obj.settings |= {4: 5} # not changed
+print(obj.settings) #{'1': 2, '3': [4, 5]}
+obj.settings = {1: 3} # changed
+print(obj.settings) #{'1': 3}
 ```
 
 # Speed Test
@@ -370,7 +487,7 @@ The execution speed may vary from computer to computer, so you need to focus on
 
 Mysql `select` - 12500 op/sec
 
-Type      | Operation/seconds | How much slower is it
+Type      | Operation/seconds | Performance impact
 ----------|-------------------|---------------------------
 int       | 11658 op/sec      | -6%
 str       | 11971 op/sec      | -4%
@@ -383,7 +500,7 @@ JsonType  | 11937 op/sec      | -4%
 
 Mysql `insert` - 8500 op/sec<br>
 
-Type      | Operation/seconds | How much slower is it
+Type      | Operation/seconds | Performance impact
 ----------|-------------------|---------------------------
 int       | 8056 op/sec       | -5%
 str       | 8173 op/sec       | -3%
@@ -394,5 +511,5 @@ JsonType  | 7297 op/sec       | -14%
 
 # Data base
 
-this module used MySQL db (<a href="https://github.com/mysql/mysql-connector-python/blob/trunk/LICENSE.txt">Licanse</a>), and for use it, you need install <a href='https://www.mysql.com'>mysql</a>
+This module uses MySQL db (<a href="https://github.com/mysql/mysql-connector-python/blob/trunk/LICENSE.txt">License</a>), and for use it, you need install <a href='https://www.mysql.com'>mysql</a>
 

{db_attribute-2.1 → db_attribute-2.1.1.0}/db_attribute/__init__.py

@@ -7,7 +7,7 @@ import db_attribute.connector as connector
 import db_attribute.discriptor as discriptor
 
 __all__ = ['DbAttribute', 'DbAttributeMetaclass', 'db_work', 'db_class', 'discriptor', 'connector', 'db_types']
-__version__ = '2.1'
+__version__ = '2.1.1.0'
 
 class DbAttributeMetaclass(type):
     dict_classes = db_types.DictClasses()
@@ -21,10 +21,15 @@ class DbAttributeMetaclass(type):
         if not cheak_class_in_bases(bases, DbAttribute):
             bases = (DbAttribute,) + bases
 
-        new_cls = super().__new__(cls, name, bases, namespace)
+        new_cls: DbAttribute = super().__new__(cls, name, bases, namespace)
 
         params_for_metaclass = {'need_add_this_class_to_dict_classes': True, 'need_DbAttributeMetaclass': True}
-        options = {'__dbworkobj__': db_types.NotSet, '__max_repr_recursion_limit__': 10, '__repr_class_name__': db_types.NotSet}
+        options = {
+            '__dbworkobj__': db_types.NotSet,
+            '__max_repr_recursion_limit__': 10,
+            '__repr_class_name__': db_types.NotSet,
+            '__skip_dbworkobj__': False
+        }
 
         __annotations__ = {}
         __dict__ = {}
@@ -67,7 +72,7 @@ class DbAttributeMetaclass(type):
             if options[i] is not db_types.NotSet:
                 setattr(new_cls, i, options[i])
 
-        if getattr(new_cls, '__dbworkobj__', None) is None:
+        if (getattr(new_cls, '__dbworkobj__', None) is None) and (not getattr(new_cls, '__skip_dbworkobj__', False)):
             raise Exception(f'The "{new_cls.__name__}" class dosn\'t have "__dbworkobj__" parameter: set "__dbworkobj__" or "Meta", see documentation')
 
         attr_names = list(__annotations__.keys())
@@ -87,6 +92,8 @@ class DbAttributeMetaclass(type):
 
             if isinstance(attr_value, db_types.DbField):
                 db_field = attr_value
+            elif isinstance(attr_value, db_types.Factory):
+                db_field = db_types.DbField(default_factory=attr_value)
             else:
                 db_field = db_types.DbField(default=attr_value)
 
@@ -95,7 +102,7 @@ class DbAttributeMetaclass(type):
             if db_field.python_type is db_types.MISSING:
                 if db_field.default is not db_types.MISSING:
                     db_field.python_type = type(db_field.default)
-                elif db_field.default_factory is not db_types.MISSING:
+                elif db_field.default_factory is not db_types.MISSING: #the idea: is to add a parameter for metaclass so as not to call default_factory to determine the type of the variable.
                     db_field.python_type = type(db_field.default_factory.get_value())
             if db_field.python_type is db_types.MISSING:
                 raise f'the type for {attr_name} of {name} is not set (add python_type for DbField or set type in annotations or set default for DbField or set default_factory for DbField)'
@@ -132,7 +139,8 @@ class DbAttributeMetaclass(type):
         params_str = ', '.join(params)
 
         init_code = (
-            f"def __init__(self, {params_str}, id:int=db_types.NotSet, _dont_add_id:bool = False):\n"
+            f"def __init__(self, {params_str + ', ' if params_str else ''}id:int=db_types.NotSet, _dont_add_id:bool = False):\n"
+            "    db_types.cheak_db_work_object(self.__class__)\n"
             "    now_locals = locals()\n"
             "    used_keys = now_locals\n"
             "    for i in ['self', 'id', '_dont_add_id']:\n"
@@ -167,8 +175,8 @@ class DbAttributeMetaclass(type):
         if params_for_metaclass['need_add_this_class_to_dict_classes']:
             cls.dict_classes.add(new_cls)
 
-        if not new_cls.__dbworkobj__.cheak_exists_id_table(new_cls.__name__):
-            new_cls.__dbworkobj__.create_id_table(new_cls.__name__)
+        if not new_cls.__skip_dbworkobj__:
+            new_cls.register_dbworkobj(new_cls.__dbworkobj__)
 
         return new_cls
 
@@ -181,6 +189,7 @@ class DbAttribute:
     __dbworkobj__: ClassVar[db_work.Db_work] = None
     __max_repr_recursion_limit__: ClassVar[int] = 10
     __repr_class_name__: ClassVar[str] = db_types.NotSet
+    __skip_dbworkobj__: ClassVar[bool] = False
 
     def __init__(self, *args, ID=None, **kwargs):
         raise 'Need set metaclass=DbAttributeMetaclass'
@@ -190,7 +199,7 @@ class DbAttribute:
         if now > self.__max_repr_recursion_limit__ or (self.id, self.__repr_class_name__) in Objs:
             return f'{self.__repr_class_name__}(id={self.id}, ...)'
         Objs.add((self.id, self.__repr_class_name__))
-        return f'{self.__repr_class_name__}(id={self.id}, {", ".join([f"{i}={obj.__get_repr__(Objs, now+1) if hasattr(obj:=getattr(self, i), '__get_repr__') else f'{getattr(self, i)}'}" for i in self.__db_fields__])})'
+        return f'''{self.__repr_class_name__}(id={self.id}, {", ".join([f"{i}={obj.__get_repr__(Objs, now+1) if hasattr(obj:=getattr(self, i), '__get_repr__') else f'{repr(getattr(self, i))}'}" for i in self.__db_fields__])})'''
 
     def _db_attribute_container_update(self, key, data=None):
         """
@@ -207,6 +216,7 @@ class DbAttribute:
 
     @classmethod
     def _db_attribute_found_ids_by_attribute(cls, attribute_name:str, attribute_value):
+        db_types.cheak_db_work_object(cls)
         tempdata = cls.__dbworkobj__.found_ids_by_value(class_name=cls.__name__, attribute_name=attribute_name, data=attribute_value, _cls_dbattribute=cls)
         if tempdata['status_code'] != 200:
             return set()
@@ -237,6 +247,7 @@ class DbAttribute:
 
     @classmethod
     def get_all_ids(cls):
+        db_types.cheak_db_work_object(cls)
         temp = cls.__dbworkobj__.get_all_ids(cls.__name__)
         if temp['status_code'] != 200:
             return db_types.Ids()
@@ -291,6 +302,7 @@ class DbAttribute:
 
     @classmethod
     def delete_objs(cls, IDs: set[int] | int, attributes:set[str]=None):
+        db_types.cheak_db_work_object(cls)
         all_attributes = object.__getattribute__(cls, '__db_fields__')
         attributes = all_attributes if attributes is None else attributes & all_attributes
         IDs = {IDs} if isinstance(IDs, int) else IDs
@@ -318,3 +330,10 @@ class DbAttribute:
         for key in kwargs:
             res &= cls._db_attribute_found_ids_by_attribute(attribute_name=key, attribute_value=kwargs[key])
         return res
+
+    @classmethod
+    def register_dbworkobj(cls, dbworkobj):
+        cls.__dbworkobj__ = dbworkobj
+        cls.__skip_dbworkobj__ = False
+        if not cls.__dbworkobj__.cheak_exists_id_table(cls.__name__):
+            cls.__dbworkobj__.create_id_table(cls.__name__)