重写了app内的主函数, 并支持了MySQL数据库, 将所有关于数据库操作的代码全部重写

bin/conf/config.yml

@@ -13,7 +13,7 @@ view:
 database:
   # 数据库类型
   # 可选 'SQLite' /'MySQL'/ -> 暂未开发
-  type: SQLite
+  type: "SQLite"
   SQLite:
     # 数据库的路径,
     # 需要从app.py文件所在目录为工作目录

bin/db/db.py

@@ -7,116 +7,289 @@
 
 
 import sqlite3
-from typing import Any
+import pymysql
 
 
 class SQLite:
     """操作SQLite数据库"""
 
-    def __init__(self, path: str = './bin/db/data.db'):
+    def __init__(self,
+                 path: str = './bin/db/data.db'
+                 ) -> None:
         """
-        初始化SQLite类
+        初始化SQLite对象
+        完成后会自动提交, 自动关闭
         :param path: 数据库路径
         """
-        self.path = path
+        self.__path = path
+        self.__conn = sqlite3.connect(self.__path)
+        self.__cursor = self.__conn.cursor()
 
-    def insert_data(self, name: str) -> None:
+    def __del__(self) -> None:
+        """
+        自动提交
+        自动关闭连接
+        :return:
+        """
+        self.__conn.commit()
+        self.__cursor.close()
+        self.__conn.close()
+
+    @property
+    def show_tables(self) -> list:
+        """
+        列出所有在数据库内的表
+        :return:
+        """
+        self.__cursor.execute('select * from sqlite_master where type="table"')
+        tables = self.__cursor.fetchall()
+        lst = []
+        for table in tables:
+            lst.append(table[1])
+        del tables
+        return lst
+
+    def exists_name(self, name: str) -> bool:
+        """
+        判断当前名称是否在数据库内
+        调用self.fetch()方法
+        :param name:
+        :return:
+        """
+        status = self.fetch(name, True)
+        if status == ():
+            return False
+        else:
+            return True
+
+    def exists_table(self, table: str) -> bool:
+        """
+        判断表是否在数据库内
+        调用self.fetching_table()方法
+        :param table:
+        :return:
+        """
+        tables = self.show_tables
+        if table in tables:
+            return True
+        else:
+            return False
+
+    def insert(self, name: str, times: int = 0) -> bool:
         """
         插入数据
         :param name:
+        :param times:
         :return:
         """
-        conn = sqlite3.connect(self.path, check_same_thread=False)
-        cursor = conn.cursor()
-        try:
-            cursor.execute('insert into ReqCount values(?, ?)', (name, 1))
-            conn.commit()
-        finally:
-            cursor.close()
-            conn.close()
+        self.__cursor.execute(
+            'insert into reqcount (name, times) values("%(name)s", %(times)s)' % {'name': name, 'times': times})
+        return True
 
-    def fetch_data(self, name: str) -> int:
+    def delete(self, name: str) -> bool:
         """
-        获取数据
+        删除数据
+        暂时不会用到此接口
         :param name:
         :return:
         """
-        conn = sqlite3.connect(self.path, check_same_thread=False)
-        cursor = conn.cursor()
-        try:
-            cursor.execute('select * from ReqCount')
-            conn.commit()
-            data = cursor.fetchall()
+        self.__cursor.execute('delete from reqcount where name="%(name)s"' % {'name': name})
+        return True
 
-            temp_dict = {}
-            for k, v in data:  # 遍历数据将元组数据转换为字典类型
-                temp_dict.setdefault(k, []).append(v)
-            for i, c in zip(temp_dict.keys(), temp_dict.values()):
-                temp_dict[i] = c[0]
+    def fetch(self, name: str, is_check: bool = False) -> tuple:
+        """
+        抓取数据
+        :param name:
+        :param is_check:
+        :return:
+        """
+        self.__cursor.execute('select * from reqcount where name="%(name)s"' % {'name': name})
+        data = self.__cursor.fetchall()
+        if not is_check:
+            self.update(name, data[0][1])
+        if len(data):
+            return data[0]
+        else:
+            return tuple(data)
 
-            if name in temp_dict.keys():
-                count = temp_dict[name]  # 获取原数字 为 整型
-                self.update_data(name, count)
-                return count
-            else:
-                # 新建用户数据
-                self.insert_data(name)
-                return 0
-        finally:
-            cursor.close()
-            conn.close()
-
-    def update_data(self, name: str, times: int) -> None:
+    def update(self, name: str, times: int) -> bool:
         """
         更新数据
         :param name:
         :param times:
         :return:
         """
