brilliance-admin 0.42.0__py3-none-any.whl → 0.43.1__py3-none-any.whl

{admin_panel → brilliance_admin}/templates/index.html

@@ -13,7 +13,7 @@
   <link rel="icon" href="{{ favicon_image }}" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>{{ title }}</title>
-  <script type="module" crossorigin src="/admin/static/index-BeniOHDv.js"></script>
+  <script type="module" crossorigin src="/admin/static/index-D9axz5zK.js"></script>
   <link rel="stylesheet" crossorigin href="/admin/static/index-vlBToOhT.css">
 </head>
 

brilliance_admin/translations.py

@@ -0,0 +1,115 @@
+import abc
+from importlib import resources
+from typing import Any, Dict
+
+import pydantic
+from asgiref.local import Local
+from pydantic_core import core_schema
+
+from brilliance_admin.utils import DataclassBase, YamlI18n, get_logger
+
+logger = get_logger()
+
+_active = Local()
+
+
+@pydantic.dataclasses.dataclass
+class TranslateText(DataclassBase):
+    slug: str
+    translation_kwargs: dict | None = None
+
+    def __init__(self, slug: str):
+        self.slug = slug
+
+    @pydantic.model_serializer(mode='plain')
+    def serialize_model(self, info: pydantic.SerializationInfo) -> str:
+        ctx = info.context or {}
+        language_context = ctx.get('language_context')
+
+        if not language_context:
+            raise AttributeError('language_context is not in context manager for serialization')
+
+        if not issubclass(type(language_context), LanguageContext):
+            raise AttributeError(f'language_context "{type(language_context)}" is not subclass of LanguageContext')
+
+        return language_context.get_text(self)
+
+    def __str__(self):
+        lm = getattr(_active, '_language_context', None)
+        if not lm:
+
+            raise AttributeError(f'language_context is not in local scope for translation: {locals()}')
+
+        if not issubclass(type(lm), LanguageContext):
+            raise AttributeError(f'language_context "{lm}" is not subclass of LanguageContext')
+
+        return lm.get_text(self)
+
+    def __mod__(self, other):
+        if not isinstance(other, dict):
+            msg = f'TranslateText only dict is supported trough % operand (slug="{self.slug}" other={type(other)})'
+            raise AttributeError(msg)
+        self.translation_kwargs = other
+        return self
+
+
+class LanguageManager(abc.ABC):
+    languages: Dict[str, str] | None
+    phrases: YamlI18n = None
+
+    def __init__(self, languages: str | None, locales_dir: str | None = None):
+        self.languages = languages
+        self.phrases = YamlI18n()
+
+        builtin_locales_dir = resources.files("brilliance_admin").joinpath("locales")
+        self.phrases.load_folder(builtin_locales_dir)
+        logger.info('Language manager builtin dir loaded: %s', builtin_locales_dir)
+
+        if locales_dir:
+            self.phrases.load_folder(locales_dir)
+            logger.info('Language manager locales_dir loaded: %s', locales_dir)
+
+        langs = ', '.join(self.phrases.data.keys())
+        logger.info('Language manager setup completed; languages: %s', langs)
+
+    def get_text(self, text, language) -> str:
+        if not isinstance(text, TranslateText):
+            return text
+
+        default_lang = list(self.languages.keys())[0]
+
+        translation = self.phrases.get_text(text.slug, language or default_lang, default_lang) or text.slug
+        if text.translation_kwargs:
+            translation %= text.translation_kwargs
+
+        return translation
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> core_schema.CoreSchema:
+        def validate(v: Any) -> "LanguageManager":
+            if isinstance(v, cls):
+                return v
+            raise TypeError(f"Expected {cls.__name__} instance")
+
+        return core_schema.no_info_plain_validator_function(
+            validate,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda v: repr(v),
+                info_arg=False,
+                return_schema=core_schema.str_schema(),
+            ),
+        )
+
+
+class LanguageContext(abc.ABC):
+    language: str | None
+    language_manager: LanguageManager
+
+    def __init__(self, language, language_manager):
+        self.language = language
+        self.language_manager = language_manager
+
+        _active._language_context = self
+
+    def get_text(self, text) -> str:
+        return self.language_manager.get_text(text, self.language)

brilliance_admin/utils.py

