vrbase 1.0.0__py3-none-any.whl

vrbase-1.0.0.dist-info/METADATA

@@ -0,0 +1,624 @@
+Metadata-Version: 2.4
+Name: vrbase
+Version: 1.0.0
+Summary: Русская документо-ориентированная база данных — проще чем SQL
+Author: Pantapan1
+Keywords: база данных,database,json,русский,documents,nosql
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+VRBase — Русская база данных
+
+Документо-ориентированная база данных на русском языке. Проще чем SQL, быстрее чем JSON вручную.
+
+https://img.shields.io/pypi/v/vrbase.svg
+https://img.shields.io/badge/python-3.8+-blue.svg
+https://img.shields.io/badge/license-MIT-green.svg
+
+---
+
+📖 Оглавление
+
+· Почему VRBase
+· Установка
+· Быстрый старт
+· Основные понятия
+· Полное руководство
+  · База данных
+  · Коробка
+  · Документы
+  · Поиск
+  · Обновление
+  · Удаление
+  · Индексы
+  · Запросы
+  · Агрегация
+  · Шифрование
+  · Миграции
+· Сравнение с SQL
+· Примеры
+· API Reference
+
+---
+
+Почему VRBase
+
+Проблема SQL
+
+```sql
+CREATE TABLE players (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    level INTEGER DEFAULT 1,
+    inventory TEXT,
+    stats TEXT
+);
+
+INSERT INTO players (name, level, inventory, stats) 
+VALUES ('Миро', 10, '["меч","щит"]', '{"hp":100,"mp":50}');
+
+SELECT * FROM players WHERE level > 5 ORDER BY level DESC LIMIT 10;
+```
+
+Решение VRBase
+
+```python
+from vrbase import База
+
+мир = База("survival")
+игроки = мир.коробка("игроки")
+
+игроки.положить({
+    "имя": "Миро",
+    "уровень": 10,
+    "инвентарь": ["меч", "щит"],
+    "статы": {"здоровье": 100, "мана": 50}
+})
+
+топ = игроки.найти(где={"уровень": "> 5"}, сортировка="уровень убыв", лимит=10)
+```
+
+Разница: Не нужно думать о схемах, типах данных, JOIN'ах, миграциях. Просто кладёшь словарь и ищешь по-русски.
+
+---
+
+Установка
+
+```bash
+pip install vrbase
+```
+
+Или из исходников:
+
+```bash
+git clone https://github.com/Pantapan1/VRBase.git
+cd VRBase
+pip install -e .
+```
+
+Зависимости: cryptography>=41.0.0 (только для шифрования)
+
+---
+
+Быстрый старт
+
+```python
+from vrbase import База
+
+# Создаём или открываем базу
+мир = База("мой_мир")
+
+# Создаём коробку (аналог таблицы)
+игроки = мир.коробка("игроки")
+
+# Добавляем игрока
+игроки.положить({
+    "имя": "Миро",
+    "уровень": 1,
+    "класс": "воин",
+    "инвентарь": ["меч", "зелье"],
+    "статы": {"здоровье": 100, "мана": 50}
+})
+
+# Ищем
+новички = игроки.найти(где={"уровень": "< 5"})
+
+# Обновляем
+игроки.обновить(где={"имя": "Миро"}, данные={"уровень": 10})
+
+# Сохраняем
+мир.сохранить()
+
+print(f"Игроков: {игроки.считать()}")
+```
+
+---
+
+Основные понятия
+
+VRBase SQL
+База Database
+Коробка Table
+Документ Row
+Ключ Column
+положить() INSERT
+найти() SELECT
+обновить() UPDATE
+удалить() DELETE
+Индекс Index
+
+---
+
+Полное руководство
+
+База данных
+
+```python
+from vrbase import База
+
+# Обычная база (файл .json)
+мир = База("survival")
+
+# База с шифрованием (.enc)
+мир = База("survival", ключ="мой_секретный_пароль")
+
+# База в конкретной папке
+мир = База("survival", путь="/path/to/survival.json")
+
+# Контекстный менеджер (авто-сохранение)
+with База("survival") as мир:
+    игроки = мир.коробка("игроки")
+    игроки.положить({"имя": "Миро"})
+# Автоматически сохранится
+
+# Просмотр информации
+print(мир.инфо())
+# {'имя': 'survival', 'коробок': 1, 'документов': 1, 'размер_байт': 256}
+
+# Бэкап
+мир.бэкап()  # → survival_2026-05-09_12-30-00.json
+
+# Сохранить копию
+мир.сохранить_как("survival_backup.json")
+
+# Очистить
+мир.очистить()  # Удаляет всё
+```
+
+Коробка
+
+```python
+игроки = мир.коробка("игроки")
+
+# Сколько документов
+print(len(игроки))        # 5
+print(игроки.размер())    # 5
+print(игроки.память())    # 2500 (байт в памяти)
+
+# Все ключи документов
+print(игроки.ключи())     # ['_id', '_создан', 'имя', 'уровень', ...]
+
+# Уникальные значения поля
+print(игроки.уникальные("класс"))  # ['воин', 'маг', 'вор']
+
+# Есть ли документ с таким условием
+if игроки.есть(где={"имя": "Миро"}):
+    print("Миро существует")
+
+# Перебор
+for игрок in игроки:
+    print(игрок['имя'])
+
+# Доступ по ID
+игрок = игроки[0]  # Первый документ
+```
+
+Документы
+
+```python
+# Добавить один
+ид = игроки.положить({
+    "имя": "Миро",
+    "уровень": 1,
+    "инвентарь": ["меч", "хлеб"],
+    "статы": {"здоровье": 100, "выносливость": 80}
+})
+print(ид)  # 0
+
+# Добавить много
+игроки.положить_много([
+    {"имя": "Кай", "уровень": 5},
+    {"имя": "Анна", "уровень": 7},
+    {"имя": "Олег", "уровень": 3}
+])
+
+# Автоматически добавляются поля:
+# _id — уникальный номер
+# _создан — время создания в ISO формате
+# _обновлён — время последнего обновления
+
+игрок = игроки.найти_один(где={"имя": "Миро"})
+print(игрок['_id'])        # 0
+print(игрок['_создан'])    # 2026-05-09T12:30:00
+```
+
+Поиск
+
+```python
+# Точное совпадение
+игроки.найти(где={"уровень": 10})
+
+# Больше / меньше
+игроки.найти(где={"уровень": "> 5"})
+игроки.найти(где={"уровень": ">= 10"})
+игроки.найти(где={"уровень": "< 3"})
+игроки.найти(где={"уровень": "!= 5"})
+
+# Диапазон
+игроки.найти(где={"уровень": "между 5 и 20"})
+
+# Поиск подстроки
+игроки.найти(где={"имя": "содержит мир"})  # найдёт "Миро", "Владимир"
+
+# Начинается с / заканчивается на
+игроки.найти(где={"имя": "начинается с М"})
+игроки.найти(где={"имя": "заканчивается на о"})
+
+# Пусто / не пусто
+игроки.найти(где={"инвентарь": "пусто"})
+игроки.найти(где={"инвентарь": "не пусто"})
+
+# Поиск по вложенному полю
+игроки.найти(где={"статы.здоровье": "> 50"})
+
+# Содержит в списке
+игроки.найти(содержит={"инвентарь": "меч"})
+
+# Сортировка
+игроки.найти(сортировка="уровень убыв")
+игроки.найти(сортировка="имя возр")
+
+# Комбинированный поиск
+ветераны = игроки.найти(
+    где={"уровень": "> 10", "класс": "воин"},
+    сортировка="уровень убыв",
+    лимит=5
+)
+
+# Найти один
+миро = игроки.найти_один(имя="Миро")
+
+# Найти по ID
+игрок = игроки.найти_по_id(0)
+```
+
+Обновление
+
+```python
+# Обновить по условию
+игроки.обновить(
+    где={"имя": "Миро"},
+    данные={"уровень": 15, "золото": 500}
+)
+
+# Обновить по ID
+игроки.обновить_по_id(0, {"уровень": 20})
+
+# Обновить все документы
+игроки.обновить_все({"бонус": 0})
+
+# Обновить вложенное поле
+игроки.обновить(
+    где={"имя": "Миро"},
+    данные={"статы.здоровье": 150}
+)
+
+# Авто-обновление _обновлён
+игрок = игроки.найти_один(имя="Миро")
+print(игрок['_обновлён'])  # 2026-05-09T13:00:00
+```
+
+Удаление
+
+```python
+# Удалить по условию
+игроки.удалить(где={"уровень": "< 2"})
+
+# Удалить по ID
+игроки.удалить_по_id(0)
+
+# Удалить всё
+игроки.удалить_все()
+```
+
+Индексы
+
+Индексы ускоряют поиск в 10-1000 раз на больших объёмах данных.
+
+```python
+# Создать индекс
+игроки.создать_индекс("имя")
+игроки.создать_индекс("уровень")
+
+# Составной индекс
+игроки.создать_индекс(["класс", "уровень"])
+
+# Поиск с индексом (автоматически используется)
+игроки.найти(где={"имя": "Миро"})  # O(log n) вместо O(n)
+
+# Удалить индекс
+игроки.удалить_индекс("имя")
+
+# Перестроить все индексы
+игроки.перестроить_индексы()
+
+# Статистика индекса
+индекс = игроки.создать_индекс("уровень")
+print(индекс.статистика())
+# {'тип': 'числовой', 'уникальных': 15, 'минимум': 1, 'максимум': 50, 'среднее': 12.3}
+```
+
+Запросы
+
+Сложные запросы через конструктор:
+
+```python
+from vrbase import Запрос
+
+# Сложный запрос
+результат = (Запрос(игроки)
+    .где(уровень="> 5")
+    .и_(класс="воин")
+    .или(класс="маг")
+    .не_(статус="мёртв")
+    .содержит(инвентарь="меч")
+    .сортировать_по("уровень", убывание=True)
+    .лимит(10)
+    .пропустить(5)
+    .выполнить())
+
+# Выбрать только определённые поля
+результат = (Запрос(игроки)
+    .выбрать("имя", "уровень")
+    .где(уровень="> 10")
+    .выполнить())
+
+# Уникальные значения
+результат = (Запрос(игроки)
+    .выбрать("класс")
+    .уникальные()
+    .выполнить())
+
+# Проверить существование
+есть = (Запрос(игроки)
+    .где(имя="Миро")
+    .существует())
+
+# Парсинг строки запроса
+from vrbase import ПарсерЗапроса
+
+запрос = ПарсерЗапроса.разобрать(
+    "выбрать имя, уровень где уровень > 5 сортировка по уровень лимит 5",
+    игроки
+)
+результат = запрос.выполнить()
+```
+
+Агрегация
+
+```python
+# Подсчёт
+стата = (игроки.агрегация()
+    .считать()
+    .выполнить())
+# [{'количество': 150}]
+
+# Группировка
+стата = (игроки.агрегация()
+    .группировать_по("класс")
+    .считать()
+    .среднее("уровень")
+    .выполнить())
+# [
+#   {'класс': 'воин', 'количество': 50, 'среднее_уровень': 12.3},
+#   {'класс': 'маг', 'количество': 30, 'среднее_уровень': 15.1}
+# ]
+
+# Сумма, минимум, максимум
+стата = (игроки.агрегация()
+    .группировать_по("класс")
+    .считать("игроков")
+    .сумма("золото", "всего_золота")
+    .максимум("уровень", "макс_уровень")
+    .выполнить())
+```
+
+Шифрование
+
+```python
+from vrbase import Шифр
+
+# Зашифровать данные
+зашифровано = Шифр.зашифровать("секретные данные", "мой_пароль")
+
+# Расшифровать
+данные = Шифр.расшифровать(зашифровано, "мой_пароль")
+
+# Зашифровать файл
+Шифр.зашифровать_файл("data.json", "пароль", "data.enc")
+
+# Расшифровать файл
+Шифр.расшифровать_файл("data.enc", "пароль", "data.json")
+
+# Хэш строки
+хэш = Шифр.хэш("важные данные")
+
+# Хэш файла
+хэш = Шифр.хэш_файла("data.json")
+
+# Сравнить файлы
+одинаковые = Шифр.сравнить_хэши("file1.json", "file2.json")
+
+# Электронная подпись
+подпись = Шифр.подписать("документ", "ключ")
+валидна = Шифр.проверить_подпись("документ", подпись, "ключ")
+
+# Сгенерировать пароль
+пароль = Шифр.сгенерировать_пароль(16)
+
+# Проверить надёжность пароля
+print(Шифр.надёжность_пароля("qwerty"))        # Слабый
+print(Шифр.надёжность_пароля("Qw3rty!@2026"))  # Очень надёжный
+```
+
+Миграции
+
+```python
+from vrbase import Миграция, МенеджерМиграций
+
+менеджер = МенеджерМиграций(мир)
+
+# Создать миграцию
+v1 = (Миграция("1.0.0", "Начальная структура")
+    .добавить_поле("игроки", "золото", 100)
+    .добавить_поле("игроки", "опыт", 0))
+
+v2 = (Миграция("1.1.0", "Добавляем магию")
+    .добавить_поле("игроки", "мана", 50)
+    .добавить_поле("игроки", "макс_мана", 50))
+
+v3 = (Миграция("2.0.0", "Переименовываем")
+    .переименовать_поле("игроки", "золото", "монеты"))
+
+# Зарегистрировать
+менеджер.зарегистрировать(v1)
+менеджер.зарегистрировать(v2)
+менеджер.зарегистрировать(v3)
+
+# Применить все
+менеджер.применить()
+
+# Применить до определённой версии
+менеджер.применить(до_версии="1.1.0")
+
+# Статус
+print(менеджер.статус())
+# {'всего': 3, 'применено': 2, 'ожидают': 1}
+
+# Откатить
+менеджер.откатить("1.0.0")
+```
+
+---
+
+Сравнение с SQL
+
+Действие SQL VRBase
+Создать таблицу CREATE TABLE ... мир.коробка("имя")
+Вставить INSERT INTO ... .положить({...})
+Выбрать все SELECT * FROM ... .найти_все()
+Выбрать с условием WHERE x = 5 .найти(где={"x": 5})
+Больше/меньше WHERE x > 5 .найти(где={"x": "> 5"})
+Сортировка ORDER BY x DESC сортировка="x убыв"
+Лимит LIMIT 10 лимит=10
+Обновить UPDATE ... SET ... .обновить(где=..., данные=...)
+Удалить DELETE FROM ... .удалить(где=...)
+Индекс CREATE INDEX ... .создать_индекс(...)
+JOIN LEFT JOIN ... Вложенные документы
+Схема Обязательна Не нужна
+Миграции ALTER TABLE ... Автоматически
+
+---
+
+Примеры
+
+RPG-бот на RuGram + VRBase
+
+```python
+from ядро import РуГрам
+from vrbase import База
+
+бот = РуГрам("ТОКЕН")
+мир = База("rpg_bot")
+игроки = мир.коробка("игроки")
+
+@бот.обработать(команда="start")
+def старт(сообщение, контекст):
+    игрок = игроки.найти_один(чат_ид=сообщение.чат.ид)
+    if not игрок:
+        игроки.положить({
+            "чат_ид": сообщение.чат.ид,
+            "имя": сообщение.от.имя,
+            "уровень": 1,
+            "здоровье": 100,
+            "золото": 0
+        })
+        мир.сохранить()
+    
+    бот.отправить(сообщение.чат.ид, "Добро пожаловать!")
+```
+
+---
+
+API Reference
+
+База
+
+Метод Описание
+База(имя, путь, ключ) Создать/открыть базу
+.коробка(имя) Получить коробку
+.сохранить() Сохранить на диск
+.загрузить() Загрузить с диска
+.бэкап() Создать копию
+.очистить() Удалить всё
+.инфо() Информация о базе
+.список_коробок() Список коробок
+.размер() Размер файла в байтах
+
+Коробка
+
+Метод Описание
+.положить(документ) Добавить документ
+.положить_много(список) Добавить много
+.найти(где, содержит, сортировка, лимит) Поиск
+.найти_один(**условия) Найти один
+.найти_все() Все документы
+.найти_по_id(ид) По ID
+.считать(где) Количество
+.обновить(где, данные) Обновить
+.обновить_по_id(ид, данные) Обновить по ID
+.обновить_все(данные) Обновить все
+.удалить(где) Удалить
+.удалить_по_id(ид) Удалить по ID
+.удалить_все() Очистить
+.есть(где) Проверить существование
+.создать_индекс(ключ) Создать индекс
+.удалить_индекс(ключ) Удалить индекс
+.уникальные(ключ) Уникальные значения
+.ключи() Все ключи
+.экспорт() Экспорт данных
+.импорт(данные) Импорт данных
+.запрос() Создать запрос
+.агрегация() Создать агрегацию
+
+---
+
+Лицензия
+
+MIT License. Свободное использование, модификация и распространение.

