cloudoll 2.4.0__py3-none-any.whl

cloudoll/orm/mysql.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+from cloudoll.orm import Mysql
+
+# for config folder conf.{env}.yaml
+
+database:
+  mysql:
+    type: mysql  # important ,default mysql
+    host: 127.0.0.1
+    port: 3306
+    user: root
+    password: 123456
+    db: test
+    charset:utf8mb4
+    pool_size:5
+
+# to get yaml config
+config = ....(database.mysql)
+
+pool = await Mysql().create_engine(**config)
+result = await pool.query("sql")
+"""
+__author__ = "chuchur/chuchur.com"
+
+from typing import Any
+from aiomysql import create_pool, DictCursor
+from aiomysql.pool import Pool
+
+# from aiomysql.cursors import Cursor
+# from aiomysql.connection import Connection
+from cloudoll.logging import print_error
+
+# from inspect import isclass, isfunction
+from .base import MeteBase
+
+
+class AttrDict(dict):
+    """Dict that can get attribute by dot, and doesn't raise KeyError"""
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            return None
+
+
+class AttrDictCursor(DictCursor):
+    dict_type = AttrDict
+
+
+class Mysql(MeteBase):
+    def __init__(self):
+        self.pool: Pool = None
+        # self.cursor: Cursor = None
+        # self.conn: Connection = None
+        # self.__MODELS__ = []
+
+    # def __call__(cls, *args: Any, **kwds: Any) -> Any:
+    #     cls.__init__(*args, **kwds)
+    #     return cls()
+
+    # @classmethod
+    async def create_engine(self, loop=None, **kw):
+        try:
+            self.pool = await create_pool(
+                host=kw.get("host", "localhost"),
+                port=kw.get("port", 3306),
+                user=kw.get("user"),
+                password=str(kw.get("password", "")),
+                db=kw.get("db"),
+                echo=kw.get("echo", False),
+                charset=kw.get("charset", "utf8"),
+                autocommit=False,  # kw.get("autocommit", False),
+                maxsize=kw.get("maxsize", 10),
+                minsize=kw.get("pool_size", 5),
+                cursorclass=AttrDictCursor,
+                connect_timeout=kw.get("connect_timeout", 10),
+                loop=loop,
+            )
+        except Exception as e:
+            print_error(f"Database connection failed,the instance : {kw.get('db')}")
+        return self

cloudoll/orm/parse.py

