pten 0.1.0__tar.gz

pten-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 1.2
+Name: pten
+Version: 0.1.0
+Summary: A tool to use Wework API quickly and easily
+Home-page: https://github.com/bendell02/pten
+Author: PENGyong
+Author-email: 1203029076@qq.com
+License: UNKNOWN
+Description: UNKNOWN
+Keywords: wework qywx wechat weixin robot app
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8

pten-0.1.0/README.md

@@ -0,0 +1,12 @@
+# pten
+
+方便快捷地使用企业微信API.
+
+## 安装
+
+```bash
+pip install pten
+```
+
+
+

pten-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pten-0.1.0/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages
+
+requires = ["apscheduler", "lunardate", "openai", "pycryptodome"]
+test_requirements = [
+    "pytest>=3",
+    "pytest-mock>=3",
+]
+
+setup(
+    name="pten",
+    version="0.1.0",
+    description="A tool to use Wework API quickly and easily",
+    author="PENGyong",
+    author_email="1203029076@qq.com",
+    url="https://github.com/bendell02/pten",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    python_requires=">=3.8",
+    install_requires=requires,
+    tests_require=test_requirements,
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    keywords="wework qywx wechat weixin robot app",
+)

pten-0.1.0/src/pten/__init__.py

@@ -0,0 +1,45 @@
+import logging
+from logging.handlers import RotatingFileHandler
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class LogColors:
+    DEBUG = "\033[96m"
+    INFO = "\033[92m"
+    WARNING = "\033[93m"
+    ERROR = "\033[91m"
+    CRITICAL = "\033[41m\033[97m"
+    RESET = "\033[0m"
+
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        level_color = {
+            logging.DEBUG: LogColors.DEBUG,
+            logging.INFO: LogColors.INFO,
+            logging.WARNING: LogColors.WARNING,
+            logging.ERROR: LogColors.ERROR,
+            logging.CRITICAL: LogColors.CRITICAL,
+        }.get(record.levelno, LogColors.RESET)
+
+        message = super().format(record)
+        return f"{level_color}{message}{LogColors.RESET}"
+
+
+formatter = ColoredFormatter(
+    "%(asctime)s | %(levelname)s | %(filename)s:%(lineno)d:%(funcName)s | %(message)s"
+)
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+
+formatter = logging.Formatter(
+    "%(asctime)s | %(levelname)s | %(filename)s:%(lineno)d:%(funcName)s | %(message)s"
+)
+maxBytes = 30 * 1024 * 1024  # 30MB
+file_handler = RotatingFileHandler(__name__ + ".log", maxBytes=maxBytes, backupCount=3)
+file_handler.setFormatter(formatter)
+
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)

pten-0.1.0/src/pten/keys.py

