valar 1.1.4__tar.gz → 1.2.0__tar.gz

{valar-1.1.4/src/valar.egg-info → valar-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valar
-Version: 1.1.4
+Version: 1.2.0
 Summary: valar for morghulis
 Home-page: https://gitee.com/GRIFFIN120/valar_dev
 Author: LYP

{valar-1.1.4 → valar-1.2.0}/setup.py

@@ -16,16 +16,16 @@ requires = [
 
 setup(
     name="valar",  # 包名
-    version="1.1.4",  # 版本号
+    version="1.2.0",  # 版本号
     author="LYP",  # 作者
     author_email="liuyinpeng@buaa.edu.cn",  # 邮箱
     description="valar for morghulis",  # 简短描述
     long_description=long_description,  # 详细说明
     long_description_content_type="text/markdown",  # 详细说明使用标记类型
-    url="https://gitee.com/GRIFFIN120/valar_dev",                     # 项目主页
+    url="https://gitee.com/GRIFFIN120/valar_dev",  # 项目主页
     packages=find_packages(where="src"),  # 需要打包的部分
     package_dir={"": "src"},  # 设置src目录为根目录
     python_requires=">=3.9",  # 项目支持的Python版本
-    install_requires=requires,                     # 项目必须的依赖
+    install_requires=requires,  # 项目必须的依赖
     include_package_data=False  # 是否包含非Python文件（如资源文件）
-)
+)

valar-1.2.0/src/valar/apps.py

@@ -0,0 +1,18 @@
+import os
+from django.apps import AppConfig
+from .classes.app_mixins.auto_migration_mixin import AutoMigrationMixin
+from .classes.app_mixins.auto_urlpatterns_mixin import AutoUrlPatternsMixin
+
+valar_app = __package__.replace('src.', '')
+
+
+class ValarConfig(AutoMigrationMixin, AutoUrlPatternsMixin, AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = __package__
+
+    def ready(self):
+        if os.environ.get('RUN_MAIN') == 'true':
+            from .dao.frame import MetaFrame
+            getattr(super(), 'set_url', None)()
+            getattr(super(), 'auto_migrate', None)()
+            MetaFrame()

{valar-1.1.4 → valar-1.2.0}/src/valar/channels/consumer.py

@@ -1,8 +1,8 @@
-
 from channels.generic.websocket import AsyncJsonWebsocketConsumer
 
 VALAR_CHANNEL_GROUP = 'VALAR'
 
+
 class ValarConsumer(AsyncJsonWebsocketConsumer):
 
     def __init__(self):
@@ -24,25 +24,23 @@ class ValarConsumer(AsyncJsonWebsocketConsumer):
         pass
 
     async def user_emit(self, event):
-        users: list = event.get('users',[])
-        data = event.get('data',{})
+        users: list = event.get('users', [])
+        data = event.get('data', {})
         if self.uid in users:
             await self.send_json(data)
 
     async def client_emit(self, event):
-        clients: list = event.get('clients',[])
-        data = event.get('data',{})
+        clients: list = event.get('clients', [])
+        data = event.get('data', {})
         if self.client in clients:
             await self.send_json(data)
 
     async def broadcast_emit(self, event):
-        data = event.get('data',{})
+        data = event.get('data', {})
         await self.send_json(data)
 
     async def register_emit(self, event):
-        users: list = event.get('users', [])
-        clients: list = event.get('clients',[])
-        if self.client in clients:
-            self.uid = users[0]
-
-
+        uid = event.get('uid', )
+        client = event.get('client')
+        if self.client == client:
+            self.uid = uid

valar-1.2.0/src/valar/channels/executer.py

@@ -0,0 +1,14 @@
+import asyncio
+
+from ..channels.sender import ValarChannelSender
+
+
+async def execute_channel(method, sender: ValarChannelSender):
+    thread = asyncio.to_thread(__execute__, method, sender)
+    asyncio.create_task(thread)
+
+
+def __execute__(method, sender: ValarChannelSender):
+    sender.start()
+    method(sender)
+    sender.stop()

valar-1.2.0/src/valar/channels/sender.py

@@ -0,0 +1,116 @@
+import json
+import time
+from datetime import datetime
+
+from asgiref.sync import async_to_sync
+from channels.layers import get_channel_layer
+from django.http import HttpRequest
+import threading
+from .consumer import VALAR_CHANNEL_GROUP
+
+
+class Channel:
+
+    def __init__(self, request: HttpRequest):
+        body = json.loads(request.body)
+        self.handler = body.get('handler')
+        self.url = body.get('url')
+        self.auth = body.get('auth')
+        self.broadcast = body.get('broadcast')
+        self.data = body.get('data')
+
+    def to_dict(self, status, payload):
+        data = {
+            'handler': self.handler,
+            'url': self.url,
+            'auth': self.auth,
+            'broadcast': self.broadcast,
+            'timestamp': datetime.now().timestamp()
+        }
+        if status:
+            data.update({'status': status})
+        if payload:
+            data.update({'payload': payload})
+        return data
+
+
+class Sender:
+
+    def __init__(self, request: HttpRequest):
+        self.client = request.headers.get('CLIENT')
+        self.uid = request.session.get('UID')
+        self.group_send = async_to_sync(get_channel_layer().group_send)
+
+
+class ValarChannelSender(Sender):
+
+    def __init__(self, request: HttpRequest, interval=1):
+        super().__init__(request)
+        self.__channel__ = Channel(request)
+        self.data = self.__channel__.data
+        self.__payload__ = None
+        self.__loading__ = False
+        self.__thread__ = None
+        self.__lock__ = threading.Lock()
+        self.__interval__ = interval
+        if self.__channel__.auth and not self.uid:
+            raise Exception('Unauthorized!')
+
+    def _run(self):
+        while self.__loading__:
+            self.__emit__()
+            time.sleep(self.__interval__)
+
+    def start(self):
+        if self.__loading__:
+            return  # 避免重复启动
+        self.__payload__ = None
+        self.__loading__ = True
+        self.__emit__('start')
+        self.__thread__ = threading.Thread(target=self._run, daemon=True)
+        self.__thread__.start()
+
+    def stop(self):
+        self.__payload__ = None
+        self.__loading__ = False
+        self.__emit__('stop')
+        if self.__thread__:
+            self.__thread__.join()
+            self.__thread__ = None
+
+    def load(self, payload):
+        with self.__lock__:
+            self.__payload__ = payload
+
+    def done(self, payload):
+        self.__emit__('done', payload)
+
+    def __emit__(self, status='proceed', data=None):
+        scope = 'broadcast' if self.__channel__.broadcast else 'client'
+        body = {
+            'type': f'{scope}.emit',
+            'data': self.__channel__.to_dict(status, data or self.__payload__),
+            'clients': [self.client],
+            'users': []
+        }
+        self.group_send(VALAR_CHANNEL_GROUP, body)
+
+
+class ValarSocketSender(Sender):
+    def __init__(self, request: HttpRequest):
+        super().__init__(request)
+        if self.uid:
+            body = {'type': 'broadcast.emit', 'uid': self.uid, 'client': self.client}
+            self.group_send(VALAR_CHANNEL_GROUP, body)
+
+    def to_users(self, payload, users: list):
+        body = {'type': 'user.emit', 'data': payload, 'users': users}
+        self.group_send(VALAR_CHANNEL_GROUP, body)
+
+    def to_clients(self, payload, clients: list):
+        body = {'type': 'client.emit', 'data': payload, 'clients': clients}
+        self.group_send(VALAR_CHANNEL_GROUP, body)
+
+    def broadcast(self, payload):
+        body = {'type': 'broadcast.emit', 'data': payload}
+        self.group_send(VALAR_CHANNEL_GROUP, body)

{valar-1.1.4 → valar-1.2.0}/src/valar/channels/views.py

@@ -1,12 +1,11 @@
-
 from .executer import execute_channel
 from .mapping import ChannelMapping
-from .sender import ValarSocketSender
+from .sender import ValarChannelSender
 from ..classes.valar_response import ValarResponse
 
 
 async def handel_channel(request, handler):
-    sender = ValarSocketSender(request)
+    sender = ValarChannelSender(request)
     method = ChannelMapping().get_handler(handler)
     await execute_channel(method, sender)
     return ValarResponse(True)

{valar-1.1.4/src/valar/classes → valar-1.2.0/src/valar/classes/app_mixins}/auto_urlpatterns_mixin.py

@@ -3,13 +3,13 @@ import importlib
 from django.conf import settings
 from django.urls import path, include
 
+
 class AutoUrlPatternsMixin:
     name = None  # 子类必须提供
+
     def set_url(self):
         root = settings.ROOT_URLCONF
         module = importlib.import_module(root)
         urlpatterns: list = getattr(module, 'urlpatterns')
         url = f'{self.name}.urls'
-        urlpatterns.append(path('data/', include(url)))
-
-
+        urlpatterns.append(path('valar/', include(url)))

valar-1.2.0/src/valar/classes/valar_minio.py

@@ -0,0 +1,80 @@
+import json
+from io import BytesIO
+from django.conf import settings
+from urllib3 import BaseHTTPResponse
+
+from ..classes.singleton_meta import SingletonMeta
+
+
+class ValarMinio(metaclass=SingletonMeta):
+
+    def __init__(self, client, entity):
+        self.client = client
+        self.bucket_name = f'{settings.BASE_DIR.name}.{entity}'.replace('_', '-').lower()
+        if client and not self.client.bucket_exists(self.bucket_name):
+            self.client.make_bucket(self.bucket_name)
+            self.client.set_bucket_policy(self.bucket_name, self.__generate_policy__())
+
+    @staticmethod
+    def get_object_name(_id, prop, file_name):
+        return f"{_id}-{prop}-{file_name}"
+
+    def upload(self, object_name, _bytes):
+        file_data = BytesIO(_bytes)
+        file_size = len(_bytes)  # file.siz
+        self.client.put_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name,
+            data=file_data,
+            length=file_size
+        )
+        return f'{self.bucket_name}/{object_name}'
+
+    def remove(self, path):
+        if path:
+            bucket_name, object_name = path.split('/')
+            self.client.remove_object(
+                bucket_name=bucket_name,
+                object_name=object_name
+            )
+
+    def read(self, object_name) -> BytesIO:
+        ret: BaseHTTPResponse = self.client.get_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name
+        )
+        return BytesIO(ret.read())
+
+    def __generate_policy__(self):
+        return json.dumps({
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Sid": "",
+                    "Effect": "Allow",
+                    "Principal": {"AWS": "*"},
+                    "Action": "s3:GetBucketLocation",
+                    "Resource": f"arn:aws:s3:::{self.bucket_name}"
+                },
+                {
+                    "Sid": "",
+                    "Effect": "Allow",
+                    "Principal": {"AWS": "*"},
+                    "Action": "s3:ListBucket",
+                    "Resource": f"arn:aws:s3:::{self.bucket_name}"
+                },
+                {
+                    "Sid": "",
+                    "Effect": "Allow",
+                    "Principal": {"AWS": "*"},
+                    "Action": "s3:GetObject",
+                    "Resource": f"arn:aws:s3:::{self.bucket_name}/*"
+                },
+                {
+                    "Sid": "",
+                    "Effect": "Allow",
+                    "Principal": {"AWS": "*"},
+                    "Action": "s3:PutObject",
+                    "Resource": f"arn:aws:s3:::{self.bucket_name}/*"
+                }
+            ]})