@@ -0,0 +1,139 @@
+from urllib.parse import unquote
+import re
+from typing import Any, Optional, List, cast
+import collections.abc as collections_abc
+
+_implicit_encoding = "ascii"
+_implicit_errors = "strict"
+
+__ALL__ = "parse_coon"
+
+
+def parse_coon(url: str):
+    pattern = re.compile(
+        r"""
+            (?P<type>[\w\+]+)://
+            (?:
+                (?P<username>[^:/]*)
+                (?::(?P<password>[^@]*))?
+            @)?
+            (?:
+                (?:
+                    \[(?P<ipv6host>[^/\?]+)\] |
+                    (?P<ipv4host>[^/:\?]+)
+                )?
+                (?::(?P<port>[^/\?]*))?
+            )?
+            (?:/(?P<db>[^\?]*))?
+            (?:\?(?P<query>.*))?
+            """,
+        re.X,
+    )
+    match = pattern.match(url)
+    if match is not None:
+        configs = match.groupdict()
+        if configs["username"] is not None:
+            configs["username"] = unquote(configs["username"])
+
+        if configs["password"] is not None:
+            configs["password"] = unquote(configs["password"])
+
+        ipv4host = configs.pop("ipv4host")
+        ipv6host = configs.pop("ipv6host")
+        configs["host"] = ipv4host or ipv6host
+        # name = components.pop("name")
+
+        if configs["port"]:
+            configs["port"] = int(configs["port"])
+
+        query = {}
+        if configs["query"] is not None:
+
+            for key, value in parse_sql(configs["query"]):
+                if key in query:
+                    query[key] = to_list(query[key])
+                    cast("List[str]", query[key]).append(value)
+                else:
+                    query[key] = value
+
+        return configs, query
+    else:
+        raise ValueError("%s is not a valid database URL" % url)
+
+
+def to_list(x: Any, default: Optional[List[Any]] = None) -> List[Any]:
+    if x is None:
+        return default  # type: ignore
+    if not isinstance(x, collections_abc.Iterable) or isinstance(x, (str, bytes)):
+        return [x]
+    elif isinstance(x, list):
+        return x
+    else:
+        return list(x)
+
+
+def parse_sql(
+    qs,
+    keep_blank_values=False,
+    strict_parsing=False,
+    encoding="utf-8",
+    errors="replace",
+    max_num_fields=None,
+    separator="&",
+):
+    qs, _coerce_result = _coerce_args(qs)
+    separator, _ = _coerce_args(separator)
+
+    if not separator or (not isinstance(separator, (str, bytes))):
+        raise ValueError("Separator must be of type string or bytes.")
+
+    if max_num_fields is not None:
+        num_fields = 1 + qs.count(separator) if qs else 0
+        if max_num_fields < num_fields:
+            raise ValueError("Max number of fields exceeded")
+
+    r = []
+    query_args = qs.split(separator) if qs else []
+    for name_value in query_args:
+        if not name_value and not strict_parsing:
+            continue
+        nv = name_value.split("=", 1)
+        if len(nv) != 2:
+            if strict_parsing:
+                raise ValueError("bad query field: %r" % (name_value,))
+            # Handle case of a control-name with no equal sign
+            if keep_blank_values:
+                nv.append("")
+            else:
+                continue
+        if len(nv[1]) or keep_blank_values:
+            name = nv[0].replace("+", " ")
+            name = unquote(name, encoding=encoding, errors=errors)
+            name = _coerce_result(name)
+            value = nv[1].replace("+", " ")
+            value = unquote(value, encoding=encoding, errors=errors)
+            value = _coerce_result(value)
+            r.append((name, value))
+    return r
+
+
+def _encode_result(obj, encoding=_implicit_encoding, errors=_implicit_errors):
+    return obj.encode(encoding, errors)
+
+
+def _noop(obj):
+    return obj
+
+
+def _decode_args(args, encoding=_implicit_encoding, errors=_implicit_errors):
+    return tuple(x.decode(encoding, errors) if x else "" for x in args)
+
+
+def _coerce_args(*args):
+    str_input = isinstance(args[0], str)
+    for arg in args[1:]:
+        if arg and isinstance(arg, str) != str_input:
+            raise TypeError("Cannot mix str and non-str arguments")
+    if str_input:
+        return args + (_noop,)
+    return _decode_args(args) + (_encode_result,)