-        conn = sqlite3.connect(self.path, check_same_thread=False)
-        cursor = conn.cursor()
-        try:
-            times += 1
-            cursor.execute('update ReqCount set times=? where name=?', (times, name))
-            conn.commit()
-        finally:
-            cursor.close()
-            conn.close()
+        self.__cursor.execute(
+            'update reqcount set times=%(times)s where name="%(name)s"' % {'times': times + 1, 'name': name})
+        return True
 
-    def fetch_table(self) -> list:
+    def fetching_table(self, table: str) -> list[dict]:
         """
-        返回已有主题列表
+        抓取主题表的数据
+        :param table:
         :return:
         """
-        conn_temp = sqlite3.connect(self.path, check_same_thread=False)
-        cursor_temp = conn_temp.cursor()
-        try:
+        status = self.exists_table(table)
+        if status:
+            tables = self.__cursor.execute('select * from %(table)s' % {'table': table})
             lst = []
-            cursor_temp.execute("select * from sqlite_master where type='table'")
-            for i in cursor_temp.fetchall():
-                lst.append(i[1])
+            for data in tables:
+                lst.append({'index': data[0],
+                            'base64': data[1],
+                            'width': data[2],
+                            'height': data[3]})
+            del tables
             return lst
-        finally:
-            cursor_temp.close()
-            conn_temp.close()
+        else:
+            return []
 
-    def fetch_style_data(self, style: str) -> list[dict[str, Any]]:
+
+class MySQL:
+    """操作MySQL数据库"""
+
+    def __init__(self,
+                 host: str,
+                 user: str,
+                 pwd: str,
+                 database: str
+                 ) -> None:
         """
-        获取主题数据库内的数据
-        :param style:
+        初始化MySQL对象并创建一个连接
+        创建的连接会在执行完毕后自动提交以及自动关闭
+        :param host: 数据库地址
+        :param user: 数据库用户名
+        :param pwd: 数据库密码
+        :param database: 数据库名
+        """
+        self.__host = host
+        self.__user = user
+        self.__password = pwd
+        self.__database = database
+        self.__conn = pymysql.connect(user=self.__user,
+                                      password=self.__password,
+                                      host=self.__host,
+                                      database=self.__database)  # 创建连接
+        self.__cursor = self.__conn.cursor()
+
+    def __del__(self):
+        """
+        自动提交
+        自动关闭连接
+        :return:
+        """
+        self.__conn.commit()
+        self.__cursor.close()
+        self.__conn.close()
+
+    @property
+    def show_tables(self) -> list:
+        """
+        查询已有的表
+        :return:
+        """
+        self.__cursor.execute('show tables;')  # 列出所有的表名
+        tuple_tables = self.__cursor.fetchall()
+        # 将元组类型转换为列表
+        tables = []
+        for origin in tuple_tables:
+            tables.append(origin[0])
+        del tuple_tables
+        return tables
+
+    def exists_name(self, name: str):
+        """
+        判断是否存在于数据库内
+        :param name:
+        :return:
+        """
+        status = self.fetch(name, True)
+        if status == ():
+            return False
+        else:
+            return True
+
+    def exists_table(self, table: str) -> bool:
+        """
+        判断表是否在数据库内
+        :param table:
+        :return:
+        """
+        tables = self.show_tables
+        if table in tables:
+            return True
+        else:
+            return False
+
+    def insert(self, name: str, times: int = 0) -> bool:
+        """
+        插入数据
+        :param name:
+        :param times:
         :return:
         """
-        conn = sqlite3.connect(self.path, check_same_thread=False)
-        cursor = conn.cursor()
         try:
-            cursor.execute('select * from %(style_name)s' % {'style_name': style})
-            data = cursor.fetchall()
-            data_set = []
-            for i in data:
-                data_set.append({'index': i[0], 'base64': i[1], 'width': i[2], 'height': i[3]})
-            return data_set
-        finally:
-            cursor.close()
-            conn.close()
+            self.__cursor.execute(
+                'insert into reqcount(name, times) values("%(name)s", %(times)s);' % {'name': name, 'times': times})
+            return True
+        except pymysql.err.IntegrityError:
+            return False
+
+    def delete(self, name: str) -> bool:
+        """
+        删除数据
+        暂时不会用到此接口
+        :param name:
+        :return:
+        """
+        self.__cursor.execute('delete from reqcount where name="%(name)s";' % {'name': name})
+        return True
+
+    def fetch(self, name: str, is_check: bool = False) -> tuple:
+        """
+        抓取数据
+        :param name:
+        :param is_check:
+        :return:
+        """
+        self.__cursor.execute('select * from reqcount where name="%(name)s";' % {'name': name})
+        data = self.__cursor.fetchall()
+        if not is_check:  # 条件适用于使用self.exists_name检查时不将数据库的计数加一
+            self.update(name, data[0][1])
+        if data == ():
+            return ()
+        else:
+            return data[0]
+
+    def update(self, name: str, times: int) -> bool:
+        """
+        更改数据
+        :param name:
+        :param times:
+        :return:
+        """
+        self.__cursor.execute(
+            'update reqcount set times="%(times)s" where name="%(name)s"";' % {'times': times + 1, 'name': name})
+        return True
+
+    def fetching_table(self, table: str) -> list:
+        """
+        抓取主题表内的数据
+        :param table:
+        :return:
+        """
+        self.__cursor.execute('select * from %(table)s' % {'table': table})
+        datas = self.__cursor.fetchall()
+        lst = []
+        for i in datas:
+            lst.append({'index': i[0],
+                        'base64': i[1],
+                        'width': i[2],
+                        'height': i[3]}
+                       )  # 向空列表内添加抓取到的数据 -> 将元组数据转换为列表
+
+        del datas
+        return lst
 
 
+__all__ = ['SQLite', 'MySQL']
+

bin/templates/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Request Counter - Index</title>
+    <!--  设置图标  -->
+    <link rel="icon" type="image/png" sizes="128x128" href="{{ url_for('static', filename='favicon.ico') }}"/>
+    <link rel="apple-touch-icon" type="image/png" sizes="128x128"
+          href="{{ url_for('static', filename='favicon.ico') }}"/>
+    <style>
+        .intro{
+            text-align: center;
+        }
+        a{
+            color: green;
+        }
+
+
+    </style>
+</head>
+<body>
+<div class="intro">
+    <br>
+    <br>
+    <i>看到这句话就说明程序正常运行啦!! <a href="https://markusjoe.github.io/RequestCounter/" target="_blank">查看文档</a></i>
+    <br>
+    <i>服务端使用Flask开发没有使用异步编程</i>
+    <br>
+    <i><a href="http://127.0.0.1:5000/get/RequestCounter">点击查看本地部署示例</a></i>
+    <br>
+    <i><a href="https://requestcounter.herokuapp.com/get/RequestCounter">点击查看已部署好的调用示例</a></i>
+    <br>
+    <i><b>注: 调用支持POST 和 GET 方法请求</b></i>
+    <br>
+    <br>
+    <i>项目开源协议: <b>Apache-2.0</b> 即:
+        <br>
+        你可以直接使用该项目提供的功能, 无需任何授权
+        <br>
+        你可以在注明来源版权信息的情况下对源代码进行任意分发和修改以及衍生
+    </i>
+    <br>
+    <!--  显示客户端的IP地址  -->
+    <i><b>你的IP地址为: {{ remote_address }}</b></i>
+</div>
+</body>
+</html>

bin/templates/view.html

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="{{ general_width }}" height="{{ general_height }}" version="1.1" xmlns="http://www.w3.org/2000/svg"
+     xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>{{ title }}</title>
+    <g>
+        {% for value in context %}
+        <image x="{{ value.position }}" y="0" width="{{ value.width }}" height="{{ value.height }}"
+               xlink:href="{{ value.base64 }}"></image>
+        {% endfor %}
+    </g>
+</svg>

bin/tests/MySQL.py

@@ -8,12 +8,9 @@
 
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy.ext.declarative import declarative_base
-from tables import *  # 导入所有的主题表模型
+from models import *  # 导入所有的主题表模型
 from typing import List, Tuple
 
-Base = declarative_base()
-
 
 class MySQL:
     """使用SQLAlchemy进行的MySQL数据库操作"""
@@ -50,8 +47,9 @@ class MySQL:
         self.database = database
         self.charset = charset
         self.engine = create_engine(
-            f'mysql+mysqlconnector://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}')  # 连接到数据库
+            f'mysql+pymysql://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}')  # 连接到数据库
         self.Session = sessionmaker(bind=self.engine)  # 创建引擎
+        self.Base = Base
 
     def __del__(self):
         """
@@ -101,7 +99,7 @@ class MySQL:
         """
         data = self.session.query(ReqCount).filter(ReqCount.name == name).all()
         for i in data:
