fletable 0.0.1__py3-none-any.whl

fletable/__init__.py

@@ -0,0 +1,3 @@
+from .editable_table import EditableTable, FieldConfig, ForeignKeyConfig
+from .sql_table import SqlTable
+from .utils import LoginView

fletable/editable_table.py

@@ -0,0 +1,237 @@
+from dataclasses import dataclass
+
+import flet as ft
+
+
+@dataclass
+class ForeignKeyConfig:
+    table: str
+    id_column: str
+    label_column: str
+
+
+@dataclass
+class FieldConfig:
+    label: str
+    foreign_key: ForeignKeyConfig | None = None
+
+
+class EditableTable:
+    def __init__(
+        self,
+        cursor,
+        table_name: str,
+        field_mapping: dict[str, FieldConfig | str],
+        width: int = 800,
+        height: int = 400,
+    ):
+        self.cursor = cursor
+        self.table_name = table_name
+        # Приводим значения словаря к FieldConfig для типобезопасных подсказок
+        self.field_configs: dict[str, FieldConfig] = {
+            name: cfg if isinstance(cfg, FieldConfig) else FieldConfig(label=str(cfg))
+            for name, cfg in field_mapping.items()
+        }
+        self.width = width
+        self.height = height
+        self.dropdown_options = self._generate_dropdown_options()
+        self.row_checkboxes: list[tuple[ft.Checkbox, dict]] = []  # (checkbox, row_data)
+        self.header_checkbox: ft.Checkbox = None
+
+    def _generate_dropdown_options(self):
+        options = {}
+        for field, cfg in self.field_configs.items():
+            # Настройки FK: явно через FieldConfig.foreign_key или по шаблону *_id
+            ref_cfg = cfg.foreign_key
+            if ref_cfg or (field.endswith("_id") and field != f"{self.table_name}_id"):
+                ref_table = ref_cfg.table if ref_cfg else field.replace("_id", "")
+                id_column = ref_cfg.id_column if ref_cfg else field
+                label_column = ref_cfg.label_column if ref_cfg else ref_table
+                try:
+                    self.cursor.execute(
+                        f"SELECT {id_column}, {label_column} FROM {ref_table}"
+                    )
+                    results = self.cursor.fetchall()
+                    options[field] = [(str(row[0]), str(row[1])) for row in results]
+                except Exception as e:
+                    print(f"[WARN] Не удалось загрузить dropdown для {field}: {e}")
+        return options
+
+    def create_add_form(self):
+        new_fields = {}
+        input_controls = []
+
+        for field in list(self.field_configs.keys())[1:]:  # Пропускаем ID
+            if field in self.dropdown_options:
+                ctrl = ft.Dropdown(
+                    options=[
+                        ft.dropdown.Option(key=str(k), text=str(v))
+                        for k, v in self.dropdown_options[field]
+                    ],
+                    value=None,
+                    expand=True,
+                    label=self.field_configs[field].label,
+                )
+            else:
+                ctrl = ft.TextField(label=self.field_configs[field].label, expand=True)
+
+            new_fields[field] = ctrl
+            input_controls.append(ctrl)
+
+        def handle_add():
+            try:
+                fields = ", ".join(new_fields.keys())
+                placeholders = ", ".join(["%s"] * len(new_fields))
+                values = [ctrl.value for ctrl in new_fields.values()]
+                insert_query = (
+                    f"INSERT INTO {self.table_name} ({fields}) VALUES ({placeholders})"
+                )
+                self.cursor.execute(insert_query, values)
+                self.cursor.connection.commit()
+                for ctrl in input_controls:
+                    ctrl.value = ""
+                print("[INFO] Запись добавлена:", values)
+                return True, "Успешно добавлено"
+            except Exception as ex:
+                print("[ERROR] Ошибка добавления:", str(ex))
+                return False, f"Ошибка: {str(ex)}"
+
+        form_row = ft.Row(input_controls)
+        return form_row, handle_add
+
+    def create_table(self):
+        db_fields = list(self.field_configs.keys())
+        query = f"SELECT {', '.join(db_fields)} FROM {self.table_name}"
+        self.cursor.execute(query)
+        data = self.cursor.fetchall()
+
+        # Очищаем список чекбоксов перед созданием новой таблицы
+        self.row_checkboxes = []
+
+        # Создаём чекбокс для заголовка (выбрать все)
+        def on_header_checkbox_change(e):
+            for checkbox, _ in self.row_checkboxes:
+                checkbox.value = self.header_checkbox.value
+            e.page.update()
+
+        self.header_checkbox = ft.Checkbox(
+            value=False, on_change=on_header_checkbox_change
+        )
+
+        rows = []
+        for row in data:
+            record_id = row[0]
+            cells = []
+            field_controls = {}
+
+            # Собираем данные строки в словарь
+            row_data = {field: value for field, value in zip(db_fields, row)}
+
+            # Создаём чекбокс для строки
+            row_checkbox = ft.Checkbox(value=False)
+            self.row_checkboxes.append((row_checkbox, row_data))
+            cells.append(ft.DataCell(row_checkbox))
+
+            for field, value in zip(db_fields, row):
+                if field == db_fields[0]:
+                    cells.append(ft.DataCell(ft.Text(str(value))))
+                    continue
+
+                if field in self.dropdown_options:
+                    ctrl = ft.Container(
+                        content=ft.Dropdown(
+                            options=[
+                                ft.dropdown.Option(key=str(k), text=v)
+                                for k, v in self.dropdown_options[field]
+                            ],
+                            value=str(value),
+                            expand=True,
+                        ),
+                        padding=5,
+                        expand=True,
+                    )
+                else:
+                    ctrl = ft.Container(
+                        content=ft.TextField(
+                            value=str(value), border=ft.InputBorder.NONE, expand=True
+                        ),
+                        padding=5,
+                        expand=True,
+                    )
+
+                field_controls[field] = ctrl.content
+                cells.append(ft.DataCell(ctrl))
+
+            def make_save_callback(record_id, controls):
+                def save(e):
+                    try:
+                        update_fields = ", ".join(
+                            f"{field} = %s" for field in controls.keys()
+                        )
+                        values = [c.value for c in controls.values()]
+                        update_query = f"UPDATE {self.table_name} SET {update_fields} WHERE {db_fields[0]} = %s"
+                        self.cursor.execute(update_query, (*values, record_id))
+                        self.cursor.connection.commit()
+                        e.page.open(ft.SnackBar(ft.Text("Изменения сохранены")))
+                        print(f"[LOG] Updated record {record_id} with values {values}")
+                    except Exception as ex:
+                        e.page.open(ft.SnackBar(ft.Text(f"Ошибка: {str(ex)}")))
+                    e.page.update()
+
+                return save
+
+            save_button = ft.IconButton(
+                icon=ft.Icons.SAVE,
+                tooltip="Сохранить",
+                on_click=make_save_callback(record_id, field_controls),
+            )
+            delete_button = ft.IconButton(
+                icon=ft.Icons.DELETE,
+                tooltip="Удалить",
+                on_click=self._handle_delete(record_id),
+            )
+            cells.append(ft.DataCell(ft.Row([save_button, delete_button], spacing=0)))
+
+            rows.append(ft.DataRow(cells=cells))
+
+        # Колонки: чекбокс + поля из mapping + действия
+        columns = (
+            [ft.DataColumn(self.header_checkbox)]
+            + [
+                ft.DataColumn(ft.Text(self.field_configs[field].label))
+                for field in db_fields
+            ]
+            + [ft.DataColumn(ft.Text("Действия"))]
+        )
+
+        return ft.DataTable(
+            columns=columns,
+            rows=rows,
+            # width=self.width - 20
+        )
+
+    def get_selected_rows(self) -> list[dict]:
+        """
+        Возвращает список словарей с данными выделенных строк.
+        Ключи словаря соответствуют полям из field_mapping.
+        """
+        selected = []
+        for checkbox, row_data in self.row_checkboxes:
+            if checkbox.value:
+                selected.append(row_data.copy())
+        return selected
+
+    def _handle_delete(self, record_id: int):
+        def callback(e):
+            try:
+                delete_query = f"DELETE FROM {self.table_name} WHERE {list(self.field_configs.keys())[0]} = %s"
+                self.cursor.execute(delete_query, (record_id,))
+                self.cursor.connection.commit()
+                e.page.open(ft.SnackBar(ft.Text("Запись удалена!")))
+                e.page.update()
+            except Exception as ex:
+                print(ex)
+                e.page.open(ft.SnackBar(ft.Text(f"Ошибка: {str(ex)}")))
+                e.page.update()
+
+        return callback

