orm-database 0.3.10__tar.gz → 0.3.11__tar.gz

orm_database-0.3.11/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.2
+Name: orm_database
+Version: 0.3.11
+Summary: This module is written to launch your programs with any database you want in the shortest time 
+Home-page: https://github.com/sisrsis/orm-database
+Author: SISRSIS
+Author-email: virussisrsis@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncpg
+Requires-Dist: motor
+Requires-Dist: mariadb
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Create table
+
+```python
+from orm_database import PostgreSQL
+from pydantic import BaseModel
+import asyncio
+
+
+class User(BaseModel):
+    username: str
+    password: str
+    email: str
+
+
+async def main():
+    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
+    await db.start()
+    
+    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
+    
+    await db.table_create_BaseModel(table="users", class_BaseModel=User)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## create table mariadb baseModel
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+
+
+asyncio.run(main())
+
+```
+
+## create table mariadb
+
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+
+
+db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
+
+
+
+
+async def main():
+    await db.start()
+    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
+
+
+asyncio.run(main())
+```
+
+`test` name table
+
+| name     |   field     |
+| -------- | ----------- |
+| username | varchar(250)|
+| email    | varchar(250)|
+| old      |    int      |
+
+
+
+## insert value 
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = {"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"}
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+```
+
+
+
+
+
+
+## insert value list 
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = [{"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"},{"user_rt":"test2","password_rt":"12342","email_rt":"test2@mail.com"},{"user_rt":"test3","password_rt":"12343","email_rt":"test3@mail.com"}]
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+
+```
+
+
+
+
+
+# select database 
+| user_rt | password_rt |    email_rt    |
+| -----   | -----       | -------------- |
+| test1   |    12341    | test1@mail.com |
+| test2   |    12342    | test2@mail.com |
+| test3   |    12343    | test3@mail.com |
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_all("tes",["user_rt","password_rt","email_rt"])
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+
+
+```
+# output 
+```json
+[
+{'user_rt': 'test1', 'password_rt': '12341', 'email_rt': 'test1@mail.com'},
+{'user_rt': 'test2', 'password_rt': '12342', 'email_rt': 'test2@mail.com'},
+{'user_rt': 'test3', 'password_rt': '12343', 'email_rt': 'test3@mail.com'}
+ ]
+ ```
+
+
+SELECT ONE ROW
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_columns("tes",{"user_rt":"test1"})
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+```
+
+output
+
+```
+('test1', '12341', 'test1@mail.com')
+```

orm_database-0.3.11/README.md

@@ -0,0 +1,229 @@
+# Create table
+
+```python
+from orm_database import PostgreSQL
+from pydantic import BaseModel
+import asyncio
+
+
+class User(BaseModel):
+    username: str
+    password: str
+    email: str
+
+
+async def main():
+    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
+    await db.start()
+    
+    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
+    
+    await db.table_create_BaseModel(table="users", class_BaseModel=User)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## create table mariadb baseModel
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+
+
+asyncio.run(main())
+
+```
+
+## create table mariadb
+
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+
+
+db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
+
+
+
+
+async def main():
+    await db.start()
+    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
+
+
+asyncio.run(main())
+```
+
+`test` name table
+
+| name     |   field     |
+| -------- | ----------- |
+| username | varchar(250)|
+| email    | varchar(250)|
+| old      |    int      |
+
+
+
+## insert value 
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = {"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"}
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+```
+
+
+
+
+
+
+## insert value list 
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = [{"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"},{"user_rt":"test2","password_rt":"12342","email_rt":"test2@mail.com"},{"user_rt":"test3","password_rt":"12343","email_rt":"test3@mail.com"}]
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+
+```
+
+
+
+
+
+# select database 
+| user_rt | password_rt |    email_rt    |
+| -----   | -----       | -------------- |
+| test1   |    12341    | test1@mail.com |
+| test2   |    12342    | test2@mail.com |
+| test3   |    12343    | test3@mail.com |
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_all("tes",["user_rt","password_rt","email_rt"])
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+
+
+```
+# output 
+```json
+[
+{'user_rt': 'test1', 'password_rt': '12341', 'email_rt': 'test1@mail.com'},
+{'user_rt': 'test2', 'password_rt': '12342', 'email_rt': 'test2@mail.com'},
+{'user_rt': 'test3', 'password_rt': '12343', 'email_rt': 'test3@mail.com'}
+ ]
+ ```
+
+
+SELECT ONE ROW
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_columns("tes",{"user_rt":"test1"})
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+```
+
+output
+
+```
+('test1', '12341', 'test1@mail.com')
+```