vrbase-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+vrbase.py,sha256=f_sk8g6AcdNc8lE24Cfueq6LprbcCAITHEf96rO_mZM,22261
+vrbase-1.0.0.dist-info/METADATA,sha256=N5haX_Co1c336K5AHQ0XMBl2FUoRPk1xyD0_RwcZf6c,19814
+vrbase-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vrbase-1.0.0.dist-info/top_level.txt,sha256=ph9YrF-dnBRXnRJ0gALZyonsUvVlLNoXnh3s_PW4oaI,7
+vrbase-1.0.0.dist-info/RECORD,,

vrbase-1.0.0.dist-info/WHEEL

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

vrbase-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vrbase

vrbase.py

@@ -0,0 +1,512 @@
+import json
+import os
+import shutil
+import hashlib
+import base64
+from datetime import datetime
+from typing import Any, List, Dict, Optional, Union
+from cryptography.fernet import Fernet
+
+
+class ОшибкаБазы(Exception):
+    pass
+
+
+class ОшибкаКоробки(Exception):
+    pass
+
+
+class ОшибкаЗапроса(Exception):
+    pass
+
+
+class ОшибкаШифрования(Exception):
+    pass
+
+
+class Шифр:
+    @staticmethod
+    def создать_ключ(пароль: str) -> bytes:
+        хэш = hashlib.sha256(пароль.encode()).digest()
+        return base64.urlsafe_b64encode(хэш[:32])
+
+    @staticmethod
+    def зашифровать(данные: str, пароль: str) -> bytes:
+        ключ = Шифр.создать_ключ(пароль)
+        фернет = Fernet(ключ)
+        return фернет.encrypt(данные.encode())
+
+    @staticmethod
+    def расшифровать(данные: bytes, пароль: str) -> str:
+        ключ = Шифр.создать_ключ(пароль)
+        фернет = Fernet(ключ)
+        return фернет.decrypt(данные).decode()
+
+
+class Условие:
+    def __init__(self):
+        self.условия_и = []
+        self.условия_или = []
+        self.условия_не = []
+        self.условия_содержит = []
+        self.сортировка = None
+        self.обратная_сортировка = False
+        self.лимит_значение = None
+        self.пропустить_значение = 0
+
+    def где(self, **условия):
+        for ключ, значение in условия.items():
+            self.условия_и.append((ключ, значение))
+        return self
+
+    def и_(self, **условия):
+        return self.где(**условия)
+
+    def или(self, **условия):
+        for ключ, значение in условия.items():
+            self.условия_или.append((ключ, значение))
+        return self
+
+    def не_(self, **условия):
+        for ключ, значение in условия.items():
+            self.условия_не.append((ключ, значение))
+        return self
+
+    def содержит(self, **условия):
+        for ключ, значение in условия.items():
+            self.условия_содержит.append((ключ, значение))
+        return self
+
+    def сортировать_по(self, ключ: str, убывание: bool = False):
+        self.сортировка = ключ
+        self.обратная_сортировка = убывание
+        return self
+
+    def лимит(self, n: int):
+        self.лимит_значение = n
+        return self
+
+    def пропустить(self, n: int):
+        self.пропустить_значение = n
+        return self
+
+    def обратно(self):
+        self.обратная_сортировка = not self.обратная_сортировка
+        return self
+
+
+class Индекс:
+    def __init__(self, имя: str, ключ: Union[str, List[str]]):
+        self.имя = имя
+        self.ключи = [ключ] if isinstance(ключ, str) else ключ
+        self.данные = {}
+
+    def добавить(self, ид_документа: int, документ: Dict):
+        значения = tuple(self.получить_значение(документ, к) for к in self.ключи)
+        if значения not in self.данные:
+            self.данные[значения] = set()
+        self.данные[значения].add(ид_документа)
+
+    def удалить(self, ид_документа: int, документ: Dict):
+        значения = tuple(self.получить_значение(документ, к) for к in self.ключи)
+        if значения in self.данные:
+            self.данные[значения].discard(ид_документа)
+            if not self.данные[значения]:
+                del self.данные[значения]
+
+    def найти(self, значение: Any) -> set:
+        значения = tuple(значение) if isinstance(значение, (list, tuple)) else (значение,)
+        if значения in self.данные:
+            return self.данные[значения]
+        return set()
+
+    def найти_диапазон(self, от_: Any, до: Any) -> set:
+        результат = set()
+        for значения, ид in self.данные.items():
+            val = значения[0]
+            if от_ <= val <= до:
+                результат.update(ид)
+        return результат
+
+    def получить_значение(self, документ: Dict, ключ: str) -> Any:
+        ключи = ключ.split(".")
+        значение = документ
+        for к in ключи:
+            if isinstance(значение, dict):
+                значение = значение.get(к)
+            else:
+                return None
+        return значение
+
+
+class Коробка:
+    def __init__(self, имя: str, база):
+        self.имя = имя
+        self.база = база
+        self.документы = []
+        self.счетчик = 0
+        self.индексы: Dict[str, Индекс] = {}
+
+    def положить(self, документ: Dict) -> int:
+        if not isinstance(документ, dict):
+            raise ОшибкаКоробки("Документ должен быть словарём")
+        ид = self.счетчик
+        документ["_id"] = ид
+        документ["_создан"] = datetime.now().isoformat()
+        self.документы.append(документ)
+        for индекс in self.индексы.values():
+            индекс.добавить(ид, документ)
+        self.счетчик += 1
+        return ид
+
+    def положить_много(self, документы: List[Dict]) -> List[int]:
+        ид_список = []
+        for документ in документы:
+            ид_список.append(self.положить(документ))
+        return ид_список
+
+    def найти(self, где: Dict = None, содержит: Dict = None, сортировка: str = None, лимит: int = None) -> List[Dict]:
+        условие = Условие()
+        if где:
+            условие.где(**где)
+        if содержит:
+            условие.содержит(**содержит)
+        if сортировка:
+            убыв = "убыв" in сортировка or "desc" in сортировка.lower()
+            ключ = сортировка.replace(" убыв", "").replace(" desc", "").replace(" возр", "").replace(" asc", "")
+            условие.сортировать_по(ключ, убыв)
+        if лимит:
+            условие.лимит(лимит)
+        return self.выполнить(условие)
+
+    def найти_один(self, где: Dict = None, **kwargs) -> Optional[Dict]:
+        if где is None and kwargs:
+            где = kwargs
+        результат = self.найти(где=где, лимит=1)
+        return результат[0] if результат else None
+
+    def найти_все(self) -> List[Dict]:
+        return self.документы.copy()
+
+    def найти_по_id(self, ид: int) -> Optional[Dict]:
+        for документ in self.документы:
+            if документ.get("_id") == ид:
+                return документ
+        return None
+
+    def считать(self, где: Dict = None) -> int:
+        если не где:
+            return len(self.документы)
+        return len(self.найти(где=где))
+
+    def выполнить(self, условие: Условие) -> List[Dict]:
+        результат = []
+
+        if условие.условия_и:
+            ид_кандидаты = None
+            for ключ, значение in условие.условия_и:
+                if ключ in self.индексы:
+                    ид = self.индексы[ключ].найти(значение)
+                    if ид_кандидаты is None:
+                        ид_кандидаты = ид
+                    else:
+                        ид_кандидаты &= ид
+            if ид_кандидаты is not None:
+                результат = [d for d in self.документы if d["_id"] in ид_кандидаты]
+            else:
+                результат = self.документы.copy()
+
+            for ключ, значение in условие.условия_и:
+                if ид_кандидаты is None:
+                    результат = [d for d in результат if self._проверить_условие(d, ключ, значение)]
+        else:
+            результат = self.документы.copy()
+
+        for ключ, значение in условие.условия_или:
+            результат_или = [d for d in self.документы if self._проверить_условие(d, ключ, значение)]
+            существующие_ид = {d["_id"] for d in результат}
+            for d in результат_или:
+                if d["_id"] not in существующие_ид:
+                    результат.append(d)
+                    существующие_ид.add(d["_id"])
+
+        for ключ, значение in условие.условия_не:
+            результат = [d for d in результат if not self._проверить_условие(d, ключ, значение)]
+
+        for ключ, значение in условие.условия_содержит:
+            результат = [d for d in результат if self._проверить_содержит(d, ключ, значение)]
+
+        if условие.сортировка:
+            результат.sort(key=lambda d: self._получить_ключ(d, условие.сортировка) or 0, reverse=условие.обратная_сортировка)
+
+        if условие.пропустить_значение:
+            результат = результат[условие.пропустить_значение:]
+
+        if условие.лимит_значение:
+            результат = результат[:условие.лимит_значение]
+
+        return результат
+
+    def обновить(self, где: Dict, данные: Dict) -> int:
+        найденные = self.найти(где=где)
+        for документ in найденные:
+            старый = документ.copy()
+            for ключ, значение in данные.items():
+                ключи = ключ.split(".")
+                цель = документ
+                for к in ключи[:-1]:
+                    if к not in цель:
+                        цель[k] = {}
+                    цель = цель[k]
+                цель[ключи[-1]] = значение
+            for имя, индекс in self.индексы.items():
+                индекс.удалить(документ["_id"], старый)
+                индекс.добавить(документ["_id"], документ)
+        return len(найденные)
+
+    def обновить_по_id(self, ид: int, данные: Dict) -> bool:
+        документ = self.найти_по_id(ид)
+        if not документ:
+            return False
+        self.обновить(где={"_id": ид}, данные=данные)
+        return True
+
+    def удалить(self, где: Dict = None) -> int:
+        if где is None:
+            return self.удалить_все()
+        найденные = self.найти(где=где)
+        for документ in найденные:
+            for имя, индекс in self.индексы.items():
+                индекс.удалить(документ["_id"], документ)
+            self.документы.remove(документ)
+        return len(найденные)
+
+    def удалить_по_id(self, ид: int) -> bool:
+        документ = self.найти_по_id(ид)
+        if not документ:
+            return False
+        self.удалить(где={"_id": ид})
+        return True
+
+    def удалить_все(self) -> int:
+        count = len(self.документы)
+        self.документы.clear()
+        for индекс in self.индексы.values():
+            индекс.данные.clear()
+        self.счетчик = 0
+        return count
+
+    def есть(self, где: Dict) -> bool:
+        return len(self.найти(где=где, лимит=1)) > 0
+
+    def создать_индекс(self, ключ: Union[str, List[str]]):
+        имя = "_".join(ключ) if isinstance(ключ, list) else ключ
+        if имя in self.индексы:
+            return self.индексы[имя]
+        индекс = Индекс(имя, ключ)
+        self.индексы[имя] = индекс
+        for документ in self.документы:
+            индекс.добавить(документ["_id"], документ)
+        return индекс
+
+    def удалить_индекс(self, ключ: str):
+        if ключ in self.индексы:
+            del self.индексы[ключ]
+
+    def уникальные(self, ключ: str) -> List[Any]:
+        значения = set()
+        for документ in self.документы:
+            val = self._получить_ключ(документ, ключ)
+            if val is not None:
+                if isinstance(val, list):
+                    for v in val:
+                        значения.add(v)
+                else:
+                    значения.add(val)
+        return sorted(значения, key=str)
+
+    def ключи(self) -> List[str]:
+        все_ключи = set()
+        for документ in self.документы:
+            все_ключи.update(документ.keys())
+        return sorted(все_ключи)
+
+    def размер(self) -> int:
+        return len(self.документы)
+
+    def _проверить_условие(self, документ: Dict, ключ: str, значение: Any) -> bool:
+        val = self._получить_ключ(документ, ключ)
+        if isinstance(значение, str) and val is not None:
+            значение_str = str(значение)
+            if значение_str.startswith("> "):
+                try:
+                    return float(val) > float(значение_str[2:])
+                except (ValueError, TypeError):
+                    return str(val) > значение_str[2:]
+            elif значение_str.startswith("< "):
+                try:
+                    return float(val) < float(значение_str[2:])
+                except (ValueError, TypeError):
+                    return str(val) < значение_str[2:]
+            elif значение_str.startswith(">= "):
+                return float(val) >= float(значение_str[3:])
+            elif значение_str.startswith("<= "):
+                return float(val) <= float(значение_str[3:])
+            elif значение_str.startswith("!= "):
+                return val != значение_str[3:]
+            elif "между" in значение_str and " и " in значение_str:
+                parts = значение_str.replace("между ", "").split(" и ")
+                try:
+                    return float(parts[0]) <= float(val) <= float(parts[1])
+                except (ValueError, TypeError):
+                    return str(parts[0]) <= str(val) <= str(parts[1])
+            elif значение_str.startswith("содержит "):
+                search_val = значение_str[9:]
+                if isinstance(val, str):
+                    return search_val.lower() in val.lower()
+                if isinstance(val, list):
+                    return search_val in val
+                return str(search_val) in str(val)
+        return val == значение
+
+    def _проверить_содержит(self, документ: Dict, ключ: str, значение: Any) -> bool:
+        val = self._получить_ключ(документ, ключ)
+        if isinstance(val, list):
+            return значение in val
+        if isinstance(val, str):
+            return str(значение) in val
+        if isinstance(val, dict):
+            return значение in val.values()
+        return False
+
+    def _получить_ключ(self, документ: Dict, ключ: str) -> Any:
+        ключи = ключ.split(".")
+        значение = документ
+        for к in ключи:
+            if isinstance(значение, dict):
+                значение = значение.get(к)
+            else:
+                return None
+        return значение
+
+    def экспорт(self) -> List[Dict]:
+        return self.документы.copy()
+
+    def импорт(self, данные: List[Dict]):
+        for документ in данные:
+            if "_id" in документ:
+                del документ["_id"]
+            if "_создан" in документ:
+                del документ["_создан"]
+            self.положить(документ)
+
+
+class База:
+    def __init__(self, имя: str, путь: str = None, ключ: str = None):
+        self.имя = имя
+        self.путь = путь or f"{имя}.json"
+        if ключ:
+            self.путь = self.путь.replace(".json", ".enc")
+        self.ключ = ключ
+        self.коробки: Dict[str, Коробка] = {}
+        self.загрузить()
+
+    def коробка(self, имя: str) -> Коробка:
+        if имя not in self.коробки:
+            self.коробки[имя] = Коробка(имя, self)
+        return self.коробки[имя]
+
+    def сохранить(self):
+        данные = {}
+        for имя, коробка in self.коробки.items():
+            данные[имя] = коробка.экспорт()
+        
+        if self.ключ:
+            json_данные = json.dumps(данные, ensure_ascii=False, indent=2)
+            зашифровано = Шифр.зашифровать(json_данные, self.ключ)
+            with open(self.путь, 'wb') as ф:
+                ф.write(зашифровано)
+        else:
+            with open(self.путь, 'w', encoding='utf-8') as ф:
+                json.dump(данные, ф, ensure_ascii=False, indent=2)
+
+    def загрузить(self):
+        if not os.path.exists(self.путь):
+            return
+        
+        try:
+            if self.ключ:
+                with open(self.путь, 'rb') as ф:
+                    зашифровано = ф.read()
+                json_данные = Шифр.расшифровать(зашифровано, self.ключ)
+                данные = json.loads(json_данные)
+            else:
+                with open(self.путь, 'r', encoding='utf-8') as ф:
+                    данные = json.load(ф)
+            
+            for имя, документы in данные.items():
+                коробка = self.коробка(имя)
+                коробка.удалить_все()
+                коробка.импорт(документы)
+        except Exception as e:
+            raise ОшибкаБазы(f"Не удалось загрузить базу: {e}")
+
+    def сохранить_как(self, путь: str):
+        старый_путь = self.путь
+        self.путь = путь
+        self.сохранить()
+        self.путь = старый_путь
+
+    def бэкап(self):
+        временная_метка = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        имя_бэкапа = self.путь.replace(".json", f"_{временная_метка}.json").replace(".enc", f"_{временная_метка}.enc")
+        shutil.copy2(self.путь, имя_бэкапа)
+        return имя_бэкапа
+
+    def очистить(self):
+        for коробка in self.коробки.values():
+            коробка.удалить_все()
+        self.коробки.clear()
+        if os.path.exists(self.путь):
+            os.remove(self.путь)
+
+    def список_коробок(self) -> List[str]:
+        return sorted(self.коробки.keys())
+
+    def размер(self) -> int:
+        if os.path.exists(self.путь):
+            return os.path.getsize(self.путь)
+        return 0
+
+    def инфо(self) -> Dict:
+        return {
+            "имя": self.имя,
+            "путь": self.путь,
+            "зашифрована": bool(self.ключ),
+            "коробок": len(self.коробки),
+            "размер_байт": self.размер(),
+            "документов": sum(к.размер() for к in self.коробки.values())
+        }
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.сохранить()
+
+    def __repr__(self):
+        return f"База('{self.имя}', коробок: {len(self.коробки)}, размер: {self.размер()} байт)"
+
+
+class Версия:
+    НОМЕР = "1.0.0"
+    НАЗВАНИЕ = "VRBase"
+    АВТОР = "Pantapan1 & RuGram Team"
+
+    @staticmethod
+    def инфо():
+        return f"{Версия.НАЗВАНИЕ} v{Версия.НОМЕР} by {Версия.АВТОР}"
+
+
+if __name__ == "__main__":
+    print(Версия.инфо())