postgresdb3 0.4.0__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.5.0/postgresdb3/orm/__init__.py

@@ -0,0 +1 @@
+from .models import Model, AsyncModel

postgresdb3-0.5.0/postgresdb3/orm/base.py

@@ -0,0 +1,91 @@
+class BaseModel:
+    db = None
+    table = None
+    pk = "id"
+    _fields = {}
+
+    def __init__(self, **kwargs):
+        for field_name in self._fields:
+            setattr(self, field_name, kwargs.get(field_name))
+
+        for key, value in kwargs.items():
+            if key not in self._fields:
+                setattr(self, key, value)
+
+    def __iter__(self):
+        for field in self._fields:
+            yield field, getattr(self, field, None)
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    @classmethod
+    def _check_setup(cls):
+        if cls.db is None:
+            raise ValueError(f"{cls.__name__}.db belgilanmagan")
+
+        if cls.table is None:
+            raise ValueError(f"{cls.__name__}.table belgilanmagan")
+
+        if not isinstance(cls._fields, dict):
+            raise ValueError(f"{cls.__name__}._fields noto‘g‘ri")
+
+    @classmethod
+    def _from_record(cls, record):
+        if record is None:
+            return None
+
+        if isinstance(record, dict):
+            return cls(**record)
+
+        if hasattr(record, "_asdict"):
+            return cls(**record._asdict())
+
+        if hasattr(record, "items"):
+            return cls(**dict(record))
+
+        if isinstance(record, (tuple, list)):
+            data = dict(zip(cls._fields.keys(), record))
+            return cls(**data)
+
+        data = {}
+        for field_name in cls._fields:
+            try:
+                if hasattr(record, field_name):
+                    data[field_name] = getattr(record, field_name)
+                else:
+                    data[field_name] = record[field_name]
+            except Exception:
+                pass
+
+        return cls(**data)
+
+    @classmethod
+    def _from_records(cls, records):
+        if not records:
+            return []
+        return [cls._from_record(record) for record in records]
+
+    @classmethod
+    def get_fields(cls):
+        return cls._fields
+
+    @classmethod
+    def get_pk_name(cls):
+        for name, field in cls._fields.items():
+            if getattr(field, "primary_key", False):
+                return name
+        return cls.pk
+
+    def to_dict(self):
+        return {
+            field_name: getattr(self, field_name, None)
+            for field_name in self._fields
+        }
+
+    def __repr__(self):
+        fields = ", ".join(
+            f"{name}={getattr(self, name, None)!r}"
+            for name in self._fields
+        )
+        return f"<{self.__class__.__name__} {fields}>"

postgresdb3-0.5.0/postgresdb3/orm/fields/__init__.py

@@ -0,0 +1,6 @@
+from .base import Field
+from .numeric import Integer, BigInteger, SmallInteger, Serial, BigSerial, Decimal
+from .text import String, Text
+from .datetime import Date, Time, Timestamp, Timestamptz
+from .misc import Boolean, JSON, JSONB, UUID, Array
+from .relations import ForeignKey

postgresdb3-0.5.0/postgresdb3/orm/fields/base.py

@@ -0,0 +1,37 @@
+class Field:
+
+    sql_type = ""
+
+    def __init__(
+        self,
+        *,
+        nullable=False,
+        primary_key=False,
+        unique=False,
+        default=None,
+        index=False
+    ):
+        self.nullable = nullable
+        self.primary_key = primary_key
+        self.unique = unique
+        self.default = default
+        self.index = index
+        self.name = None
+
+    def to_sql(self):
+
+        parts = [self.name, self.sql_type]
+
+        if self.primary_key:
+            parts.append("PRIMARY KEY")
+
+        if self.unique:
+            parts.append("UNIQUE")
+
+        if not self.nullable and not self.primary_key:
+            parts.append("NOT NULL")
+
+        if self.default is not None:
+            parts.append(f"DEFAULT {self.default}")
+
+        return " ".join(parts)

postgresdb3-0.5.0/postgresdb3/orm/fields/datetime.py

@@ -0,0 +1,17 @@
+from .base import Field
+
+
+class Date(Field):
+    sql_type = "DATE"
+
+
+class Time(Field):
+    sql_type = "TIME"
+
+
+class Timestamp(Field):
+    sql_type = "TIMESTAMP"
+
+
+class Timestamptz(Field):
+    sql_type = "TIMESTAMPTZ"

postgresdb3-0.5.0/postgresdb3/orm/fields/misc.py

@@ -0,0 +1,28 @@
+from .base import Field
+
+
+class Boolean(Field):
+    sql_type = "BOOLEAN"
+
+
+class JSON(Field):
+    sql_type = "JSON"
+
+
+class JSONB(Field):
+    sql_type = "JSONB"
+
+
+class UUID(Field):
+    sql_type = "UUID"
+
+
+class Array(Field):
+
+    def __init__(self, base_type, **kwargs):
+        super().__init__(**kwargs)
+        self.base_type = base_type
+
+    @property
+    def sql_type(self):
+        return f"{self.base_type}[]"

postgresdb3-0.5.0/postgresdb3/orm/fields/numeric.py

@@ -0,0 +1,32 @@
+from .base import Field
+
+class Integer(Field):
+    sql_type = "INTEGER"
+
+
+class BigInteger(Field):
+    sql_type = "BIGINT"
+
+
+class SmallInteger(Field):
+    sql_type = "SMALLINT"
+
+
+class Serial(Field):
+    sql_type = "SERIAL"
+
+
+class BigSerial(Field):
+    sql_type = "BIGSERIAL"
+
+
+class Decimal(Field):
+
+    def __init__(self, precision=10, scale=2, **kwargs):
+        super().__init__(**kwargs)
+        self.precision = precision
+        self.scale = scale
+
+    @property
+    def sql_type(self):
+        return f"NUMERIC({self.precision},{self.scale})"