cloudoll/orm/postgres.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+from cloudoll.orm.postgres import Postgres
+
+# for config folder conf.{env}.yaml
+
+database:
+  pg:
+    type: postgres  # important ,default mysql
+    host: 127.0.0.1
+    port: 3306
+    user: root
+    password: 123456
+    db: test
+    echo: True
+    timeout: 60
+    pool_size:5
+
+# to get yaml config
+config = ....(database.postgres)
+
+pool = await Postgres().create_engine(**config)
+result = await pool.query("sql")
+"""
+__author__ = "chuchur/chuchur.com"
+
+from aiopg import create_pool, Pool, Cursor, Connection
+from ..logging import print_error
+from .base import MeteBase
+from typing import Any
+
+
+class Postgres(MeteBase):
+    def __init__(self):
+        self.pool: Pool = None
+        self.cursor: Cursor = None
+        self.conn: Connection = None
+        # self.__MODELS__ = []
+
+    def __call__(cls, *args: Any, **kwds: Any) -> Any:
+        cls.__init__(*args, **kwds)
+        return cls()
+
+    @classmethod
+    async def create_engine(self, **kw):
+        try:
+            host = (kw.get("host", "localhost"),)
+            port = (kw.get("port", 5432),)
+            user = (kw.get("user"),)
+            password = (str(kw.get("password", "")),)
+            db = (kw.get("db"),)
+            dsn = f"dbname={db[0]} user={user[0]} password={password[0]} host={host[0]} port={port[0]}"
+            self.pool = await create_pool(
+                dsn=dsn,
+                timeout=kw.get("timeout", 10.0),
+                enable_json=kw.get("enable_json"),
+                enable_hstore=kw.get("enable_hstore"),
+                enable_uuid=kw.get("enable_uuid"),
+                enable_uuid=kw.get("enable_uuid"),
+                pool_recycle=kw.get("pool_recycle", 10),
+                echo=kw.get("echo", False),
+                minsize=kw.get("pool_size", 5),
+                maxsize=kw.get("pool_size", 10),
+            )
+        except Exception as e:
+            # print_error(e)
+            print_error(f"Database connection failed,the instance : {kw.get('db')}")
+
+        return self

cloudoll/robot/dingtalk.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# docs: https://open.dingtalk.com/document/group/message-types-and-data-format
+__author__ = "chuchur/chuchur.com"
+
+import base64
+import hashlib
+import hmac
+from ..logging import print_error
+from curl_cffi import requests as http
+import time
+from urllib import parse
+
+
+class Client(object):
+    def __init__(self, **kw):
+        self._webhook = kw.get("webhook")
+        self._secret = kw.get("secret")
+        self._access_token = kw.get("access_token")
+
+    def _get_sign(self):
+        secret = self._secret
+        if not secret:
+            print_error("缺少secret")
+            return None, None
+
+        # 拼接timestamp和secret
+        timestamp = str(round(time.time() * 1000))
+        string_to_sign = "{}\n{}".format(timestamp, secret)
+        hmac_code = hmac.new(
+            secret.encode("utf-8"),
+            string_to_sign.encode("utf-8"),
+            digestmod=hashlib.sha256,
+        ).digest()
+
+        # 对结果进行base64处理
+        sign = base64.b64encode(hmac_code).decode("utf-8")
+        sign = parse.quote(sign)
+        return timestamp, sign
+
+    def upload(self, type: str, filepath: str):
+        """
+        上传媒体
+        :params access_token
+        :params type 文件类型 image|voice|video|file
+        :params filepath 要上传的文件路径
+        """
+        access_token = self._access_token
+        if not access_token:
+            print_error("请配置access_token")
+            return False
+        url = "https://oapi.dingtalk.com/media/upload?access_token=%s" % access_token
+        with open(filepath, "rb") as f:
+            files = {"media": f}
+            result = http.post(url=url, files=files, data={"type": type})
+            res = result.json()
+            if res["errcode"] == 0:
+                return res
+            else:
+                print_error(res["errmsg"])
+
+    def send(self, data: dict):
+        """
+        发送除签名外的自定义消息结构体 https://open.dingtalk.com/document/orgapp-server/message-types-and-data-format
+        :params data 自定义消息结构体
+        """
+        webhook = self._webhook
+        if not webhook:
+            print_error("缺少webhook")
+            return False
+        timestamp, sign = self._get_sign()
+        if not timestamp or not sign:
+            return False
+        url = webhook + "&timestamp=%s&sign=%s" % (timestamp, sign)
+        result = http.post(
+            url=url,
+            json={**data},
+            # data=data
+            # data=json.dumps(data)
+        )
+        if result:
+            res = result.json()
+            if res["errcode"] == 0:
+                print_error("发送成功！")
+                return True
+            else:
+                print_error("发送失败")
+                print_error(res["errmsg"])
+                return False
+
+    def send_text(self, text: str):
+        """
+        发送文本消息
+        :params text 消息内容
+        """
+
+        return self.send(
+            data={
+                "msgtype": "text",
+                "text": {"content": text},
+            }
+        )
+
+    def _send_media(self, type, media_id, **kw):
+        """
+        发送媒体
+        :params type 媒体类型 image|voice|video|file
+        :params media_id 媒体ID
+        """
+        data = {"msgtype": type}
+        data[type] = {"media_id": media_id}
+        if type == "voice":
+            data["voice"]["duration"] = kw.get("duration")
+        return self.send(data)
+
+    def send_markdown(self, title, text):
+        """
+        发送Markdown消息
+        :params title 标题
+        :params text markdown结构体
+        """
+        return self.send(
+            data={"msgtype": "markdown", "markdown": {"title": title, "text": text}}
+        )
+
+    def send_image(self, media_id: str):
+        """
+        发送图片消息
+        :params media_id 媒体ID
+        """
+        return self._send_media("image", media_id)
+
+    def send_voice(self, media_id: str, duration: str):
+        """
+        发送语音消息
+        :params media_id 媒体ID
+        :params duration 正整数，小于60，表示音频时长。
+        """
+        return self._send_media("voice", media_id, duration=duration)
+
+    def send_file(self, media_id: str):
+        """
+        发送文件消息
+        :params media_id 媒体ID
+        """
+        return self._send_media("file", media_id)
+
+    def send_link(self, messageUrl, picUrl, title, text):
+        """
+        发送链接消息
+        :params messageUrl 链接地址
+        :params picUrl 链接的小图
+        :params title 链接标题 100字内
+        :params text 链接副标题 500字内
+        """
+        return self.send(
+            data={
+                "msgtype": "link",
+                "link": {
+                    "picUrl": picUrl,
+                    "messageUrl": messageUrl,
+                    "title": title,
+                    "text": text,
+                },
+            }
+        )
+
+    def send_card(self, **kw):
+        """
+        发送卡片消息
+        :params title 标题
+        :params text 消息内容 必填
+        :params single_title 查看详情(按钮文字) btns 二选一
+        :params single_url 查看详情(链接) btns 二选一
+        :params btn_orientation 按钮排列顺序。0|1
+        :params btns 按钮 [{title:'',actionURL:''}]
+        """
+        title = kw.get("title", "")
+        text = kw.get("text", "")
+        single_title = kw.get("single_title", "")
+        single_url = kw.get("single_url", "")
+        btn_orientation = kw.get("btn_orientation", 0)
+        btns = kw.get("btns", []) or []
+        return self.send(
+            data={
+                "msgtype": "actionCard",
+                "actionCard": {
+                    "title": title,
+                    "text": text,
+                    "singleTitle": single_title,
+                    "singleUrl": single_url,
+                    "btnOrientation": btn_orientation,
+                    "btns": btns,
+                },
+            }
+        )
+
+    def send_freecard(self, links: list):
+        """
+        发送卡片消息
+        :params links [{ title:'',messageURL:'',picURL:''}]
+        """
+        return self.send(
+            data={
+                "msgtype": "feedCard",
+                "feedCard": {"links": links},
+            }
+        )

cloudoll/robot/feishu.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+__author__ = "chuchur/chuchur.com"
+
+import hashlib, hmac, time, base64
+from curl_cffi import requests as http
+from ..logging import print_error, print_info
+
+
+class Client(object):
+    def __init__(self, **kw):
+        self._webhook = kw.get("webhook")
+        self._secret = kw.get("secret")
+
+    def _get_sign(self):
+        secret = self._secret
+        if not secret:
+            print_error("缺少secret")
+            return None, None
+        # 拼接timestamp和secret
+        timestamp = int(time.time())
+        string_to_sign = "{}\n{}".format(timestamp, secret)
+        hmac_code = hmac.new(
+            string_to_sign.encode("utf-8"), digestmod=hashlib.sha256
+        ).digest()
+
+        # 对结果进行base64处理
+        sign = base64.b64encode(hmac_code).decode("utf-8")
+
+        return timestamp, sign
+
+    def send(self, data: dict):
+        """
+        发送除签名外的自定义消息结构体
+        :params data 自定义消息结构体
+        """
+        webhook = self._webhook
+        if not webhook:
+            print_error("缺少webhook")
+            return False
+        timestamp, sign = self._get_sign()
+        if not timestamp or not sign:
+            return False
+        result = http.post(
+            url=webhook,
+            json={"timestamp": timestamp, "sign": sign, **data},
+        )
+        if result:
+            res = result.json()
+            if res["StatusCode"] == 0:
+                print_info("发送成功")
+                return False
+            else:
+                print_error("发送失败！")
+                return True
+
+    def send_text(self, text: str):
+        """
+        发送文本消息
+        :params text 消息内容
+        """
+        return self.send(
+            data={
+                "msg_type": "text",
+                "content": {"text": text},
+            }
+        )
+
+    def send_card(self, **kw):
+        """
+        发送卡片消息
+        :params content 卡片内容,str
+        :params elements 参见 ：https://open.feishu.cn/document/ukTMukTMukTM/uMjNwUjLzYDM14yM2ATN
+        :params template 标题背景颜色 blue|wathet|truquoise|green|yellow|orange|red|carmine|violet|purple|indigo|grey
+        :params i18n 多语言 {'zh_cn':'...'}
+        """
+        content = kw.get("content", "")
+        i18n = kw.get("i18n", {})
+        elements = kw.get("elements", [])
+        template = kw.get("template", "blue")
+        return self.send(
+            data={
+                "msg_type": "interactive",
+                "card": {
+                    "config": {
+                        "wide_screen_mode": True,
+                        "enable_forward": True,
+                        "update_multi": True,
+                    },
+                    "header": {
+                        "title": {
+                            "tag": "plain_text",
+                            "content": content,
+                            "i18n": i18n,
+                        },
+                        "template": template,
+                    },
+                    "elements": elements,
+                },
+            }
+        )