@@ -0,0 +1,205 @@
+"""
+pten.keys
+~~~~~~~~~~~~
+
+This module implements the keys class for getting keys from local file.
+
+"""
+
+from . import logger
+import configparser
+from configparser import ConfigParser
+from datetime import datetime
+import json
+from pathlib import Path
+
+
+class Keys:
+    """Keys class for getting keys from local file
+
+    :param keys_filepath: The path of the keys file. Default is "pten_keys.ini"
+    """
+
+    def __init__(self, keys_filepath="pten_keys.ini", *args, **kwargs):
+        self.key_cfg = ConfigParser()
+        self.keys_filepath = Path(keys_filepath)
+        self.TOKEN_PATH = Path("pten_token.json")
+        self.bot_weebhook_key = None
+        self.access_token = None
+        self.access_token_expire_time = float("-inf")
+        self.corp_jsapi_ticket = None
+        self.corp_jsapi_ticket_expire_time = float("-inf")
+        self.app_jsapi_ticket = None
+        self.app_jsapi_ticket_expire_time = float("-inf")
+
+        logger.info(f"keys_filepath : {self.keys_filepath}")
+
+        if not self.keys_filepath.is_file():
+            logger.error(f"Can not find file {self.keys_filepath}")
+
+    def _get_local_keys(self, section: str, options=[]):
+        """Get keys from local file
+        :param section: Section name of the keys
+        :param options: The keys you want to get
+        :return: generator of the keys
+        """
+        if self.keys_filepath.is_file():
+            self.key_cfg.clear()
+            self.key_cfg.read(self.keys_filepath)
+            try:
+                for option in options:
+                    yield self.key_cfg.get(section, option)
+            except (configparser.NoSectionError, configparser.NoOptionError):
+                raise configparser.Error("KeyConfigError")
+        else:
+            raise FileNotFoundError(f"Can not find file {self.keys_filepath}")
+
+    def get_key(self, section: str, option: str):
+        """Get keys from local file
+        :param section: Section name of the keys
+        :param option: The key you want to get
+        :return: key value
+        """
+        return next(self._get_local_keys(section, [option]))
+
+    def get_keys(self, section: str, options=[]):
+        """Get keys from local file
+        :param section: Section name of the keys
+        :param options: The keys you want to get
+        :return: dict of the keys
+        """
+        res = {}
+        for k, v in zip(options, self._get_local_keys(section, options)):
+            res.update({k: v})
+        return res
+
+    def get_debug_mode(self):
+        debug_mode_str = "false"
+        try:
+            debug_mode_str = self.get_key("globals", "debug_mode")
+        except (configparser.Error, FileNotFoundError):
+            debug_mode_str = "false"
+
+        debug_mode = debug_mode_str.lower() in ("true", "yes", "on", "1")
+        return debug_mode
+
+    def get_proxies(self):
+        proxies = None
+        try:
+            proxies = self.get_keys(section="proxies", options=["http", "https"])
+        except (configparser.Error, FileNotFoundError):
+            pass
+
+        return proxies
+
+    def get_bot_weebhook_key(self):
+        if self.bot_weebhook_key is None:
+            key = next(self._get_local_keys(section="bot", options=["webhook_key"]))
+            self.bot_weebhook_key = key
+
+        return self.bot_weebhook_key
+
+    def get_app_agentid(self):
+        return next(self._get_local_keys(section="app", options=["agentid"]))
+
+    def get_contact_sync_secret(self):
+        try:
+            s = self.get_key("wwapi", "contact_sync_secret")
+        except StopIteration:
+            logger.warning("Can not find contact_sync_secret in keys ini file")
+            s = None
+        return s
+
+    @staticmethod
+    def load_from_file(file_path: Path, key):
+        if not file_path.is_file():
+            raise FileNotFoundError(f"Can not find file {file_path}.")
+
+        dict = json.loads(file_path.read_text())
+        if key not in dict:
+            raise KeyError(f"Can not find token of {key}.")
+
+        return dict[key]
+
+    @staticmethod
+    def save_to_file(file_path: Path, key, info):
+        token_dict = {}
+        if file_path.is_file():
+            token_dict = json.loads(file_path.read_text())
+
+        token_dict.update({key: info})
+        file_path.write_text(json.dumps(token_dict))
+
+    def get_access_token(self, token_key):
+        if self.access_token_expire_time > datetime.now().timestamp():
+            return self.access_token
+
+        token_info = Keys.load_from_file(self.TOKEN_PATH, token_key)
+        self.access_token_expire_time = token_info.get("expire_time", float("-inf"))
+        if self.access_token_expire_time < datetime.now().timestamp():
+            logger.warning(f"Token of {token_key} is expired.")
+            raise Exception("Token expired")
+
+        self.access_token = token_info["access_token"]
+        return self.access_token
+
+    def save_access_token(self, token_key, access_token):
+        self.access_token = access_token
+        self.access_token_expire_time = datetime.now().timestamp() + 7200
+        token_info = {
+            "access_token": access_token,
+            "expire_time": self.access_token_expire_time,
+        }
+        Keys.save_to_file(self.TOKEN_PATH, token_key, token_info)
+
+    def get_corp_jsapi_ticket(self, token_key):
+        now = datetime.now().timestamp()
+        if self.corp_jsapi_ticket_expire_time > now:
+            return self.corp_jsapi_ticket
+
+        ticket_key = token_key + "_corp_jsapi_ticket"
+        ticket_info = Keys.load_from_file(self.TOKEN_PATH, ticket_key)
+        expire_time = ticket_info.get("expire_time", float("-inf"))
+        self.corp_jsapi_ticket_expire_time = expire_time
+        if expire_time < now:
+            logger.warning(f"Ticket of {ticket_key} is expired.")
+            raise Exception("Ticket expired")
+
+        self.corp_jsapi_ticket = ticket_info["corp_jsapi_ticket"]
+        return self.corp_jsapi_ticket
+
+    def save_corp_jsapi_ticket(self, token_key, corp_jsapi_ticket):
+        ticket_key = token_key + "_corp_jsapi_ticket"
+        self.corp_jsapi_ticket = corp_jsapi_ticket
+        self.corp_jsapi_ticket_expire_time = datetime.now().timestamp() + 7200
+        ticket_info = {
+            "corp_jsapi_ticket": corp_jsapi_ticket,
+            "expire_time": self.corp_jsapi_ticket_expire_time,
+        }
+        Keys.save_to_file(self.TOKEN_PATH, ticket_key, ticket_info)
+
+    def get_app_jsapi_ticket(self, token_key):
+        now = datetime.now().timestamp()
+        if self.app_jsapi_ticket_expire_time > now:
+            return self.app_jsapi_ticket
+
+        ticket_key = token_key + "_app_jsapi_ticket"
+        ticket_info = Keys.load_from_file(self.TOKEN_PATH, ticket_key)
+        expire_time = ticket_info.get("expire_time", float("-inf"))
+        self.app_jsapi_ticket_expire_time = expire_time
+        if expire_time < now:
+            logger.warning(f"Ticket of {ticket_key} is expired.")
+            raise Exception("Ticket expired")
+
+        self.app_jsapi_ticket = ticket_info["app_jsapi_ticket"]
+        return self.app_jsapi_ticket
+
+    def save_app_jsapi_ticket(self, token_key, app_jsapi_ticket):
+        ticket_key = token_key + "_app_jsapi_ticket"
+        self.app_jsapi_ticket = app_jsapi_ticket
+        self.app_jsapi_ticket_expire_time = datetime.now().timestamp() + 7200
+        ticket_info = {
+            "app_jsapi_ticket": app_jsapi_ticket,
+            "expire_time": self.app_jsapi_ticket_expire_time,
+        }
+        Keys.save_to_file(self.TOKEN_PATH, ticket_key, ticket_info)