-            print(i.times)
+            return i.times
 
     def fetchall(self) -> List[Tuple]:
         """
@@ -126,3 +124,7 @@ class MySQL:
         for tup in tables:
             table_list.append((tup.k, tup.v, tup.w, tup.h))
         return table_list
+
+    def create(self):
+        self.Base.metadata.create_all(self.engine)
+

bin/tests/MySQLSET/__init__.py

@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-# -- coding:utf-8 --
-# @Author: markushammered@gmail.com
-# @Development Tool: PyCharm
-# @Create Time: 2022/2/26
-# @File Name: __init__.py.py
-
-

bin/tests/MySQL_.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -- coding:utf-8 --
+# @Author: markushammered@gmail.com
+# @Development Tool: PyCharm
+# @Create Time: 2022/2/27
+# @File Name: MySQL_.py
+
+
+import pymysql
+
+
+class MySQL:
+    """操作MySQL数据库"""
+
+    def __init__(self,
+                 host: str,
+                 user: str,
+                 pwd: str,
+                 database: str
+                 ) -> None:
+        """
+        初始化MySQL对象并创建一个连接
+        创建的连接会在执行完毕后自动提交以及自动关闭
+        :param host: 数据库地址
+        :param user: 数据库用户名
+        :param pwd: 数据库密码
+        :param database: 数据库名
+        """
+        self.__host = host
+        self.__user = user
+        self.__password = pwd
+        self.__database = database
+        self.__conn = pymysql.connect(user=self.__user,
+                                      password=self.__password,
+                                      host=self.__host,
+                                      database=self.__database)  # 创建连接
+        self.__cursor = self.__conn.cursor()
+
+    def __del__(self):
+        """
+        自动提交
+        自动关闭连接
+        :return:
+        """
+        self.__conn.commit()
+        self.__cursor.close()
+        self.__conn.close()
+
+    @property
+    def show_tables(self) -> list:
+        """
+        查询已有的表
+        :return:
+        """
+        self.__cursor.execute('show tables;')  # 列出所有的表名
+        tuple_tables = self.__cursor.fetchall()
+        # 将元组类型转换为列表
+        tables = []
+        for origin in tuple_tables:
+            tables.append(origin[0])
+        del tuple_tables
+        return tables
+
+    def exists_name(self, name: str):
+        """
+        判断是否存在于数据库内
+        :param name:
+        :return:
+        """
+        status = self.fetch(name)
+        if status == ():
+            return False
+        else:
+            return True
+
+    def exists_table(self, table: str) -> bool:
+        """
+        判断表是否在数据库内
+        :param table:
+        :return:
+        """
+        tables = self.show_tables
+        if table in tables:
+            return True
+        else:
+            return False
+
+    def insert(self, name: str, times: int = 0) -> bool:
+        """
+        插入数据
+        :param name:
+        :param times:
+        :return:
+        """
+        try:
+            self.__cursor.execute(
+                'insert into reqcount(name, times) values("%(name)s", %(times)s);' % {'name': name, 'times': times})
+            return True
+        except pymysql.err.IntegrityError:
+            return False
+
+    def delete(self, name: str) -> bool:
+        """
+        删除数据
+        :param name:
+        :return:
+        """
+        self.__cursor.execute('delete from reqcount where name="%(name)s";' % {'name': name})
+        return True
+
+    def fetch(self, name: str) -> bool or tuple:
+        """
+        抓取数据
+        :param name:
+        :return:
+        """
+        self.__cursor.execute('select * from reqcount where name="%(name)s";' % {'name': name})
+        data = self.__cursor.fetchall()
+        if data == ():
+            return False
+        else:
+            return data[0]
+
+    def update(self, name: str, times: int) -> bool:
+        """
+        更改数据
+        :param name:
+        :param times:
+        :return:
+        """
+        self.__cursor.execute(
+            'update reqcount set times="%(times)s where name="%(name)s"";' % {'times': times, 'name': name})
+        return True
+
+    def fetching_table(self, table: str) -> list:
+        """
+        抓取主题表内的数据
+        :param table:
+        :return:
+        """
+        self.__cursor.execute('select * from %(table)s' % {'table': table})
+        datas = self.__cursor.fetchall()
+        lst = []
+        for i in datas:
+            lst.append({'k': i[0],
+                        'v': i[1],
+                        'w': i[2],
+                        'h': i[3]}
+                       )  # 向空列表内添加抓取到的数据 -> 将元组数据转换为列表
+
+        del datas
+        return lst
+
+
+__all__ = ['MySQL']

bin/tests/SQLite_.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# -- coding:utf-8 --
+# @Author: markushammered@gmail.com
+# @Development Tool: PyCharm
+# @Create Time: 2022/2/27
+# @File Name: SQLite_.py
+
+
+import sqlite3
+
+
+class SQLite:
+    """操作SQLite数据库"""
+
+    def __init__(self,
+                 path: str = './bin/db/data.db'
+                 ) -> None:
+        """
+        初始化SQLite对象
+        :param path: 数据库路径
+        """
+        self.__path = path
+        self.__conn = sqlite3.connect(self.__path)
+        self.__cursor = self.__conn.cursor()
+
+    def __del__(self) -> None:
+        """
+        自动提交
+        自动关闭连接
+        :return:
+        """
+        self.__conn.commit()
+        self.__cursor.close()
+        self.__conn.close()
+
+    @property
+    def show_tables(self) -> list:
+        """
+        列出所有在数据库内的表
+        :return:
+        """
+        self.__cursor.execute('select * from sqlite_master where type="table"')
+        tables = self.__cursor.fetchall()
+        lst = []
+        for table in tables:
+            lst.append(table[1])
+        del tables
+        return lst
+
+    def exist_name(self, name: str) -> bool:
+        """
+        判断当前名称是否在数据库内
+        调用fetch方法判断
+        :param name:
+        :return:
+        """
+        status = self.fetch(name)
+        if status == ():
+            return False
+        else:
+            return True
+
+    def exist_table(self, table: str) -> bool:
+        """
+        判断表是否在数据库内
+        :param table:
+        :return:
+        """
+        tables = self.show_tables
+        if table in tables:
+            return True
+        else:
+            return False
+
+    def insert(self, name: str, times: int) -> bool:
+        """
+        插入数据
+        :param name:
+        :param times:
+        :return:
+        """
+        self.__cursor.execute(
+            'insert into reqcount values(name="%(name)s", times=%(times)s)' % {'name': name, 'times': times})
+        return True
+
+    def delete(self, name: str) -> bool:
+        """
+        删除数据
+        :param name:
+        :return:
+        """
+        self.__cursor.execute('delete from reqcount where name="%(name)s"' % {'name': name})
+        return True
+
+    def fetch(self, name: str) -> tuple:
+        """
+        抓取数据
+        :param name:
+        :return:
+        """
+        self.__cursor.execute('select * from reqcount where name="%(name)s"' % {'name': name})
+        data = self.__cursor.fetchall()
+        if len(data):
+            return data[0]
+        else:
+            return tuple(data)
+
+    def update(self, name: str, times: int) -> bool:
+        """
+        更新数据
+        :param name:
+        :param times:
+        :return:
+        """
+        self.__cursor.execute(
+            'update reqcount set times=%(times)s where name="%(name)s"' % {'times': times, 'name': name})
+        return True
+
+    def fetching_table(self, table: str) -> list[dict]:
+        """
+        抓取主题表的数据
+        :param table:
+        :return:
+        """
+        status = self.exist_table(table)
+        if status:
+            tables = self.__cursor.execute('select * from %(table)s' % {'table': table})
+            lst = []
+            for data in tables:
+                lst.append({'index': data[0],
+                            'base64': data[1],
+                            'width': data[2],
+                            'height': data[3]})
+                del tables
+                return lst
+        else:
+            return []
+
+
+sqlite = SQLite('../db/data.db')
+print(sqlite.fetching_table('gelbooru'))

bin/tests/models.py

@@ -9,7 +9,7 @@
 from sqlalchemy import Column
 from sqlalchemy import Integer
 from sqlalchemy import String
-from sqlalchemy import Text
+from sqlalchemy import VARCHAR
 from sqlalchemy.ext.declarative import declarative_base
 
 Base = declarative_base()
@@ -20,351 +20,351 @@ Base = declarative_base()
 class ReqCount(Base):
     """计数器数据库模型"""
 
-    __tablename__ = 'ReqCount'
+    __tablename__ = 'reqcount'
     name = Column(String(20), primary_key=True)  # 名称
     times = Column(Integer())  # 次数
 
 
 class gelbooru(Base):
     __tablename__ = 'gelbooru'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class moebooru(Base):
     __tablename__ = 'moebooru'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class g(Base):
     __tablename__ = 'g'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class cripple(Base):
     __tablename__ = 'cripple'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class blacked(Base):
     __tablename__ = 'blacked'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class rule34(Base):
     __tablename__ = 'rule34'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class steambanner(Base):
     __tablename__ = 'steambanner'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class lefty(Base):
     __tablename__ = 'lefty'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class crewbooru(Base):
     __tablename__ = 'crewbooru'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class sthg(Base):
     __tablename__ = 'sthg'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class rfck(Base):
     __tablename__ = 'rfck'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class lisu(Base):
     __tablename__ = 'lisu'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class tv(Base):
     __tablename__ = 'tv'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class lewd(Base):
     __tablename__ = 'lewd'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class amibooru(Base):
     __tablename__ = 'amibooru'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class blankatlas(Base):
     __tablename__ = 'blankatlas'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class mmballbusting(Base):
     __tablename__ = 'mmballbusting'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class sss(Base):
     __tablename__ = 'sss'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class legolamb(Base):
     __tablename__ = 'legolamb'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class goldengator(Base):
     __tablename__ = 'goldengator'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class r6gdrawfriends(Base):
     __tablename__ = 'r6gdrawfriends'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class vivi(Base):
     __tablename__ = 'vivi'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class twifanartsfw(Base):
     __tablename__ = 'twifanartsfw'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class hololive(Base):
     __tablename__ = 'hololive'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class vglobby(Base):
     __tablename__ = 'vglobby'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class jaypee(Base):
     __tablename__ = 'jaypee'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class melanin(Base):
     __tablename__ = 'melanin'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class orb(Base):
     __tablename__ = 'orb'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class min(Base):
     __tablename__ = 'min'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class mjg(Base):
     __tablename__ = 'mjg'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class cloppers(Base):
     __tablename__ = 'cloppers'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class townofgravityfalls(Base):
     __tablename__ = 'townofgravityfalls'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class brown(Base):
     __tablename__ = 'brown'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class enacdoa(Base):
     __tablename__ = 'enacdoa'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class daifuku(Base):
     __tablename__ = 'daifuku'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class osc(Base):
     __tablename__ = 'osc'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class girlsfeet(Base):
     __tablename__ = 'girlsfeet'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class hybreedsgeneral(Base):
     __tablename__ = 'hybreedsgeneral'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class sr(Base):
     __tablename__ = 'sr'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class mono(Base):
     __tablename__ = 'mono'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class riskofrain(Base):
     __tablename__ = 'riskofrain'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class neovb(Base):
     __tablename__ = 'neovb'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
 
 class ffsr(Base):
     __tablename__ = 'ffsr'
-    k = Column(Text, primary_key=True)
-    v = Column(Text)
+    k = Column(VARCHAR(500), primary_key=True)
+    v = Column(VARCHAR(500))
     w = Column(Integer())
     h = Column(Integer())
 
@@ -373,4 +373,4 @@ __all__ = ['ReqCount', 'gelbooru', 'moebooru', 'g', 'cripple', 'blacked', 'rule3
            'sthg', 'rfck', 'lisu', 'tv', 'lewd', 'amibooru', 'blankatlas', 'mmballbusting', 'sss', 'legolamb',
            'goldengator', 'r6gdrawfriends', 'vivi', 'twifanartsfw', 'hololive', 'vglobby', 'jaypee', 'melanin', 'orb',
            'min', 'mjg', 'cloppers', 'townofgravityfalls', 'brown', 'enacdoa', 'daifuku', 'osc', 'girlsfeet',
-           'hybreedsgeneral', 'sr', 'mono', 'riskofrain', 'neovb', 'ffsr']
+           'hybreedsgeneral', 'sr', 'mono', 'riskofrain', 'neovb', 'ffsr', 'Base']

bin/utils/error.py

@@ -9,74 +9,54 @@
 from typing import Optional
 from flask import jsonify
 from flask import Response
-from bin.db.db import SQLite
 from bin.utils.logger import logger
 
 
 class ErrorProcess:
     """处理错误的页面"""
-    def __init__(self) -> None:
-        self.msg_template = {'code': -2,
-                             'msg': Optional[str],
-                             'data': Optional[list]}
 
-    def get_theme_list(self) -> Response:
+    def __init__(self, db) -> None:
         """