{orm_database-0.3.10 → orm_database-0.3.11}/orm_database/orm_database.py

@@ -29,19 +29,59 @@ class MariaDB:
         query = query_baseModel_create_table(table,class_BaseModel)
         cur = self.db.cursor() 
         cur.execute(query)
-        cur.close()
-
+        self.db.commit()
 
     async def teble_create(self, table: str, field: dict):
         query = query_create_table(table,field)
         cur = self.db.cursor() 
         cur.execute(query)
-        cur.close()
+        self.db.commit()
 
     async def insert_value(self, table: str, value: dict):
         query = query_insert_value(table,value)
-        await self.db.execute(query)
-        await self.db.close()
+        cur = self.db.cursor() 
+        print(query)
+        cur.execute(query)
+        self.db.commit()
+
+
+    async def insert_values(self, table: str, values: list):
+        cur = self.db.cursor() 
+        for value in values:
+            query = query_insert_values(table=table,value=value)
+            cur.execute(query)
+        self.db.commit()
+
+
+    async def select_all(self, table: str, filed: list, all: bool = False):
+        cur = self.db.cursor()
+        query = query_select(table=table,filed=filed,all=all)
+        cur.execute(query)
+        result = cur.fetchall()
+        print(result)
+        data = {}
+        data_row = []
+        for a in result:
+            print(a)
+            conter = 0
+            for b in a:
+                data[filed[conter]] = b
+                conter += 1
+            data_row.append(dict(data))
+        return data_row
+
+
+    async def select_columns(self, table: str, filed: dict):
+        cur = self.db.cursor()
+        query = select_columns(table=table,filed=filed)
+        fileds = list(filed.keys())
+        try:
+            
+            cur.execute(query,(filed[fileds[0]],))
+            row = cur.fetchone()
+            return row
+        except:
+            return None
 
 
 
@@ -76,22 +116,8 @@ class PostgreSQL:
 
     async def insert_values(self, table: str, values: list):
         for value in values:
-            query = f"INSERT INTO {table}  ( "
-            filed_key = list(value.keys())
-            for a in filed_key:
-                query = query + " " + a + " " + ","
-            query = query[:-1]
-            query = query + ")"
-            query = query + " VALUES ("
-
-            filed_value = list(value.values())
-            for a in filed_value:
-                query = query + " '" + str(a) + "' " + ","
-            query = query[:-1]
-            query = query + ")"
-            print(query)
+            query = query_insert_values(table=table,value=value)
             await self.db.execute(query)
-            query = ""
         await self.db.close()
 
     async def select_all(self, table: str, filed: list, all: bool = False):

{orm_database-0.3.10 → orm_database-0.3.11}/orm_database/orm_query.py

@@ -50,7 +50,7 @@ def query_create_table(table:str,field:dict):
 
 
 def query_insert_value(table:str,value:dict):
-    uery = f"INSERT INTO {table}  ( "
+    query = f"INSERT INTO {table}  ( "
     filed_key = list(value.keys())
     for a in filed_key:
         query = query + " " + a + " " + ","
@@ -62,4 +62,45 @@ def query_insert_value(table:str,value:dict):
         query = query + " '" + str(a) + "' " + ","
     query = query[:-1]
     query = query + ")"
+    return query
+
+def query_insert_values(table:str,value:dict):
+    query = f"INSERT INTO {table}  ( "
+    filed_key = list(value.keys())
+    for a in filed_key:
+        query = query + " " + a + " " + ","
+    query = query[:-1]
+    query = query + ")"
+    query = query + " VALUES ("
+
+    filed_value = list(value.values())
+    for a in filed_value:
+        query = query + " '" + str(a) + "' " + ","
+    query = query[:-1]
+    query = query + ")"
+    return query
+
+
+# print output SELECT * FROM tes
+# print output SELECT user_rt FROM tes
+def  query_select(table:str,filed:list,all:bool=False):
+    if all == True:
+        query = "SELECT * FROM " + table
+    if all == False:
+        query = "SELECT "
+        for a in filed:
+            query = query + a + ","
+        query = query[:-1]
+        query = query + " FROM " + table
+        return query
+    
+
+
+
+def select_columns(table:str,filed:dict):
+    query = "SELECT * "
+    query = query + " FROM "
+    query = query + table + " WHERE "
+    fileds = list(filed.keys())
+    query = query + fileds[0]+"="+"%s"
     return query

