db-attribute 2.1.1.0__tar.gz → 2.1.2__tar.gz

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

@@ -1,23 +1,22 @@
 Metadata-Version: 2.4
 Name: db_attribute
-Version: 2.1.1.0
+Version: 2.1.2
 Summary: DataBase attribute package
 Home-page: https://github.com/shutkanos/Db-Attribute
 Author: Shutkanos
 Author-email: Shutkanos <Shutkanos836926@mail.ru>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/shutkanos/Db-Attribute
 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
+Keywords: db,database,attribute,db_attribute,db attribute,DbAttribute,database attribute,orm,ORM,attribute orm,attribute ORM,attr,attr ORM,attr orm,db attr,DbAttr
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mysql-connector-python>=1.4
+Requires-Dist: mysql-connector-python>=8.4.0
 Requires-Dist: orjson
 Dynamic: author
 Dynamic: home-page
@@ -57,8 +56,13 @@ The library provides tools for declarative model definition, relationship manage
 * [Supported types](#supported-types)
 * [Install](#install)
 * [How to use it](#how-to-use-it)
+    * [Connect to DB](#connect-to-db)
+        * [MySQL](#mysql)
+        * [SQLite](#sqlite)
     * [Create class](#create-class)
         * [Options](#options)
+        * [Register db work object](#register-db-work-object)
+        * [Class inheritance](#class-inheritance)
     * [Work with obj](#work-with-obj)
         * [Create new object](#create-new-object)
         * [Finding objects](#finding-objects)
@@ -66,6 +70,7 @@ The library provides tools for declarative model definition, relationship manage
         * [Change attribute of obj](#change-attribute-of-obj)
         * [Dump mode](#dump-mode)
     * [Types](#types)
+        * [DbField](#dbfield)
         * [Db attribute](#db-attribute)
         * [Db classes](#db-classes)
         * [Custom Db Classes](#custom-db-classes) 
@@ -97,6 +102,37 @@ pip install git+https://github.com/shutkanos/Db-Attribute.git
 
 # How to use it
 
+## Connect to DB
+
+### MySQL
+Connect to MySQL database by providing host, credentials, and database name:
+
+```python
+from db_attribute import db_work, connector
+
+connect_obj = connector.MySQLConnection(host='localhost', user='root', password='password', database='mydb')
+db_work_obj = db_work.Db_work(connect_obj)
+```
+
+### SQLite
+Connect to SQLite database (local file or in-memory):
+
+```python
+from db_attribute import db_work, connector
+
+# File-based database
+connect_obj = connector.SQLiteConnection('/path/to/database.db')
+db_work_obj = db_work.Db_work(connect_obj)
+
+# In-memory database
+connect_obj = connector.SQLiteConnection(':memory:')
+db_work_obj = db_work.Db_work(connect_obj)
+
+# With specific options
+connect_obj = connector.SQLiteConnection('/path/to/database.db', timeout=10)
+db_work_obj = db_work.Db_work(connect_obj)
+```
+
 ## Create class
 
 To create any class (Table):
@@ -110,16 +146,17 @@ To create any class (Table):
 from db_attribute import DbAttribute, DbAttributeMetaclass, db_work, connector
 from db_attribute.db_types import DbField
 
-connect_obj = connector.Connection(host=*mysqlhost*, user=*user*, password=*password*, database=*databasename*)
+connect_obj = connector.MySQLConnection(host='localhost', user='root', password='password', database='mydb')
 db_work_obj = db_work.Db_work(connect_obj)
 
+
 class User(DbAttribute, metaclass=DbAttributeMetaclass, __dbworkobj__=db_work_obj):
-    name: str = DbField(default='NotSet') # Ok
-    age: int = -1 # Ok
-    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
-    settings: dict = DbField(default_factory=dict) # Ok
+    name: str = DbField(default='NotSet')  # Ok
+    age: int = -1  # Ok
+    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
+    settings: dict = DbField(default_factory=dict)  # Ok
 ```
 
 Each instance has a unique `id` identifier. It is inherited from DbAttribute and stored in `__dict__`
@@ -155,6 +192,96 @@ All options:
 * `__dbworkobj__` - database work object (required parameter),
 * `__max_repr_recursion_limit__` - maximum recursion limit for `__repr__` of DbAttribute
 * `__repr_class_name__` - sets the name of this class when using the method `__repr__` of DbAttribute
+* `__table_name__` - sets custom table name instead of the class name. By default, it is inherited (like any other class attribute), so child classes automatically share the same tables as the parent.
+
+### Register db work object
+
+If `dbworkobj` is not available at the time of class definition, you can defer registration using one of two approaches.
+
+#### Using `__skip_dbworkobj__ = True`
+
+Set `__skip_dbworkobj__ = True` in `Meta`, then call `register_dbworkobj()` on each class individually:
+
+```python
+class BaseMeta:
+    __skip_dbworkobj__ = True
+
+class User(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+
+class Book(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+
+User.register_dbworkobj(dbworkobj)
+Book.register_dbworkobj(dbworkobj)
+```
+
+#### Using `DbWorkMarker` (recommended for multiple classes)
+
+Define a marker with a group name, place it in `Meta.__dbworkobj__`, then connect all classes at once via `DbWorkManager`:
+
+```python
+from db_attribute.db_types import DbWorkMarker, DbWorkManager
+
+class MainMeta:
+    __dbworkobj__ = DbWorkMarker('main')
+
+class User(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = MainMeta
+
+class Book(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = MainMeta
+
+DbWorkManager.connect('main', dbworkobj)
+```
+
+### Class inheritance
+
+A developer can create a child class from an existing DbAttribute class. The child class stores **all its fields** (including inherited ones) in its own separate database tables, fully isolated from the parent's tables.
+
+```python
+from db_attribute.db_types import DbField
+
+class UserBase(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+    nameuser: str = DbField(default="")
+    rank: str = DbField(default="User")
+
+    def promote(self):
+        self.rank = 'Admin'
+
+class UserChild(UserBase):
+    some_data: int = DbField(default=0)
+
+user1 = UserChild(id=1, nameuser="Oleg", some_data=1)
+user2 = UserChild(id=2, nameuser="Bob", some_data=2)
+print(user1) # UserChild(id=1, nameuser='Oleg', rank='User', some_data=1)
+print(user2) # UserChild(id=2, nameuser='Bob', rank='User', some_data=2)
+user2.promote()
+print(user2) # UserChild(id=2, nameuser='Bob', rank='Admin', some_data=2)
+```
+
+Key points:
+
+* The child class inherits all fields and methods from the parent
+* No need to repeat `metaclass=DbAttributeMetaclass` — it is inherited automatically
+* The child uses the same `dbworkobj` as the parent by default; a different one can be set via `Meta`
+* `UserBase` and `UserChild` are completely independent in the database: `UserBase(id=1)` and `UserChild(id=1)` are different records stored in different tables
+* Methods defined in the parent work correctly on child instances and write to the child's own tables:
+
+```python
+user1.promote()
+print(user1.rank) # 'Admin' — written to table 'cls userchild atr rank', not 'cls userbase atr rank'
+```
+
+To use a different `dbworkobj` for the child class, set it via `Meta`:
+
+```python
+class UserPremium(UserBase):
+    class Meta:
+        __dbworkobj__ = other_dbworkobj
+    premium_level: int = DbField(default=1)
+```
 
 ## Work with obj
 
@@ -165,6 +292,9 @@ To create an object, use an id (optional) and other fields (optional),
 ```python
 obj = User(id=3) # other field set to defaults value
 print(obj) # User(id=3, name=*default value*)
+# or:
+obj = User.get(id=3)
+print(obj) # User(id=3, name=*default value*)
 ```
 ```python
 obj = User(name='Ben', id=3)
@@ -180,20 +310,20 @@ print(obj) # User(id=5, name='Alica')
 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
-print(obj) #User(id=3, name='Ben', age=10)
+obj = User(name='Ben', age=20, id=3) #insert obj to db
+print(obj) # User(id=3, name='Ben', age=20)
 
 obj = User(id=3)
-print(obj) #User(id=3, name='Ben', age=10)
+print(obj) # User(id=3, name='Ben', age=20)
 
 obj = User('Anna', id=3)
-print(obj) #User(id=3, name='Anna', age=10)
+print(obj) # User(id=3, name='Anna', age=20)
 
-obj = User(age=15, id=3)
-print(obj) #User(id=3, name='Anna', age=15)
+obj = User(age=25, id=3)
+print(obj) # User(id=3, name='Anna', age=25)
 
 obj = User(id=3)
-print(obj) #User(id=3, name='Anna', age=15)
+print(obj) # User(id=3, name='Anna', age=25)
 ```
 
 ### Finding objects
@@ -207,21 +337,25 @@ The `get()` method returns:
 
 ```python
 #create objs
-obj = User(name='Bob', age=2, id=1)
-obj = User(name='Bob', age=3, id=2)
-obj = User(name='Anna', age=2, id=3)
+obj = User(name='Bob', age=20, id=1)
+obj = User(name='Bob', age=30, id=2)
+obj = User(name='Anna', age=20, id=3)
 #finds objs
-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
+print(User.get(id=2))                                   # User(id=2, name='Bob', age=30)
+print(User.get((User.age == 30) & (User.name == 'Bob')))# User(id=2, name='Bob', age=30)
+print(User.get(User.name == 'Anna'))                    # User(id=3, name='Anna', age=20)
+print(User.get(User.name == 'Bob'))                     # User(id=1, name='Bob', age=20)
+print(User.get(User.name == 'Other name'))              # None
+#finds all objs
+print(User.gets(User.name == 'Bob'))                    # [User(id=1, name='Bob', age=20), User(id=2, name='Bob', age=30)]
+print(User.gets([2, 3]))                                # [User(id=2, name='Bob', age=30), User(id=3, name='Anna', age=20)]
 ```
 
 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 == 30) & (User.name == 'Bob')) # ((User.age = 30) and (User.name = 'Bob'))
 ```
 
 Use '&' and '|' instead of the 'and' and 'or' operators. The 'and' and 'or' operators are not supported
@@ -232,16 +366,16 @@ 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=30), User(id=2, name='Bob', age=20), User(id=3, name='Anna', age=20)]
 
-print([i for i in User if i.age < 3])
-#[User(id=2, name='Bob', age=2), User(id=3, name='Anna', age=2)]
+print([i for i in User if i.age < 30])
+# [User(id=2, name='Bob', age=20), User(id=3, name='Anna', age=20)]
 
 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=30)
+# User(id=2, name='Bob', age=20)
+# User(id=3, name='Anna', age=20)
 ```
 ⚠️ Iterations loads all objects - not recommended for large tables
 
@@ -250,12 +384,12 @@ for i in User:
 ```python
 obj = User(name='Bob', list_of_books=[], id=1)
 
-print(obj) #User(id=1, name='Bob', list_of_books=[])
+print(obj) # User(id=1, name='Bob', list_of_books=[])
 
 obj.name = 'Anna'
 obj.list_of_books.append('Any name of book')
 
-print(obj) #User(id=1, name='Anna', list_of_books=['Any name of book'])
+print(obj) # User(id=1, name='Anna', list_of_books=['Any name of book'])
 ```
 
 ### Dump mode
@@ -310,6 +444,27 @@ user.set_auto_dump_mode()
 
 ## Types
 
+### DbField
+
+Dbfield is used to configure fields, namely:
+
+* `default` (Any): the default value of this Field (default takes precedence over the default_factory)
+* `default_factory` (Any): the default factory of this Field
+* `python_type` (Any): python type of data, example: str, int (python_type takes precedence over the data type specified in the annotation)
+* `mysql_type` (str): mysql type of data, example: 'varchar(50)', 'bigint'
+* `repr` (bool): Include field in `__repr__()` output
+* `init` (bool): Include field in constructor (`__init__()`)
+* `search_default` (bool): When True, applies default value during searches if record is missing in this field's table (Use this parameter if you understand what it is responsible for.)
+
+For example:
+
+```python
+class User(DbAttribute, metaclass=DbAttributeMetaclass):
+    Meta = BaseMeta
+    name: str = DbField(default='NotSet', mysql_type='varchar(32)')
+    hash: str = DbField(default_factory=lambda: str(uuid.uuid4()), mysql_type='varchar(512)', repr=False, init=False, search_default=False)
+```
+
 ### Db attribute
 
 A developer can set the Db attribute class as data type for another Db attribute class
@@ -329,20 +484,20 @@ 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, ...)))
-#And Found with use id of obj:
+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
@@ -362,29 +517,29 @@ 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, ...)]))
+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
 When collections are stored in memory, they converted to Db classes
 ```python
 obj = User(1, list_of_books=[1, 2, 3])
-print(type(obj.list_of_books)) #DbList
+print(type(obj.list_of_books)) # DbList
 ```
 ```python
 obj = User(1, times=[datetime(2024, 1, 1)])
-print(type(obj.times[0])) #DbDatetime
+print(type(obj.times[0])) # DbDatetime
 ```
 And when collections dumped to db, they converted to json
 ```python
 obj = User(1, list_of_books=[1, 2, 3])
-print(obj.list_of_books.dumps()) #{"t": "DbList", "d": [1, 2, 3]}
+print(obj.list_of_books.dumps()) # {"t": "DbList", "d": [1, 2, 3]}
 ```
 ```python
 obj = User(1, times=[datetime(2024, 1, 1), datetime(2027, 7, 7)])
 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"}]}
+# {"t": "DbList", "d": [{"t": "DbDatetime", "d": "2024-01-01T00:00:00"}, {"t": "DbDatetime", "d": "2027-07-07T00:00:00"}]}
 ```
 
 ### Custom Db Classes
@@ -476,6 +631,7 @@ obj.settings = {1: 3} # changed
 print(obj.settings) #{'1': 3}
 ```
 
+
 # Speed Test
 
 The execution speed may vary from computer to computer, so you need to focus on the specified number of operations per second of a regular mysql
@@ -512,4 +668,3 @@ JsonType  | 7297 op/sec       | -14%
 # Data base
 
 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.1.0 → db_attribute-2.1.2}/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.1.0'
+__version__ = '2.1.2'
 
 class DbAttributeMetaclass(type):
     dict_classes = db_types.DictClasses()
@@ -28,7 +28,8 @@ class DbAttributeMetaclass(type):
             '__dbworkobj__': db_types.NotSet,
             '__max_repr_recursion_limit__': 10,
             '__repr_class_name__': db_types.NotSet,
-            '__skip_dbworkobj__': False
+            '__skip_dbworkobj__': False,
+            '__table_name__': db_types.NotSet
         }
 
         __annotations__ = {}
@@ -66,12 +67,24 @@ class DbAttributeMetaclass(type):
         if not params_for_metaclass['need_DbAttributeMetaclass']:
             return new_cls
 
-        new_cls.__repr_class_name__ = name
-
         for i in options:
             if options[i] is not db_types.NotSet:
                 setattr(new_cls, i, options[i])
 
+        if getattr(new_cls, '__table_name__', db_types.NotSet) is db_types.NotSet:
+            new_cls.__table_name__ = name
+
+        dbworkobj_value = getattr(new_cls, '__dbworkobj__', None)
+        if isinstance(dbworkobj_value, db_types.DbWorkMarker):
+            db_types.DbWorkManager.register_class(dbworkobj_value.group_id, new_cls)
+            new_cls.__skip_dbworkobj__ = True
+
+        if '__repr_class_name__' not in kwargs:
+            own_meta = namespace.get('Meta', None)
+            own_meta_has_repr = own_meta is not None and '__repr_class_name__' in getattr(own_meta, '__dict__', {})
+            if not own_meta_has_repr:
+                new_cls.__repr_class_name__ = name
+
         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')
 
@@ -90,6 +103,11 @@ class DbAttributeMetaclass(type):
             if get_origin(attr_type) is ClassVar:
                 continue
 
+            if isinstance(attr_value, discriptor.DbAttributeDiscriptor):
+                if attr_name in __db_fields__:
+                    continue
+                attr_value = db_types.MISSING
+
             if isinstance(attr_value, db_types.DbField):
                 db_field = attr_value
             elif isinstance(attr_value, db_types.Factory):
@@ -145,14 +163,14 @@ class DbAttributeMetaclass(type):
             "    used_keys = now_locals\n"
             "    for i in ['self', 'id', '_dont_add_id']:\n"
             "        used_keys.pop(i)\n"
-            "    if not self.__dbworkobj__.cheak_exists_id_table(self.__class__.__name__):\n"
-            "        self.__dbworkobj__.create_id_table(self.__class__.__name__)\n"
+            "    if not self.__dbworkobj__.cheak_exists_id_table(self.__class__.__table_name__):\n"
+            "        self.__dbworkobj__.create_id_table(self.__class__.__table_name__)\n"
             "    if isinstance(id, db_types.Id):\n"
             "        id = id.Id\n"
             "    if id is db_types.NotSet:\n"
-            "        id = self.__dbworkobj__.get_new_id(self.__class__.__name__)['data']\n"
+            "        id = self.__dbworkobj__.get_new_id(self.__class__.__table_name__)['data']\n"
             "    elif not (_dont_add_id and len([i for i in used_keys if used_keys[i] is not db_types.NotSet]) == 0):\n"
-            "        self.__dbworkobj__.add_id(self.__class__.__name__, id)\n"
+            "        self.__dbworkobj__.add_id(self.__class__.__table_name__, id)\n"
             "    setattr(self, 'id', id)\n"
             "    for name in __db_fields__:\n"
             "        value = used_keys[name]\n"
@@ -190,6 +208,7 @@ class DbAttribute:
     __max_repr_recursion_limit__: ClassVar[int] = 10
     __repr_class_name__: ClassVar[str] = db_types.NotSet
     __skip_dbworkobj__: ClassVar[bool] = False
+    __table_name__: ClassVar[str] = db_types.NotSet
 
     def __init__(self, *args, ID=None, **kwargs):
         raise 'Need set metaclass=DbAttributeMetaclass'
@@ -199,7 +218,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'{repr(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__ if self.__db_fields__[i].repr])})'''
 
     def _db_attribute_container_update(self, key, data=None):
         """
@@ -217,7 +236,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)
+        tempdata = cls.__dbworkobj__.found_ids_by_value(class_name=cls.__table_name__, attribute_name=attribute_name, data=attribute_value, _cls_dbattribute=cls)
         if tempdata['status_code'] != 200:
             return set()
         return tempdata['data']
@@ -237,22 +256,56 @@ class DbAttribute:
             if not Ids:
                 return None
             id = Ids.list_ids[0]
+        if isinstance(id, db_types.Ids) and len(id) > 1:
+            id = id[0]
         if isinstance(id, db_types.Id):
             id = id.Id
-        if isinstance(id, int) or isinstance(id, db_types.Id):
+        if isinstance(id, int):
             obj = cls.__new__(cls)
             obj.id = id
             return obj
         return None
 
+    @classmethod
+    def gets(cls, ids):
+        """
+        return List of objects
+        :type ids: List[int | db_types.Id] | discriptor.Condition | db_types.Ids
+        :return: List[obj]
+        """
+        if isinstance(ids, discriptor.Condition):
+            ids = ids.found()
+        if isinstance(ids, db_types.Ids):
+            ids = list(ids)
+        if not (isinstance(ids, list)) or isinstance(ids, db_types.Ids):
+            return []
+        res = []
+        for id in ids:
+            if isinstance(id, db_types.Id):
+                id = id.Id
+            if isinstance(id, int):
+                obj = cls.__new__(cls)
+                obj.id = id
+                res.append(obj)
+        return res
+
     @classmethod
     def get_all_ids(cls):
         db_types.cheak_db_work_object(cls)
-        temp = cls.__dbworkobj__.get_all_ids(cls.__name__)
+        temp = cls.__dbworkobj__.get_all_ids(cls.__table_name__)
         if temp['status_code'] != 200:
             return db_types.Ids()
         return db_types.Ids(temp['data'])
 
+    def get_attribute(self, attribute_name, attribute_type=None):
+        cls = object.__getattribute__(self, '__class__')
+        db_field = object.__getattribute__(self, '__db_fields__').get(attribute_name, None)
+        if db_field is None:
+            return
+        if attribute_type is None:
+            attribute_type = db_field.python_type
+        return cls.__dict__[attribute_name].get(self, attribute_type=attribute_type)
+
     def dump(self, attributes:set[str]=None):
         """
         Use it func, if you need dump the data to db, with manual_dump_mode
@@ -307,7 +360,7 @@ class DbAttribute:
         attributes = all_attributes if attributes is None else attributes & all_attributes
         IDs = {IDs} if isinstance(IDs, int) else IDs
         dbworkobj = cls.__dbworkobj__
-        clsname = cls.__name__
+        clsname = cls.__table_name__
         for ID in IDs:
             for db_attr in attributes:
                 dbworkobj.del_attribute_value(class_name=clsname, attribute_name=db_attr, ID=ID)
@@ -335,5 +388,5 @@ class DbAttribute:
     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__)
+        if not cls.__dbworkobj__.cheak_exists_id_table(cls.__table_name__):
+            cls.__dbworkobj__.create_id_table(cls.__table_name__)