postgresdb3 0.3.5__tar.gz → 0.5.0__tar.gz

postgresdb3-0.5.0/PKG-INFO

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: postgresdb3
+Version: 0.5.0
+Summary: Python uchun oddiy PostgreSQL wrapper
+Author: Abdulbosit Alijonov
+Project-URL: Source Code, https://github.com/AlijonovUz/PostgresDB
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2>=2.9
+Requires-Dist: asyncpg>=0.31.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PostgresDB3
+
+![PyPI Version](https://img.shields.io/pypi/v/postgresdb3)
+![Python Version](https://img.shields.io/pypi/pyversions/postgresdb3)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+**PostgresDB3** — PostgreSQL bilan ishlash uchun oddiy, qulay va yengil Python wrapper.
+Kutubxona sync va async ishlashni qo‘llab-quvvatlaydi hamda sodda ORM imkoniyatlarini ham taqdim etadi.
+
+---
+
+# O‘rnatish
+
+```bash
+pip install postgresdb3
+```
+
+---
+
+# Asosiy imkoniyatlar
+
+* PostgreSQL bilan **sync va async** ishlash
+* CRUD amallari
+* `where`, `join`, `group_by`, `order_by`, `limit`, `offset`
+* `like`, `ilike`, `in`, `isnull`, `gt`, `lt` kabi filterlar
+* Raw SQL bajarish imkoniyati
+* Sodda ORM tizimi
+* Async ORM qo‘llab-quvvatlash
+
+---
+
+# Sync foydalanish
+
+```python
+from postgresdb3 import PostgresDB
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword",
+    host="localhost",
+    port=5432
+)
+
+# Jadval yaratish
+db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+# Bitta qator qo‘shish
+db.insert("users", "name, age", ("Ali", 25))
+
+# Bir nechta qator qo‘shish
+db.insert_many(
+    "users",
+    "name, age",
+    [("Vali", 30), ("Gulnoza", 22), ("Hasan", 28)]
+)
+
+# Barcha ma'lumotlarni olish
+users = db.select("users")
+print(users)
+
+# Faqat kerakli ustunlarni olish
+users = db.select("users", columns=["id", "name"])
+print(users)
+
+# Bitta qatorni olish
+user = db.select("users", where={"name": "Ali"}, fetchone=True)
+print(user)
+
+# Shart bilan qidirish
+adults = db.select("users", where={"age__gt": 18})
+print(adults)
+
+# LIKE qidiruv
+users_like = db.select("users", where={"name__like": "%Ali%"})
+print(users_like)
+
+# ILIKE qidiruv
+users_ilike = db.select("users", where={"name__ilike": "%ali%"})
+print(users_ilike)
+
+# IN operatori
+selected_users = db.select("users", where={"id__in": [1, 2, 3]})
+print(selected_users)
+
+# NULL tekshirish
+users_with_name = db.select("users", where={"name__isnull": False})
+print(users_with_name)
+
+# Tartiblash va limit
+ordered_users = db.select(
+    "users",
+    where={"age__gt": 18},
+    order_by="age DESC",
+    limit=2
+)
+print(ordered_users)
+
+# Pagination
+paged_users = db.select(
+    "users",
+    order_by="id ASC",
+    limit=2,
+    offset=2
+)
+print(paged_users)
+
+# Ma'lumotni yangilash
+db.update("users", "age", 26, "name", "Ali")
+
+# Ma'lumotni o‘chirish
+db.delete("users", "name", "Ali")
+
+# Jadvalni o‘chirish
+db.drop("users", cascade=False)
+
+# Raw SQL bajarish
+result = db.raw("SELECT name, age FROM users WHERE age > %s", [25], fetchall=True)
+print(result)
+
+# Connectionni yopish
+db.close()
+```
+
+---
+
+# Async foydalanish
+
+```python
+import asyncio
+from postgresdb3 import AsyncPostgresDB
+
+async def main():
+    db = AsyncPostgresDB(
+        database="mydb",
+        user="postgres",
+        password="mypassword",
+        host="localhost",
+        port=5432
+    )
+
+    await db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+    await db.insert("users", "name, age", ["Ali", 25])
+
+    await db.insert_many(
+        "users",
+        "name, age",
+        [["Vali", 30], ["Gulnoza", 22], ["Hasan", 28]]
+    )
+
+    users = await db.select("users")
+    print(users)
+
+    user = await db.select("users", where={"name": "Ali"}, fetchone=True)
+    print(user)
+
+    adults = await db.select("users", where={"age__gt": 18})
+    print(adults)
+
+    users_ilike = await db.select("users", where={"name__ilike": "%ali%"})
+    print(users_ilike)
+
+    await db.update("users", "age", 26, "name", "Ali")
+
+    await db.delete("users", "name", "Ali")
+
+    await db.drop("users", cascade=False)
+
+    result = await db.raw(
+        "SELECT name, age FROM users WHERE age > $1",
+        [25],
+        fetchall=True
+    )
+
+    print(result)
+
+    await db.close_pool()
+
+asyncio.run(main())
+```
+
+---
+
+# ORM foydalanish
+
+## Sync ORM
+
+```python
+from postgresdb3 import PostgresDB
+from postgresdb3.orm import Model
+from postgresdb3.orm.fields import Serial, String, Integer, Text
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(Model):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+    about = Text(nullable=True)
+
+User.create_table()
+
+user = User.create(name="Ali", age=20)
+
+print(User.all())
+
+user = User.find(1)
+
+user.update(name="Valijon")
+
+user.delete()
+```
+
+---
+
+# Qo‘shimcha
+
+`%s` va `$1` bilan parametrizatsiya qilish xavfsiz va SQL injection'dan himoya qiladi.
+
+`where` va `join` yordamida murakkab so‘rovlar yozish mumkin.
+
+`limit`, `offset` va `order_by` parametrlaridan foydalanib ma'lumotlarni tartiblash va sahifalash oson.
+
+`raw()` metodi orqali kerak bo‘lganda to‘g‘ridan-to‘g‘ri SQL so‘rov yozish mumkin.
+

postgresdb3-0.5.0/README.md

@@ -0,0 +1,233 @@
+# PostgresDB3
+
+![PyPI Version](https://img.shields.io/pypi/v/postgresdb3)
+![Python Version](https://img.shields.io/pypi/pyversions/postgresdb3)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+**PostgresDB3** — PostgreSQL bilan ishlash uchun oddiy, qulay va yengil Python wrapper.
+Kutubxona sync va async ishlashni qo‘llab-quvvatlaydi hamda sodda ORM imkoniyatlarini ham taqdim etadi.
+
+---
+
+# O‘rnatish
+
+```bash
+pip install postgresdb3
+```
+
+---
+
+# Asosiy imkoniyatlar
+
+* PostgreSQL bilan **sync va async** ishlash
+* CRUD amallari
+* `where`, `join`, `group_by`, `order_by`, `limit`, `offset`
+* `like`, `ilike`, `in`, `isnull`, `gt`, `lt` kabi filterlar
+* Raw SQL bajarish imkoniyati
+* Sodda ORM tizimi
+* Async ORM qo‘llab-quvvatlash
+
+---
+
+# Sync foydalanish
+
+```python
+from postgresdb3 import PostgresDB
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword",
+    host="localhost",
+    port=5432
+)
+
+# Jadval yaratish
+db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+# Bitta qator qo‘shish
+db.insert("users", "name, age", ("Ali", 25))
+
+# Bir nechta qator qo‘shish
+db.insert_many(
+    "users",
+    "name, age",
+    [("Vali", 30), ("Gulnoza", 22), ("Hasan", 28)]
+)
+
+# Barcha ma'lumotlarni olish
+users = db.select("users")
+print(users)
+
+# Faqat kerakli ustunlarni olish
+users = db.select("users", columns=["id", "name"])
+print(users)
+
+# Bitta qatorni olish
+user = db.select("users", where={"name": "Ali"}, fetchone=True)
+print(user)
+
+# Shart bilan qidirish
+adults = db.select("users", where={"age__gt": 18})
+print(adults)
+
+# LIKE qidiruv
+users_like = db.select("users", where={"name__like": "%Ali%"})
+print(users_like)
+
+# ILIKE qidiruv
+users_ilike = db.select("users", where={"name__ilike": "%ali%"})
+print(users_ilike)
+
+# IN operatori
+selected_users = db.select("users", where={"id__in": [1, 2, 3]})
+print(selected_users)
+
+# NULL tekshirish
+users_with_name = db.select("users", where={"name__isnull": False})
+print(users_with_name)
+
+# Tartiblash va limit
+ordered_users = db.select(
+    "users",
+    where={"age__gt": 18},
+    order_by="age DESC",
+    limit=2
+)
+print(ordered_users)
+
+# Pagination
+paged_users = db.select(
+    "users",
+    order_by="id ASC",
+    limit=2,
+    offset=2
+)
+print(paged_users)
+
+# Ma'lumotni yangilash
+db.update("users", "age", 26, "name", "Ali")
+
+# Ma'lumotni o‘chirish
+db.delete("users", "name", "Ali")
+
+# Jadvalni o‘chirish
+db.drop("users", cascade=False)
+
+# Raw SQL bajarish
+result = db.raw("SELECT name, age FROM users WHERE age > %s", [25], fetchall=True)
+print(result)
+
+# Connectionni yopish
+db.close()
+```
+
+---
+
+# Async foydalanish
+
+```python
+import asyncio
+from postgresdb3 import AsyncPostgresDB
+
+async def main():
+    db = AsyncPostgresDB(
+        database="mydb",
+        user="postgres",
+        password="mypassword",
+        host="localhost",
+        port=5432
+    )
+
+    await db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+    await db.insert("users", "name, age", ["Ali", 25])
+
+    await db.insert_many(
+        "users",
+        "name, age",
+        [["Vali", 30], ["Gulnoza", 22], ["Hasan", 28]]
+    )
+
+    users = await db.select("users")
+    print(users)
+
+    user = await db.select("users", where={"name": "Ali"}, fetchone=True)
+    print(user)
+
+    adults = await db.select("users", where={"age__gt": 18})
+    print(adults)
+
+    users_ilike = await db.select("users", where={"name__ilike": "%ali%"})
+    print(users_ilike)
+
+    await db.update("users", "age", 26, "name", "Ali")
+
+    await db.delete("users", "name", "Ali")
+
+    await db.drop("users", cascade=False)
+
+    result = await db.raw(
+        "SELECT name, age FROM users WHERE age > $1",
+        [25],
+        fetchall=True
+    )
+
+    print(result)
+
+    await db.close_pool()
+
+asyncio.run(main())
+```
+
+---
+
+# ORM foydalanish
+
+## Sync ORM
+
+```python
+from postgresdb3 import PostgresDB
+from postgresdb3.orm import Model
+from postgresdb3.orm.fields import Serial, String, Integer, Text
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(Model):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+    about = Text(nullable=True)
+
+User.create_table()
+
+user = User.create(name="Ali", age=20)
+
+print(User.all())
+
+user = User.find(1)
+
+user.update(name="Valijon")
+
+user.delete()
+```
+
+---
+
+# Qo‘shimcha
+
+`%s` va `$1` bilan parametrizatsiya qilish xavfsiz va SQL injection'dan himoya qiladi.
+
+`where` va `join` yordamida murakkab so‘rovlar yozish mumkin.
+
+`limit`, `offset` va `order_by` parametrlaridan foydalanib ma'lumotlarni tartiblash va sahifalash oson.
+
+`raw()` metodi orqali kerak bo‘lganda to‘g‘ridan-to‘g‘ri SQL so‘rov yozish mumkin.
+

postgresdb3-0.5.0/postgresdb3/__init__.py

@@ -0,0 +1 @@
+from .core import PostgresDB, AsyncPostgresDB

{postgresdb3-0.3.5/postgresdb3 → postgresdb3-0.5.0/postgresdb3/core}/async_db.py

@@ -95,11 +95,171 @@ class AsyncPostgresDB:
 
         await self._manager(sql, commit=True)
 
+    def _validate_identifier(self, value: str, name: str = "identifier") -> str:
+        """
+        Jadval yoki ustun nomi uchun minimal tekshiruv.
+        Faqat harf, raqam, underscore va nuqtaga ruxsat beradi.
+        """
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"{name} bo'sh bo'lmasligi kerak")
+
+        cleaned = value.replace("_", "").replace(".", "")
+        if not cleaned.isalnum():
+            raise ValueError(f"Invalid {name}: {value}")
+
+        return value
+
+    def _normalize_columns(self, columns: str | list[str]) -> str:
+        """
+        columns list bo'lsa stringga aylantiradi.
+        list bo'lsa har bir column validate qilinadi.
+        str bo'lsa SQL expression bo'lishi mumkinligi uchun o'z holicha qaytariladi.
+        """
+        if isinstance(columns, list):
+            if not columns:
+                raise ValueError("columns bo'sh list bo'lmasligi kerak")
+
+            validated_columns = [self._validate_identifier(col, "column") for col in columns]
+            return ", ".join(validated_columns)
+
+        if not isinstance(columns, str) or not columns.strip():
+            raise ValueError("columns noto'g'ri bo'lishi mumkin emas")
+
+        return columns
+
+    def _build_where(self, where: Any, start_index: int = 1) -> tuple[str, list]:
+        """
+        Qo'llab-quvvatlanadi:
+
+        1) tuple:
+           ("age > $1", [18])
+
+        2) dict:
+           {
+               "age__gt": 18,
+               "name__ilike": "%ali%",
+               "status": "active",
+               "id__in": [1, 2, 3],
+               "deleted_at__isnull": True
+           }
+
+        3) list[tuple]:
+           [
+               ("age", ">", 18),
+               ("name", "ILIKE", "%ali%"),
+               ("status", "=", "active")
+           ]
+        """
+        if where is None:
+            return "", []
+
+        if isinstance(where, tuple) and len(where) == 2:
+            condition, values = where
+            return condition, list(values)
+
+        if isinstance(where, dict):
+            clauses = []
+            params = []
+            index = start_index
+
+            operator_map = {
+                "eq": "=",
+                "ne": "!=",
+                "gt": ">",
+                "gte": ">=",
+                "lt": "<",
+                "lte": "<=",
+                "like": "LIKE",
+                "ilike": "ILIKE",
+            }
+
+            for key, value in where.items():
+                if "__" in key:
+                    field, op = key.rsplit("__", 1)
+                else:
+                    field, op = key, "eq"
+
+                self._validate_identifier(field, "where field")
+
+                if op in operator_map:
+                    clauses.append(f"{field} {operator_map[op]} ${index}")
+                    params.append(value)
+                    index += 1
+
+                elif op == "in":
+                    if not isinstance(value, (list, tuple)) or not value:
+                        raise ValueError(f"{field}__in uchun bo'sh bo'lmagan list/tuple kerak")
+
+                    placeholders = ", ".join(f"${i}" for i in range(index, index + len(value)))
+                    clauses.append(f"{field} IN ({placeholders})")
+                    params.extend(value)
+                    index += len(value)
+
+                elif op == "not_in":
+                    if not isinstance(value, (list, tuple)) or not value:
+                        raise ValueError(f"{field}__not_in uchun bo'sh bo'lmagan list/tuple kerak")
+
+                    placeholders = ", ".join(f"${i}" for i in range(index, index + len(value)))
+                    clauses.append(f"{field} NOT IN ({placeholders})")
+                    params.extend(value)
+                    index += len(value)
+
+                elif op == "isnull":
+                    if value:
+                        clauses.append(f"{field} IS NULL")
+                    else:
+                        clauses.append(f"{field} IS NOT NULL")
+
+                else:
+                    raise ValueError(f"Noma'lum operator: {op}")
+
+            return " AND ".join(clauses), params
+
+        if isinstance(where, list):
+            clauses = []
+            params = []
+            index = start_index
+
+            for item in where:
+                if len(item) != 3:
+                    raise ValueError("List formatidagi where elementlari (field, operator, value) bo'lishi kerak")
+
+                field, operator, value = item
+                self._validate_identifier(field, "where field")
+                op = operator.upper()
+
+                if op in {"=", "!=", ">", ">=", "<", "<=", "LIKE", "ILIKE"}:
+                    clauses.append(f"{field} {op} ${index}")
+                    params.append(value)
+                    index += 1
+
+                elif op in {"IN", "NOT IN"}:
+                    if not isinstance(value, (list, tuple)) or not value:
+                        raise ValueError(f"{field} {op} uchun bo'sh bo'lmagan list/tuple kerak")
+
+                    placeholders = ", ".join(f"${i}" for i in range(index, index + len(value)))
+                    clauses.append(f"{field} {op} ({placeholders})")
+                    params.extend(value)
+                    index += len(value)
+
+                elif op == "IS NULL":
+                    clauses.append(f"{field} IS NULL")
+
+                elif op == "IS NOT NULL":
+                    clauses.append(f"{field} IS NOT NULL")
+
+                else:
+                    raise ValueError(f"Noma'lum operator: {operator}")
+
+            return " AND ".join(clauses), params
+
+        raise TypeError("where tuple, dict yoki list bo'lishi kerak")
+
     async def select(
             self,
             table: str,
-            columns: str = "*",
-            where: Optional[List[Any]] = None,
+            columns: str | list[str] = "*",
+            where: tuple | dict | list | None = None,
             join: Optional[List[tuple]] = None,
             group_by: Optional[str] = None,
             order_by: Optional[str] = None,
@@ -112,8 +272,11 @@ class AsyncPostgresDB:
 
         Args:
             table (str): Asosiy jadval nomi.
-            columns (str): Tanlanadigan ustunlar (default: "*").
-            where (Optional[List[Any]]): ("shart", [qiymatlar])
+            columns (str | list[str]): Tanlanadigan ustunlar.
+            where:
+                tuple — ("age > $1", [18])
+                dict  — {"age__gt": 18, "name__ilike": "%ali%"}
+                list  — [("age", ">", 18), ("name", "ILIKE", "%ali%")]
             join (Optional[List[tuple]]): [("INNER JOIN", "orders", "users.id = orders.user_id")]
             group_by (Optional[str]): GROUP BY ustuni.
             order_by (Optional[str]): ORDER BY qoidasi.
@@ -124,17 +287,22 @@ class AsyncPostgresDB:
         Returns:
             asyncpg.Record yoki list[asyncpg.Record]
         """
+        table = self._validate_identifier(table, "table")
+        columns = self._normalize_columns(columns)
+
         sql = f"SELECT {columns} FROM {table}"
         params: List[Any] = []
 
         if join:
             for join_type, join_table, on_condition in join:
+                join_table = self._validate_identifier(join_table, "join table")
                 sql += f" {join_type} {join_table} ON {on_condition}"
 
         if where:
-            condition, values = where
-            sql += f" WHERE {condition}"
-            params.extend(values)
+            condition, values = self._build_where(where, start_index=1)
+            if condition:
+                sql += f" WHERE {condition}"
+                params.extend(values)
 
         if group_by:
             sql += f" GROUP BY {group_by}"
@@ -143,11 +311,11 @@ class AsyncPostgresDB:
             sql += f" ORDER BY {order_by}"
 
         if limit is not None:
-            sql += f" LIMIT $%d" % (len(params) + 1)
+            sql += f" LIMIT ${len(params) + 1}"
             params.append(limit)
 
         if offset is not None:
-            sql += " OFFSET $%d" % (len(params) + 1)
+            sql += f" OFFSET ${len(params) + 1}"
             params.append(offset)
 
         return await self._manager(sql, *params, fetchone=fetchone, fetchall=not fetchone)