postgresdb3 0.2.2__tar.gz → 0.3.0__tar.gz

{postgresdb3-0.2.2 → postgresdb3-0.3.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: postgresdb3
-Version: 0.2.2
+Version: 0.3.0
 Summary: Python uchun oddiy PostgreSQL wrapper
-Home-page: https://github.com/AlijonovUz/PostgresDB
 Author: Abdulbosit Alijonov
+Project-URL: Source Code, https://github.com/AlijonovUz/PostgresDB
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -15,7 +15,7 @@ Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
-Dynamic: home-page
+Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -31,7 +31,7 @@ Oddiy va qulay Python wrapper PostgreSQL bazasi bilan ishlash uchun.
 ## O'rnatish
 
 ``` bash
-    pip install postgresdb3
+pip install postgresdb3
 ```
 
 ## Foydalanish (Sync)

{postgresdb3-0.2.2 → postgresdb3-0.3.0}/README.md

@@ -9,7 +9,7 @@ Oddiy va qulay Python wrapper PostgreSQL bazasi bilan ishlash uchun.
 ## O'rnatish
 
 ``` bash
-    pip install postgresdb3
+pip install postgresdb3
 ```
 
 ## Foydalanish (Sync)

{postgresdb3-0.2.2 → postgresdb3-0.3.0}/postgresdb3/async_db.py

@@ -11,7 +11,7 @@ class AsyncPostgresDB:
     Aiogram kabi async frameworklar bilan to‘g‘ridan-to‘g‘ri ishlash uchun mos.
     """
 
-    def __init__(self, database: str, user: str, password: str, host: str = "localhost", port: int = 5432):
+    def __init__(self, database: str, user: str, password: str, host: str = "localhost", port: int = 5432) -> None:
         """
         PostgreSQL bazasiga ulanishni tayyorlaydi.
 
@@ -29,7 +29,7 @@ class AsyncPostgresDB:
         self.port = port
         self.pool: Optional[asyncpg.pool.Pool] = None
 
-    async def manager(self, sql: str, *params, fetchone=False, fetchall=False, commit=False):
+    async def _manager(self, sql: str, *params, fetchone=False, fetchall=False, commit=False) -> Any:
         """
         Markaziy metod: barcha SQL so‘rovlarni bajaradi.
 
@@ -63,7 +63,7 @@ class AsyncPostgresDB:
             if fetchall:
                 return await conn.fetch(sql, *params)
 
-    async def close_pool(self):
+    async def close_pool(self) -> None:
         """
         Connection poolni yopadi.
         """
@@ -71,7 +71,7 @@ class AsyncPostgresDB:
             await self.pool.close()
             self.pool = None
 
-    async def create(self, table: str, columns: str):
+    async def create(self, table: str, columns: str) -> None:
         """
         Jadval yaratadi (agar mavjud bo‘lsa o‘tkazib yuboradi).
 
@@ -79,26 +79,26 @@ class AsyncPostgresDB:
             table (str): Jadval nomi.
             columns (str): Ustunlar va turlari, misol: "id SERIAL PRIMARY KEY, name TEXT".
         """
-        await self.manager(f"CREATE TABLE IF NOT EXISTS {table} ({columns})", commit=True)
+        await self._manager(f"CREATE TABLE IF NOT EXISTS {table} ({columns})", commit=True)
 
-    async def drop(self, table: str):
+    async def drop(self, table: str) -> None:
         """
         Jadvalni o‘chiradi (agar mavjud bo‘lsa).
 
         Args:
             table (str): Jadval nomi.
         """
-        await self.manager(f"DROP TABLE IF EXISTS {table} CASCADE", commit=True)
+        await self._manager(f"DROP TABLE IF EXISTS {table} CASCADE", commit=True)
 
     async def select(
-        self, table: str, columns: str = "*",
-        where: Optional[List[Any]] = None,
-        join: Optional[List[tuple]] = None,
-        group_by: Optional[str] = None,
-        order_by: Optional[str] = None,
-        limit: Optional[int] = None,
-        fetchone: bool = False
-    ):
+            self, table: str, columns: str = "*",
+            where: Optional[List[Any]] = None,
+            join: Optional[List[tuple]] = None,
+            group_by: Optional[str] = None,
+            order_by: Optional[str] = None,
+            limit: Optional[int] = None,
+            fetchone: bool = False
+    ) -> Any:
         """
         Jadvaldan ma'lumotlarni tanlash.
 
@@ -137,9 +137,9 @@ class AsyncPostgresDB:
             sql += f" LIMIT $%d" % (len(params) + 1)
             params.append(limit)
 
-        return await self.manager(sql, *params, fetchone=fetchone, fetchall=not fetchone)
+        return await self._manager(sql, *params, fetchone=fetchone, fetchall=not fetchone)
 
-    async def insert(self, table: str, columns: str, values: List[Any]):
+    async def insert(self, table: str, columns: str, values: List[Any]) -> None:
         """
         Jadvalga yangi qator qo‘shadi.
 
@@ -148,11 +148,52 @@ class AsyncPostgresDB:
             columns (str): Ustunlar nomi, misol: "name, age".
             values (List[Any]): Qiymatlar, misol: ["Ali", 25].
         """
-        placeholders = ", ".join(f"${i+1}" for i in range(len(values)))
+        placeholders = ", ".join(f"${i + 1}" for i in range(len(values)))
         sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
-        await self.manager(sql, *values, commit=True)
+        await self._manager(sql, *values, commit=True)
 
-    async def update(self, table: str, set_column: str, set_value: Any, where_column: str, where_value: Any):
+    async def insert_many(self, table: str, columns: str, values_list: List[List[Any]]) -> None:
+        """
+        Jadvalga bir nechta qator qo‘shish (bulk insert).
+
+        Args:
+            table (str): Jadval nomi.
+            columns (str): Ustunlar nomi, misol: "name, age".
+            values_list (List[List[Any]]): Qiymatlar ro‘yxati, misol: [["Ali", 25], ["Vali", 30]].
+
+        Raises:
+            ValueError: Agar `values_list` bo‘sh bo‘lsa.
+
+        Notes:
+            - `asyncpg` kutubxonasida har bir parametr uchun unikal `$n` indekslari kerak,
+              shuning uchun har bir qator uchun ketma-ket `$1, $2, ...` ishlatiladi.
+            - Metod barcha qatorlarni bir so‘rovda qo‘shadi.
+            - `fetchmany` kerak emas, chunki bu insert operatsiyasi natija qaytarmaydi.
+
+        Example:
+            await db.insert_many(
+                "users",
+                "name, age",
+                [["Ali", 25], ["Vali", 30], ["Guli", 22]]
+            )
+        """
+        if not values_list:
+            raise ValueError("values_list bo'sh bo'lishi mumkin emas")
+
+        placeholders_list = []
+        flat_values = []
+        counter = 1
+
+        for values in values_list:
+            placeholders = ", ".join(f"${i}" for i in range(counter, counter + len(values)))
+            placeholders_list.append(f"({placeholders})")
+            flat_values.extend(values)
+            counter += len(values)
+
+        sql = f"INSERT INTO {table} ({columns}) VALUES {', '.join(placeholders_list)}"
+        await self._manager(sql, *flat_values, commit=True)
+
+    async def update(self, table: str, set_column: str, set_value: Any, where_column: str, where_value: Any) -> None:
         """
         Jadvaldagi qatorni yangilaydi.
 
@@ -164,9 +205,9 @@ class AsyncPostgresDB:
             where_value (Any): Filtrlash qiymati.
         """
         sql = f"UPDATE {table} SET {set_column} = $1 WHERE {where_column} = $2"
-        await self.manager(sql, set_value, where_value, commit=True)
+        await self._manager(sql, set_value, where_value, commit=True)
 
-    async def delete(self, table: str, where_column: str, where_value: Any):
+    async def delete(self, table: str, where_column: str, where_value: Any) -> None:
         """
         Jadvaldan qator o‘chiradi.
 
@@ -176,7 +217,7 @@ class AsyncPostgresDB:
             where_value (Any): Filtrlash qiymati.
         """
         sql = f"DELETE FROM {table} WHERE {where_column} = $1"
-        await self.manager(sql, where_value, commit=True)
+        await self._manager(sql, where_value, commit=True)
 
     async def list_tables(self, schema: str = "public") -> List[str]:
         """
@@ -189,15 +230,15 @@ class AsyncPostgresDB:
             List[str]: Jadval nomlari
         """
         sql = """
-            SELECT table_name
-            FROM information_schema.tables
-            WHERE table_schema = $1
-            ORDER BY table_name
-        """
-        result = await self.manager(sql, schema, fetchall=True)
+              SELECT table_name
+              FROM information_schema.tables
+              WHERE table_schema = $1
+              ORDER BY table_name \
+              """
+        result = await self._manager(sql, schema, fetchall=True)
         return [r["table_name"] for r in result]
 
-    async def describe_table(self, table: str, schema: str = "public"):
+    async def describe_table(self, table: str, schema: str = "public") -> List[str]:
         """
         Jadval ustunlari haqida ma'lumot beradi.
 
@@ -209,14 +250,15 @@ class AsyncPostgresDB:
             list[asyncpg.Record]: Har bir ustun bo‘yicha ma’lumot
         """
         sql = """
-            SELECT column_name, data_type, is_nullable, column_default
-            FROM information_schema.columns
-            WHERE table_schema = $1 AND table_name = $2
-            ORDER BY ordinal_position
-        """
-        return await self.manager(sql, schema, table, fetchall=True)
-
-    async def alter(self, table: str, action: str):
+              SELECT column_name, data_type, is_nullable, column_default
+              FROM information_schema.columns
+              WHERE table_schema = $1
+                AND table_name = $2
+              ORDER BY ordinal_position \
+              """
+        return await self._manager(sql, schema, table, fetchall=True)
+
+    async def alter(self, table: str, action: str) -> None:
         """
         Jadval strukturasi o‘zgartirish (ALTER TABLE).
 
@@ -225,4 +267,4 @@ class AsyncPostgresDB:
             action (str): ALTER TABLE dan keyingi SQL qismi, misol: "ADD COLUMN age INT".
         """
         sql = f"ALTER TABLE {table} {action}"
-        await self.manager(sql, commit=True)
+        await self._manager(sql, commit=True)

postgresdb3-0.3.0/postgresdb3/sync_db.py

@@ -0,0 +1,344 @@
+from typing import Any
+import psycopg2
+
+
+class PostgresDB:
+
+    def __init__(self, database: str, user: str, password: str, host: str = "localhost", port: int = 5432) -> None:
+        """
+        PostgreSQL bazasiga ulanish.
+
+        Parametrlar:
+            database (str): Bazaning nomi
+            user (str): Foydalanuvchi
+            password (str): Parol
+            host (str): Server manzili (standart = localhost)
+            port (int): Port (standart = 5432)
+        """
+        self.connection = psycopg2.connect(
+            database=database, user=user, password=password, host=host, port=port
+        )
+
+    def _manager(
+            self,
+            sql: str,
+            params: list | tuple | None = None,
+            *,
+            commit: bool = False,
+            many: bool = False,
+            fetchone: bool = False,
+            fetchall: bool = False,
+            fetchmany: int | None = None
+    ) -> Any:
+        """
+        SQL so'rovlarini xavfsiz bajaruvchi yagona, ichki metod.
+
+        Bu metod **protected** bo‘lib, tashqaridan ishlatish tavsiya etilmaydi.
+        Public uchun `raw()` metodini ishlatish yaxshiroq.
+
+        Parametrlar
+        ----------
+        sql : str
+            Bajariladigan SQL so'rov. Majburiy.
+        params : tuple, list yoki None, ixtiyoriy
+            SQL so‘rovga parametrlarni bog‘lash uchun ishlatiladi. Default: None.
+            Agar `many=True` bo‘lsa, bu **tuple lar ro‘yxati** bo‘lishi kerak.
+        commit : bool, ixtiyoriy
+            Agar True bo‘lsa, tranzaksiya bajarilgandan keyin commit qilinadi.
+            Default: False. INSERT, UPDATE, DELETE kabi so‘rovlar uchun kerak.
+        many : bool, ixtiyoriy
+            Agar True bo‘lsa, so‘rovni bir nechta parametrlar bilan qayta bajaradi
+            (`cursor.executemany()` ishlatiladi). Default: False.
+            `fetchone`, `fetchall` yoki `fetchmany` bilan birga ishlatilmaydi.
+        fetchone : bool, ixtiyoriy
+            Agar True bo‘lsa, so‘rov natijasidan faqat bitta qator qaytariladi.
+            Default: False. `fetchall`, `fetchmany` yoki `many=True` bilan ishlamaydi.
+        fetchall : bool, ixtiyoriy
+            Agar True bo‘lsa, so‘rov natijasidagi barcha qatorlar qaytariladi.
+            Default: False. `fetchone`, `fetchmany` yoki `many=True` bilan ishlamaydi.
+        fetchmany : int yoki None, ixtiyoriy
+            Agar butun son N berilsa, so‘rov natijasidan N ta qator qaytariladi.
+            Default: None. `fetchone`, `fetchall` yoki `many=True` bilan ishlamaydi.
+
+        Returns
+        -------
+        result : any
+            So‘rov natijasi fetch parametriga bog‘liq:
+            - `fetchone=True` → bitta qator (tuple)
+            - `fetchall=True` → barcha qatorlar ro‘yxati
+            - `fetchmany=N` → N ta qator ro‘yxati
+            - `many=True` → None
+            - Fetch parametri ishlatilmasa → None
+
+        Raises
+        ------
+        ValueError
+            - Agar `sql` bo‘sh yoki None bo‘lsa.
+            - Agar bir vaqtda `fetchone` va `fetchall` True bo‘lsa.
+            - Agar `many=True` fetch parametrlar bilan birga ishlatilsa.
+
+        Izohlar
+        --------
+        - Bu metod connection va cursor ni context manager orqali avtomatik boshqaradi.
+        - Exceptionlar va tranzaksiya nazorati psycopg2 tomonidan amalga oshiriladi.
+        - Tashqarida ishlatishda `raw()` yoki yuqori darajadagi metodlar (`insert()`, `select()`, `insert_many()`) ishlatilishi tavsiya etiladi.
+        - Tashqaridan bevosita chaqirish tavsiya etilmaydi.
+        """
+
+        if fetchone and fetchall:
+            raise ValueError("fetchone and fetchall cannot be True at the same time")
+        if many and (fetchone or fetchall or fetchmany):
+            raise ValueError("cannot use fetchone/fetchall/fetchmany with many=True")
+
+        with self.connection.cursor() as cursor:
+            if many:
+                cursor.executemany(sql, params)
+                result = None
+            else:
+                cursor.execute(sql, params)
+                if fetchone:
+                    result = cursor.fetchone()
+                elif fetchall:
+                    result = cursor.fetchall()
+                elif fetchmany is not None:
+                    result = cursor.fetchmany(fetchmany)
+                else:
+                    result = None
+
+            if commit:
+                self.connection.commit()
+
+        return result
+
+    def close(self) -> None:
+        self.connection.close()
+
+    def raw(
+            self,
+            sql: str,
+            params: list | tuple | None = None,
+            *,
+            commit: bool = False,
+            many: bool = False,
+            fetchone: bool = False,
+            fetchall: bool = False,
+            fetchmany: int | None = None
+    ) -> Any:
+        """
+        SQL so'rovini bevosita bajarish (raw execution).
+
+        Faqat ilg'or foydalanish uchun. Bu metod ichki `_manager` metodini chaqiradi.
+        Tashqaridan oddiy foydalanuvchilar uchun `select()`, `insert()`, `update()`,
+        `delete()` yoki `insert_many()` metodlarini ishlatish tavsiya etiladi.
+
+        Parametrlar
+        ----------
+        sql : str
+            Bajariladigan SQL so'rov. Majburiy.
+        params : tuple, list yoki None, ixtiyoriy
+            SQL so‘rovga parametrlarni bog‘lash uchun ishlatiladi. Default: None.
+        commit : bool, ixtiyoriy
+            Agar True bo‘lsa, tranzaksiya bajarilgandan keyin commit qilinadi.
+            Default: False.
+        fetchone : bool, ixtiyoriy
+            Agar True bo‘lsa, so‘rov natijasidan faqat bitta qator qaytariladi.
+            Default: False. `fetchall` bilan birga ishlatilmaydi.
+        fetchall : bool, ixtiyoriy
+            Agar True bo‘lsa, so‘rov natijasidagi barcha qatorlar qaytariladi.
+            Default: False. `fetchone` bilan birga ishlatilmaydi.
+
+        Returns
+        -------
+        result : any
+            So‘rov natijasi fetch parametriga bog‘liq:
+            - `fetchone=True` → bitta qator (tuple)
+            - `fetchall=True` → barcha qatorlar ro‘yxati
+            - Hech qaysi fetch parametr ishlatilmasa → None
+
+        Raises
+        ------
+        ValueError
+            - Agar bir vaqtda `fetchone` va `fetchall` True bo‘lsa.
+
+        Misol
+        ------
+        >>> db.raw("SELECT * FROM users WHERE age > %s", (18,), fetchall=True)
+        """
+        if fetchone and fetchall:
+            raise ValueError("fetchone va fetchall bir vaqtda True bo‘la olmaydi")
+
+        return self._manager(
+            sql,
+            params,
+            commit=commit,
+            many=many,
+            fetchone=fetchone,
+            fetchall=fetchall,
+            fetchmany=fetchmany,
+        )
+
+    def create(self, table: str, columns: str) -> None:
+        """
+        table: str - jadval nomi
+        columns: str - ustunlar va turlari, misol: "id SERIAL PRIMARY KEY, name VARCHAR(100)"
+        """
+        sql = f"CREATE TABLE IF NOT EXISTS {table} ({columns})"
+        self._manager(sql, commit=True)
+
+    def drop(self, table: str) -> None:
+        """
+        table: str - o'chiriladigan jadval nomi
+        """
+        sql = f"DROP TABLE IF EXISTS {table} CASCADE"
+        self._manager(sql, commit=True)
+
+    def select(
+            self,
+            table: str,
+            columns: str = "*",
+            where: tuple | None = None,
+            join: list[tuple] | None = None,
+            group_by: str | None = None,
+            order_by: str | None = None,
+            limit: int | None = None,
+            fetchone: bool = False
+    ) -> Any:
+        """
+        table: str — asosiy jadval
+        columns: str — tanlanadigan ustunlar ("id, name")
+        where: tuple | None — ("age > %s", [18])
+        join: list | None — [("INNER JOIN", "orders", "users.id = orders.user_id")]
+        group_by: str | None — "age"
+        order_by: str | None — "age DESC"
+        limit: int | None
+        """
+
+        sql = f"SELECT {columns} FROM {table}"
+        params = []
+
+        if join:
+            for join_type, join_table, on_condition in join:
+                sql += f" {join_type} {join_table} ON {on_condition}"
+
+        if where:
+            condition, values = where
+            sql += f" WHERE {condition}"
+            params.extend(values)
+
+        if group_by:
+            sql += f" GROUP BY {group_by}"
+
+        if order_by:
+            sql += f" ORDER BY {order_by}"
+
+        if limit:
+            sql += f" LIMIT %s"
+            params.append(limit)
+
+        if fetchone:
+            return self._manager(sql, params, fetchone=True)
+        return self._manager(sql, params, fetchall=True)
+
+    def insert(self, table: str, columns: str, values: tuple | list) -> None:
+        """
+        table: str - jadval nomi
+        columns: str - ustunlar, misol: "name, email, age"
+        values: tuple yoki list - ustun qiymatlari, misol: ("Ali", "ali@mail.com", 25)
+        """
+        placeholders = ", ".join(["%s"] * len(values))
+        sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
+        self._manager(sql, values, commit=True)
+
+    def insert_many(self, table: str, columns: str, values_list: list[tuple]) -> None:
+        """
+        Jadvalga bir nechta qatorni qo'shish (bulk insert).
+
+        Parametrlar
+        ----------
+        table : str
+            Jadval nomi.
+        columns : str
+            Ustunlar, misol: "name, email, age".
+        values_list : list of tuples
+            Har tuple bitta qator qiymatlari, misol:
+            [("Ali", "ali@mail.com", 25), ("Vali", "vali@mail.com", 30)]
+
+        Misol
+        ------
+        >>> db.insert_many(
+        ...     "users",
+        ...     "name, email, age",
+        ...     [("Ali", "ali@mail.com", 25), ("Vali", "vali@mail.com", 30)]
+        ... )
+        """
+        if not values_list:
+            raise ValueError("values_list bo'sh bo'lishi mumkin emas")
+
+        placeholders = ", ".join(["%s"] * len(values_list[0]))
+        sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
+
+        self._manager(sql, values_list, commit=True, many=True)
+
+    def update(self, table: str, set_column: str, set_value: Any, where_column: str, where_value: Any) -> None:
+        """
+        Jadvaldagi ma'lumotni yangilash.
+
+        Parametrlar:
+            table (str): Jadval nomi.
+            set_column (str): O'zgartiriladigan ustun.
+            set_value (Any): Yangi qiymat.
+            where_column (str): Filtrlash ustuni.
+            where_value (Any): Qaysi qatorda o'zgarish bo'lishi.
+
+        Izoh:
+            Faqat WHERE shartiga mos kelgan qatorlar yangilanadi.
+        """
+        sql = f"UPDATE {table} SET {set_column} = %s WHERE {where_column} = %s"
+        self._manager(sql, (set_value, where_value), commit=True)
+
+    def delete(self, table: str, where_column: str, where_value: Any) -> None:
+        """
+        Jadvaldan qator o'chirish.
+        """
+        sql = f"DELETE FROM {table} WHERE {where_column} = %s"
+        self._manager(sql, (where_value,), commit=True)
+
+    def list_tables(self, schema="public") -> list[tuple]:
+        """
+        Bazadagi mavjud jadvallar ro'yxatini qaytaradi.
+
+        schema: str — schema nomi (standart: public)
+        """
+        sql = """
+              SELECT table_name
+              FROM information_schema.tables
+              WHERE table_schema = %s
+              ORDER BY table_name; \
+              """
+        return self._manager(sql, (schema,), fetchall=True)
+
+    def describe_table(self, table: str, schema: str = "public") -> list[tuple]:
+        """
+        Jadval ustunlari haqida ma'lumot beradi.
+        """
+        sql = """
+              SELECT column_name,
+                     data_type,
+                     is_nullable,
+                     column_default
+              FROM information_schema.columns
+              WHERE table_schema = %s
+                AND table_name = %s
+              ORDER BY ordinal_position; \
+              """
+        return self._manager(sql, (schema, table), fetchall=True)
+
+    def alter(self, table: str, action: str) -> Any:
+        """
+        Universal ALTER TABLE metodi.
+
+        table: str — jadval nomi
+        action: str — ALTER TABLE dan keyingi qism
+        """
+        sql = f"ALTER TABLE {table} {action}"
+        return self._manager(sql, commit=True)

{postgresdb3-0.2.2 → postgresdb3-0.3.0}/postgresdb3.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: postgresdb3
-Version: 0.2.2
+Version: 0.3.0
 Summary: Python uchun oddiy PostgreSQL wrapper
-Home-page: https://github.com/AlijonovUz/PostgresDB
 Author: Abdulbosit Alijonov
+Project-URL: Source Code, https://github.com/AlijonovUz/PostgresDB
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -15,7 +15,7 @@ Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
-Dynamic: home-page
+Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -31,7 +31,7 @@ Oddiy va qulay Python wrapper PostgreSQL bazasi bilan ishlash uchun.
 ## O'rnatish
 
 ``` bash
-    pip install postgresdb3
+pip install postgresdb3
 ```
 
 ## Foydalanish (Sync)

{postgresdb3-0.2.2 → postgresdb3-0.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name="postgresdb3",
-    version="0.2.2",
+    version="0.3.0",
     packages=find_packages(),
     install_requires=[
         "psycopg2>=2.9",
@@ -15,7 +15,9 @@ setup(
     description="Python uchun oddiy PostgreSQL wrapper",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    url="https://github.com/AlijonovUz/PostgresDB",
+    project_urls={
+        "Source Code": "https://github.com/AlijonovUz/PostgresDB",
+    },
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",

postgresdb3-0.2.2/postgresdb3/sync_db.py

@@ -1,189 +0,0 @@
-import psycopg2
-
-
-class PostgresDB:
-
-    def __init__(self, database, user, password, host="localhost", port=5432):
-        """
-        PostgreSQL bazasiga ulanish.
-
-        Parametrlar:
-            database (str): Bazaning nomi
-            user (str): Foydalanuvchi
-            password (str): Parol
-            host (str): Server manzili (standart = localhost)
-            port (int): Port (standart = 5432)
-        """
-        self.connect = psycopg2.connect(
-            database=database, user=user, password=password, host=host, port=port
-        )
-
-    def manager(
-            self,
-            sql=None,
-            params=None,
-            *,
-            commit=False,
-            fetchall=False,
-            fetchone=False,
-    ):
-        """
-        Barcha SQL amallarni boshqaruvchi yagona metod.
-
-        Parametrlar:
-            sql (str | None): Bajariladigan SQL so'rov.
-            params (tuple | list | None): Parametrlar.
-            commit (bool): Tranzaksiyani tasdiqlash.
-            fetchall (bool): Barcha natijalarni olish.
-            fetchone (bool): Bitta natija olish.
-        """
-
-        with self.connect as connect:
-            result = None
-            with connect.cursor() as cursor:
-                cursor.execute(sql, params)
-
-                if commit:
-                    connect.commit()
-                elif fetchall:
-                    result = cursor.fetchall()
-                elif fetchone:
-                    result = cursor.fetchone()
-
-            return result
-
-    def create(self, table, columns):
-        """
-        table: str - jadval nomi
-        columns: str - ustunlar va turlari, misol: "id SERIAL PRIMARY KEY, name VARCHAR(100)"
-        """
-        sql = f"CREATE TABLE IF NOT EXISTS {table} ({columns})"
-        self.manager(sql, commit=True)
-
-    def drop(self, table):
-        """
-        table: str - o'chiriladigan jadval nomi
-        """
-        sql = f"DROP TABLE IF EXISTS {table} CASCADE"
-        self.manager(sql, commit=True)
-
-    def select(
-            self,
-            table,
-            columns="*",
-            where=None,
-            join=None,
-            group_by=None,
-            order_by=None,
-            limit=None,
-            fetchone=False,
-    ):
-        """
-        table: str — asosiy jadval
-        columns: str — tanlanadigan ustunlar ("id, name")
-        where: tuple | None — ("age > %s", [18])
-        join: list | None — [("INNER JOIN", "orders", "users.id = orders.user_id")]
-        group_by: str | None — "age"
-        order_by: str | None — "age DESC"
-        limit: int | None
-        """
-
-        sql = f"SELECT {columns} FROM {table}"
-        params = []
-
-        if join:
-            for join_type, join_table, on_condition in join:
-                sql += f" {join_type} {join_table} ON {on_condition}"
-
-        if where:
-            condition, values = where
-            sql += f" WHERE {condition}"
-            params.extend(values)
-
-        if group_by:
-            sql += f" GROUP BY {group_by}"
-
-        if order_by:
-            sql += f" ORDER BY {order_by}"
-
-        if limit:
-            sql += f" LIMIT %s"
-            params.append(limit)
-
-        if fetchone:
-            return self.manager(sql, params, fetchone=True)
-        return self.manager(sql, params, fetchall=True)
-
-    def insert(self, table, columns, values):
-        """
-        table: str - jadval nomi
-        columns: str - ustunlar, misol: "name, email, age"
-        values: tuple yoki list - ustun qiymatlari, misol: ("Ali", "ali@mail.com", 25)
-        """
-        placeholders = ", ".join(["%s"] * len(values))
-        sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
-        self.manager(sql, values, commit=True)
-
-    def update(self, table, set_column, set_value, where_column, where_value):
-        """
-        Jadvaldagi ma'lumotni yangilash.
-
-        Parametrlar:
-            table (str): Jadval nomi.
-            set_column (str): O'zgartiriladigan ustun.
-            set_value (Any): Yangi qiymat.
-            where_column (str): Filtrlash ustuni.
-            where_value (Any): Qaysi qatorda o'zgarish bo'lishi.
-
-        Izoh:
-            Faqat WHERE shartiga mos kelgan qatorlar yangilanadi.
-        """
-        sql = f"UPDATE {table} SET {set_column} = %s WHERE {where_column} = %s"
-        return self.manager(sql, (set_value, where_value), commit=True)
-
-    def delete(self, table, where_column, where_value):
-        """
-        Jadvaldan qator o'chirish.
-        """
-        sql = f"DELETE FROM {table} WHERE {where_column} = %s"
-        return self.manager(sql, (where_value,), commit=True)
-
-    def list_tables(self, schema="public"):
-        """
-        Bazadagi mavjud jadvallar ro'yxatini qaytaradi.
-
-        schema: str — schema nomi (standart: public)
-        """
-        sql = """
-              SELECT table_name
-              FROM information_schema.tables
-              WHERE table_schema = %s
-              ORDER BY table_name; \
-              """
-        return self.manager(sql, (schema,), fetchall=True)
-
-    def describe_table(self, table, schema="public"):
-        """
-        Jadval ustunlari haqida ma'lumot beradi.
-        """
-        sql = """
-              SELECT column_name,
-                     data_type,
-                     is_nullable,
-                     column_default
-              FROM information_schema.columns
-              WHERE table_schema = %s
-                AND table_name = %s
-              ORDER BY ordinal_position; \
-              """
-        return self.manager(sql, (schema, table), fetchall=True)
-
-    def alter(self, table, action):
-        """
-        Universal ALTER TABLE metodi.
-
-        table: str — jadval nomi
-        action: str — ALTER TABLE dan keyingi qism
-        """
-        sql = f"ALTER TABLE {table} {action}"
-        return self.manager(sql, commit=True)