{valar-1.1.4 → valar-1.2.0}/src/valar/classes/valar_response.py

@@ -1,7 +1,8 @@
 from django.http import JsonResponse
 
+
 class ValarResponse(JsonResponse):
-    def __init__(self, data, message='', code='info'):
+    def __init__(self, data=True, message='', code='info'):
         self.message = message
         self.code = code
         super(ValarResponse, self).__init__(data, safe=False)

valar-1.2.0/src/valar/dao/__init__.py

@@ -0,0 +1,45 @@
+from ..dao.abstract import AbstractDao
+from ..dao.mon_dao import MonDao
+from ..dao.orm_dao import OrmDao
+
+
+class Dao(AbstractDao):
+
+    def __init__(self, entity, db='orm'):
+        self.dao = OrmDao(entity) if db == 'orm' else MonDao(entity)
+        self.db = db
+        self.entity = entity
+        self.name = self.dao.name
+        self.is_tree = self.dao.is_tree
+        self.fields = self.dao.fields
+        self.manager = self.dao.manager
+
+    def save_many(self, array: list):
+        self.dao.save_many(array)
+
+    def save_one(self, item, with_id=False):
+        return self.dao.save_one(item, with_id)
+
+    def delete_one(self, _id):
+        return self.dao.delete_one(_id)
+
+    def find_one(self, _id):
+        return self.dao.find_one(_id)
+
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        return self.dao.find(conditions, orders, size, page)
+
+    def values(self, conditions, props):
+        return self.dao.values(conditions, props)
+
+    def update(self, template, conditions):
+        return self.dao.update(template, conditions)
+
+    def delete(self, conditions=None) -> list:
+        return self.dao.delete(conditions)
+
+    def serialize(self, o, code=None):
+        return self.dao.serialize(o, code)
+
+    def tree(self, root, conditions=None):
+        return self.dao.tree(root, conditions)