-        直接获取可选主题
-        :return:
+        初始化
+        :param db:
         """
-        logger.debug('获取主题')
-        table_list = SQLite().fetch_table()
-        self.msg_template['code'] = 200
-        self.msg_template['msg'] = '当前已保存到数据库的主题如下'
-        self.msg_template['data'] = table_list
-        return jsonify(self.msg_template)
+        self.db = db  # 数据库对象
+        self.response = {'code': Optional[int],
+                         'msg': Optional[str],
+                         'data': Optional[list]}
 
-    def error_theme(self, theme: str) -> Response:
+    def theme_error(self, theme: str) -> Response:
         """
         错误的主题
         :param theme:
         :return:
         """
         logger.debug('错误的主题')
-        table_list = SQLite().fetch_table()
-        self.msg_template['code'] = -2
-        self.msg_template['msg'] = f'错误的主题: {theme}. 以下是已保存的主题'
-        self.msg_template['data'] = table_list
-        return jsonify(self.msg_template)
+        table_list = self.db().show_tables
+        self.response['code'] = -2
+        self.response['msg'] = f'错误的主题: {theme}. 以下是已保存的主题'
+        self.response['data'] = table_list
+        return jsonify(self.response)
 
-    def error_length(self, length: int or str) -> Response:
+    def length_error(self, length: int or str) -> Response:
         """
         数值太长显示此页面
         :param length:
         :return:
         """
-        logger.debug('错误的长度')
-        self.msg_template['code'] = -2
-        self.msg_template['msg'] = f'错误的长度: {length}'
-        self.msg_template['data'] = None
-        return jsonify(self.msg_template)
+        self.response['code'] = -2
+        self.response['msg'] = f'错误的长度: {length}'
+        self.response['data'] = []
+        return jsonify(self.response)
 
-    def too_lang_to_count(self, name: str) -> Response:
+    def count_error(self, name: str) -> Response:
         """
         数据过长重置数据
         :param name:
         :return:
         """
-        logger.debug('超出计数器最大计数限制')
-        SQLite().update_data(name, 0)
-        self.msg_template['code'] = 200
-        self.msg_template['msg'] = '当前长度已超过最大可计数范围. 已将此名称的计数器重置为零'
-        self.msg_template['data'] = None
-        return jsonify(self.msg_template)
-
-    def arg_not_be_full(self) -> Response:
-        """
-        参数不完整
-        :return:
-        """
-        logger.debug('参数不完整')
-        self.msg_template['code'] = -2
-        self.msg_template['msg'] = '参数填写错误或填写不完整'
-        self.msg_template['data'] = None
-        return jsonify(self.msg_template)
+        self.db().update(name, 0)
+        self.response['code'] = 200
+        self.response['msg'] = '当前长度已超过最大可计数范围. 已将此名称的计数器重置为零'
+        self.response['data'] = []
+        return jsonify(self.response)

bin/utils/features.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# -- coding:utf-8 --
+# @Author: markushammered@gmail.com
+# @Development Tool: PyCharm
+# @Create Time: 2022/2/28
+# @File Name: features.py
+
+
+from typing import Optional
+from flask import jsonify
+from flask import Response
+
+
+class Features:
+    """特殊操作"""
+
+    def __init__(self, db) -> None:
+        """
+        初始化
+        :param db:
+        """
+        self.db = db
+        self.response = {'code': Optional[int],
+                         'msg': Optional[str],
+                         'data': Optional[list]}
+
+    def theme_list(self) -> Response:
+        """
+        读取已有数据库并返回一个列表
+        :return:
+        """
+        table_list = self.db().show_tables
+        self.response['code'] = 200
+        self.response['msg'] = '当前已保存到数据库的主题如下'
+        self.response['data'] = table_list
+        return jsonify(self.response)

bin/utils/packing_logs.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-# -- coding:utf-8 --
-# @Author: markushammered@gmail.com
-# @Development Tool: PyCharm
-# @Create Time: 2022/2/18
-# @File Name: packing_logs.py
-
-
-import os
-import time
-import tarfile
-
-
-def make_targz():
-    """
-    打包为tar.gz
-    压缩文件
-    :return:
-    """
-    output_dir = f'./static/cache/{time.strftime("%Y-%m-%d %H")}.tar.gz'
-    tar = tarfile.open(output_dir, 'w:gz')
-    for root, dir, files in os.walk('./bin/log'):
-        for file in files:
-            pathfile = os.path.join(root, file)
-            tar.add(pathfile)
-    tar.close()
-
-
-__all__ = ['make_targz']

bin/utils/view.py

@@ -7,72 +7,69 @@
 
 
 from flask import render_template
-from bin.db.db import SQLite
 
 
-def view_template(style: str, length: int, name: str, count: str) -> str or tuple[bool, str]:
+def view_template(style: str, length: int, name: str, count: str, DB) -> str or tuple[bool, str]:
     """
     渲染模板