orm_database-0.3.11/orm_database.egg-info/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.2
+Name: orm_database
+Version: 0.3.11
+Summary: This module is written to launch your programs with any database you want in the shortest time 
+Home-page: https://github.com/sisrsis/orm-database
+Author: SISRSIS
+Author-email: virussisrsis@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncpg
+Requires-Dist: motor
+Requires-Dist: mariadb
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Create table
+
+```python
+from orm_database import PostgreSQL
+from pydantic import BaseModel
+import asyncio
+
+
+class User(BaseModel):
+    username: str
+    password: str
+    email: str
+
+
+async def main():
+    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
+    await db.start()
+    
+    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
+    
+    await db.table_create_BaseModel(table="users", class_BaseModel=User)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## create table mariadb baseModel
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+
+
+asyncio.run(main())
+
+```
+
+## create table mariadb
+
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+
+
+db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
+
+
+
+
+async def main():
+    await db.start()
+    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
+
+
+asyncio.run(main())
+```
+
+`test` name table
+
+| name     |   field     |
+| -------- | ----------- |
+| username | varchar(250)|
+| email    | varchar(250)|
+| old      |    int      |
+
+
+
+## insert value 
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = {"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"}
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+```
+
+
+
+
+
+
+## insert value list 
+
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+    data = [{"user_rt":"test1","password_rt":"12341","email_rt":"test1@mail.com"},{"user_rt":"test2","password_rt":"12342","email_rt":"test2@mail.com"},{"user_rt":"test3","password_rt":"12343","email_rt":"test3@mail.com"}]
+    await db.start()
+    await db.teble_create_BaseModel("tes",users)
+    await db.insert_values("tes",data)
+
+
+
+asyncio.run(main())
+
+```
+
+
+
+
+
+# select database 
+| user_rt | password_rt |    email_rt    |
+| -----   | -----       | -------------- |
+| test1   |    12341    | test1@mail.com |
+| test2   |    12342    | test2@mail.com |
+| test3   |    12343    | test3@mail.com |
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_all("tes",["user_rt","password_rt","email_rt"])
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+
+
+```
+# output 
+```json
+[
+{'user_rt': 'test1', 'password_rt': '12341', 'email_rt': 'test1@mail.com'},
+{'user_rt': 'test2', 'password_rt': '12342', 'email_rt': 'test2@mail.com'},
+{'user_rt': 'test3', 'password_rt': '12343', 'email_rt': 'test3@mail.com'}
+ ]
+ ```
+
+
+SELECT ONE ROW
+
+```python
+from orm_database import MariaDB
+import asyncio
+from pydantic import BaseModel , Field
+
+
+db = MariaDB(host="127.0.0.1",database="login",password="12341234",port=3306,user="root")
+
+class users(BaseModel):
+    user_rt : str = Field(varchar=20)
+    password_rt : str = Field(varchar=20)
+    email_rt : str = Field(varchar=20)
+
+
+async def main():
+
+    await db.start()
+    test = await db.select_columns("tes",{"user_rt":"test1"})
+    print(test)
+
+
+
+
+asyncio.run(main())
+
+```
+
+output
+
+```
+('test1', '12341', 'test1@mail.com')
+```

{orm_database-0.3.10 → orm_database-0.3.11}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
    name='orm_database',
-   version='0.3.10',
+   version='0.3.11',
    description='This module is written to launch your programs with any database you want in the shortest time ',
    license="MIT",
    author='SISRSIS',