valar-1.2.0/src/valar/dao/abstract.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+
+from bson import ObjectId
+
+from ..dao.engine import ValarEngine
+
+
+class AbstractField(ABC):
+    db = None
+    entity = None
+    prop = None
+    label = None
+    domain = None
+    refer = None
+
+    @abstractmethod
+    def to_dict(self):
+        pass
+
+
+class AbstractDao(ABC):
+    engine = ValarEngine()
+    db = None
+    entity = None
+    name = None
+    is_tree = False
+    fields = {}
+
+    def props(self, domain=None):
+        return [prop for prop, field in self.fields.items() if field.domain == domain or domain is None]
+
+    def full_props(self):
+        return {
+            prop: {
+                "prop": prop,
+                "domain": field.domain,
+                "label": field.label,
+            }
+            for prop, field in self.fields.items()
+        }
+
+    def get_meta_field(self, prop) -> AbstractField:
+        return self.fields[prop]
+
+    @abstractmethod
+    def save_one(self, item, with_id=False):
+        pass
+
+    @abstractmethod
+    def save_many(self, array: list):
+        pass
+
+    @abstractmethod
+    def values(self, conditions, props):
+        pass
+
+    @abstractmethod
+    def delete_one(self, _id):
+        pass
+
+    @abstractmethod
+    def find_one(self, _id):
+        pass
+
+    @abstractmethod
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        pass
+
+    @abstractmethod
+    def update(self, template, conditions):
+        pass
+
+    @abstractmethod
+    def delete(self, conditions=None) -> list:
+        pass
+
+    @abstractmethod
+    def serialize(self, o, code=None):
+        pass
+
+    @abstractmethod
+    def tree(self, root, conditions=None):
+        pass
+
+    def search(self, includes=None, excludes=None, orders=None):
+        conditions = [{"includes": includes or {}, "excludes": excludes or {}}]
+        results, _ = self.find(conditions, orders)
+        return results
+
+    def object_id(self, _id):
+        try:
+            return int(_id) if self.db == 'orm' else ObjectId(_id)
+        except Exception:
+            return None
+
+    # @abstractmethod
+    # def values(self, props, conditions, orders=None):
+    #     pass
+    #
+    # @abstractmethod
+    # def group(self, props, conditions, orders=None):
+    #     pass
+    #
+    # @abstractmethod
+    # def count(self, props, conditions):
+    #     pass