-    :param count: 
-    :param name:
-    :param length:
     :param style:
+    :param length:
+    :param name:
+    :param count:
+    :param DB:
     :return:
     """
-    if style not in SQLite().fetch_table():  # 选择的主题不在数据库内
-        return [False, 'BadLength']
-    origin_data = SQLite().fetch_style_data(style)  # 获取数据库内的数据
+    datas = DB().fetching_table(style)
     context = []
-    if count != '0000000000':
-        for i in count:  # 通过elif语句依次判断数字
-            if i == '0':
-                context.append({'base64': origin_data[0]['base64'],
-                                'width': origin_data[0]['width'],
-                                'height': origin_data[0]['height']})
-            elif i == '1':
-                context.append({'base64': origin_data[1]['base64'],
-                                'width': origin_data[1]['width'],
-                                'height': origin_data[1]['height']})
-            elif i == '2':
-                context.append({'base64': origin_data[2]['base64'],
-                                'width': origin_data[2]['width'],
-                                'height': origin_data[2]['height']})
-            elif i == '3':
-                context.append({'base64': origin_data[3]['base64'],
-                                'width': origin_data[3]['width'],
-                                'height': origin_data[3]['height']})
-            elif i == '4':
-                context.append({'base64': origin_data[4]['base64'],
-                                'width': origin_data[4]['width'],
-                                'height': origin_data[4]['height']})
-            elif i == '5':
-                context.append({'base64': origin_data[5]['base64'],
-                                'width': origin_data[5]['width'],
-                                'height': origin_data[5]['height']})
-            elif i == '6':
-                context.append({'base64': origin_data[6]['base64'],
-                                'width': origin_data[6]['width'],
-                                'height': origin_data[6]['height']})
-            elif i == '7':
-                context.append({'base64': origin_data[7]['base64'],
-                                'width': origin_data[7]['width'],
-                                'height': origin_data[7]['height']})
-            elif i == '8':
-                context.append({'base64': origin_data[8]['base64'],
-                                'width': origin_data[8]['width'],
-                                'height': origin_data[8]['height']})
-            elif i == '9':
-                context.append({'base64': origin_data[9]['base64'],
-                                'width': origin_data[9]['width'],
-                                'height': origin_data[9]['height']})
+    for i in count:
+        if i == '0':
+            context.append({'base64': datas[0]['base64'],
+                            'width': datas[0]['width'],
+                            'height': datas[0]['height']})
+        elif i == '1':
+            context.append({'base64': datas[1]['base64'],
+                            'width': datas[1]['width'],
+                            'height': datas[1]['height']})
+        elif i == '2':
+            context.append({'base64': datas[2]['base64'],
+                            'width': datas[2]['width'],
+                            'height': datas[2]['height']})
+        elif i == '3':
+            context.append({'base64': datas[3]['base64'],
+                            'width': datas[3]['width'],
+                            'height': datas[3]['height']})
+        elif i == '4':
+            context.append({'base64': datas[4]['base64'],
+                            'width': datas[4]['width'],
+                            'height': datas[4]['height']})
+        elif i == '5':
+            context.append({'base64': datas[5]['base64'],
+                            'width': datas[5]['width'],
+                            'height': datas[5]['height']})
+        elif i == '6':
+            context.append({'base64': datas[6]['base64'],
+                            'width': datas[6]['width'],
+                            'height': datas[6]['height']})
+        elif i == '7':
+            context.append({'base64': datas[7]['base64'],
+                            'width': datas[7]['width'],
+                            'height': datas[7]['height']})
+        elif i == '8':
+            context.append({'base64': datas[8]['base64'],
+                            'width': datas[8]['width'],
+                            'height': datas[8]['height']})
+        elif i == '9':
+            context.append({'base64': datas[9]['base64'],
+                            'width': datas[9]['width'],
+                            'height': datas[9]['height']})
 
     for p, i in zip(context, range(0, length)):
         p['position'] = i * p['width']  # 设置每张图片对应的位置
 
-    general_width = origin_data[0]['width'] * length  # 计算出图片总长度
-    general_height = origin_data[0]['height']  # 总宽度
+    general_width = datas[0]['width'] * length  # 计算出图片总长度
+    general_height = datas[0]['height']  # 总宽度
 
-    return True, render_template('view.html',
+    return render_template('view.html',
                                  context=context,
                                  title=name,
                                  general_height=general_height,