deepfos 1.1.60__py3-none-any.whl

deepfos/lib/httpcli.py

@@ -0,0 +1,106 @@
+"""HTTP客户端"""
+
+import atexit
+import threading
+import asyncio
+import aiohttp
+import requests
+from .utils import auto_setup
+from .asynchronous import register_on_loop_shutdown
+from deepfos.options import OPTION
+
+
+class AioHttpCli:
+    session = {}
+
+    @classmethod
+    async def get_session(cls):
+        tid = threading.get_ident()
+        if (
+            (session := cls.session.get(tid)) is None
+            or session.closed
+            or session._loop.is_closed()  # noqa
+        ):
+            cls.session[tid] = aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False))
+            register_on_loop_shutdown(cls.close_current)
+        return cls.session[tid]
+
+    @classmethod
+    async def get(cls, url, *, allow_redirects=True, **kwargs):
+        session = await cls.get_session()
+        return await session.get(
+            url,
+            allow_redirects=allow_redirects,
+            verify_ssl=OPTION.api.verify_ssl,
+            timeout=OPTION.api.timeout,
+            **kwargs
+        )
+
+    @classmethod
+    async def post(cls, url, *, data=None, **kwargs):
+        session = await cls.get_session()
+        return await session.post(
+            url,
+            data=data,
+            verify_ssl=OPTION.api.verify_ssl,
+            timeout=OPTION.api.timeout,
+            **kwargs
+        )
+
+    @classmethod
+    async def close(cls):
+        for session in cls.session.values():
+            await session.close()
+            await asyncio.sleep(0)
+            del session
+        cls.session = {}
+
+    @classmethod
+    async def close_current(cls):
+        tid = threading.get_ident()
+        session = cls.session.pop(tid, None)
+        if session is not None:
+            await session.close()
+            await asyncio.sleep(0)
+            del session
+
+
+class SyncHttpCli:
+    """同步HTTP客户端"""
+    session: requests.Session = None
+
+    @classmethod
+    def setup(cls):
+        if cls.session is None:
+            session = requests.Session()
+            cls.session = session
+
+    @classmethod
+    @auto_setup
+    def post(cls, url, headers=None, **kwargs):
+        return cls.session.post(
+            url,
+            headers=headers,
+            timeout=(4, 180),
+            verify=OPTION.api.verify_ssl,
+            **kwargs
+        )
+
+    @classmethod
+    @auto_setup
+    def get(cls, url, params=None, headers=None):
+        return cls.session.get(
+            url,
+            params=params,
+            headers=headers,
+            timeout=(4, 180),
+            verify=OPTION.api.verify_ssl,
+        )
+
+
+def _close_session(): # pragma: no cover
+    if SyncHttpCli.session is not None:
+        SyncHttpCli.session.close()
+
+
+atexit.register(_close_session)

deepfos/lib/jsonstreamer.py

@@ -0,0 +1,80 @@
+import os
+
+from deepfos.boost import jstream
+
+
+class JsonStreamer:
+    def __init__(self, file, key: str):
+        self.key = key.encode('utf-8')
+        # 是否在引号内
+        self.in_double_quotation = False
+        # 是否在转义符内
+        self.in_escape = False
+        # 花括号个数
+        self.lbrace = 0
+        self.rbrace = 0
+        # 匹配的键是否已开始
+        self.is_started = False
+        # 当前已匹配的键段
+        self.matched_index = 0
+        # 是否已找到完整的值
+        self.finished = False
+
+        if isinstance(file, str):
+            if os.path.exists(file):
+                self.file = open(file, 'rb')
+                self.should_close = True
+            else:
+                raise ValueError('Filename or IO value expected.')
+        elif isinstance(file, JsonStreamer):
+            self.should_close = True
+            self.file = file
+        else:
+            self.should_close = False
+            self.file = file
+
+    def read(self, length: int = 1024):
+        result = b''
+        read_size = length
+        while len(result) < length:
+            if self.finished:
+                break
+            temp = self.file.read(read_size)
+            if len(temp) == 0:
+                break
+            result = result + jstream.read(temp, self)
+            read_size = length - len(result)
+        return result
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if getattr(self, 'should_close', False):
+            self.file.close()
+            self.should_close = False
+
+
+class JsonStreamMultiKeyPath:
+    def __init__(self, file, key_path: str):
+        all_key = key_path.split('.')
+        streamer = JsonStreamer(file, all_key[0])
+        for key in all_key[1::]:
+            streamer = JsonStreamer(streamer, key)
+        self.streamer = streamer
+
+    def __enter__(self):
+        return self.streamer
+
+    def __exit__(self, *args):
+        self.streamer.close()
+
+    def read(self, length: int = 1024):
+        return self.streamer.read(length)
+
+    def close(self):
+        self.streamer.close()
+
+    def __del__(self):
+        if getattr(self, 'streamer', None):
+            self.streamer.close()