valar-1.2.0/src/valar/dao/defaults/field_keys_default.py

@@ -0,0 +1,48 @@
+meta_field_key_defaults = {
+    'valar.Meta': {
+        'default': ('pick', ['db', 'entity', 'name', 'tree']),
+    },
+    'valar.MetaView': {
+        'list': ('pick', ['code', 'name']),
+        'core': ('pick', ['name', 'enable', 'lock', 'property']),
+        'style': ('pick', ['form_width', 'form_height', 'table_width', 'table_height']),
+        'rest': ('pick',
+                 ['allow_search', 'allow_order', 'allow_insert', 'allow_remove', 'allow_download', 'allow_upload']),
+        'edit': ('pick', ['allow_edit', 'allow_edit_on_form', 'allow_edit_on_cell', 'allow_edit_on_sort']),
+    },
+    'valar.MetaField': {
+        'tool': (
+            'pick',
+            [
+                'name', 'domain', 'tool', 'refer', 'format'
+            ]
+        ),
+        'rest': (
+            'pick',
+            [
+                'name', 'not_null',
+                'allow_edit', 'allow_sort', 'allow_search', 'allow_download', 'allow_upload', 'allow_update'
+            ]
+        ),
+        'table': (
+            'pick',
+            [
+                'name', 'unit', 'column_width', 'fixed', 'align', 'edit_on_table', 'hide_on_table',
+                'header_color', 'cell_color'
+            ]
+        ),
+        'form': (
+            'pick',
+            [
+                'name', 'span',
+                'hide_on_form', 'hide_on_form_insert', 'hide_on_form_edit', 'hide_on_form_branch', 'hide_on_form_leaf'
+            ]
+        ),
+    },
+    'vtest.Vala': {
+        'simple': ('pick', ['id', 'name', 'text_field', 'boolean_field', 'integer_field', 'float_field']),
+        'date': ('pick', ['id', 'name', 'date_field', 'datetime_field', 'time_field']),
+        'special': ('pick', ['id', 'name', 'text_field', 'json_field', 'file', 'm2m']),
+        'ref': ('pick', ['id', 'name', 'm2o', 'm2m', 'o2o_id']),
+    },
+}

