af-db-teach 0.1.0__tar.gz

af_db_teach-0.1.0/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2025 Abbas Faramarzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy...
+(متن کامل مجوز MIT را می‌توانید از https://opensource.org/licenses/MIT کپی کنید)

af_db_teach-0.1.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: af_db_teach
+Version: 0.1.0
+Summary: Core SQLite ORM with separate educational modules
+Home-page: https://github.com/abbasfaramarzi/af_db_teach
+Author: Abbas Faramarzi Filabadi
+Author-email: Abbas Faramarzi Filabadi <abbasfaramarzi@068gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/abbasfaramarzi/af_db_teach
+Project-URL: Bug Reports, https://github.com/abbasfaramarzi/af_db_teach/issues
+Project-URL: Source, https://github.com/abbasfaramarzi/af_db_teach
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+```markdown
+# af_db_teach
+
+A simple, educational ORM for SQLite in Python.  
+This package allows you to work with an SQLite database without writing raw SQL queries.  
+Designed for small projects and learning ORM concepts.
+
+## Features
+
+- Define models using Python classes and simple attributes
+- Automatic CRUD operations (Create, Read, Update, Delete)
+- Automatic table management (create, update schema, drop)
+- Support for default data (`_default_data`)
+- Helper methods like search, borrow/return (in the library example)
+- Export all tables and data as a dictionary with `db_deeep_interface`
+
+## Installation
+
+```bash
+pip install af_db_teach
+```
+
+> **Note:** This package will be published on PyPI soon. You can also use it directly from the GitHub repository.
+
+## Quick Start
+
+### 1. Define a Model
+
+```python
+from af_db_teach import Model
+
+class Product(Model):
+    _primary_key = "id"
+    id = 0
+    name = ""
+    price = 0.0
+    in_stock = 1
+```
+
+- The table name is automatically derived from the class name (lowercase): `product`
+- Fields are defined as class attributes.
+- Data types (INTEGER, REAL, TEXT) are inferred from the example values (`int`, `float`, `str`).
+
+### 2. Work with the Database
+
+```python
+# Connect and create the table
+db = Product("shop.db")
+
+# Insert a row
+new_id = db.insert_one(name="Python Book", price=25000, in_stock=1)
+
+# Get all records
+all_products = db.get_all()
+
+# Get a single record by primary key
+product = db.get_one(1)
+
+# Update a record
+db.update(1, price=27000)
+
+# Delete a record
+db.delete(1)
+
+# Drop the entire table
+db.delete_table()
+```
+
+### 3. Default Data
+
+You can define `_default_data` in your model class to insert initial records:
+
+```python
+class Category(Model):
+    id = 0
+    title = ""
+
+    _default_data = [
+        (1, "Electronics"),
+        (2, "Books"),
+        (3, "Clothing"),
+    ]
+```
+
+> Note: The order of values must match the order of fields returned by `table_fields()`.
+
+## Model Methods
+
+| Method | Description |
+|--------|-------------|
+| `insert_one(**kwargs)` | Insert a new row. Returns `lastrowid`. |
+| `get_all(where="", params=())` | Get all rows (optional WHERE clause). |
+| `get_one(row_id)` | Get a single row by primary key. |
+| `update(row_id, **kwargs)` | Update specified fields. |
+| `delete(row_id)` | Delete a row by primary key. |
+| `delete_table(table_name=None)` | Drop the entire table. |
+| `db_deeep_interface()` | Return a dictionary of all tables and their contents. |
+
+## Complete Example: Library Management
+
+The file `library_orm_demo.py` provides a practical library system example:
+
+```python
+from af_db_teach import Model
+from datetime import date
+
+class Book(Model):
+    _primary_key = "id"
+    id = 0
+    title = ""
+    author = ""
+    year = 2000
+    is_available = 1
+
+    def borrow(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 1:
+            return self.update(book_id, is_available=0)
+        return False
+
+    def return_book(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 0:
+            return self.update(book_id, is_available=1)
+        return False
+
+# Usage
+book_db = Book("library.db")
+book_db.insert_one(title="Thus Spoke Zarathustra", author="Nietzsche", year=1885)
+book_db.borrow(1)       # borrow the book
+book_db.return_book(1)  # return it
+```
+
+Run the full demo:
+
+```bash
+python library_orm_demo.py
+```
+
+## Advanced Notes
+
+### 1. Ignoring a Table
+
+The `Keywords` class contains a list `ignores_table_name_list`. If a table name is in this list, `create_table` will not create it. You can extend this list:
+
+```python
+from af_db_teach import Keywords
+Keywords.ignores_table_name_list.append("my_temp_table")
+```
+
+### 2. Base Class `TableBase`
+
+If you need a model without direct database connection (just the table structure), you can inherit from `TableBase`.
+
+### 3. Connecting to an Existing Database
+
+```python
+db = Model("my_database.db")
+```
+
+If the database file does not exist, it will be created.
+
+## License
+
+This project is released under the MIT License.
+
+## Author
+
+Abbas Faramarzi  
+[Email](mailto:abbasfaramarzi@068gmail.com)  
+[GitHub Repository](https://github.com/abbasfaramarzi/af_db_teach)
+
+---
+
+**af_db_teach** – A simple tool for learning and using ORM in small Python projects.
+```

af_db_teach-0.1.0/README.md

@@ -0,0 +1,176 @@
+```markdown
+# af_db_teach
+
+A simple, educational ORM for SQLite in Python.  
+This package allows you to work with an SQLite database without writing raw SQL queries.  
+Designed for small projects and learning ORM concepts.
+
+## Features
+
+- Define models using Python classes and simple attributes
+- Automatic CRUD operations (Create, Read, Update, Delete)
+- Automatic table management (create, update schema, drop)
+- Support for default data (`_default_data`)
+- Helper methods like search, borrow/return (in the library example)
+- Export all tables and data as a dictionary with `db_deeep_interface`
+
+## Installation
+
+```bash
+pip install af_db_teach
+```
+
+> **Note:** This package will be published on PyPI soon. You can also use it directly from the GitHub repository.
+
+## Quick Start
+
+### 1. Define a Model
+
+```python
+from af_db_teach import Model
+
+class Product(Model):
+    _primary_key = "id"
+    id = 0
+    name = ""
+    price = 0.0
+    in_stock = 1
+```
+
+- The table name is automatically derived from the class name (lowercase): `product`
+- Fields are defined as class attributes.
+- Data types (INTEGER, REAL, TEXT) are inferred from the example values (`int`, `float`, `str`).
+
+### 2. Work with the Database
+
+```python
+# Connect and create the table
+db = Product("shop.db")
+
+# Insert a row
+new_id = db.insert_one(name="Python Book", price=25000, in_stock=1)
+
+# Get all records
+all_products = db.get_all()
+
+# Get a single record by primary key
+product = db.get_one(1)
+
+# Update a record
+db.update(1, price=27000)
+
+# Delete a record
+db.delete(1)
+
+# Drop the entire table
+db.delete_table()
+```
+
+### 3. Default Data
+
+You can define `_default_data` in your model class to insert initial records:
+
+```python
+class Category(Model):
+    id = 0
+    title = ""
+
+    _default_data = [
+        (1, "Electronics"),
+        (2, "Books"),
+        (3, "Clothing"),
+    ]
+```
+
+> Note: The order of values must match the order of fields returned by `table_fields()`.
+
+## Model Methods
+
+| Method | Description |
+|--------|-------------|
+| `insert_one(**kwargs)` | Insert a new row. Returns `lastrowid`. |
+| `get_all(where="", params=())` | Get all rows (optional WHERE clause). |
+| `get_one(row_id)` | Get a single row by primary key. |
+| `update(row_id, **kwargs)` | Update specified fields. |
+| `delete(row_id)` | Delete a row by primary key. |
+| `delete_table(table_name=None)` | Drop the entire table. |
+| `db_deeep_interface()` | Return a dictionary of all tables and their contents. |
+
+## Complete Example: Library Management
+
+The file `library_orm_demo.py` provides a practical library system example:
+
+```python
+from af_db_teach import Model
+from datetime import date
+
+class Book(Model):
+    _primary_key = "id"
+    id = 0
+    title = ""
+    author = ""
+    year = 2000
+    is_available = 1
+
+    def borrow(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 1:
+            return self.update(book_id, is_available=0)
+        return False
+
+    def return_book(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 0:
+            return self.update(book_id, is_available=1)
+        return False
+
+# Usage
+book_db = Book("library.db")
+book_db.insert_one(title="Thus Spoke Zarathustra", author="Nietzsche", year=1885)
+book_db.borrow(1)       # borrow the book
+book_db.return_book(1)  # return it
+```
+
+Run the full demo:
+
+```bash
+python library_orm_demo.py
+```
+
+## Advanced Notes
+
+### 1. Ignoring a Table
+
+The `Keywords` class contains a list `ignores_table_name_list`. If a table name is in this list, `create_table` will not create it. You can extend this list:
+
+```python
+from af_db_teach import Keywords
+Keywords.ignores_table_name_list.append("my_temp_table")
+```
+
+### 2. Base Class `TableBase`
+
+If you need a model without direct database connection (just the table structure), you can inherit from `TableBase`.
+
+### 3. Connecting to an Existing Database
+
+```python
+db = Model("my_database.db")
+```
+
+If the database file does not exist, it will be created.
+
+## License
+
+This project is released under the MIT License.
+
+## Author
+
+Abbas Faramarzi  
+[Email](mailto:abbasfaramarzi@068gmail.com)  
+[GitHub Repository](https://github.com/abbasfaramarzi/af_db_teach)
+
+---
+
+**af_db_teach** – A simple tool for learning and using ORM in small Python projects.
+```

af_db_teach-0.1.0/af_db_teach/__init__.py

@@ -0,0 +1,6 @@
+from .keywords import Keywords
+from .table_base import TableBase
+from .model import Model
+
+# optionally define __all__ for "from package import *"
+__all__ = ['Keywords', 'TableBase', 'Model']

af_db_teach-0.1.0/af_db_teach/keywords.py

@@ -0,0 +1,2 @@
+class Keywords:
+    ignores_table_name_list = ["afdbinterface"]

af_db_teach-0.1.0/af_db_teach/model.py

@@ -0,0 +1,101 @@
+import sqlite3
+from typing import List, Dict, Any, Optional
+from .keywords import Keywords
+from .table_base import TableBase
+
+class Model(TableBase):
+    def __init__(self, db_path="library.db"):
+        self.conn = sqlite3.connect(db_path)
+        self.conn.row_factory = sqlite3.Row
+        self.cursor = self.conn.cursor()
+        self._primary_key = "id"
+        self.create_table()
+
+    @property
+    def available_tables(self) -> List[str]:
+        return [row[0] for row in self.cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")]
+
+    def get_column_names(self, table_name: str) -> List[str]:
+        return [info[1] for info in self.cursor.execute(f"PRAGMA table_info({table_name})").fetchall()]
+
+    def create_table(self) -> None:
+        if self.table_name not in Keywords.ignores_table_name_list:
+            desired_fields = self.table_fields()
+            desired_sql = self._create_table_sql(primary_key=getattr(self, "_primary_key", None))
+
+            if self.table_name not in self.available_tables:
+                self.cursor.execute(desired_sql)
+                if hasattr(self.__class__, '_default_data') and self.__class__._default_data:
+                    self._insert_default_data()
+            else:
+                existing_cols = self.get_column_names(self.table_name)
+                if sorted(desired_fields) != sorted(existing_cols):
+                    self.delete_table(self.table_name)
+                    self.cursor.execute(desired_sql)
+                    if hasattr(self.__class__, '_default_data') and self.__class__._default_data:
+                        self._insert_default_data()
+            self.conn.commit()
+
+    def _insert_default_data(self):
+        fields = self.table_fields()
+        placeholders = ','.join(['?'] * len(fields))
+        query = f"INSERT INTO {self.table_name} ({','.join(fields)}) VALUES ({placeholders})"
+        try:
+            self.cursor.executemany(query, self.__class__._default_data)
+            self.conn.commit()
+        except Exception as e:
+            print(f"Default data insert error: {e}")
+
+    def insert_one(self, **kwargs) -> int:
+        fields = list(kwargs.keys())
+        values = tuple(kwargs.values())
+        placeholders = ','.join(['?'] * len(fields))
+        query = f"INSERT INTO {self.table_name} ({','.join(fields)}) VALUES ({placeholders})"
+        self.cursor.execute(query, values)
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def get_all(self, where: str = "", params: tuple = ()) -> List[Dict]:
+        query = f"SELECT * FROM {self.table_name}"
+        if where:
+            query += f" WHERE {where}"
+        rows = self.cursor.execute(query, params).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_one(self, row_id: int) -> Optional[Dict]:
+        result = self.get_all(where=f"{self._primary_key}=?", params=(row_id,))
+        return result[0] if result else None
+
+    def update(self, row_id: int, **kwargs) -> bool:
+        if not kwargs:
+            return False
+        set_clause = ", ".join([f"{k}=?" for k in kwargs.keys()])
+        values = list(kwargs.values()) + [row_id]
+        query = f"UPDATE {self.table_name} SET {set_clause} WHERE {self._primary_key}=?"
+        try:
+            self.cursor.execute(query, values)
+            self.conn.commit()
+            return True
+        except Exception as e:
+            print(f"Update error: {e}")
+            return False
+
+    def delete(self, row_id: int) -> bool:
+        try:
+            self.cursor.execute(f"DELETE FROM {self.table_name} WHERE {self._primary_key}=?", (row_id,))
+            self.conn.commit()
+            return True
+        except Exception:
+            return False
+
+    def delete_table(self, table_name: str = None):
+        tname = table_name or self.table_name
+        self.cursor.execute(f"DROP TABLE IF EXISTS {tname}")
+        self.conn.commit()
+
+    def db_deeep_interface(self) -> Dict[str, List[Dict]]:
+        result = {}
+        for table in self.available_tables:
+            rows = self.cursor.execute(f"SELECT * FROM {table}").fetchall()
+            result[table] = [dict(row) for row in rows]
+        return result

af_db_teach-0.1.0/af_db_teach/table_base.py

@@ -0,0 +1,38 @@
+from typing import List
+
+class TableBase:
+    @property
+    def table_name(self) -> str:
+        return self.__class__.__name__.lower()
+
+    def table_fields(self) -> List[str]:
+        fields = []
+        for name, value in self.__class__.__dict__.items():
+            if name.startswith('__') and name.endswith('__'):
+                continue
+            if name.startswith('_'):
+                continue
+            if callable(value):
+                continue
+            fields.append(name)
+        return fields
+
+    def _column_type(self, field_name: str) -> str:
+        value = getattr(self.__class__, field_name, None)
+        if isinstance(value, int):
+            return "INTEGER"
+        elif isinstance(value, float):
+            return "REAL"
+        elif isinstance(value, str):
+            return "TEXT"
+        else:
+            return "TEXT"
+
+    def _create_table_sql(self, primary_key: str = None) -> str:
+        fields = self.table_fields()
+        if not fields:
+            raise ValueError(f"No fields for table {self.table_name}")
+        cols = [f"{f} {self._column_type(f)}" for f in fields]
+        if primary_key and primary_key in fields:
+            cols.append(f"PRIMARY KEY ({primary_key})")
+        return f"CREATE TABLE {self.table_name} ({', '.join(cols)})"

af_db_teach-0.1.0/af_db_teach.egg-info/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: af_db_teach
+Version: 0.1.0
+Summary: Core SQLite ORM with separate educational modules
+Home-page: https://github.com/abbasfaramarzi/af_db_teach
+Author: Abbas Faramarzi Filabadi
+Author-email: Abbas Faramarzi Filabadi <abbasfaramarzi@068gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/abbasfaramarzi/af_db_teach
+Project-URL: Bug Reports, https://github.com/abbasfaramarzi/af_db_teach/issues
+Project-URL: Source, https://github.com/abbasfaramarzi/af_db_teach
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+```markdown
+# af_db_teach
+
+A simple, educational ORM for SQLite in Python.  
+This package allows you to work with an SQLite database without writing raw SQL queries.  
+Designed for small projects and learning ORM concepts.
+
+## Features
+
+- Define models using Python classes and simple attributes
+- Automatic CRUD operations (Create, Read, Update, Delete)
+- Automatic table management (create, update schema, drop)
+- Support for default data (`_default_data`)
+- Helper methods like search, borrow/return (in the library example)
+- Export all tables and data as a dictionary with `db_deeep_interface`
+
+## Installation
+
+```bash
+pip install af_db_teach
+```
+
+> **Note:** This package will be published on PyPI soon. You can also use it directly from the GitHub repository.
+
+## Quick Start
+
+### 1. Define a Model
+
+```python
+from af_db_teach import Model
+
+class Product(Model):
+    _primary_key = "id"
+    id = 0
+    name = ""
+    price = 0.0
+    in_stock = 1
+```
+
+- The table name is automatically derived from the class name (lowercase): `product`
+- Fields are defined as class attributes.
+- Data types (INTEGER, REAL, TEXT) are inferred from the example values (`int`, `float`, `str`).
+
+### 2. Work with the Database
+
+```python
+# Connect and create the table
+db = Product("shop.db")
+
+# Insert a row
+new_id = db.insert_one(name="Python Book", price=25000, in_stock=1)
+
+# Get all records
+all_products = db.get_all()
+
+# Get a single record by primary key
+product = db.get_one(1)
+
+# Update a record
+db.update(1, price=27000)
+
+# Delete a record
+db.delete(1)
+
+# Drop the entire table
+db.delete_table()
+```
+
+### 3. Default Data
+
+You can define `_default_data` in your model class to insert initial records:
+
+```python
+class Category(Model):
+    id = 0
+    title = ""
+
+    _default_data = [
+        (1, "Electronics"),
+        (2, "Books"),
+        (3, "Clothing"),
+    ]
+```
+
+> Note: The order of values must match the order of fields returned by `table_fields()`.
+
+## Model Methods
+
+| Method | Description |
+|--------|-------------|
+| `insert_one(**kwargs)` | Insert a new row. Returns `lastrowid`. |
+| `get_all(where="", params=())` | Get all rows (optional WHERE clause). |
+| `get_one(row_id)` | Get a single row by primary key. |
+| `update(row_id, **kwargs)` | Update specified fields. |
+| `delete(row_id)` | Delete a row by primary key. |
+| `delete_table(table_name=None)` | Drop the entire table. |
+| `db_deeep_interface()` | Return a dictionary of all tables and their contents. |
+
+## Complete Example: Library Management
+
+The file `library_orm_demo.py` provides a practical library system example:
+
+```python
+from af_db_teach import Model
+from datetime import date
+
+class Book(Model):
+    _primary_key = "id"
+    id = 0
+    title = ""
+    author = ""
+    year = 2000
+    is_available = 1
+
+    def borrow(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 1:
+            return self.update(book_id, is_available=0)
+        return False
+
+    def return_book(self, book_id):
+        book = self.get_one(book_id)
+        if book and book['is_available'] == 0:
+            return self.update(book_id, is_available=1)
+        return False
+
+# Usage
+book_db = Book("library.db")
+book_db.insert_one(title="Thus Spoke Zarathustra", author="Nietzsche", year=1885)
+book_db.borrow(1)       # borrow the book
+book_db.return_book(1)  # return it
+```
+
+Run the full demo:
+
+```bash
+python library_orm_demo.py
+```
+
+## Advanced Notes
+
+### 1. Ignoring a Table
+
+The `Keywords` class contains a list `ignores_table_name_list`. If a table name is in this list, `create_table` will not create it. You can extend this list:
+
+```python
+from af_db_teach import Keywords
+Keywords.ignores_table_name_list.append("my_temp_table")
+```
+
+### 2. Base Class `TableBase`
+
+If you need a model without direct database connection (just the table structure), you can inherit from `TableBase`.
+
+### 3. Connecting to an Existing Database
+
+```python
+db = Model("my_database.db")
+```
+
+If the database file does not exist, it will be created.
+
+## License
+
+This project is released under the MIT License.
+
+## Author
+
+Abbas Faramarzi  
+[Email](mailto:abbasfaramarzi@068gmail.com)  
+[GitHub Repository](https://github.com/abbasfaramarzi/af_db_teach)
+
+---
+
+**af_db_teach** – A simple tool for learning and using ORM in small Python projects.
+```

af_db_teach-0.1.0/af_db_teach.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+af_db_teach/__init__.py
+af_db_teach/keywords.py
+af_db_teach/model.py
+af_db_teach/table_base.py
+af_db_teach.egg-info/PKG-INFO
+af_db_teach.egg-info/SOURCES.txt
+af_db_teach.egg-info/dependency_links.txt
+af_db_teach.egg-info/top_level.txt

af_db_teach-0.1.0/af_db_teach.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

af_db_teach-0.1.0/af_db_teach.egg-info/top_level.txt

@@ -0,0 +1 @@
+af_db_teach

af_db_teach-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "af_db_teach"
+version = "0.1.0"
+authors = [
+    {name = "Abbas Faramarzi Filabadi", email = "abbasfaramarzi@068gmail.com"},
+]
+description = "Core SQLite ORM with separate educational modules"
+readme = "README.md"
+requires-python = ">=3.6"
+license = {text = "MIT License"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/abbasfaramarzi/af_db_teach"
+"Bug Reports" = "https://github.com/abbasfaramarzi/af_db_teach/issues"
+"Source" = "https://github.com/abbasfaramarzi/af_db_teach"

af_db_teach-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

af_db_teach-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="af_db_teach",
+    version="0.1.0",
+    author="Abbas Faramarzi Filabadi",
+    author_email="abbasfaramarzi@068gmail.com",
+    description="Core SQLite ORM with separate educational modules",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/abbasfaramarzi/af_db_teach",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)