pten-0.1.0/src/pten/notice.py

@@ -0,0 +1,216 @@
+"""
+pten.notice
+~~~~~~~~~~~~
+
+This module implements the notice functions.
+
+"""
+
+from . import logger
+from .keys import Keys
+from apscheduler.schedulers.blocking import BaseScheduler
+import datetime
+from lunardate import LunarDate
+from openai import OpenAI
+import requests
+import json
+
+
+class Notice:
+    def __init__(self):
+        self.report_func = print
+        self.scheduler: BaseScheduler = None
+
+    def set_report_func(self, func):
+        self.report_func = func
+
+    def set_scheduler(self, scheduler: BaseScheduler):
+        self.scheduler = scheduler
+
+    def report_text(self, text):
+        self.report_func(text)
+
+
+class Birthday(Notice):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def get_date_str_from_lunar_date(
+        lunar_year, lunar_month, lunar_day, hour=8, minute=3, is_leap_month=False
+    ):
+        lunar_date = LunarDate(lunar_year, lunar_month, lunar_day, is_leap_month)
+        solar_date = lunar_date.toSolarDate()
+        return f"{solar_date} {hour:02d}:{minute:02d}:00"
+
+    @staticmethod
+    def is_leap_month(lunar_year, lunar_month):
+        return lunar_month == LunarDate.leapMonthForYear(lunar_year)
+
+    @staticmethod
+    def get_now_lunar_date():
+        now_solar_date = datetime.datetime.now()
+        year = now_solar_date.year
+        month = now_solar_date.month
+        day = now_solar_date.day
+        now_lunar_date = LunarDate.fromSolarDate(year, month, day)
+        return now_lunar_date
+
+    @staticmethod
+    def generate_birthday_greeting(who, greeting_words=None):
+        msg = f"今天是{who}的生日，让我们来祝福{who}吧"
+        if greeting_words:
+            msg = f"今天是{who}的生日，{greeting_words}"
+
+        return msg
+
+    def _add_lunar_schedule(
+        self, msg, lunar_year, lunar_month, lunar_day, hour, minute
+    ):
+        run_date = self.get_date_str_from_lunar_date(
+            lunar_year, lunar_month, lunar_day, hour, minute, False
+        )
+        args = [msg, lunar_month, lunar_day, hour, minute]
+        func = self.report_lunar_birthday
+        self.scheduler.add_job(func, "date", run_date=run_date, args=args)
+
+        # solve leap month
+        if not self.is_leap_month(lunar_year, lunar_month):
+            return
+        run_date = self.get_date_str_from_lunar_date(
+            lunar_year, lunar_month, lunar_day, hour, minute, True
+        )
+        self.scheduler.add_job(func, "date", run_date=run_date, args=args)
+
+    def _add_solar_schedule(self, msg, year, month, day, hour, minute):
+        solar_date = datetime.date(year, month, day)
+        run_date = f"{solar_date} {hour:02d}:{minute:02d}:00"
+        args = [msg, month, day, hour, minute]
+        func = self.report_solar_birthday
+        self.scheduler.add_job(func, "date", run_date=run_date, args=args)
+
+    def report_lunar_birthday(self, msg, lunar_month, lunar_day, hour=8, minute=3):
+        self.report_func(msg)
+
+        if self.scheduler is None:
+            return
+
+        # add next year's schedule job
+        now_lunar_date = self.get_now_lunar_date()
+        self._add_lunar_schedule(
+            msg, now_lunar_date.year + 1, lunar_month, lunar_day, hour, minute
+        )
+
+    def report_solar_birthday(self, msg, month, day, hour=8, minute=3):
+        self.report_func(msg)
+
+        if self.scheduler is None:
+            return
+
+        # add next year's schedule job
+        today = datetime.date.today()
+        next_year = today.year + 1
+        self._add_solar_schedule(msg, next_year, month, day, hour, minute)
+
+    def add_lunar_schedule(
+        self,
+        lunar_month,
+        lunar_day,
+        hour=8,
+        minute=3,
+        who="someone",
+        greeting_words=None,
+    ):
+        if self.scheduler is None:
+            logger.error("Scheduler is not set. Please set_scheduler() first.")
+            return
+
+        msg = self.generate_birthday_greeting(who, greeting_words)
+
+        now_lunar_date = self.get_now_lunar_date()
+        lunar_date = LunarDate(now_lunar_date.year, lunar_month, lunar_day)
+        if lunar_date < LunarDate.today():
+            lunar_date = LunarDate(now_lunar_date.year + 1, lunar_month, lunar_day)
+
+        self._add_lunar_schedule(
+            msg, lunar_date.year, lunar_month, lunar_day, hour, minute
+        )
+
+    def add_solar_schedule(
+        self, month, day, hour=8, minute=3, who="someone", greeting_words=None
+    ):
+        if self.scheduler is None:
+            logger.error("Scheduler is not set. Please set_scheduler() first.")
+            return
+
+        msg = self.generate_birthday_greeting(who, greeting_words)
+
+        now = datetime.datetime.now()
+        solar_date = datetime.date(now.year, month, day)
+        if solar_date < now.date():
+            solar_date = solar_date.replace(year=now.year + 1)
+
+        self._add_solar_schedule(msg, solar_date.year, month, day, hour, minute)
+
+
+class Deepseek(Notice):
+    def __init__(self, keys_filepath="pten_keys.ini", **kwargs):
+        super().__init__()
+        self.keys = Keys(keys_filepath)
+        sk_api_key = self.keys.get_key("ai", "deepseek_api_key")
+        self.deepseek_client = OpenAI(
+            api_key=sk_api_key,
+            base_url="https://api.deepseek.com",
+        )
+
+    def get_completion(self, prompt):
+        response = self.deepseek_client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant"},
+                {"role": "user", "content": prompt},
+            ],
+            stream=False,
+        )
+
+        return response.choices[0].message.content
+
+
+class Weather(Notice):
+    def __init__(self, keys_filepath="pten_keys.ini", **kwargs):
+        super().__init__()
+        self.keys = Keys(keys_filepath)
+        self.api_key = self.keys.get_key("weather", "seniverse_api_key")
+        self.cities = {}
+
+    def add_city(self, city_name, city_code):
+        self.cities[city_name] = city_code
+
+    def get_weather(self, city_code):
+        url = f"https://api.seniverse.com/v3/weather/now.json?key={self.api_key}&location={city_code}&language=zh-Hans&unit=c"
+
+        response = requests.get(url)
+        weather_json = json.loads(response.text)
+        weather = weather_json["results"][0]["now"]
+
+        return weather
+
+    def get_city_weather(self, city_name, city_code):
+        weather = self.get_weather(city_code)
+
+        weather_text = weather.get("text")
+        weather_temperature = weather.get("temperature")
+
+        weather_str = f"{city_name}: {weather_text},\t 温度: {weather_temperature}度"
+
+        return weather_str
+
+    def report_weather(self):
+        if not self.cities:
+            logger.warning("No city added. Please add_city() first.")
+            return
+        weather_str = "今日天气："
+        for city_name, city_code in self.cities.items():
+            weather_str += "\n" + self.get_city_weather(city_name, city_code)
+
+        self.report_func(weather_str)