valar-1.2.0/src/valar/dao/defaults/field_values_default.py

@@ -0,0 +1,135 @@
+meta_field_value_defaults = {
+    'valar.Meta': {
+        "__init__": {
+            "db": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'orm': 'SQL',
+                        'mon': 'MongoDB',
+                        'center': '剧中对齐',
+                    }
+                }
+            },
+        }
+    },
+    'valar.MetaView': {
+        "__init__": {
+            "meta_id": {
+                'allow_edit': False,
+            },
+            "code": {
+                'allow_edit': False,
+            },
+            "name": {
+                'span': 24
+            }
+        },
+        "core": {
+            "name": {
+                'span': 16
+            },
+            "enable": {
+                "span": 8
+            }
+        }
+    },
+    'valar.MetaFieldDomain': {
+        "__init__": {
+            "default_id": {
+                "tool": "tree"
+            },
+            "search_id": {
+                "tool": "tree"
+            },
+            "tools": {
+                "tool": "tree",
+                "refer": {
+                    "display": "code"
+                }
+            },
+            "align": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'left': '左对齐',
+                        'right': '右对齐',
+                        'center': '剧中对齐',
+                    }
+                }
+            }
+        }
+    },
+    'valar.MetaField': {
+        "rest": {
+            "name": {
+                'hide_on_form': False
+            },
+        },
+        "__init__": {
+            "column_width": {
+                'unit': 'px'
+            },
+            "name": {
+                'span': 24,
+                'hide_on_form': True
+            },
+            "fixed": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'left': '左侧固定',
+                        'right': '右侧固定',
+                    }
+                }
+            },
+            "align": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'left': '左对齐',
+                        'right': '右对齐',
+                        'center': '剧中对齐',
+                    }
+                }
+            },
+            "prop": {
+                'allow_edit': False,
+                'column_width': 120
+            },
+            "domain": {
+                'allow_edit': False,
+                'column_width': 120,
+            },
+            "tool": {
+                'column_width': 100,
+                'span': 24,
+                'tool': 'tree',
+                'refer': {
+                    'entity': 'valar.MetaFieldTool',
+                    'includes': {'metafielddomain__name': '${domain}'},
+                    'value': 'code', 'display': 'code', "isTree": True
+                }
+
+            },
+            "span": {
+                'column_width': 100,
+                "format": {"min": 0, "max": 24, "step": 1, "precision": 0, "step_strictly": True}
+            },
+            "refer": {
+                'allow_edit': False,
+                'column_width': 80
+            },
+            "format": {
+                'allow_edit': False,
+                'column_width': 80
+            },
+            'header_color': {
+                'tool': 'color',
+            },
+            'cell_color': {
+                'tool': 'color',
+            }
+        }
+    }
+}