postgresdb3 0.4.0__tar.gz → 0.6.0__tar.gz

postgresdb3-0.6.0/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: postgresdb3
+Version: 0.6.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 quyidagilarni qo‘llab-quvvatlaydi:
+
+- Sync va Async ishlash
+- CRUD operatsiyalari
+- Query builder (`where`, `join`, `group_by`, `order_by`, `limit`, `offset`)
+- Kengaytirilgan filterlar (`gt`, `lt`, `like`, `ilike`, `in`, `isnull`)
+- Raw SQL bajarish
+- Sodda ORM tizimi
+
+---
+
+# O‘rnatish
+
+```bash
+pip install postgresdb3
+````
+
+---
+
+# Sync foydalanish
+
+```python
+from postgresdb3 import PostgresDB
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+# Jadval yaratish
+db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+# Qator qo‘shish
+db.insert("users", "name, age", ("Ali", 25))
+
+# Barcha ma'lumotlar
+users = db.select("users")
+
+# Shart bilan qidirish
+adults = db.select("users", where={"age__gt": 18})
+
+# Tartiblash
+users = db.select("users", order_by="age DESC")
+
+# Yangilash
+db.update("users", "age", 26, "name", "Ali")
+
+# O‘chirish
+db.delete("users", "name", "Ali")
+
+db.close()
+```
+
+---
+
+# Async foydalanish
+
+```python
+import asyncio
+from postgresdb3 import AsyncPostgresDB
+
+async def main():
+
+    db = AsyncPostgresDB(
+        database="mydb",
+        user="postgres",
+        password="mypassword"
+    )
+
+    await db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+    await db.insert("users", "name, age", ["Ali", 25])
+
+    users = await db.select("users")
+
+    adults = await db.select("users", where={"age__gt": 18})
+
+    await db.update("users", "age", 26, "name", "Ali")
+
+    await db.delete("users", "name", "Ali")
+
+    await db.close_pool()
+
+asyncio.run(main())
+```
+
+---
+
+# ORM foydalanish
+
+PostgresDB3 oddiy ORM tizimini ham taqdim etadi.
+
+## Sync ORM
+
+```python
+from postgresdb3 import PostgresDB
+from postgresdb3.orm import Model
+from postgresdb3.orm.fields import Serial, String, Integer
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(Model):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+
+User.create_table()
+
+# create
+user = User.create(name="Ali", age=20)
+
+# all
+users = User.all()
+
+# find
+user = User.find(1)
+
+# filter
+users = User.filter(age__gt=18).all()
+
+# get
+user = User.get(id=1)
+
+# exclude
+users = User.exclude(name="Ali").all()
+
+# update
+user.update(name="Valijon")
+
+# delete
+user.delete()
+```
+
+---
+
+## Async ORM
+
+```python
+from postgresdb3 import AsyncPostgresDB
+from postgresdb3.orm import AsyncModel
+from postgresdb3.orm.fields import Serial, String, Integer
+
+db = AsyncPostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(AsyncModel):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+
+await User.create_table()
+
+user = await User.create(name="Ali", age=20)
+
+users = await User.all()
+
+user = await User.find(1)
+
+users = await User.filter(age__gt=18).all()
+
+user = await User.get(id=1)
+
+users = await User.exclude(name="Ali").all()
+
+await user.update(name="Valijon")
+
+await user.delete()
+```
+
+---
+
+# Filter operatorlari
+
+| Operator | Tavsif           |
+| -------- | ---------------- |
+| eq       | teng             |
+| ne       | teng emas        |
+| gt       | katta            |
+| gte      | katta yoki teng  |
+| lt       | kichik           |
+| lte      | kichik yoki teng |
+| like     | LIKE             |
+| ilike    | ILIKE            |
+| in       | IN               |
+| not_in   | NOT IN           |
+| isnull   | NULL tekshirish  |
+
+Misol:
+
+```python
+User.filter(age__gt=18)
+User.filter(name__ilike="%ali%")
+User.filter(id__in=[1,2,3])
+User.filter(name__ne="Ali")
+```
+
+---
+
+# Raw SQL
+
+```python
+result = db.raw(
+    "SELECT name FROM users WHERE age > %s",
+    [18],
+    fetchall=True
+)
+```

postgresdb3-0.6.0/README.md

@@ -0,0 +1,229 @@
+# 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 quyidagilarni qo‘llab-quvvatlaydi:
+
+- Sync va Async ishlash
+- CRUD operatsiyalari
+- Query builder (`where`, `join`, `group_by`, `order_by`, `limit`, `offset`)
+- Kengaytirilgan filterlar (`gt`, `lt`, `like`, `ilike`, `in`, `isnull`)
+- Raw SQL bajarish
+- Sodda ORM tizimi
+
+---
+
+# O‘rnatish
+
+```bash
+pip install postgresdb3
+````
+
+---
+
+# Sync foydalanish
+
+```python
+from postgresdb3 import PostgresDB
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+# Jadval yaratish
+db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+# Qator qo‘shish
+db.insert("users", "name, age", ("Ali", 25))
+
+# Barcha ma'lumotlar
+users = db.select("users")
+
+# Shart bilan qidirish
+adults = db.select("users", where={"age__gt": 18})
+
+# Tartiblash
+users = db.select("users", order_by="age DESC")
+
+# Yangilash
+db.update("users", "age", 26, "name", "Ali")
+
+# O‘chirish
+db.delete("users", "name", "Ali")
+
+db.close()
+```
+
+---
+
+# Async foydalanish
+
+```python
+import asyncio
+from postgresdb3 import AsyncPostgresDB
+
+async def main():
+
+    db = AsyncPostgresDB(
+        database="mydb",
+        user="postgres",
+        password="mypassword"
+    )
+
+    await db.create("users", "id SERIAL PRIMARY KEY, name VARCHAR(100), age INT")
+
+    await db.insert("users", "name, age", ["Ali", 25])
+
+    users = await db.select("users")
+
+    adults = await db.select("users", where={"age__gt": 18})
+
+    await db.update("users", "age", 26, "name", "Ali")
+
+    await db.delete("users", "name", "Ali")
+
+    await db.close_pool()
+
+asyncio.run(main())
+```
+
+---
+
+# ORM foydalanish
+
+PostgresDB3 oddiy ORM tizimini ham taqdim etadi.
+
+## Sync ORM
+
+```python
+from postgresdb3 import PostgresDB
+from postgresdb3.orm import Model
+from postgresdb3.orm.fields import Serial, String, Integer
+
+db = PostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(Model):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+
+User.create_table()
+
+# create
+user = User.create(name="Ali", age=20)
+
+# all
+users = User.all()
+
+# find
+user = User.find(1)
+
+# filter
+users = User.filter(age__gt=18).all()
+
+# get
+user = User.get(id=1)
+
+# exclude
+users = User.exclude(name="Ali").all()
+
+# update
+user.update(name="Valijon")
+
+# delete
+user.delete()
+```
+
+---
+
+## Async ORM
+
+```python
+from postgresdb3 import AsyncPostgresDB
+from postgresdb3.orm import AsyncModel
+from postgresdb3.orm.fields import Serial, String, Integer
+
+db = AsyncPostgresDB(
+    database="mydb",
+    user="postgres",
+    password="mypassword"
+)
+
+class User(AsyncModel):
+    db = db
+    table = "users"
+
+    id = Serial(primary_key=True)
+    name = String()
+    age = Integer()
+
+await User.create_table()
+
+user = await User.create(name="Ali", age=20)
+
+users = await User.all()
+
+user = await User.find(1)
+
+users = await User.filter(age__gt=18).all()
+
+user = await User.get(id=1)
+
+users = await User.exclude(name="Ali").all()
+
+await user.update(name="Valijon")
+
+await user.delete()
+```
+
+---
+
+# Filter operatorlari
+
+| Operator | Tavsif           |
+| -------- | ---------------- |
+| eq       | teng             |
+| ne       | teng emas        |
+| gt       | katta            |
+| gte      | katta yoki teng  |
+| lt       | kichik           |
+| lte      | kichik yoki teng |
+| like     | LIKE             |
+| ilike    | ILIKE            |
+| in       | IN               |
+| not_in   | NOT IN           |
+| isnull   | NULL tekshirish  |
+
+Misol:
+
+```python
+User.filter(age__gt=18)
+User.filter(name__ilike="%ali%")
+User.filter(id__in=[1,2,3])
+User.filter(name__ne="Ali")
+```
+
+---
+
+# Raw SQL
+
+```python
+result = db.raw(
+    "SELECT name FROM users WHERE age > %s",
+    [18],
+    fetchall=True
+)
+```

postgresdb3-0.6.0/postgresdb3/__init__.py

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

{postgresdb3-0.4.0/postgresdb3 → postgresdb3-0.6.0/postgresdb3/core}/async_db.py

@@ -165,6 +165,7 @@ class AsyncPostgresDB:
             operator_map = {
                 "eq": "=",
                 "ne": "!=",
+                "not": "!=",
                 "gt": ">",
                 "gte": ">=",
                 "lt": "<",

{postgresdb3-0.4.0/postgresdb3 → postgresdb3-0.6.0/postgresdb3/core}/sync_db.py

@@ -241,6 +241,7 @@ class PostgresDB:
             operator_map = {
                 "eq": "=",
                 "ne": "!=",
+                "not": "!=",
                 "gt": ">",
                 "gte": ">=",
                 "lt": "<",

postgresdb3-0.6.0/postgresdb3/orm/__init__.py

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

postgresdb3-0.6.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.6.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.6.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.6.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.6.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.6.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})"