orm_database-0.3.10/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.2
-Name: orm_database
-Version: 0.3.10
-Summary: This module is written to launch your programs with any database you want in the shortest time 
-Home-page: https://github.com/sisrsis/orm-database
-Author: SISRSIS
-Author-email: virussisrsis@gmail.com
-License: MIT
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: asyncpg
-Requires-Dist: motor
-Requires-Dist: mariadb
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
-
-# Create table
-
-```python
-from orm_database import PostgreSQL
-from pydantic import BaseModel
-import asyncio
-
-
-class User(BaseModel):
-    username: str
-    password: str
-    email: str
-
-
-async def main():
-    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
-    await db.start()
-    
-    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
-    
-    await db.table_create_BaseModel(table="users", class_BaseModel=User)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## create table mariadb baseModel
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-from pydantic import BaseModel , Field
-
-
-db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
-
-class users(BaseModel):
-    user_rt : str = Field(varchar=20)
-    password_rt : str = Field(varchar=20)
-    email_rt : str = Field(varchar=20)
-
-
-async def main():
-    await db.start()
-    await db.teble_create_BaseModel("tes",users)
-
-
-asyncio.run(main())
-
-```
-
-## create table mariadb
-
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-
-
-db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
-
-
-
-
-async def main():
-    await db.start()
-    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
-
-
-asyncio.run(main())
-```
-
-`test` name table
-
-| name     |   field     |
-| -------- | ----------- |
-| username | varchar(250)|
-| email    | varchar(250)|
-| old      |    int      |
-
-
-
-
-

orm_database-0.3.10/README.md

@@ -1,87 +0,0 @@
-# Create table
-
-```python
-from orm_database import PostgreSQL
-from pydantic import BaseModel
-import asyncio
-
-
-class User(BaseModel):
-    username: str
-    password: str
-    email: str
-
-
-async def main():
-    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
-    await db.start()
-    
-    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
-    
-    await db.table_create_BaseModel(table="users", class_BaseModel=User)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## create table mariadb baseModel
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-from pydantic import BaseModel , Field
-
-
-db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
-
-class users(BaseModel):
-    user_rt : str = Field(varchar=20)
-    password_rt : str = Field(varchar=20)
-    email_rt : str = Field(varchar=20)
-
-
-async def main():
-    await db.start()
-    await db.teble_create_BaseModel("tes",users)
-
-
-asyncio.run(main())
-
-```
-
-## create table mariadb
-
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-
-
-db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
-
-
-
-
-async def main():
-    await db.start()
-    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
-
-
-asyncio.run(main())
-```
-
-`test` name table
-
-| name     |   field     |
-| -------- | ----------- |
-| username | varchar(250)|
-| email    | varchar(250)|
-| old      |    int      |
-
-
-
-
-

orm_database-0.3.10/orm_database.egg-info/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.2
-Name: orm_database
-Version: 0.3.10
-Summary: This module is written to launch your programs with any database you want in the shortest time 
-Home-page: https://github.com/sisrsis/orm-database
-Author: SISRSIS
-Author-email: virussisrsis@gmail.com
-License: MIT
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: asyncpg
-Requires-Dist: motor
-Requires-Dist: mariadb
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
-
-# Create table
-
-```python
-from orm_database import PostgreSQL
-from pydantic import BaseModel
-import asyncio
-
-
-class User(BaseModel):
-    username: str
-    password: str
-    email: str
-
-
-async def main():
-    db = PostgreSQL(host="127.0.0.1", user="postgres", password="", database="your_database_name")
-    await db.start()
-    
-    await db.table_create("users", {"username": "varchar", "password": "varchar", "email": "varchar"})
-    
-    await db.table_create_BaseModel(table="users", class_BaseModel=User)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## create table mariadb baseModel
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-from pydantic import BaseModel , Field
-
-
-db = MariaDB(host="127.0.0.1",database="login",password="",port=3306,user="root")
-
-class users(BaseModel):
-    user_rt : str = Field(varchar=20)
-    password_rt : str = Field(varchar=20)
-    email_rt : str = Field(varchar=20)
-
-
-async def main():
-    await db.start()
-    await db.teble_create_BaseModel("tes",users)
-
-
-asyncio.run(main())
-
-```
-
-## create table mariadb
-
-
-
-```python
-from orm_database import MariaDB
-import asyncio
-
-
-db = MariaDB(host="127.0.0.1",database="",password="",port=3306,user="root")
-
-
-
-
-async def main():
-    await db.start()
-    await db.teble_create("test",{"username":"varchar(250)","email":"varchar(250)","old":"int"})
-
-
-asyncio.run(main())
-```
-
-`test` name table
-
-| name     |   field     |
-| -------- | ----------- |
-| username | varchar(250)|
-| email    | varchar(250)|
-| old      |    int      |
-
-
-
-
-