deepfos/lib/msg.py

@@ -0,0 +1,394 @@
+import asyncio
+from enum import Enum
+from functools import partial
+from typing import Dict, List, Union, Literal, TYPE_CHECKING
+
+from deepfos import OPTION
+from deepfos.api.models.system import (
+    MessageTemplateListVOResp, MessageTemplateListQueryDto,
+    MessageTemplateListVO, MessageTemplateParamResp,
+    MessageTemplateParamListQueryDto
+)
+from deepfos.api.platform import PlatformAPI
+from deepfos.api.system import SystemAPI
+from deepfos.db.dbkits import SyncMeta
+from deepfos.exceptions import MsgCenterError
+from deepfos.lib.asynchronous import future_property
+from deepfos.lib.decorator import cached_property
+from deepfos.lib.utils import fetch_all_pages
+
+__all__ = ['MsgCenter', 'AsyncMsgCenter']
+
+
+class TemplateType(Enum):
+    # 平台公告
+    plat = 1
+    # 站内消息
+    station = 2
+    # 短信
+    sms = 3
+    # 邮箱
+    email = 4
+
+
+def _tpl_list_count(resp: Union[MessageTemplateListVOResp, MessageTemplateParamResp]):
+    return len(resp.list)
+
+
+class AsyncMsgCenter:
+    """消息中心"""
+
+    def __init__(self):
+        self.__class__.templates.submit(self)
+        self.system = SystemAPI(sync=False)
+        self.platform = PlatformAPI(sync=False)
+
+    @cached_property
+    def type_api_map(self):
+        svc = self.system.msg_service
+        return {
+            TemplateType.plat: (svc.push_plat_notice, svc.push_plat_notice),
+            TemplateType.station: (svc.push_station_message, svc.push_station_message),
+            TemplateType.email: (svc.push_email_message, svc.send_email),
+            TemplateType.sms: (svc.push_sms_message, svc.send_sms),
+        }
+
+    @future_property(on_demand=True)
+    async def templates(self) -> Dict[str, MessageTemplateListVO]:
+        """当前有效的空间消息模板"""
+
+        def impl(api, num, size):
+            return api(MessageTemplateListQueryDto(pageNum=num, pageSize=size))
+
+        pages = await fetch_all_pages(
+            partial(impl, api=self.system.msg_template.page),
+            count_getter=_tpl_list_count,
+            page_size=100,
+            page_no_key='num',
+            page_size_key='size'
+        )
+        return {vo.templateCode: vo for p in pages if p.list
+                for vo in p.list if vo.status == 1}
+
+    async def _params(self, template_id: int) -> List[Dict]:
+        def impl(api, num, size):
+            return api(MessageTemplateParamListQueryDto(
+                pageNum=num, pageSize=size, templateId=template_id
+            ))
+
+        pages = await fetch_all_pages(
+            partial(impl, api=self.system.msg_template.get_template_param),
+            count_getter=_tpl_list_count,
+            page_size=100,
+            page_no_key='num',
+            page_size_key='size'
+        )
+        return [
+            {'name': vo.paramName, 'scope': vo.scope}
+            for p in pages if p.list for vo in p.list
+        ]
+
+    async def _fit_param(self, tpl_id, scope: Literal[1, 2], param=None):
+        if not param:
+            param = {}
+
+        valid = {p['name'] for p in (await self._params(tpl_id)) if p['scope'] == scope}
+        scope_name = {1: '标题', 2: '内容'}
+        if lacked := (valid - param.keys()):
+            raise ValueError(f'{scope_name[scope]}参数: {lacked} 缺失')
+
+        return [
+            {'paramName': k, 'paramValue': str(param[k]), 'scope': scope}
+            for k in valid
+        ]
+
+    async def _publish(
+        self,
+        template: MessageTemplateListVO,
+        receivers: List,
+        sender: str = None,
+        title_param: Dict[str, str] = None,
+        content_param: Dict[str, str] = None,
+        attachments: Dict[str, Union[str, bytes]] = None,
+        cc_email: List[str] = None,
+        api_idx: Literal[0, 1] = 0
+    ) -> List:
+        payload = {
+            'receiver': receivers,
+            'sender': sender or OPTION.api.header.get('user'),
+            'templateCode': template.templateCode,
+            'params': [
+                *(await self._fit_param(template.id, 1, title_param)),
+                *(await self._fit_param(template.id, 2, content_param)),
+            ]
+        }
+        tpl_type = TemplateType(template.type)
+        if cc_email:
+            payload['ccEmail'] = cc_email
+
+        if tpl_type in [TemplateType.email, TemplateType.station] and attachments:
+            async def _gen_attach(name, file):
+                return {
+                    'id': (await self.platform.file.upload('DL', name, file)).id,
+                    'space': OPTION.api.header.get('space')
+                }
+
+            payload['attachment'] = await asyncio.gather(*[
+                _gen_attach(name, file) for name, file in attachments.items()
+            ])
+
+        api = self.type_api_map[tpl_type][api_idx]
+        resp = await api(payload)
+        if resp.failure:
+            raise MsgCenterError(*resp.failure)
+        
+        return resp.success
+
+    async def publish(
+        self,
+        template_code: str,
+        receiver_users: List[str] = None,
+        receiver_groups: List[str] = None,
+        sender: str = None,
+        title_param: Dict[str, str] = None,
+        content_param: Dict[str, str] = None,
+        attachments: Dict[str, Union[str, bytes]] = None,
+    ) -> List:
+        """推送指定消息模版的消息
+
+        Args:
+            template_code: 模板编码
+            sender: 可选，发送人userid，默认为当前用户id
+            receiver_users: 可选，收件人userid列表
+            receiver_groups: 可选，收件人groupid列表
+            title_param: 可选，标题变量
+            content_param: 可选，内容变量
+            attachments: 可选，站内消息或邮箱的消息附件，以 文件名: 文件(字符串/bytes) 的字典形式提供
+
+        .. admonition:: 示例
+
+            .. code-block:: python
+
+                from deepfos.lib.msg import MsgCenter
+                msg = MsgCenter()
+
+            #. 推送带附件的站内消息
+
+                .. code-block:: python
+
+                    # demo_station标题如下:
+                    # 标题【{var1}】
+                    # 内容如下:
+                    # 内容【{var1}】
+                    #
+                    # 发送至1个用户和1个用户组, 并附上2个文件附件
+
+                    msg.publish(
+                        'demo_station',
+                        receiver_users=['00000000-0000-0000-0000-000000000000'],
+                        receiver_groups=['00000000-0000-0000-0000-000000000001'],
+                        title_param={'var1': 'a'},
+                        content_param={'var1': 'b'},
+                        attachments={
+                            'file1.txt': 'Some text...',
+                            'file2.txt': 'More text...',
+                        }
+                    )
+
+        See Also:
+
+            :meth:`send_mail`
+            :meth:`send_sms`
+
+        """
+        template = self.templates.get(template_code)
+        if not template:
+            raise ValueError('模板编码对应的模板不存在或未启用')
+
+        receivers = []
+        if receiver_users:
+            receivers.extend([{'id': r, 'type': 'USER'} for r in receiver_users])
+        if receiver_groups:
+            receivers.extend([{'id': r, 'type': 'GROUP'} for r in receiver_groups])
+
+        if not receivers:
+            raise ValueError('需提供receiver_users和receiver_groups中的至少一项')
+
+        return await self._publish(
+            template, sender=sender, receivers=receivers,
+            title_param=title_param, content_param=content_param,
+            attachments=attachments,
+        )
+
+    async def send_mail(
+        self,
+        template_code: str,
+        receivers: List[str],
+        sender: str = None,
+        title_param: Dict[str, str] = None,
+        content_param: Dict[str, str] = None,
+        attachments: Dict[str, Union[str, bytes]] = None,
+        cc_email: List[str] = None,
+    ) -> List:
+        """发送指定消息模版的邮件
+
+        Args:
+            template_code: 模板编码
+            receivers: 收件人邮箱列表
+            sender: 可选，发送人userid，默认为当前用户id
+            title_param: 可选，标题变量
+            content_param: 可选，内容变量
+            attachments: 可选，附件，以 文件名: 文件(字符串/bytes) 的字典形式提供
+            cc_email: 可选，抄送人列表
+
+
+        .. admonition:: 示例
+
+            .. code-block:: python
+
+                from deepfos.lib.msg import MsgCenter
+                msg = MsgCenter()
+
+            #. 发送邮件
+
+                .. code-block:: python
+
+                    # demo_mail标题如下:
+                    # 邮件标题【{var2}】
+                    # 内容如下:
+                    # 邮件内容【{var2}】
+                    #
+                    # 发送至一个邮箱并抄送另一个邮箱, 并附上2个文件附件
+
+                    msg.send_mail(
+                        'demo_mail',
+                        receivers=['xxx@a.com'],
+                        cc_email=['yyy@b.com'],
+                        title_param={'var2': '42'},
+                        content_param={'var2': '24'},
+                        attachments={
+                            'file1.txt': 'Some text...',
+                            'file2.txt': 'More text...',
+                        }
+                    )
+
+        See Also:
+
+            :meth:`publish`
+            :meth:`send_sms`
+
+        """
+        template = self.templates.get(template_code)
+        if not template:
+            raise ValueError('模板编码对应的模板不存在或未启用')
+
+        if (tpl_type := TemplateType(template.type)) is not TemplateType.email:
+            raise ValueError(f'模板类型[{tpl_type}]非邮箱类型')
+
+        return await self._publish(
+            template, sender=sender, receivers=receivers,
+            title_param=title_param, content_param=content_param,
+            attachments=attachments, cc_email=cc_email,
+            api_idx=1
+        )
+
+    async def send_sms(
+        self,
+        template_code: str,
+        receivers: List[str],
+        sender: str = None,
+        title_param: Dict[str, str] = None,
+        content_param: Dict[str, str] = None
+    ) -> List:
+        """发送指定消息模版的短信
+
+        Args:
+            template_code: 模板编码
+            receivers: 收件人手机号列表
+            sender: 可选，发送人userid，默认为当前用户id
+            title_param: 可选，标题变量
+            content_param: 可选，内容变量
+
+
+        .. admonition:: 示例
+
+            .. code-block:: python
+
+                from deepfos.lib.msg import MsgCenter
+                msg = MsgCenter()
+
+            #. 发送短信
+
+                .. code-block:: python
+
+                    # demo_sms标题如下:
+                    # 短信标题【{var3}】
+                    # 内容如下:
+                    # 短信内容【{var3}】
+                    #
+                    # 发送至2个手机号
+
+                    msg.send_mail(
+                        'demo_sms',
+                        receivers=['15000000000', '13000000000'],
+                        title_param={'var3': 'Hello'},
+                        content_param={'var3': 'World'}
+                    )
+
+        See Also:
+
+            :meth:`publish`
+            :meth:`send_mail`
+
+        """
+        template = self.templates.get(template_code)
+        if not template:
+            raise ValueError('模板编码对应的模板不存在或未启用')
+
+        if (tpl_type := TemplateType(template.type)) is not TemplateType.sms:
+            raise ValueError(f'模板类型[{tpl_type}]非短信类型')
+
+        return await self._publish(
+            template, sender=sender, receivers=receivers,
+            title_param=title_param, content_param=content_param,
+            api_idx=1
+        )
+
+
+class MsgCenter(AsyncMsgCenter, metaclass=SyncMeta):
+    synchronize = ('publish', 'send_mail', 'send_sms',)
+
+    if TYPE_CHECKING:  # pragma: no cover
+        def publish(
+            self,
+            template_code: str,
+            receiver_users: List[str] = None,
+            receiver_groups: List[str] = None,
+            sender: str = None,
+            title_param: Dict[str, str] = None,
+            content_param: Dict[str, str] = None,
+            attachments: Dict[str, Union[str, bytes]] = None,
+        ) -> List:
+            ...
+
+        def send_mail(
+            self,
+            template_code: str,
+            receivers: List[str],
+            sender: str = None,
+            title_param: Dict[str, str] = None,
+            content_param: Dict[str, str] = None,
+            attachments: Dict[str, Union[str, bytes]] = None,
+            cc_email: List[str] = None,
+        ) -> List:
+            ...
+
+        def send_sms(
+            self,
+            template_code: str,
+            receivers: List[str],
+            sender: str = None,
+            title_param: Dict[str, str] = None,
+            content_param: Dict[str, str] = None
+        ) -> List:
+            ...