@@ -0,0 +1,153 @@
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, Protocol
+
+import yaml
+from pydantic import TypeAdapter
+from pydantic_core import core_schema
+
+
+class SupportsStr(Protocol):
+    def __str__(self) -> str: ...
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type, handler):
+        def validate(v):
+            if not hasattr(v, '__str__'):
+                raise TypeError(f'value must implement __str__, got {type(v)}')
+            return v
+
+        return core_schema.no_info_plain_validator_function(validate)
+
+
+def get_logger():
+    try:
+        # pylint: disable=import-outside-toplevel
+        import structlog
+        return structlog.get_logger('brilliance_admin')
+    except ImportError:
+        return logging.getLogger('brilliance_admin')
+
+
+class DeserializeAction:
+    CREATE = 0
+    UPDATE = 1
+    TABLE_ACTION = 2
+    FILTERS = 3
+
+
+class DataclassBase:
+    def model_dump(self, *args, **kwargs) -> dict:
+        adapter = TypeAdapter(type(self))
+        return adapter.dump_python(self, *args, **kwargs)
+
+    def to_dict(self, keep_none=True) -> dict:
+        data = self.model_dump()
+        return {
+            k: v for k, v in data.items()
+            if v is not None and not keep_none
+        }
+
+
+def humanize_field_name(name: str) -> str:
+    # Convert snake_case / kebab-case / mixed tokens to Title Case with acronyms preserved
+    s = name.replace("-", "_")
+    parts = [p for p in s.split("_") if p]
+
+    def cap(token: str) -> str:
+        # Keep common acronyms uppercase
+        if token.lower() in {"id", "ip", "url", "api", "http", "https", "h2h"}:
+            return token.upper()
+        # If token contains digits, capitalize first letter only (e.g. "h2h" -> "H2h")
+        if re.search(r"\d", token):
+            return token[:1].upper() + token[1:].lower()
+        return token[:1].upper() + token[1:].lower()
+
+    return " ".join(cap(p) for p in parts)
+
+
+def iter_locale_files(directory) -> list[Path]:
+    if isinstance(directory, str):
+        directory = Path(directory)
+
+    if not directory.exists():
+        raise FileNotFoundError(directory)
+    if not directory.is_dir():
+        raise NotADirectoryError(directory)
+
+    for path in directory.rglob('*'):
+        if not path.is_file():
+            continue
+
+        yield path
+
+
+def merge_dict_data(base: dict, extra: dict) -> dict:
+    if not isinstance(base, dict):
+        raise TypeError('base must be dict')
+    if not isinstance(extra, dict):
+        raise TypeError('extra must be dict')
+
+    result = base.copy()
+    for key, value in extra.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge_dict_data(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+class YamlI18n:
+    data: Dict[str, Any] = {}
+
+    def load_folder(self, path):
+        for file_path in iter_locale_files(path):
+            with file_path.open(encoding='utf-8') as f:
+                data = yaml.safe_load(f)
+
+            if not isinstance(data, dict):
+                msg = f'YAML root must be dict: {file_path}, got {type(data)}'
+                raise TypeError(msg)
+
+            language = file_path.stem
+            if language not in self.data:
+                self.data[language] = {}
+
+            if not isinstance(self.data[language], dict):
+                raise TypeError(f'language root must be dict: {language}')
+
+            self.data[language] = merge_dict_data(self.data[language], data)
+
+    def get_text(self, slug, language, default_language):
+        if not isinstance(slug, str):
+            raise TypeError(f'slug must be str, got {type(slug)}')
+
+        if not isinstance(language, str):
+            raise TypeError(f'language must be str, got {type(language)}')
+
+        if not isinstance(default_language, str):
+            raise TypeError(f'default_language must be str, got {type(default_language)}')
+
+        if not self.data:
+            raise ValueError('i18n data is empty')
+
+        for lang in (language, default_language):
+            if lang not in self.data:
+                continue
+
+            node = self.data[lang]
+
+            for part in slug.split('.'):
+                if not isinstance(node, dict):
+                    node = None
+                    break
+                if part not in node:
+                    node = None
+                    break
+                node = node[part]
+
+            if isinstance(node, str):
+                return node
+
+        raise KeyError(f'translation key not found: {slug}')

brilliance_admin-0.43.1.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: brilliance-admin
+Version: 0.43.1
+Summary: Simple and lightweight admin panel framework powered by FastAPI and Vue3 Vuetify together.. Some call it heavenly in its brilliance.
+License-Expression: AGPL-3.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asgiref>=3.11
+Requires-Dist: fastapi>=0.115
+Requires-Dist: jinja2>=3.1
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: example
+Requires-Dist: uvicorn>=0.34.0; extra == "example"
+Requires-Dist: faker>=38.2.0; extra == "example"
+Requires-Dist: pyjwt>=2.10.1; extra == "example"
+Requires-Dist: structlog>=25.5.0; extra == "example"
+Requires-Dist: rich>=14.2.0; extra == "example"
+Provides-Extra: tests
+Requires-Dist: pytest>=8.4.2; extra == "tests"
+Requires-Dist: pytest-asyncio>=1.2.0; extra == "tests"
+Requires-Dist: httpx>=0.28.1; extra == "tests"
+Requires-Dist: pytest-mock>=3.15.1; extra == "tests"
+Requires-Dist: sqlalchemy>=2.0.41; extra == "tests"
+Requires-Dist: aiosqlite>=0.22.1; extra == "tests"
+Requires-Dist: factory-boy>=3.3.3; extra == "tests"
+Requires-Dist: pyjwt>=2.10.1; extra == "tests"
+Provides-Extra: scalar
+Requires-Dist: scalar-fastapi>=1.5.0; extra == "scalar"
+Dynamic: license-file
+
+<div align="center">
+  <img src="https://github.com/brilliance-admin/backend-python/blob/main/example/static/logo-outline.png?raw=true"
+       alt="Brilliance Admin"
+       width="600">
+
+[![PyPI](https://img.shields.io/pypi/v/brilliance-admin)](https://pypi.org/project/brilliance-admin/)
+[![CI](https://github.com/brilliance-admin/backend-python/actions/workflows/deploy.yml/badge.svg)](https://github.com/brilliance-admin/backend-python/actions)
+
+Simple and lightweight admin panel framework powered by `FastAPI` and `Vue3` `Vuetify` together. \
+Integrated with `SQLAlchemy`. Inspaired by Django Admin and DRF.\
+_Some call it heavenly in its brilliance._
+
+### [Live Demo](https://brilliance-admin.com/) | [Demo Sources](https://github.com/brilliance-admin/backend-python/tree/main/example) | Documentation (todo)
+
+  <img src="https://github.com/brilliance-admin/backend-python/blob/main/screenshots/websitemockupgenerator.png?raw=true"
+       alt="Preview">
+
+</div>
+
+**Key ideas:**
+- **API oriented**\
+Works entirely on FastAPI and provides a prebuilt SPA [frontend](https://github.com/brilliance-admin/frontend) via static files (Vue3 + Vuetify). No separate startup is required.
+> Data generation/updating API separated from rendering fontend with zero hardcode, this makes it possible to have a single frontend with multiple backend implementations in different languages and makes test coverage easier.
+- **Rich visualization**\
+Providing rich and convenient ways to display and manage data (tables, charts, etc) from any data source.
+- **ORM**\
+Automatic schema generation and methods for CRUD operations.
+- **Minimal boilerplate**\
+Focused on simplified, but rich configuration.
+
+**How it works:**
+- After authentication, the user receives the admin panel schema, and the frontend renders it
+- The frontend communicates with the backend via API to fetch and modify data
+
+### Features:
+
+* Tables with full CRUD support, including filtering, sorting, and pagination.
+* Ability to define custom table actions with forms, response messages, and file downloads.
+* Graphs via ChartJS
+* Localization support
+* Adapted for different screen sizes and mobile devices
+* Authorization via any account data source
+
+**Integrations:**
+* **SQLAlchemy** - schema autogeneration for tables + CRUD operations + authorization
+
+**Planned:**
+* Role-based access control system
+* Nested data support for creation and detail views
+* Django ORM inegration
+
+## How to use it
+
+Installation:
+``` shell
+pip install brilliance-admin
+```
+
+You need to generate `AdminSchema` instance:
+``` python
+from brilliance_admin import schema
+
+
+class CategoryExample(schema.CategoryTable):
+    "Implementation of get_list and retrieve; update and create are optional"
+
+
+admin_schema = schema.AdminSchema(
+    title='Admin Panel',
+    auth=YourAdminAuthentication(),
+    groups=[
+        schema.Group(
+            slug='example',
+            title='Example',
+            icon='mdi-star',
+            categories=[
+                CategoryExample(),
+            ]
+        ),
+    ],
+)
+
+admin_app = admin_schema.generate_app()
+
+# Your FastAPI app
+app = FastAPI()
+app.mount('/admin', admin_app)
+```
+
+## SQLAlchemy integration
+
+Supports automatic schema generation for CRUD tables:
+
+``` python
+category = sqlalchemy.SQLAlchemyAdmin(db_async_session=async_sessionmaker, model=Terminal)
+```
+
+> [!NOTE]
+> If `table_schema` is not specified, it will be generated automatically with all discovered fields and relationships
+
+Now, the `category` instance can be passed to `categories`.
+
+### DRF class style schema
+
+``` python
+from brilliance_admin import sqlalchemy
+from brilliance_admin.translations import TranslateText as _
+
+from your_project.models import Terminal
+
+
+class TerminalFiltersSchema(sqlalchemy.SQLAlchemyFieldsSchema):
+    model = Terminal
+    fields = ['id', 'created_at']
+    created_at = schema.DateTimeField(range=True)
+
+
+class TerminalSchema(sqlalchemy.SQLAlchemyFieldsSchema):
+    model = Terminal
+    list_display = ['id', 'merchant_id']
+
+
+class TerminalAdmin(sqlalchemy.SQLAlchemyAdmin):
+    db_async_session = async_sessionmaker
+    model = Terminal
+    title = _('terminals')
+    icon = 'mdi-console-network-outline'
+    
+    ordering_fields = ['id']
+    search_fields = ['id', 'title']
+
+    table_schema = TerminalSchema()
+    table_filters = TerminalFiltersSchema()
+
+
+category = TerminalAdmin()
+```
+
+### Can be used both via inheritance and instancing
+
+Optionally, functional-style generation can be used to reduce boilerplate code
+
+Availiable for `SQLAlchemyAdmin` and `SQLAlchemyFieldsSchema`
+
+``` python
+category = sqlalchemy.SQLAlchemyAdmin(
+    db_async_session=async_sessionmaker,
+    model=Terminal,
+
+    table_schema = sqlalchemy.SQLAlchemyFieldsSchema(
+        model=Terminal, 
+        list_display=['id', 'merchant_id'],
+    ),
+    table_filters = sqlalchemy.SQLAlchemyFieldsSchema(
+        model=Terminal, 
+        fields=['id', 'created_at'],
+        created_at=schema.DateTimeField(range=True),
+    ),
+)
+```
+
+### SQLAlchemy JWT Authentication
+
+``` python
+auth = sqlalchemy.SQLAlchemyJWTAdminAuthentication(
+    secret='auth_secret',
+    db_async_session=async_session,
+    user_model=User,
+)
+```
+
+## Comparison of Similar Projects
+
+| Criterion | Brilliance Admin | Django Admin/Unfold | FastAPI Admin | Starlette Admin |
+|---------|------------------|---------------|---------------|-----------------|
+| Base framework | FastAPI | Django | FastAPI | Starlette / FastAPI |
+| Rendering model | Prebuilt Vue 3 + Vuetify SPA + Jinja2 | Server-side Django templates | Server-side Jinja2 templates + Tabler UI | Server-side Jinja2 templates + Tabler UI |
+| Frontend architecture | Separate frontend (SPA) | Classic server-rendered UI | Server-rendered UI with JS interactivity | Server-rendered UI with JS interactivity |
+| Data source | Any source + SQLAlchemy | Django ORM | Tortoise ORM | Any source + SQLAlchemy, MongoDB |
+| Multiple databases per model | Yes | Database routers | No (global engine) | Yes (session per ModelView) |
+| Schema generation | User-defined format | From Django models | From ORM models | User-defined format |
+| Async support | Yes | No | Yes | Yes |
+| API-first approach | Yes | No | Partially | Partially |

brilliance_admin-0.43.1.dist-info/RECORD

@@ -0,0 +1,74 @@
+brilliance_admin/__init__.py,sha256=qxGzLVhFNm2FKL2lVt7bEFb6pTPqyXEQvUsDfyfv6SM,183
+brilliance_admin/auth.py,sha256=d57XRfLJIbOosLP1-0SCFkePPT8M5WhLcwxu4yW92RA,673
+brilliance_admin/docs.py,sha256=fKeJKuiCCi1jHRmNcmkuDD6_2di7bwc6-w8V1VCTu0s,1231
+brilliance_admin/exceptions.py,sha256=7_L3qVTwdLrzmDJjGv2yqCOVECP35wh0NyTvgjP7ETc,913
+brilliance_admin/translations.py,sha256=9IHS7ld0dghjIvHgko4ueRMoJ53VcblcFCEkgxQEG4A,3847
+brilliance_admin/utils.py,sha256=C5Rc7DUC9HnGIu4R9rdNGGtvZ3vrkWBNoDr-ijCPD3w,4593
+brilliance_admin/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brilliance_admin/api/routers.py,sha256=GXz-GFXRH5VbDH1r5O9LLnnmaMhbQq4RctzVEubHnsk,810
+brilliance_admin/api/utils.py,sha256=ezvHK49OlpCdT9fLB41Y1nswZDLdzC3zTcQtGtuTYUk,999
+brilliance_admin/api/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brilliance_admin/api/views/auth.py,sha256=Qmd9KuFqCeNhQukYl0W62kcUYPMtgMekjkaTvz1AArM,1133
+brilliance_admin/api/views/autocomplete.py,sha256=oJbt-xD4sKnOyQIxT0mFqyRvPxFk9KUyJabKzLY888s,1508
+brilliance_admin/api/views/graphs.py,sha256=nn91zoFRZ0FvSkFJoTy7ZQEr8B2cUj43nd8OxPsSmTQ,1351
+brilliance_admin/api/views/index.py,sha256=DkMshrs5zmqpbbF9G2RhqeLGFKMrkrAmQ6nnba7aLl8,1400
+brilliance_admin/api/views/schema.py,sha256=MS9v9Qy3cRO9gGs4uW2PNRBS6Uw48sLRGRe49jnJ2yM,1019
+brilliance_admin/api/views/settings.py,sha256=2A9suZQONEtW9LkFban29Fe5ipQaaGT0CzpxnbuotJQ,1166
+brilliance_admin/api/views/table.py,sha256=29vLEwueHWBS8Dq6nBvujwy4CTs9v8ZcM1ErF9lYgIc,5932
+brilliance_admin/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brilliance_admin/integrations/sqlalchemy/__init__.py,sha256=tIegMU2eIW_zA-PdblCXCjenHAY4sGBUWKuz97ns4gE,275
+brilliance_admin/integrations/sqlalchemy/auth.py,sha256=99O7zmhcKWB3cWGTbMd3OSyIJ81Vcfz7byDK6oLinm8,4910
+brilliance_admin/integrations/sqlalchemy/autocomplete.py,sha256=baRroMwGg35uR5zt-aiQc2-ugX4hpwNf79R6bZH9UX0,1416
+brilliance_admin/integrations/sqlalchemy/fields.py,sha256=AayeFmwKA5JooiCok7wPLJNSDQCiy5p-iQjrr9HMMSw,9412
+brilliance_admin/integrations/sqlalchemy/fields_schema.py,sha256=fZu7I77POvcUHBVc7i0yKGZcAzDumVGMpsbX7TMByo4,10914
+brilliance_admin/integrations/sqlalchemy/table/__init__.py,sha256=g_in2pLTi8UQnT5uNFA8mLW5mxlT84irQ7yVaP_OSS4,605
+brilliance_admin/integrations/sqlalchemy/table/base.py,sha256=nZzHk56NyhfTll9vX9j5zzA557mLdQ-u-GccTFXIFSs,4873
+brilliance_admin/integrations/sqlalchemy/table/create.py,sha256=z40PuKJYZ6goJdhsANVuEyTW1gh0PipCBdBSe5Ii5Tw,2693
+brilliance_admin/integrations/sqlalchemy/table/delete.py,sha256=Awv50IG7DQsYrHVlk4dtYBMwexmlO92xhMBgrgEDBgs,731
+brilliance_admin/integrations/sqlalchemy/table/list.py,sha256=--KVTLbuCr1fD79q0LXqlu6CuiYA3QhQj6rrdP7jR14,6692
+brilliance_admin/integrations/sqlalchemy/table/retrieve.py,sha256=b-Kyft1ecG2nAj8krTumyeY2LaONBGgBwyfLayL-ilw,2140
+brilliance_admin/integrations/sqlalchemy/table/update.py,sha256=AGEEbEsgKre784Dg4_kTKB6NfMwdAwNiMjm0ZKeg-LE,3543
+brilliance_admin/locales/en.yml,sha256=lCM58SoP4HExXFCTHpl8pYw82tH_8TvlrcCXZDXYb5c,1129
+brilliance_admin/locales/ru.yml,sha256=hXZwS71Z_aAyK9DB14pwmbtLI5xn6PvsnuLIZlEexbM,1661
+brilliance_admin/schema/__init__.py,sha256=X-izShvv84jkFU47WfpUwtvRh3NOv570iUB3NRNEIDU,248
+brilliance_admin/schema/admin_schema.py,sha256=fKVtaLkFkDF8ZkjIftackZ4rfCDcqLvci8PO6ZLycgc,6393
+brilliance_admin/schema/category.py,sha256=Y2DuDmSve_-Lnx3zOQlbVcslywJhcwV49z1bOhSKIGs,4105
+brilliance_admin/schema/group.py,sha256=Gdz3ME_EfQP_CFPou6OOJZWGWXKIYgB3zNX_oWsClwE,2240
+brilliance_admin/schema/graphs/__init__.py,sha256=qvmZv9QWdiutPtN5VYQLYbsjY2SOg8p_XRaz2rUlIxY,44
+brilliance_admin/schema/graphs/category_graphs.py,sha256=2nj_oiAoGXwGhc-gNVNFMNKDCkCdUWVn6u9CRCsb2DA,1513
+brilliance_admin/schema/table/__init__.py,sha256=vuRw8HBuak2LaTZi2dNn5YOrJPalQps-O3Ht-d0AZV4,378
+brilliance_admin/schema/table/admin_action.py,sha256=0ymRL9DKkBK-AF6wKy7K9R4hkmblh55eHuZA_rjO1Lk,2018
+brilliance_admin/schema/table/category_table.py,sha256=BNdxspZ9Di6_bX0QQEGxgZLlddC7GIAWjBYha6bLtZo,6449
+brilliance_admin/schema/table/fields_schema.py,sha256=PvNHIYqDeLvM2qy32vCmLQ6VORl7bJQhSVcGUP1LIEw,8276
+brilliance_admin/schema/table/table_models.py,sha256=xidraifRYbXGkiVLn6dJ96dkOhW8-22ynE-fbiOjfAU,1018
+brilliance_admin/schema/table/fields/__init__.py,sha256=RW-sIFTAaSQo4mMR6iWtnefogWPjmg6KAsDwe9mKW1k,291
+brilliance_admin/schema/table/fields/base.py,sha256=gocPyNZvLFpv_3VXA8ptCcZKK8uVFlTiwzgiuOnN1FI,7791
+brilliance_admin/schema/table/fields/function_field.py,sha256=4fm9kS8zpBG5oqp9sA81NQDHiqvU0BQmpf-wjkTuuwM,1780
+brilliance_admin/static/index-D9axz5zK.js,sha256=KB_EHC9hoBK_LinkeMaE897Ws4Tl8xlJ8c_smbis_VE,3202111
+brilliance_admin/static/index-vlBToOhT.css,sha256=hoVCpcStTHdAVRm37k1umrNdXjOwIIveu9lxk4ocpEc,983028
+brilliance_admin/static/materialdesignicons-webfont-CYDMK1kx.woff2,sha256=5S1g9kJnzaoIQitQurXUW9NeZisDua91F5zq4ArF_Is,385360
+brilliance_admin/static/materialdesignicons-webfont-CgCzGbLl.woff,sha256=SNPuxqtw3HoZCPm6LyCOClhxi57hbj9qvbXbT0Yfolg,561776
+brilliance_admin/static/materialdesignicons-webfont-D3kAzl71.ttf,sha256=vXJaejiTnltZkE4benJlkZ7OwlYWbs5p1RXCEAUWWQc,1243500
+brilliance_admin/static/materialdesignicons-webfont-DttUABo4.eot,sha256=hhrqBUjMya-Y3sUgvjQLji1L65e6NIk6ya9RGkSeP6I,1243720
+brilliance_admin/static/vanilla-picker-B6E6ObS_.js,sha256=aVVU5PLkFXbK22gMndNsa5QNWtZxQBEqtd2Fp8HYfwE,18804
+brilliance_admin/static/tinymce/tinymce.min.js,sha256=4KlST3LusLGTHzCqhWmoENGfb4aeSvmj9IlL-v6ATeg,1171290
+brilliance_admin/static/tinymce/dark-first/content.min.css,sha256=tCWU8dU3Y4eejwO9fjZ22eIwrq8q5iFSlyR8FlQ8-dU,4788
+brilliance_admin/static/tinymce/dark-first/skin.min.css,sha256=XaCMxHAKdwqA0HyM2l_vvA1KRwhOC7bbX3Bz2z0f1jw,50376
+brilliance_admin/static/tinymce/dark-slim/content.min.css,sha256=fyLDj0yRBtk8ypK6LL3aI2PHyH6x7ISDncpbHOuvwPI,4730
+brilliance_admin/static/tinymce/dark-slim/skin.min.css,sha256=tzEwzhO0ToVn_l1AkBRK6vwz9dSqjEpQbTNao12Kqy0,49965
+brilliance_admin/static/tinymce/img/example.png,sha256=R18xquUdQyQvA6dFZUIXkLucVO2mMJpgV1oHI4cFQJ0,14708
+brilliance_admin/static/tinymce/img/tinymce.woff2,sha256=_XmHMFsFYH9PlgREy6LOzYYFgvs2fGIMcr2vXt2Q-ik,15764
+brilliance_admin/static/tinymce/lightgray/content.min.css,sha256=UgkDCoTokZ99doSjtoycaZAZVjO00I1XikWjBpWf9NI,3193
+brilliance_admin/static/tinymce/lightgray/skin.min.css,sha256=ypP9oqgJwhKl2-B_ATE6uC77pqPjVYP6vz7EzBuiiSU,38232
+brilliance_admin/static/tinymce/lightgray/fonts/tinymce.woff,sha256=o69L1waoOPHkqgihbpfjT_qTB8PJsZJeJTR7aL8IH8M,7664
+brilliance_admin/static/tinymce/plugins/accordion/plugin.js,sha256=jf3gA0MkE2Gshhe8pTJP5JUVI56G3YlBZQSoevPWeuc,1251
+brilliance_admin/static/tinymce/plugins/accordion/css/accordion.css,sha256=u5UQkMNA9fboQgOOuJCgoJ3Dm-9vDYDJDAmpPbB-yWM,282
+brilliance_admin/static/tinymce/plugins/codesample/css/prism.css,sha256=exAdMtHbvwW7-DEs567MX65Fq1aJQTfREP5pw8gW-AY,1736
+brilliance_admin/static/tinymce/plugins/customLink/plugin.js,sha256=illBNpnHDkBsLG6wo_jDPF6z7CGnO1MQWUoDwZKy6vQ,5589
+brilliance_admin/static/tinymce/plugins/customLink/css/link.css,sha256=gh5nvY8Z92hJfCEBPnIm4jIPCcKKbJnab-30oIfX7Hc,56
+brilliance_admin/templates/index.html,sha256=ZLJ_TKUvBDIo_hYfbW43ov0S_bFrzBF-283XP6BKtDI,1294
+brilliance_admin-0.43.1.dist-info/licenses/LICENSE,sha256=PjeDRXGbVLtKul5Xpfco_6CyB6bYGWVVPrO0oubquuM,727
+brilliance_admin-0.43.1.dist-info/METADATA,sha256=SgnEDyBA7AYrXHFP-T0K906C-rurqdqKHDkgr6Tl72s,7459
+brilliance_admin-0.43.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+brilliance_admin-0.43.1.dist-info/top_level.txt,sha256=almFFSWrVYieI3i54hYL0fMUaeuIYiazS2Kx4wtK-ns,17
+brilliance_admin-0.43.1.dist-info/RECORD,,

brilliance_admin-0.43.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+brilliance_admin

admin_panel/api/routers.py

@@ -1,18 +0,0 @@
-from fastapi import APIRouter
-
-from .views.schema import router as schema_router
-from .views.table import router as schema_table
-from .views.auth import router as schema_auth
-from .views.autocomplete import router as schema_autocomplete
-from .views.graphs import router as schema_graphs
-from .views.settings import router as schema_settings
-from .views.index import router as schema_index
-
-admin_panel_router = APIRouter()
-admin_panel_router.include_router(schema_router)
-admin_panel_router.include_router(schema_table)
-admin_panel_router.include_router(schema_auth)
-admin_panel_router.include_router(schema_autocomplete)
-admin_panel_router.include_router(schema_graphs)
-admin_panel_router.include_router(schema_settings)
-admin_panel_router.include_router(schema_index)