valar 1.0.20__tar.gz → 1.0.22__tar.gz

{valar-1.0.20/src/valar.egg-info → valar-1.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valar
-Version: 1.0.20
+Version: 1.0.22
 Summary: valar for morghulis
 Author: LYP
 Author-email: liuyinpeng@buaa.edu.cn

{valar-1.0.20 → valar-1.0.22}/setup.py

@@ -3,9 +3,6 @@ from setuptools import setup, find_packages
 with open("README.md", "r", encoding="utf-8") as f:
     long_description = f.read()
 
-# with open('requirements.txt', "r", encoding="utf-8") as f:
-#     required = f.read().splitlines()
-
 requires = [
     'channels==3.0.3',
     'pymongo~=4.11.2',
@@ -19,7 +16,7 @@ requires = [
 
 setup(
     name="valar",  # 包名
-    version="1.0.20",  # 版本号
+    version="1.0.22",  # 版本号
     author="LYP",  # 作者
     author_email="liuyinpeng@buaa.edu.cn",  # 邮箱
     description="valar for morghulis",  # 简短描述

valar-1.0.22/src/valar/channels/__init__.py

@@ -0,0 +1 @@
+VALAR_CHANNEL_GROUP = 'VALAR'

valar-1.0.22/src/valar/channels/consumer.py

@@ -0,0 +1,48 @@
+
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+
+from ..channels import VALAR_CHANNEL_GROUP
+
+class ValarConsumer(AsyncJsonWebsocketConsumer):
+
+    def __init__(self):
+        self.client = None
+        self.uid = None
+        super().__init__()
+
+    async def connect(self):
+        params = self.scope['url_route']['kwargs']
+        self.client = params.get('client')
+        await self.channel_layer.group_add(VALAR_CHANNEL_GROUP, self.channel_name)
+        await self.accept()
+
+    async def disconnect(self, code):
+        await self.channel_layer.group_discard(VALAR_CHANNEL_GROUP, self.channel_name)
+        await self.close(code)
+
+    async def receive_json(self, data, *args, **kwargs):
+        pass
+
+    async def user_emit(self, event):
+        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',{})
+        if self.client in clients:
+            await self.send_json(data)
+
+    async def broadcast_emit(self, event):
+        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]
+
+

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

@@ -0,0 +1,13 @@
+import asyncio
+
+async def execute_channel(method, sender):
+    thread = asyncio.to_thread(__execute__, method, sender)
+    asyncio.create_task(thread)
+
+
+def __execute__(method, sender):
+    sender.to_clients(None, [sender.client], 'start')
+    method(sender)
+    sender.to_clients(None, [sender.client], 'stop')
+
+

valar-1.0.22/src/valar/channels/mapping.py

@@ -0,0 +1,21 @@
+import importlib
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+class ChannelMapping:
+    def __init__(self):
+        root = settings.ROOT_URLCONF
+        module = importlib.import_module(root)
+        name = 'channel_mapping'
+        if hasattr(module, name):
+            self.mapping: dict = getattr(module, name)
+        else:
+            raise ImproperlyConfigured("%r has no attribute %r" % (root, name))
+
+    def get_handler(self, handler):
+        method = self.mapping.get(handler)
+        if method is None:
+            raise ImproperlyConfigured("Cannot find handler - %r" % handler)
+        return method
+

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

@@ -0,0 +1,60 @@
+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
+
+from ..channels import VALAR_CHANNEL_GROUP
+
+
+class ValarSocketSender:
+    def __init__(self, request: HttpRequest, data=None):
+        body = json.loads(request.body)
+        auth = request.headers.get('AUTH')
+        self.client = request.headers.get('CLIENT')
+        self.uid = request.session.get('UID')
+        self.handlerKey = body.get('handlerKey')
+        self.channelKey = body.get('channelKey', 'default')
+        self.data = data or body.get('data')
+        self.send = get_channel_layer().group_send
+        self.start_time = time.time()
+        if auth and not self.uid:
+            raise Exception('Unauthorized!')
+
+
+    def __convert_body(self, emit, payload, status ,clients = None, users = None):
+        return {
+            'type': emit,
+            'data': {
+                'status': status,
+                'handlerKey': self.handlerKey,
+                'channelKey': self.channelKey,
+                'payload': payload,
+                'timestamp': datetime.now().timestamp()
+            },
+            'clients': clients or [],
+            'users': users or [],
+        }
+
+
+    def to_users(self, payload,  users, status='proceed'):
+        body = self.__convert_body(emit='user.emit', payload=payload, status=status, users=users)
+        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+
+    def to_clients(self,payload, clients, status='proceed', wait=False):
+        current_time = time.time()
+        time_span = current_time - self.start_time
+        if (wait and time_span > 1 and status == 'proceed') or not wait:
+            body = self.__convert_body(emit='client.emit', payload=payload, status=status, clients=clients)
+            async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+            self.start_time = current_time
+
+    def broadcast(self, payload, status):
+        body = self.__convert_body(emit='broadcast.emit', payload=payload, status=status)
+        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+
+    def register(self):
+        body = self.__convert_body(emit='register.emit',  payload=None, status=None,clients=[self.client], users=[self.uid])
+        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)

valar-1.0.22/src/valar/channels/views.py

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

valar-1.0.22/src/valar/core/counter.py

@@ -0,0 +1,9 @@
+class Counter:
+    def __init__(self, array_or_int):
+        self.length = array_or_int if isinstance(array_or_int,int) else len(array_or_int)
+        self.index = 0
+
+    def tick(self):
+        self.index += 1
+        percentage = round(self.index * 100 / self.length)
+        return {"index": self.index, "length": self.length, "percentage": percentage}

valar-1.0.22/src/valar/core/dao/_mon_array2tree.py

@@ -0,0 +1,18 @@
+def array2tree(data, mapping):
+    mapping = mapping or {}
+    lookup = {}
+    for array in data:
+        for i in range(len(array)):
+            key = '/'.join(array[0:i+1])
+            item = mapping.get(key, {})
+            value = item.get('value', array[i])
+            label = item.get('label', value)
+            display = item.get('display')
+            item = lookup.get(key, {'value': value,'label':label,'display':display})
+            if i < len(array) -1:
+                item['children'] = item.get('children', [])
+            lookup[key] = item
+            if i > 0:
+                parent =   '/'.join(array[0:i])
+                lookup[parent]['children'].append(lookup[key])
+    return [lookup[root] for root in [*set([array[0] for array in data])]]

valar-1.0.22/src/valar/core/dao/dao_base.py

@@ -0,0 +1,50 @@
+from .dao_mon import MonDao
+from .dao_orm import OrmDao
+from ..dao_abstract import AbstractDao
+
+
+class Dao(AbstractDao):
+
+    def __init__(self, entity, db='orm'):
+        self.entity = entity
+        self.db = db
+        self.dao: AbstractDao = OrmDao(entity) if db == 'orm' else MonDao(entity)
+
+    def get_model(self):
+        self.dao.get_model()
+
+    def save_one(self, item):
+        return self.dao.save_one(item)
+
+    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 update(self, template, conditions):
+        return self.dao.update(template, conditions)
+
+    def delete(self, conditions):
+        return self.dao.delete(conditions)
+
+    def transform(self, o, code=None):
+        return self.dao.transform(o)
+
+    def tree(self, root, conditions=None):
+        return self.dao.tree(conditions, root)
+
+
+
+    # def values(self, props, conditions, orders=None):
+    #     pass
+    #
+    # def group(self, props, conditions, orders=None):
+    #     pass
+    #
+    # def count(self, props, conditions):
+    #     pass
+

valar-1.0.22/src/valar/core/dao/dao_mon.py

@@ -0,0 +1,76 @@
+from pymongo.results import InsertOneResult
+from pymongo.synchronous.cursor import Cursor
+
+from .engine import DaoEngine
+from .model_mon import MonModel
+from .query_mon import MonQuery
+from ..dao_abstract import AbstractDao
+
+
+class MonDao(AbstractDao):
+    def __init__(self, entity):
+        self.entity = entity
+        engine = DaoEngine().mon
+        self.model:MonModel = engine.get_model(entity)
+        self.objects = self.model.manager
+
+    def get_model(self):
+        return self.model
+
+    def save_one(self, item):
+        oid, item = self.model.detach_item(item)
+        if oid:
+            self.objects.update_one({'_id': oid}, {'$set': item})
+        else:
+            bean: InsertOneResult = self.objects.insert_one(item)
+            oid = bean.inserted_id
+            self.objects.update_one({'_id': oid}, {'$set': {'sort': str(oid)}})
+        return self.objects.find_one({'_id': oid})
+
+    def delete_one(self, _id):
+        oid = self.model.object_id(_id)
+        flag = False
+        if oid:
+            self.objects.delete_one({'_id': oid})
+            flag = True
+        return flag
+
+    def find_one(self, _id):
+        oid = self.model.object_id(_id)
+        return self.objects.find_one({'_id': oid}) if oid else None
+
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        query = MonQuery(conditions, orders)
+        skip = (page - 1) * size
+        total = self.objects.count_documents(query.finder)
+        cursor = self.objects.find(query.finder, query.orders).skip(skip)
+        if size:
+            cursor = cursor.limit(size)
+        return cursor, total
+
+    def update(self, template, conditions):
+        if template and len(template.keys()):
+            oid, item = self.model.detach_item(template)
+            query = MonQuery(conditions)
+            self.objects.update_many(query.finder, {'$set': item})
+            return True
+        return False
+
+    def delete(self, conditions):
+        query = MonQuery(conditions)
+        self.objects.delete_many(query.finder)
+
+    def transform(self, o, code=None):
+        if isinstance(o, Cursor):
+            return [__to_item__(doc) for doc in o]
+        else:
+            return __to_item__(o)
+
+    def tree(self, root, conditions=None):
+        pass
+
+
+def __to_item__(o):
+    o['id'] = str(o['_id'])
+    del o['_id']
+    return o

valar-1.0.22/src/valar/core/dao/dao_orm.py

@@ -0,0 +1,96 @@
+import datetime
+from django.core.paginator import Paginator
+from django.db.models import QuerySet
+
+from .engine import DaoEngine
+from .query_orm import OrmQuery
+from ..dao_abstract import AbstractDao
+
+
+class OrmDao(AbstractDao):
+    def __init__(self, entity):
+        self.entity = entity
+        engine = DaoEngine().orm
+        self.model = engine.get_model(entity)
+        self.objects = self.model.manager
+
+    def get_model(self):
+        return self.model
+
+    def save_one(self, item):
+        oid, simple_item, complex_item  = self.model.detach_item(item)
+        query_set = self.objects.filter(id=oid) if oid else []
+        if len(query_set):
+            simple_item['modify_time'] = datetime.datetime.now()
+            query_set.update(**simple_item)
+            bean = query_set.first()
+        else:
+            bean = self.objects.create(**simple_item)
+            bean.sort = bean.id
+            bean.save()
+        self.model.save_complex_field(complex_item, bean)
+        bean.save()
+        return bean
+
+    def delete_one(self, _id):
+        oid = self.model.object_id(_id)
+        flag = False
+        if oid:
+            query_set = self.objects.filter(id=oid)
+            self.model.remove_files(query_set)
+            query_set.delete()
+            flag = True
+        return flag
+
+    def find_one(self, _id):
+        oid = self.model.object_id(_id)
+        return self.objects.filter(id=oid).first() if oid else None
+
+
+
+    def find(self, conditions=None, orders=None,size=0, page=1):
+        query = OrmQuery(conditions, orders)
+        query_set = self.objects.filter(query.includes).exclude(query.excludes).order_by(*query.orders)
+        total = query_set.count()
+        if size:
+            paginator = Paginator(query_set, size)
+            query_set = paginator.page(page).object_list
+        return query_set, total
+
+    def update(self, template, conditions):
+        if template and len(template.keys()):
+            oid, simple_item, complex_item = self.model.detach_item(template)
+            query_set, total = self.find(conditions)
+            query_set.update(**simple_item)
+            return True
+        return False
+
+    def delete(self, conditions):
+        query_set, total = self.find(conditions)
+        self.model.remove_files(query_set)
+        query_set.delete()
+
+    def transform(self, o, code=None):
+        if isinstance(o, QuerySet):
+            return self.model.to_dict(o, code)
+        else:
+            return o.full()
+
+    def tree(self, root, conditions=None):
+        all_set, _ = self.find([])
+        query = OrmQuery(conditions)
+        if query.is_empty(conditions):
+            return all_set
+        values = all_set.values('id', 'pid')
+        mapping = {item['id']: item['pid'] for item in values}
+        results, _ = self.find(conditions)
+        id_set = {root}
+        for item in results:
+            _id = item.id
+            route = []
+            while _id is not None:
+                route.append(_id)
+                _id = mapping.get(_id)
+            if root in route:
+                id_set.update(route)
+        return all_set.filter(id__in=id_set).order_by('-sort')

valar-1.0.22/src/valar/core/dao/engine.py

@@ -0,0 +1,12 @@
+
+from ..singleton_meta import SingletonMeta
+from .engine_mon import MonEngine
+from .engine_orm import OrmEngine
+
+
+class DaoEngine(metaclass=SingletonMeta):
+
+    def __init__(self):
+        self.mon = MonEngine()
+        self.orm = OrmEngine()
+

valar-1.0.22/src/valar/core/dao/engine_minio.py

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

valar-1.0.22/src/valar/core/dao/engine_mon.py

@@ -0,0 +1,34 @@
+import pymongo
+from django.conf import settings
+
+from .model_mon import MonModel
+
+
+class MonEngine:
+
+    def __init__(self):
+        uri = f'mongodb://localhost:27017/'
+        mongo = settings.MONGO
+        if mongo:
+            param = ['host', 'port', 'username', 'password']
+            host, port, username, password = [mongo.get(p) for p in param]
+            uri = f'mongodb://{username}:{password}@{host}:{port}/'
+
+        client = pymongo.MongoClient(uri, **{
+            'maxPoolSize': 10,
+            'minPoolSize': 0,
+            'maxIdleTimeMS': 10000,
+            'connectTimeoutMS': 10000,
+            'socketTimeoutMS': 10000,
+            'serverSelectionTimeoutMS': 10000,
+        })
+        database =  client[settings.BASE_APP]
+        self.uri = uri
+        self.client = client
+        self.database = database
+
+    def get_mapping(self):
+        return  {col['name']: self.database[col['name']] for col in self.database.list_collections()}
+
+    def get_model(self,entity)->MonModel:
+        return MonModel(self.database, entity)

valar-1.0.22/src/valar/core/dao/engine_orm.py

@@ -0,0 +1,25 @@
+from django.apps import apps
+
+from .model_orm import OrmModel
+from ..valar_models import VModel
+
+
+class OrmEngine:
+
+    def __init__(self):
+        mapping = {}
+        for model in apps.get_models():
+            if issubclass(model, VModel):
+                path, name = model.__module__, model.__name__
+                prefix = 'src.valar.' if path.startswith('src') else 'valar.'
+                app = path.replace('.models', '').replace(prefix, '')
+                entity = '%s.%s' % (app, name)
+                mapping[entity] = model
+        self.mapping = mapping
+
+    def get_mapping(self)->dict:
+        return self.mapping
+
+    def get_model(self,entity)->OrmModel:
+        mod = self.mapping.get(entity)
+        return OrmModel(mod, entity)

valar-1.0.22/src/valar/core/dao/model_mon.py

@@ -0,0 +1,24 @@
+from bson import ObjectId
+from bson.errors import InvalidId
+from pymongo.synchronous.collection import Collection
+
+
+class MonModel:
+
+    def __init__(self, database, entity):
+        self.entity = entity
+        self.name = entity.replace('.', '_')
+        self.manager: Collection = database[self.name]
+
+    @staticmethod
+    def object_id(_id):
+        try:
+            return ObjectId(_id)
+        except(InvalidId, TypeError):
+            return None
+
+    def detach_item(self, item):
+        _id = item.get('id')
+        if _id:
+            del item['id']
+        return self.object_id(_id), item