fletable/sql_table.py

@@ -0,0 +1,128 @@
+from dataclasses import dataclass
+
+import flet as ft
+
+from .editable_table import FieldConfig
+
+
+@dataclass
+class DisplayValue:
+    id: str
+    label: str
+
+
+class SqlTable:
+    """
+    Read-only таблица: только отображение и выбор строк.
+
+    Пример:
+        table = SqlTable(cursor, "users", {"user_id": "ID", "name": "Имя"})
+        data_table = table.create_table()
+        selected = table.get_selected_rows()
+    """
+
+    def __init__(
+        self,
+        cursor,
+        table_name: str,
+        field_mapping: dict[str, FieldConfig | str],
+        width: int = 800,
+        height: int = 400,
+    ):
+        self.cursor = cursor
+        self.table_name = table_name
+        self.field_configs: dict[str, FieldConfig] = {
+            name: cfg if isinstance(cfg, FieldConfig) else FieldConfig(label=str(cfg))
+            for name, cfg in field_mapping.items()
+        }
+        self.width = width
+        self.height = height
+        self.dropdown_options = self._generate_dropdown_options()
+        self.row_checkboxes: list[tuple[ft.Checkbox, dict]] = []
+        self.header_checkbox: ft.Checkbox = None
+
+    def _generate_dropdown_options(self) -> dict[str, list[DisplayValue]]:
+        """
+        Подтягиваем значения для внешних ключей, чтобы показывать подписанные лейблы.
+        """
+        options: dict[str, list[DisplayValue]] = {}
+        for field, cfg in self.field_configs.items():
+            ref_cfg = cfg.foreign_key
+            if ref_cfg or (field.endswith("_id") and field != f"{self.table_name}_id"):
+                ref_table = ref_cfg.table if ref_cfg else field.replace("_id", "")
+                id_column = ref_cfg.id_column if ref_cfg else field
+                label_column = ref_cfg.label_column if ref_cfg else ref_table
+                try:
+                    self.cursor.execute(
+                        f"SELECT {id_column}, {label_column} FROM {ref_table}"
+                    )
+                    results = self.cursor.fetchall()
+                    options[field] = [
+                        DisplayValue(id=str(row[0]), label=str(row[1]))
+                        for row in results
+                    ]
+                except Exception as e:
+                    print(f"[WARN] Не удалось загрузить dropdown для {field}: {e}")
+        return options
+
+    def _label_for_fk(self, field: str, value) -> str:
+        """
+        Возвращает человеко-читаемое значение для внешнего ключа.
+        """
+        if field not in self.dropdown_options:
+            return str(value)
+        for option in self.dropdown_options[field]:
+            if option.id == str(value):
+                return option.label
+        return str(value)
+
+    def create_table(self) -> ft.DataTable:
+        db_fields = list(self.field_configs.keys())
+        query = f"SELECT {', '.join(db_fields)} FROM {self.table_name}"
+        self.cursor.execute(query)
+        data = self.cursor.fetchall()
+
+        self.row_checkboxes = []
+
+        def on_header_checkbox_change(e):
+            for checkbox, _ in self.row_checkboxes:
+                checkbox.value = self.header_checkbox.value
+            e.page.update()
+
+        self.header_checkbox = ft.Checkbox(
+            value=False, on_change=on_header_checkbox_change
+        )
+
+        rows = []
+        for row in data:
+            row_data = {field: value for field, value in zip(db_fields, row)}
+            row_checkbox = ft.Checkbox(value=False)
+            self.row_checkboxes.append((row_checkbox, row_data))
+
+            cells = [ft.DataCell(row_checkbox)]
+            for field, value in zip(db_fields, row):
+                display_value = self._label_for_fk(field, value)
+                cells.append(ft.DataCell(ft.Text(display_value)))
+
+            rows.append(ft.DataRow(cells=cells))
+
+        columns = [ft.DataColumn(self.header_checkbox)] + [
+            ft.DataColumn(ft.Text(self.field_configs[field].label))
+            for field in db_fields
+        ]
+
+        return ft.DataTable(
+            columns=columns,
+            rows=rows,
+        )
+
+    def get_selected_rows(self) -> list[dict]:
+        """
+        Возвращает список словарей с данными выделенных строк.
+        Ключи словаря соответствуют полям из field_mapping.
+        """
+        selected = []
+        for checkbox, row_data in self.row_checkboxes:
+            if checkbox.value:
+                selected.append(row_data.copy())
+        return selected

fletable/utils.py

@@ -0,0 +1,117 @@
+import flet as ft
+
+
+class LoginView(ft.View):
+    """Login form view for user authentication.
+
+    Creates an interface for user authentication with login and password fields.
+    Validates user credentials against the database and displays appropriate
+    error messages.
+
+    :param user_table: Name of the database table containing user data
+    :type user_table: str
+    :param user_login_col: Name of the column in the table containing user logins
+    :type user_login_col: str
+    :param user_password_col: Name of the column in the table containing user passwords
+    :type user_password_col: str
+    :param dbapi_cursor: Database cursor for executing SQL queries
+    :type dbapi_cursor: dbapi.cursor
+
+    Example::
+
+        login_view = LoginView(
+            user_table="employees",
+            user_login_col="login",
+            user_password_col="password",
+            dbapi_cursor=connection.cursor(),
+        )
+        page.views.append(login_view)
+        page.update()
+    """
+
+    def __init__(
+        self,
+        user_table,
+        user_login_col,
+        user_password_col,
+        dbapi_cursor,
+        next,
+        user_role_col=None,
+        user_role_key=None,
+        user_id_col=None,
+        user_id_key=None,
+    ):
+        super().__init__()
+        self.user_table = user_table
+        self.user_login_col = user_login_col
+        self.user_password_col = user_password_col
+        self.user_role_col = user_role_col
+        self.user_role_key = user_role_key
+        self.cursor = dbapi_cursor
+        self.next_func = next
+        self.user_id_col = user_id_col
+        self.user_id_key = user_id_key
+
+        title = ft.Text("Вход", size=20, weight="bold")
+        self.login = ft.TextField(label="Логин")
+        self.password = ft.TextField(
+            label="Пароль", password=True, can_reveal_password=True
+        )
+        self.submit = ft.FilledButton("Войти", on_click=self.check_credentials)
+
+        self.route = "/login"
+        self.form = ft.Column(
+            [
+                ft.Row(controls=[title], alignment=ft.MainAxisAlignment.CENTER),
+                self.login,
+                self.password,
+                ft.Row(controls=[self.submit], alignment=ft.MainAxisAlignment.END),
+            ],
+            width=300,
+        )
+        self.horizontal_alignment = ft.CrossAxisAlignment.CENTER
+        self.vertical_alignment = ft.MainAxisAlignment.CENTER
+        self.controls = [self.form]
+
+    def check_credentials(self, e):
+        login = self.login.value
+        password = self.password.value
+        self.password.error_text = None
+        self.login.error_text = None
+        if not (login and password):
+            if not login:
+                self.login.error_text = "введите логин"
+            else:
+                self.login.error_text = None
+            if not password:
+                self.password.error_text = "Введите пароль"
+            else:
+                self.password.error_text = None
+            self.page.update()
+            return
+        self.page.update()
+
+        self.cursor.execute(
+            f"""
+            SELECT {self.user_role_col if self.user_role_col else -1}, {self.user_id_col if self.user_id_col else -1}
+            FROM {self.user_table} 
+            WHERE {self.user_login_col}='{login}' AND {self.user_password_col}='{password}'
+            """
+        )
+        result = self.cursor.fetchone()
+        if not result:
+            dlg = ft.AlertDialog(
+                title=ft.Text("Предупреждение"),
+                content=ft.Text("Неверный логин и пароль"),
+                alignment=ft.alignment.center,
+                title_padding=ft.padding.all(25),
+                actions=[ft.TextButton("Ok", on_click=lambda e: self.page.close(dlg))],
+            )
+            self.page.open(dlg)
+            return
+        if self.user_role_col and self.user_role_key and result[0] != -1:
+            self.page.client_storage.set(self.user_role_key, result[0])
+            self.page.client_storage.set(self.user_id_key, result[1])
+
+        self.page.views.pop()
+        self.next_func(self.page)

fletable-0.0.1.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: fletable
+Version: 0.0.1
+Summary: Tables that take data from SQL database
+Home-page: https://github.com/RichCake/fletable
+Author: RichCake
+Author-email: abs2016123@gmail.com
+Project-URL: GitHub, https://github.com/RichCake/fletable
+Keywords: flet sql table
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: flet==0.28.3
+Requires-Dist: flet-cli==0.28.3
+Requires-Dist: flet-desktop==0.28.3
+Requires-Dist: flet-web==0.28.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Fletable
+
+**Fletable** — Python-библиотека для создания интерактивных таблиц с данными из SQL-баз в приложениях на Flet. Поддерживает редактирование данных, автоматическую обработку внешних ключей и удобную работу с формами.
+
+## ✨ Возможности
+
+- 📝 **Редактируемые таблицы** — изменение, добавление и удаление записей прямо в интерфейсе
+- 👀 **Таблицы только для чтения** — отображение данных с возможностью выбора строк
+- 🔗 **Автоматическая обработка внешних ключей** — dropdown-списки для связанных таблиц
+- ✅ **Множественный выбор** — чекбоксы для выделения строк
+- 🔐 **Встроенная форма авторизации** — готовый компонент для входа пользователей
+- 🎨 **Настраиваемые подписи полей** — удобное отображение имен колонок
+
+## 📦 Установка
+
+```bash
+pip install fletable
+```
+
+Или установите из исходного кода:
+
+```bash
+git clone <repository-url>
+cd fletable
+pip install -e .
+```
+
+## 🚀 Быстрый старт
+
+### 1. Редактируемая таблица
+
+```python
+import flet as ft
+import psycopg2
+from fletable import EditableTable, FieldConfig
+
+def main(page: ft.Page):
+    # Подключение к базе данных
+    conn = psycopg2.connect(
+        host="localhost",
+        database="mydb",
+        user="user",
+        password="password"
+    )
+    cursor = conn.cursor()
+    
+    # Создание таблицы
+    table = EditableTable(
+        cursor=cursor,
+        table_name="employees",
+        field_mapping={
+            "employee_id": "ID",
+            "name": "Имя",
+            "email": "Email",
+            "department_id": FieldConfig(
+                label="Отдел",
+                foreign_key=ForeignKeyConfig(
+                    table="departments",
+                    id_column="department_id",
+                    label_column="department_name"
+                )
+            )
+        },
+    )
+    
+    # Форма добавления
+    add_form, handle_add = table.create_add_form()
+    
+    def add_record(e):
+        success, message = handle_add()
+        if success:
+            # Обновление таблицы после добавления
+            container.content = table.create_table()
+            page.update()
+    
+    add_button = ft.ElevatedButton("Добавить", on_click=add_record)
+    
+    # Контейнер с таблицей
+    container = ft.Container(
+        content=table.create_table(),
+        padding=10
+    )
+    
+    page.add(
+        ft.Column([
+            ft.Text("Управление сотрудниками", size=24, weight="bold"),
+            add_form,
+            add_button,
+            container
+        ])
+    )
+
+ft.app(target=main)
+```
+
+### 2. Таблица только для чтения
+
+```python
+import flet as ft
+from fletable import SqlTable
+
+def main(page: ft.Page):
+    # Подключение к БД
+    cursor = conn.cursor()
+    
+    # Создание read-only таблицы
+    table = SqlTable(
+        cursor=cursor,
+        table_name="products",
+        field_mapping={
+            "product_id": "ID",
+            "product_name": "Название",
+            "price": "Цена",
+            "category_id": "Категория"
+        }
+    )
+    
+    # Кнопка для получения выделенных строк
+    def show_selected(e):
+        selected = table.get_selected_rows()
+        print("Выбрано записей:", len(selected))
+        for row in selected:
+            print(row)
+    
+    page.add(
+        ft.Column([
+            ft.Container(content=table.create_table(), padding=10),
+            ft.ElevatedButton("Показать выбранные", on_click=show_selected)
+        ])
+    )
+
+ft.app(target=main)
+```
+
+### 3. Форма авторизации
+
+```python
+import flet as ft
+from fletable import LoginView
+
+def main(page: ft.Page):
+    def after_login(page):
+        # Переход на главную страницу после успешного входа
+        page.views.append(
+            ft.View("/home", [
+                ft.Text("Добро пожаловать!")
+            ])
+        )
+        page.update()
+    
+    login_view = LoginView(
+        user_table="users",
+        user_login_col="login",
+        user_password_col="password",
+        dbapi_cursor=cursor,
+        next=after_login,
+        user_role_col="role",
+        user_role_key="user_role",
+        user_id_col="user_id",
+        user_id_key="current_user_id"
+    )
+    
+    page.views.append(login_view)
+    page.update()
+
+ft.app(target=main)
+```
+
+## 📚 Документация API
+
+### EditableTable
+
+Класс для создания редактируемых таблиц с поддержкой CRUD-операций.
+
+#### Конструктор
+
+```python
+EditableTable(
+    cursor,                          # Курсор базы данных (DB-API 2.0)
+    table_name: str,                 # Имя таблицы в БД
+    field_mapping: dict,             # Маппинг полей {column: label или FieldConfig}
+    width: int = 800,                # Ширина таблицы (пикселей)
+    height: int = 400                # Высота таблицы (пикселей)
+)
+```
+
+#### Методы
+
+- **`create_table()`** — создает и возвращает `ft.DataTable` с данными
+- **`create_add_form()`** — создает форму для добавления новых записей, возвращает `(form_row, handle_add)`
+- **`get_selected_rows()`** — возвращает список словарей с данными выделенных строк
+
+### SqlTable
+
+Класс для создания таблиц только для чтения с возможностью выбора строк.
+
+#### Конструктор
+
+```python
+SqlTable(
+    cursor,                          # Курсор базы данных
+    table_name: str,                 # Имя таблицы
+    field_mapping: dict,             # Маппинг полей
+    width: int = 800,
+    height: int = 400
+)
+```
+
+#### Методы
+
+- **`create_table()`** — создает и возвращает `ft.DataTable`
+- **`get_selected_rows()`** — возвращает выделенные строки
+
+### FieldConfig
+
+Конфигурация для настройки отображения полей.
+
+```python
+@dataclass
+class FieldConfig:
+    label: str                       # Отображаемое название поля
+    foreign_key: ForeignKeyConfig | None = None  # Конфигурация внешнего ключа
+```
+
+### ForeignKeyConfig
+
+Настройка внешнего ключа для автоматического создания dropdown-списков.
+
+```python
+@dataclass
+class ForeignKeyConfig:
+    table: str                       # Имя связанной таблицы
+    id_column: str                   # Колонка с ID
+    label_column: str                # Колонка с отображаемым значением
+```
+
+### LoginView
+
+Готовая форма авторизации пользователей.
+
+```python
+LoginView(
+    user_table: str,                 # Таблица с пользователями
+    user_login_col: str,             # Колонка с логином
+    user_password_col: str,          # Колонка с паролем
+    dbapi_cursor,                    # Курсор БД
+    next: callable,                  # Функция после успешного входа
+    user_role_col: str = None,       # Колонка с ролью (опционально)
+    user_role_key: str = None,       # Ключ для хранения роли
+    user_id_col: str = None,         # Колонка с ID пользователя
+    user_id_key: str = None          # Ключ для хранения ID
+)
+```
+
+## 🔧 Автоматическая обработка внешних ключей
+
+Fletable автоматически создает dropdown-списки для полей с именами, заканчивающимися на `_id` (кроме первичного ключа таблицы):
+
+```python
+field_mapping = {
+    "order_id": "ID заказа",
+    "customer_id": "Клиент",        # Автоматически создаст dropdown из таблицы "customer"
+    "product_id": "Товар"           # Автоматически создаст dropdown из таблицы "product"
+}
+```
+
+Для более точной настройки используйте `ForeignKeyConfig`:
+
+```python
+field_mapping = {
+    "order_id": "ID заказа",
+    "customer_id": FieldConfig(
+        label="Клиент",
+        foreign_key=ForeignKeyConfig(
+            table="customers",
+            id_column="customer_id",
+            label_column="full_name"
+        )
+    )
+}
+```
+
+## 💡 Примеры использования
+
+### Обновление таблицы после изменений
+
+```python
+def refresh_table(e):
+    container.content = table.create_table()
+    page.update()
+
+refresh_button = ft.IconButton(
+    icon=ft.Icons.REFRESH,
+    on_click=refresh_table
+)
+```
+
+### Работа с выделенными строками
+
+```python
+def process_selected(e):
+    selected = table.get_selected_rows()
+    for row in selected:
+        print(f"ID: {row['employee_id']}, Name: {row['name']}")
+```
+
+### Массовое удаление
+
+```python
+def delete_selected(e):
+    selected = table.get_selected_rows()
+    for row in selected:
+        cursor.execute(
+            "DELETE FROM employees WHERE employee_id = %s",
+            (row['employee_id'],)
+        )
+    conn.commit()
+    refresh_table(e)
+```
+
+## 🗄️ Поддерживаемые базы данных
+
+Fletable работает с любыми базами данных, поддерживающими DB-API 2.0:
+
+- PostgreSQL (psycopg2)
+- MySQL (mysql-connector-python)
+- SQLite (sqlite3)
+- Oracle
+- Microsoft SQL Server
+
+## 📋 Требования
+
+- Python >= 3.6
+- flet >= 0.28.3
+- Драйвер базы данных (psycopg2, mysql-connector, и т.д.)
+
+## 🤝 Участие в разработке
+
+Мы приветствуем ваши предложения и pull request'ы!
+
+## 📄 Лицензия
+
+MIT License
+
+## 👨‍💻 Автор
+
+**RichCake**  
+Email: abs2016123@gmail.com
+
+---
+
+⭐ Если вам понравился проект, поставьте звезду на GitHub!
+

fletable-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+fletable/__init__.py,sha256=bAuv-OvRBPuBJWlqU2Gq3b0ppj2-L5qS0SkuPk6RBTM,134
+fletable/editable_table.py,sha256=PcUPxmfIsZzBgHCAPFgD-8nG1fe-kq8Tf9A9Hq69Y1s,9399
+fletable/sql_table.py,sha256=Q-XzZR8mhMnHffaT63UuBP0B1lmHCsR5m8DgTRigPx8,4675
+fletable/utils.py,sha256=o7gaTyBw5VL0cYs-6IqnTuU7PtmQwsdqXKTGzBxEVI4,4186
+fletable-0.0.1.dist-info/METADATA,sha256=m0U4g78ikOf1x4_P4jXB5oFDwMfShJpYF43U1G9THjc,11959
+fletable-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fletable-0.0.1.dist-info/top_level.txt,sha256=YofKKSe3S3HQ1YwJwI7CVrF_1KEHcYwzLEBezSPppGk,9
+fletable-0.0.1.dist-info/RECORD,,

fletable-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fletable-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+fletable