36 |
--------------------------------------------------------------------------------
/backend/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | .idea
3 | *.db
4 | .vscode
5 | files
6 | logs
7 | *.log
8 | ChatGPT-Proxy-V4
9 | *.json
10 | data*
11 | build
12 | dist
13 |
--------------------------------------------------------------------------------
/backend/alembic.ini:
--------------------------------------------------------------------------------
1 | # A generic, single database configuration.
2 |
3 | [alembic]
4 | # path to migration scripts
5 | script_location = alembic
6 |
7 | # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
8 | # Uncomment the line below if you want the files to be prepended with date and time
9 | # file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
10 |
11 | # sys.path path, will be prepended to sys.path if present.
12 | # defaults to the current working directory.
13 | prepend_sys_path = .
14 |
15 | # timezone to use when rendering the date within the migration file
16 | # as well as the filename.
17 | # If specified, requires the python-dateutil library that can be
18 | # installed by adding `alembic[tz]` to the pip requirements
19 | # string value is passed to dateutil.tz.gettz()
20 | # leave blank for localtime
21 | # timezone =
22 |
23 | # max length of characters to apply to the
24 | # "slug" field
25 | # truncate_slug_length = 40
26 |
27 | # set to 'true' to run the environment during
28 | # the 'revision' command, regardless of autogenerate
29 | # revision_environment = false
30 |
31 | # set to 'true' to allow .pyc and .pyo files without
32 | # a source .py file to be detected as revisions in the
33 | # versions/ directory
34 | # sourceless = false
35 |
36 | # version location specification; This defaults
37 | # to alembic/versions. When using multiple version
38 | # directories, initial revisions must be specified with --version-path.
39 | # The path separator used here should be the separator specified by "version_path_separator" below.
40 | # version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
41 |
42 | # version path separator; As mentioned above, this is the character used to split
43 | # version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
44 | # If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
45 | # Valid values for version_path_separator are:
46 | #
47 | # version_path_separator = :
48 | # version_path_separator = ;
49 | # version_path_separator = space
50 | version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
51 |
52 | # set to 'true' to search source files recursively
53 | # in each "version_locations" directory
54 | # new in Alembic version 1.10
55 | # recursive_version_locations = false
56 |
57 | # the output encoding used when revision files
58 | # are written from script.py.mako
59 | # output_encoding = utf-8
60 |
61 | sqlalchemy.url = sqlite+aiosqlite:///data/database.db
62 |
63 |
64 | [post_write_hooks]
65 | # post_write_hooks defines scripts or Python functions that are run
66 | # on newly generated revision scripts. See the documentation for further
67 | # detail and examples
68 |
69 | # format using "black" - use the console_scripts runner, against the "black" entrypoint
70 | # hooks = black
71 | # black.type = console_scripts
72 | # black.entrypoint = black
73 | # black.options = -l 79 REVISION_SCRIPT_FILENAME
74 |
75 | # Logging configuration
--------------------------------------------------------------------------------
/backend/alembic/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration with an async dbapi.
--------------------------------------------------------------------------------
/backend/alembic/env.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 |
3 | from alembic import context
4 | from sqlalchemy import pool
5 | from sqlalchemy.engine import Connection
6 | from sqlalchemy.ext.asyncio import async_engine_from_config
7 |
8 | from api.models.db import Base
9 | import uuid
10 |
11 | # this is the Alembic Config object, which provides
12 | # access to the values within the .ini file in use.
13 | config = context.config
14 |
15 | # Interpret the config file for Python logging.
16 | # This line sets up loggers basically.
17 |
18 | # 阻止 alembic 重复配置日志
19 | # if config.config_file_name is not None:
20 | # fileConfig(config.config_file_name, disable_existing_loggers=False)
21 |
22 | # add your model's MetaData object here
23 | # for 'autogenerate' support
24 | # from myapp import mymodel
25 | # target_metadata = mymodel.Base.metadata
26 | target_metadata = Base.metadata
27 |
28 |
29 | # other values from the config, defined by the needs of env.py,
30 | # can be acquired:
31 | # my_important_option = config.get_main_option("my_important_option")
32 | # ... etc.
33 |
34 |
35 | def run_migrations_offline() -> None:
36 | """Run migrations in 'offline' mode.
37 |
38 | This configures the context with just a URL
39 | and not an Engine, though an Engine is acceptable
40 | here as well. By skipping the Engine creation
41 | we don't even need a DBAPI to be available.
42 |
43 | Calls to context.execute() here emit the given string to the
44 | script output.
45 |
46 | """
47 | url = config.get_main_option("sqlalchemy.url")
48 | context.configure(
49 | url=url,
50 | target_metadata=target_metadata,
51 | literal_binds=True,
52 | dialect_opts={"paramstyle": "named"},
53 | )
54 |
55 | with context.begin_transaction():
56 | context.run_migrations()
57 |
58 |
59 | def do_run_migrations(connection: Connection) -> None:
60 | context.configure(connection=connection, target_metadata=target_metadata)
61 |
62 | with context.begin_transaction():
63 | context.run_migrations()
64 |
65 |
66 | async def run_async_migrations() -> None:
67 | """In this scenario we need to create an Engine
68 | and associate a connection with the context.
69 |
70 | """
71 |
72 | connectable = async_engine_from_config(
73 | config.get_section(config.config_ini_section, {}),
74 | prefix="sqlalchemy.",
75 | poolclass=pool.NullPool,
76 | )
77 |
78 | async with connectable.connect() as connection:
79 | await connection.run_sync(do_run_migrations)
80 |
81 | await connectable.dispose()
82 |
83 |
84 | def run_migrations_online() -> None:
85 | """Run migrations in 'online' mode."""
86 |
87 | connectable = config.attributes.get("connection", None)
88 |
89 | if connectable is None:
90 | asyncio.run(run_async_migrations())
91 | else:
92 | do_run_migrations(connectable)
93 |
94 |
95 | if context.is_offline_mode():
96 | run_migrations_offline()
97 | else:
98 | run_migrations_online()
99 |
--------------------------------------------------------------------------------
/backend/alembic/script.py.mako:
--------------------------------------------------------------------------------
1 | """${message}
2 |
3 | Revision ID: ${up_revision}
4 | Revises: ${down_revision | comma,n}
5 | Create Date: ${create_date}
6 |
7 | """
8 | from alembic import op
9 | import sqlalchemy as sa
10 | ${imports if imports else ""}
11 |
12 | # revision identifiers, used by Alembic.
13 | revision = ${repr(up_revision)}
14 | down_revision = ${repr(down_revision)}
15 | branch_labels = ${repr(branch_labels)}
16 | depends_on = ${repr(depends_on)}
17 |
18 |
19 | def upgrade() -> None:
20 | ${upgrades if upgrades else "pass"}
21 |
22 |
23 | def downgrade() -> None:
24 | ${downgrades if downgrades else "pass"}
25 |
--------------------------------------------------------------------------------
/backend/alembic/versions/0d790c2c26dc_add_uploaded_files_table.py:
--------------------------------------------------------------------------------
1 | """Add uploaded_files table
2 |
3 | Revision ID: 0d790c2c26dc
4 | Revises: aa3d85891014
5 | Create Date: 2023-09-26 19:21:46.195955
6 |
7 | """
8 | from alembic import op
9 | import sqlalchemy as sa
10 | from api.database.custom_types import UTCDateTime, Pydantic
11 | from api.models.json import UploadedFileOpenaiWebInfo
12 |
13 | # revision identifiers, used by Alembic.
14 | revision = '0d790c2c26dc'
15 | down_revision = 'aa3d85891014'
16 | branch_labels = None
17 | depends_on = None
18 |
19 |
20 | def upgrade() -> None:
21 | # ### commands auto generated by Alembic - please adjust! ###
22 | op.create_table('uploaded_files',
23 | sa.Column('id', sa.Uuid(), nullable=False, comment='uuid'),
24 | sa.Column('original_filename', sa.String(length=256), nullable=False, comment='原始文件名'),
25 | sa.Column('size', sa.Integer(), nullable=False, comment='文件大小(bytes)'),
26 | sa.Column('content_type', sa.String(length=256), nullable=True, comment='文件类型'),
27 | sa.Column('storage_path', sa.String(length=1024), nullable=True,
28 | comment='文件在服务器的存储路径，相对于配置中的存储路径；为空表示未在服务器上存储，即未上传或者已清理'),
29 | sa.Column('upload_time', UTCDateTime(timezone=True),
30 | nullable=False, comment='上传日期'),
31 | sa.Column('uploader_id', sa.Integer(), nullable=False, comment='上传的用户id'),
32 | sa.Column('openai_web_info', Pydantic(UploadedFileOpenaiWebInfo), nullable=True),
33 | sa.ForeignKeyConstraint(['uploader_id'], ['user.id'], ),
34 | sa.PrimaryKeyConstraint('id')
35 | )
36 | # ### end Alembic commands ###
37 |
38 |
39 | def downgrade() -> None:
40 | # ### commands auto generated by Alembic - please adjust! ###
41 | op.drop_table('uploaded_files')
42 | # ### end Alembic commands ###
43 |
--------------------------------------------------------------------------------
/backend/alembic/versions/333722b0921e_add_source_id_for_baseconversation.py:
--------------------------------------------------------------------------------
1 | """Add source_id for BaseConversation
2 |
3 | Revision ID: 333722b0921e
4 | Revises: 7d94b5503088
5 | Create Date: 2024-02-03 12:29:17.095124
6 |
7 | """
8 | from alembic import op
9 | import sqlalchemy as sa
10 |
11 |
12 | # revision identifiers, used by Alembic.
13 | revision = '333722b0921e'
14 | down_revision = '7d94b5503088'
15 | branch_labels = None
16 | depends_on = None
17 |
18 |
19 | def upgrade() -> None:
20 | # ### commands auto generated by Alembic - please adjust! ###
21 | op.add_column('conversation', sa.Column('source_id', sa.String(length=256), nullable=True, comment='对话来源id'))
22 | # ### end Alembic commands ###
23 |
24 |
25 | def downgrade() -> None:
26 | # ### commands auto generated by Alembic - please adjust! ###
27 | op.drop_column('conversation', 'source_id')
28 | # ### end Alembic commands ###
29 |
--------------------------------------------------------------------------------
/backend/alembic/versions/7d94b5503088_add_extra_info_in_uploadedfileinfo.py:
--------------------------------------------------------------------------------
1 | """Add extra_info in UploadedFileInfo
2 |
3 | Revision ID: 7d94b5503088
4 | Revises: 0d790c2c26dc
5 | Create Date: 2023-11-16 09:08:43.300383
6 |
7 | """
8 | from alembic import op
9 | import sqlalchemy as sa
10 | from api.database.custom_types import Pydantic
11 | from api.models.json import UploadedFileExtraInfo
12 |
13 | # revision identifiers, used by Alembic.
14 | revision = '7d94b5503088'
15 | down_revision = '0d790c2c26dc'
16 | branch_labels = None
17 | depends_on = None
18 |
19 |
20 | def upgrade() -> None:
21 | # ### commands auto generated by Alembic - please adjust! ###
22 | op.add_column('uploaded_files', sa.Column('extra_info', Pydantic(UploadedFileExtraInfo), nullable=True))
23 | # ### end Alembic commands ###
24 |
25 |
26 | def downgrade() -> None:
27 | # ### commands auto generated by Alembic - please adjust! ###
28 | op.drop_column('uploaded_files', 'extra_info')
29 | # ### end Alembic commands ###
30 |
--------------------------------------------------------------------------------
/backend/alembic/versions/aa3d85891014_baseline.py:
--------------------------------------------------------------------------------
1 | """baseline
2 |
3 | Revision ID: aa3d85891014
4 | Revises:
5 | Create Date: 2023-09-26 18:47:07.076974
6 |
7 | """
8 | from alembic import op
9 | import sqlalchemy as sa
10 |
11 |
12 | # revision identifiers, used by Alembic.
13 | revision = 'aa3d85891014'
14 | down_revision = None
15 | branch_labels = None
16 | depends_on = None
17 |
18 |
19 | def upgrade() -> None:
20 | pass
21 |
22 |
23 | def downgrade() -> None:
24 | pass
25 |
--------------------------------------------------------------------------------
/backend/api/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maxduke/chatgpt-web-share/2d52c390be890c0c94203ef95fb72ba3e83add0b/backend/api/__init__.py
--------------------------------------------------------------------------------
/backend/api/conf/__init__.py:
--------------------------------------------------------------------------------
1 | from .config import Config
2 | from .credentials import Credentials
3 |
--------------------------------------------------------------------------------
/backend/api/conf/base_config.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 |
4 | from typing import TypeVar, Generic, Type, get_args
5 |
6 | from pydantic import BaseModel
7 | from ruamel.yaml import YAML
8 | from fastapi.encoders import jsonable_encoder
9 |
10 | from api.exceptions import ConfigException
11 |
12 | T = TypeVar("T", bound=BaseModel)
13 |
14 |
15 | class BaseConfig(Generic[T]):
16 | _model: T = None
17 | _config_path = None
18 | _model_type = None
19 |
20 | def __init__(self, model_type: Type[BaseModel], config_filename: str, load_config: bool = True):
21 | self._model_type = model_type
22 | config_dir = os.environ.get('CWS_CONFIG_DIR', './data/config')
23 | self._config_path = os.path.join(config_dir, config_filename)
24 | if load_config:
25 | self.load()
26 | else:
27 | self._model = self._model_type()
28 |
29 | def __getattr__(self, key):
30 | return getattr(self._model, key)
31 |
32 | def __setattr__(self, key, value):
33 | if key in ('_model', '_config_path', '_model_type'):
34 | super().__setattr__(key, value)
35 | else:
36 | setattr(self._model, key, value)
37 |
38 | def schema(self):
39 | return self._model.schema()
40 |
41 | def model(self):
42 | return self._model.copy()
43 |
44 | def update(self, model: T):
45 | self._model = self._model_type.model_validate(model)
46 |
47 | def load(self):
48 | if not os.path.exists(self._config_path):
49 | raise ConfigException(f"Config file not found: {self._config_path}")
50 | try:
51 | with open(self._config_path, mode='r', encoding='utf-8') as f:
52 | # 读取配置
53 | yaml = YAML()
54 | config_dict = yaml.load(f) or {}
55 | self._model = self._model_type.model_validate(config_dict)
56 | except Exception as e:
57 | raise ConfigException(f"Cannot read config ({self._config_path}), error: {str(e)}")
58 |
59 | def save(self):
60 | config_dict = jsonable_encoder(self._model.model_dump())
61 | # 复制 self._config_path 备份一份
62 | config_dir = os.path.dirname(self._config_path)
63 | if not os.path.exists(config_dir):
64 | raise ConfigException(f"Config dir not found: {config_dir}")
65 | backup_config_path = os.path.join(config_dir, f"{os.path.basename(self._config_path)}.backup.yaml")
66 | shutil.copyfile(self._config_path, backup_config_path)
67 | with open(self._config_path, mode='w', encoding='utf-8') as sf:
68 | yaml = YAML()
69 | yaml.dump(config_dict, sf)
70 |
--------------------------------------------------------------------------------
/backend/api/conf/credentials.py:
--------------------------------------------------------------------------------
1 | from typing import Optional
2 |
3 | from pydantic import BaseModel
4 |
5 | from api.conf.base_config import BaseConfig
6 | from utils.common import SingletonMeta
7 |
8 | _TYPE_CHECKING = False
9 |
10 |
11 | class CredentialsModel(BaseModel):
12 | openai_web_access_token: Optional[str] = None
13 | # chatgpt_account_username: Optional[str] = None
14 | # chatgpt_account_password: Optional[str] = None
15 | openai_api_key: Optional[str] = None
16 |
17 |
18 | class Credentials(BaseConfig[CredentialsModel], metaclass=SingletonMeta):
19 | if _TYPE_CHECKING:
20 | openai_web_access_token: Optional[str]
21 | # chatgpt_account_username: Optional[str]
22 | # chatgpt_account_password: Optional[str]
23 | openai_api_key: Optional[str]
24 |
25 | def __init__(self, load_config: bool = True):
26 | super().__init__(CredentialsModel, "credentials.yaml", load_config=load_config)
27 |
--------------------------------------------------------------------------------
/backend/api/database/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maxduke/chatgpt-web-share/2d52c390be890c0c94203ef95fb72ba3e83add0b/backend/api/database/__init__.py
--------------------------------------------------------------------------------
/backend/api/database/custom_types/__init__.py:
--------------------------------------------------------------------------------
1 | from .guid import GUID
2 | from .pydantic_type import Pydantic
3 | from .utc_datetime import UTCDateTime
4 |
--------------------------------------------------------------------------------
/backend/api/database/custom_types/guid.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy.types import TypeDecorator, CHAR
2 | from sqlalchemy.dialects.postgresql import UUID
3 | import uuid
4 |
5 |
6 | class GUID(TypeDecorator):
7 | """Platform-independent GUID type.
8 | https://docs.sqlalchemy.org/en/20/core/custom_types.html#backend-agnostic-guid-type
9 |
10 | Uses PostgreSQL's UUID type, otherwise uses CHAR(32), storing as stringified hex values.
11 | """
12 |
13 | impl = CHAR
14 | cache_ok = True
15 |
16 | def load_dialect_impl(self, dialect):
17 | if dialect.name == "postgresql":
18 | return dialect.type_descriptor(UUID())
19 | else:
20 | return dialect.type_descriptor(CHAR(32))
21 |
22 | def process_bind_param(self, value, dialect):
23 | if value is None:
24 | return value
25 | elif dialect.name == "postgresql":
26 | return str(value)
27 | else:
28 | if not isinstance(value, uuid.UUID):
29 | return "%.32x" % uuid.UUID(value).int
30 | else:
31 | # hexstring
32 | return "%.32x" % value.int
33 |
34 | def process_result_value(self, value, dialect):
35 | if value is None:
36 | return value
37 | else:
38 | if not isinstance(value, uuid.UUID):
39 | value = uuid.UUID(value)
40 | return value
41 |
--------------------------------------------------------------------------------
/backend/api/database/custom_types/pydantic_type.py:
--------------------------------------------------------------------------------
1 | import json
2 | from typing import Type, Any, Optional
3 |
4 | import sqlalchemy
5 | from fastapi.encoders import jsonable_encoder
6 | from pydantic import BaseModel
7 | from sqlalchemy import Dialect
8 | from sqlalchemy.dialects.postgresql import JSONB
9 | from sqlalchemy.sql.type_api import _T
10 |
11 |
12 | class Pydantic(sqlalchemy.types.TypeDecorator):
13 | """Pydantic type.
14 | SAVING:
15 | - Uses SQLAlchemy JSON type under the hood.
16 | - Acceps the pydantic model and converts it to a dict on save.
17 | - SQLAlchemy engine JSON-encodes the dict to a string.
18 | RETRIEVING:
19 | - Pulls the string from the database.
20 | - SQLAlchemy engine JSON-decodes the string to a dict.
21 | - Uses the dict to create a pydantic model.
22 |
23 | https://roman.pt/posts/pydantic-in-sqlalchemy-fields/
24 | """
25 |
26 | @property
27 | def python_type(self) -> Type[Any]:
28 | return BaseModel
29 |
30 | def process_literal_param(self, value: Optional[_T], dialect: Dialect) -> str:
31 | if value is None:
32 | return "NULL"
33 | else:
34 | # 将 Pydantic 对象转换为 JSON 字符串
35 | json_str = json.dumps(jsonable_encoder(value))
36 | if dialect.name == "postgresql":
37 | # 对于 PostgreSQL，需要用 E'' 引用 JSON 字符串（未测试）
38 | return f"E'{json_str}'"
39 | else:
40 | # 对于其他数据库，使用单引号引用 JSON 字符串
41 | return f"'{json_str}'"
42 |
43 | impl = sqlalchemy.types.JSON
44 |
45 | def __init__(self, pydantic_type):
46 | super().__init__()
47 | self.pydantic_type = pydantic_type
48 |
49 | def load_dialect_impl(self, dialect):
50 | # Use JSONB for PostgreSQL and JSON for other databases.
51 | if dialect.name == "postgresql":
52 | return dialect.type_descriptor(JSONB())
53 | else:
54 | return dialect.type_descriptor(sqlalchemy.JSON())
55 |
56 | def process_bind_param(self, value, dialect):
57 | # return value.dict() if value else None
58 | return jsonable_encoder(value) if value else None
59 |
60 | def process_result_value(self, value, dialect):
61 | return self.pydantic_type.model_validate(value) if value else None
62 |
--------------------------------------------------------------------------------
/backend/api/database/custom_types/utc_datetime.py:
--------------------------------------------------------------------------------
1 | import datetime
2 |
3 | from sqlalchemy.types import DateTime, TypeDecorator
4 |
5 | from datetime import timezone
6 |
7 |
8 | class UTCDateTime(TypeDecorator):
9 | """Almost equivalent to :class:`~sqlalchemy.types.DateTime` with
10 | ``timezone=True`` option, but it differs from that by:
11 |
12 | - Never silently take naive :class:`~datetime.datetime`, instead it
13 | always raise :exc:`ValueError` unless time zone aware value.
14 | - :class:`~datetime.datetime` value's :attr:`~datetime.datetime.tzinfo`
15 | is always converted to UTC.
16 | - Unlike SQLAlchemy's built-in :class:`~sqlalchemy.types.DateTime`,
17 | it never return naive :class:`~datetime.datetime`, but time zone
18 | aware value, even with SQLite or MySQL.
19 |
20 | modified from https://github.com/spoqa/sqlalchemy-utc
21 | """
22 |
23 | impl = DateTime(timezone=True)
24 | cache_ok = True
25 |
26 | def process_bind_param(self, value, dialect):
27 | if value is not None:
28 | if not isinstance(value, datetime.datetime):
29 | raise TypeError('expected datetime.datetime, not ' +
30 | repr(value))
31 | elif value.tzinfo is None:
32 | raise ValueError('naive datetime is disallowed')
33 | return value.astimezone(timezone.utc)
34 |
35 | def process_result_value(self, value, dialect):
36 | if value is not None:
37 | if value.tzinfo is None:
38 | value = value.replace(tzinfo=timezone.utc)
39 | else:
40 | value = value.astimezone(timezone.utc)
41 | return value
--------------------------------------------------------------------------------
/backend/api/database/mongodb.py:
--------------------------------------------------------------------------------
1 | from beanie import init_beanie
2 | from motor.motor_asyncio import AsyncIOMotorClient
3 |
4 | from api.conf import Config
5 | from api.models.doc import OpenaiApiConversationHistoryDocument, OpenaiWebConversationHistoryDocument, AskLogDocument, \
6 | RequestLogDocument
7 | from utils.logger import get_logger
8 |
9 | logger = get_logger(__name__)
10 | config = Config()
11 |
12 |
13 | client: AsyncIOMotorClient | None = None
14 |
15 |
16 | async def init_mongodb():
17 | global client
18 | client = AsyncIOMotorClient(config.data.mongodb_url)
19 | await init_beanie(database=client[config.data.mongodb_db_name],
20 | document_models=[OpenaiApiConversationHistoryDocument, OpenaiWebConversationHistoryDocument, AskLogDocument,
21 | RequestLogDocument])
22 | # 展示当前mongodb数据库用量
23 | db = client[config.data.mongodb_db_name]
24 | stats = await db.command({"dbStats": 1})
25 | logger.info(
26 | f"MongoDB initialized. dataSize: {stats['dataSize'] / 1024 / 1024:.2f} MB, objects: {stats['objects']}")
27 | await handle_timeseries()
28 |
29 |
30 | async def handle_timeseries():
31 | """
32 | 对于 AskStatDocument 和 HTTPRequestStatDocument, 当 expireAfterSeconds 更改时，beanie 并不会自动更改
33 | 此时需要主动更改
34 | """
35 | global client
36 | assert client is not None, "MongoDB not initialized"
37 | db = client[config.data.mongodb_db_name]
38 | time_series_docs = [AskLogDocument, RequestLogDocument]
39 | config_ttls = [config.stats.ask_stats_ttl, config.stats.request_stats_ttl]
40 | for doc, config_ttl in zip(time_series_docs, config_ttls):
41 | collection_name = doc.get_collection_name()
42 | coll_info = await db.command({"listCollections": 1, "filter": {"name": collection_name}})
43 | if not coll_info["cursor"]["firstBatch"]:
44 | logger.error(f"Collection {collection_name} not found")
45 | continue
46 | current_ttl = coll_info["cursor"]["firstBatch"][0]["options"]["expireAfterSeconds"]
47 |
48 | # 关闭自动过期
49 | if current_ttl != "off" and config_ttl == -1:
50 | await db.command({
51 | "collMod": collection_name,
52 | "expireAfterSeconds": "off"
53 | })
54 | logger.info(f"Auto expire of collection {collection_name} disabled")
55 | continue
56 |
57 | # 更改过期时间
58 | if current_ttl != config_ttl:
59 | logger.info(f"Updating TTL of collection {collection_name} from {current_ttl} to {config_ttl}")
60 | db.command({
61 | "collMod": collection_name,
62 | "expireAfterSeconds": config_ttl
63 | })
64 | else:
65 | logger.debug(f"TTL of collection {collection_name} not change: {config_ttl}")
66 |
--------------------------------------------------------------------------------
/backend/api/enums/__init__.py:
--------------------------------------------------------------------------------
1 | from .models import ChatSourceTypes, OpenaiWebChatModels, OpenaiApiChatModels
2 | from .status import OpenaiWebChatStatus
3 |
--------------------------------------------------------------------------------
/backend/api/enums/models.py:
--------------------------------------------------------------------------------
1 | from enum import auto
2 |
3 | from strenum import StrEnum
4 |
5 |
6 | class ChatSourceTypes(StrEnum):
7 | openai_web = auto()
8 | openai_api = auto()
9 |
10 |
11 | def get_model_code_mapping(source_cls):
12 | from api.conf import Config
13 |
14 | cls_to_source = {
15 | "OpenaiWebChatModels": ChatSourceTypes.openai_web,
16 | "OpenaiApiChatModels": ChatSourceTypes.openai_api,
17 | }
18 | source = cls_to_source.get(source_cls.__name__, None)
19 | source_model_code_mapping = {
20 | "openai_web": Config().openai_web.model_code_mapping,
21 | "openai_api": Config().openai_api.model_code_mapping,
22 | }
23 | return source_model_code_mapping[source]
24 |
25 |
26 | class BaseChatModelEnum(StrEnum):
27 | def code(self):
28 | result = get_model_code_mapping(self.__class__).get(self.name, None)
29 | assert result, f"model name not found: {self.name}"
30 | return result
31 |
32 | @classmethod
33 | def from_code(cls, code: str):
34 | for name, value in get_model_code_mapping(cls).items():
35 | if value == code:
36 | return cls[name]
37 | return None
38 |
39 |
40 | class OpenaiWebChatModels(BaseChatModelEnum):
41 | gpt_3_5 = auto()
42 | gpt_4 = auto()
43 | gpt_4o = auto()
44 | o1 = auto()
45 | o1_mini = auto()
46 |
47 |
48 | class OpenaiApiChatModels(BaseChatModelEnum):
49 | gpt_3_5 = auto()
50 | gpt_4 = auto()
51 | gpt_4o = auto()
52 | o1 = auto()
53 | o1_mini = auto()
54 |
55 |
56 | if __name__ == "__main__":
57 | print(list(OpenaiWebChatModels))
58 |
--------------------------------------------------------------------------------
/backend/api/enums/options.py:
--------------------------------------------------------------------------------
1 | from enum import auto
2 | from strenum import StrEnum
3 |
4 |
5 | class OpenaiWebFileUploadStrategyOption(StrEnum):
6 | server_upload_only = auto()
7 | browser_upload_only = auto()
8 | browser_upload_when_file_size_exceed = auto()
9 |
--------------------------------------------------------------------------------
/backend/api/enums/status.py:
--------------------------------------------------------------------------------
1 | from enum import auto
2 | from strenum import StrEnum
3 |
4 |
5 | class OpenaiWebChatStatus(StrEnum):
6 | asking = auto()
7 | queueing = auto()
8 | idling = auto()
9 |
--------------------------------------------------------------------------------
/backend/api/exceptions.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 |
3 |
4 | class SelfDefinedException(Exception):
5 | def __init__(self, reason: Any = None, message: str = "", code: int = -1) -> None:
6 | self.reason = reason # 异常主要原因
7 | self.message = message # 更细节的描述
8 | self.code = code # 错误码：-1 为默认；0～1000 以内正数为 http 错误码；10000 以上为自定义错误码
9 |
10 | def __str__(self):
11 | return f"{self.__class__.__name__}: [{self.code}] {self.reason} {self.message}"
12 |
13 |
14 | class AuthenticationFailedException(SelfDefinedException):
15 | def __init__(self, message: str = ""):
16 | super().__init__(reason="errors.authenticationFailed", message=message, code=10401)
17 |
18 |
19 | class AuthorityDenyException(SelfDefinedException):
20 | def __init__(self, message: str = ""):
21 | super().__init__(reason="errors.authorityDeny", message=message, code=10403)
22 |
23 |
24 | class UserNotExistException(SelfDefinedException):
25 | def __init__(self, message: str = ""):
26 | super().__init__(reason="errors.userNotExist", message=message)
27 |
28 |
29 | class UserAlreadyExists(SelfDefinedException):
30 | def __init__(self, message: str = ""):
31 | super().__init__(reason="errors.userAlreadyExists", message=message)
32 |
33 |
34 | class InvalidParamsException(SelfDefinedException):
35 | def __init__(self, message: str = ""):
36 | super().__init__(reason="errors.invalidParams", message=message)
37 |
38 |
39 | class ResourceNotFoundException(SelfDefinedException):
40 | def __init__(self, message: str = ""):
41 | super().__init__(reason="errors.resourceNotFound", message=message, code=404)
42 |
43 |
44 | class InvalidRequestException(SelfDefinedException):
45 | def __init__(self, message: str = ""):
46 | super().__init__(reason="errors.invalidRequest", message=message)
47 |
48 |
49 | class InternalException(SelfDefinedException):
50 | def __init__(self, message: str = ""):
51 | super().__init__(reason="errors.internal", message=message)
52 |
53 |
54 | class ConfigException(SelfDefinedException):
55 | def __init__(self, message: str = ""):
56 | super().__init__(reason="errors.config", message=message)
57 |
58 |
59 | class OpenaiException(SelfDefinedException):
60 | def __init__(self, reason: str, message: str = "", code: int = -1):
61 | super().__init__(reason=reason, message=message, code=code)
62 |
63 |
64 | class OpenaiWebException(OpenaiException):
65 | def __init__(self, message: str = "", code: int = -1):
66 | super().__init__(reason="errors.openaiWeb", message=message, code=code)
67 |
68 |
69 | class OpenaiApiException(OpenaiException):
70 | def __init__(self, message: str = "", code: int = -1):
71 | super().__init__(reason="errors.openaiWeb", message=message, code=code)
72 |
73 |
74 | class ArkoseForwardException(Exception):
75 | def __init__(self, message: str = "", code: int = 404):
76 | self.message = message
77 | self.code = code
78 |
--------------------------------------------------------------------------------
/backend/api/file_provider.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 | import uuid
4 | from datetime import datetime, timezone
5 | from mimetypes import guess_type
6 | from pathlib import Path
7 |
8 | from PIL import Image
9 | import aiofiles
10 | from fastapi import UploadFile
11 | from sqlalchemy import select
12 | from sqlalchemy.ext.asyncio import AsyncSession
13 |
14 | from api.conf import Config
15 | from api.models.db import UploadedFileInfo
16 | from api.models.json import UploadedFileExtraInfo
17 |
18 | config = Config()
19 |
20 |
21 | class FileProvider:
22 | def __init__(self, storage_dir: Path = None, max_size: int = None):
23 | self.max_size = max_size or config.data.max_file_upload_size
24 | self.storage_dir = storage_dir or (Path(config.data.data_dir) / "uploads")
25 | if not self.storage_dir.exists():
26 | self.storage_dir.mkdir()
27 |
28 | async def save_file(self, file: UploadFile, user_id: int, session: AsyncSession) -> UploadedFileInfo:
29 | file_name = f"{uuid.uuid4()}.dat"
30 | file_dir_path = self.storage_dir / f"{user_id}"
31 | file_path = file_dir_path / file_name
32 |
33 | if not file_dir_path.exists():
34 | file_dir_path.mkdir(parents=True)
35 |
36 | async with aiofiles.open(file_path, "wb") as buffer:
37 | while True:
38 | chunk = await file.read(1024 * 1024) # read by 1MB chunk
39 | if not chunk:
40 | break
41 | await buffer.write(chunk)
42 |
43 | # check if file is image
44 | content_type = file.content_type or guess_type(file.filename)[0]
45 | if content_type.startswith("image/"):
46 | img = Image.open(file_path)
47 | width, height = img.size
48 | else:
49 | width, height = None, None
50 |
51 | file_info = UploadedFileInfo(
52 | original_filename=file.filename,
53 | size=file.size,
54 | content_type=guess_type(file.filename)[0],
55 | storage_path=str(file_path.relative_to(self.storage_dir)),
56 | uploader_id=user_id,
57 | upload_time=datetime.now().astimezone(tz=timezone.utc),
58 | extra_info=UploadedFileExtraInfo(width=width, height=height)
59 | )
60 | session.add(file_info)
61 | await session.commit()
62 |
63 | return file_info
64 |
65 | async def get_file_info(self, file_id: uuid.UUID, session: AsyncSession):
66 | result = await session.execute(select(UploadedFileInfo).where(UploadedFileInfo.id == file_id))
67 | file_info = result.scalars().first()
68 | return file_info
69 |
70 | def get_absolute_path(self, path: str) -> Path:
71 | return self.storage_dir / path
72 |
--------------------------------------------------------------------------------
/backend/api/globals.py:
--------------------------------------------------------------------------------
1 | server_log_filename = None
2 |
3 | startup_time = None
4 |
--------------------------------------------------------------------------------
/backend/api/middlewares/__init__.py:
--------------------------------------------------------------------------------
1 | from .asgi_logger import AccessLoggerMiddleware
2 | from .request_statistics import StatisticsMiddleware
3 |
4 |
--------------------------------------------------------------------------------
/backend/api/middlewares/asgi_logger/__init__.py:
--------------------------------------------------------------------------------
1 | from .middleware import AccessLoggerMiddleware
--------------------------------------------------------------------------------
/backend/api/middlewares/asgi_logger/utils.py:
--------------------------------------------------------------------------------
1 | from urllib.parse import quote
2 |
3 | from asgiref.typing import HTTPScope
4 |
5 |
6 | def get_client_addr(scope: HTTPScope):
7 | if scope["client"] is None:
8 | return "-" # pragma: no cover
9 | return f"{scope['client'][0]}:{scope['client'][1]}"
10 |
11 |
12 | def get_path_with_query_string(scope: HTTPScope) -> str:
13 | path_with_query_string = quote(scope.get("root_path", "") + scope["path"])
14 | if scope["query_string"]: # pragma: no cover
15 | return f"{path_with_query_string}?{scope['query_string'].decode('ascii')}"
16 | return path_with_query_string
--------------------------------------------------------------------------------
/backend/api/middlewares/request_statistics.py:
--------------------------------------------------------------------------------
1 | import json
2 | import re
3 | import time
4 | from typing import Optional
5 |
6 | from asgiref.typing import ASGI3Application, HTTPScope, ASGIReceiveCallable, ASGISendCallable
7 | from fastapi.routing import APIRoute
8 |
9 | import api.globals as g
10 | from api.models.doc import RequestLogDocument, RequestLogMeta
11 |
12 | from utils.logger import get_logger
13 |
14 | logger = get_logger(__name__)
15 |
16 |
17 | class StatisticsMiddleware:
18 | """
19 | 统计请求的中间件
20 | """
21 |
22 | def __init__(
23 | self,
24 | app: ASGI3Application,
25 | filter_keywords: Optional[list[str]] = None,
26 | ) -> None:
27 | self.app = app
28 | self.filter_keywords = filter_keywords
29 |
30 | async def __call__(self, scope: HTTPScope, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
31 | if scope["type"] != "http" and scope["type"] != "websocket":
32 | return await self.app(scope, receive, send)
33 |
34 | raw_status_code = None
35 | body_code = None
36 |
37 | async def send_with_inspecting_body(message):
38 | """用于记录状态码"""
39 | nonlocal raw_status_code, body_code
40 | if message["type"] == "http.response.start":
41 | raw_status_code = message.get("status", None)
42 | elif message["type"] == "http.response.body":
43 | body = message.get("body", None) # byte string
44 | if body is not None:
45 | body = body.decode("utf-8")
46 | try:
47 | body = json.loads(body)
48 | body_code = body.get("code", None)
49 | except json.JSONDecodeError:
50 | pass
51 |
52 | await send(message)
53 |
54 | start_time = time.time()
55 |
56 | await self.app(scope, receive, send_with_inspecting_body)
57 |
58 | end_time = time.time()
59 |
60 | route: APIRoute | None = scope.get("route", None)
61 | if route is None:
62 | return
63 |
64 | if self.filter_keywords:
65 | for keyword in self.filter_keywords:
66 | if route.path.find(keyword) != -1:
67 | return
68 |
69 | user_id = None
70 | if "auth_user" in scope:
71 | user = scope["auth_user"]
72 | user_id = user.id
73 |
74 | if scope.get("method"):
75 | method = scope["method"]
76 | elif scope["type"] == "websocket":
77 | method = "WEBSOCKET"
78 | else:
79 | logger.debug(f"Unknown method for scope type: {scope['type']}")
80 | return
81 |
82 | elapsed_ms = end_time - start_time
83 | elapsed_ms = round(elapsed_ms * 1000, 2)
84 |
85 | await RequestLogDocument(
86 | meta=RequestLogMeta(route_path=route.path, method=method),
87 | user_id=user_id,
88 | elapsed_ms=elapsed_ms,
89 | status=body_code or raw_status_code or scope.get("ask_websocket_close_code", None),
90 | ).create()
91 |
--------------------------------------------------------------------------------
/backend/api/models/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maxduke/chatgpt-web-share/2d52c390be890c0c94203ef95fb72ba3e83add0b/backend/api/models/__init__.py
--------------------------------------------------------------------------------
/backend/api/models/doc/openai_web_code_interpreter.py:
--------------------------------------------------------------------------------
1 | from typing import Optional, Literal, Any
2 |
3 | from pydantic import BaseModel
4 |
5 |
6 | class OpenaiWebChatMessageMetadataAttachment(BaseModel):
7 | name: Optional[str] = None
8 | id: Optional[str] = None
9 | size: Optional[int] = None
10 | height: Optional[int] = None
11 | width: Optional[int] = None
12 | mimeType: Optional[str] = None
13 |
14 |
15 | class OpenaiWebChatMessageMetadataAggregateResultMessage(BaseModel):
16 | message_type: Optional[Literal['image', 'stream'] | str] = None
17 | time: Optional[float] = None
18 | sender: Optional[Literal['server'] | str] = None
19 | # image
20 | image_url: Optional[str] = None
21 | # stream
22 | stream_name: Optional[str] = None
23 | text: Optional[str] = None
24 |
25 |
26 | class OpenaiWebChatMessageMetadataAggregateResult(BaseModel):
27 | status: Optional[Literal['failed_with_in_kernel_exception', 'success'] | str] = None
28 | run_id: Optional[str] = None
29 | start_time: Optional[float] = None
30 | update_time: Optional[float] = None
31 | end_time: Optional[float] = None
32 | final_expression_output: Optional[Any] = None
33 | code: Optional[str] = None
34 | in_kernel_exception: Optional[dict[str, Any]] = None # name, traceback [], args [], notes []
35 | messages: Optional[list[OpenaiWebChatMessageMetadataAggregateResultMessage]] = None
36 | jupyter_messages: Optional[list[Any]] = None
37 |
--------------------------------------------------------------------------------
/backend/api/models/json.py:
--------------------------------------------------------------------------------
1 | import datetime
2 | from typing import Optional, Generic, TypeVar, get_args, Literal
3 |
4 | from pydantic import model_validator, BaseModel, Field, create_model, RootModel
5 |
6 | from api.enums import OpenaiWebChatModels, OpenaiApiChatModels
7 |
8 | ModelT = TypeVar('ModelT', bound=OpenaiWebChatModels | OpenaiApiChatModels)
9 |
10 |
11 | class OpenaiWebPerModelAskCount(RootModel[dict[str, int]]):
12 | root: dict[str, int] = {model: 0 for model in list(OpenaiWebChatModels)}
13 |
14 | @model_validator(mode="after")
15 | @classmethod
16 | def check(cls, m):
17 | # 如果某个值缺失，则默认设置为0
18 | for model in list(OpenaiWebChatModels):
19 | if model not in m.root:
20 | m.root[model] = 0
21 | return m
22 |
23 | @staticmethod
24 | def unlimited():
25 | return OpenaiWebPerModelAskCount(root={model: -1 for model in list(OpenaiWebChatModels)})
26 |
27 |
28 | class OpenaiApiPerModelAskCount(RootModel[dict[str, int]]):
29 | root: dict[str, int] = {model: 0 for model in list(OpenaiApiChatModels)}
30 |
31 | @model_validator(mode="after")
32 | @classmethod
33 | def check(cls, m):
34 | for model in list(OpenaiApiChatModels):
35 | if model not in m.root:
36 | m.root[model] = 0
37 | return m
38 |
39 | @staticmethod
40 | def unlimited():
41 | return OpenaiApiPerModelAskCount(root={model: -1 for model in list(OpenaiApiChatModels)})
42 |
43 |
44 | class TimeWindowRateLimit(BaseModel):
45 | window_seconds: int = Field(..., description="时间窗口大小，单位为秒")
46 | max_requests: int = Field(..., description="在给定时间窗口内最多的请求次数")
47 |
48 |
49 | class DailyTimeSlot(BaseModel):
50 | start_time: datetime.time = Field(..., description="每天可使用的开始时间")
51 | end_time: datetime.time = Field(..., description="每天可使用的结束时间")
52 |
53 |
54 | class CustomOpenaiApiSettings(BaseModel):
55 | url: Optional[str] = None
56 | key: Optional[str] = None
57 |
58 |
59 | class UploadedFileOpenaiWebInfo(BaseModel):
60 | file_id: Optional[str] = None
61 | use_case: Optional[Literal['my_files', 'multimodal'] | str] = None
62 | upload_url: Optional[str] = Field(None, description="上传文件的url, 上传后应清空该字段")
63 | download_url: Optional[str] = None
64 |
65 |
66 | class UploadedFileExtraInfo(BaseModel):
67 | width: Optional[int] = None
68 | height: Optional[int] = None
69 |
--------------------------------------------------------------------------------
/backend/api/models/types.py:
--------------------------------------------------------------------------------
1 | from typing import Literal
2 |
3 | SourceTypeLiteral = Literal["openai_web", "openai_api"]
4 |
--------------------------------------------------------------------------------
/backend/api/routers/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maxduke/chatgpt-web-share/2d52c390be890c0c94203ef95fb72ba3e83add0b/backend/api/routers/__init__.py
--------------------------------------------------------------------------------
/backend/api/routers/logs.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from datetime import datetime
3 |
4 | from fastapi import APIRouter, Depends
5 |
6 | import api.globals as g
7 | from api.conf import Config, Credentials
8 | from api.models.db import User
9 | from api.models.doc import AskLogDocument
10 | from api.schemas import LogFilterOptions
11 | from api.users import current_super_user
12 | from utils.logger import get_logger
13 |
14 | logger = get_logger(__name__)
15 | config = Config()
16 | credentials = Credentials()
17 |
18 | router = APIRouter()
19 |
20 |
21 | def read_last_n_lines(file_path, n, exclude_key_words=None):
22 | if exclude_key_words is None:
23 | exclude_key_words = []
24 | try:
25 | with open(file_path, "r") as f:
26 | lines = f.readlines()[::-1]
27 | except FileNotFoundError:
28 | return [f"File not found: {file_path}"]
29 | last_n_lines = []
30 | for line in lines:
31 | if len(last_n_lines) >= n:
32 | break
33 | if any([line.find(key_word) != -1 for key_word in exclude_key_words]):
34 | continue
35 | last_n_lines.append(line)
36 | return last_n_lines[::-1]
37 |
38 |
39 | @router.post("/logs/server", tags=["logs"])
40 | async def get_server_logs(_user: User = Depends(current_super_user), options: LogFilterOptions = LogFilterOptions()):
41 | lines = read_last_n_lines(
42 | g.server_log_filename,
43 | options.max_lines,
44 | options.exclude_keywords
45 | )
46 | return lines
47 |
48 |
49 | @router.get("/logs/completions", tags=["logs"], response_model=list[AskLogDocument])
50 | async def get_completion_logs(start_time: datetime = None, end_time: datetime = None, max_results: int = 100,
51 | _user: User = Depends(current_super_user)):
52 | criteria = []
53 | if start_time:
54 | criteria.append(AskLogDocument.time >= start_time)
55 | if end_time:
56 | criteria.append(AskLogDocument.time <= end_time)
57 | if not criteria:
58 | logs = await AskLogDocument.find_all().sort(-AskLogDocument.time).limit(max_results).to_list()
59 | else:
60 | logs = await AskLogDocument.find(*criteria).sort(-AskLogDocument.time).limit(max_results).to_list()
61 | return logs
62 |
--------------------------------------------------------------------------------
/backend/api/routers/status.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime, timedelta
2 |
3 | from fastapi import Depends, APIRouter
4 | from fastapi_cache.decorator import cache
5 |
6 | from api.models.db import User
7 | from api.models.doc import AskLogDocument
8 | from api.routers.conv import openai_web_manager
9 | from api.routers.system import count_active_users_cached, count_active_users
10 | from api.schemas.status_schemas import CommonStatusSchema
11 | from api.users import current_active_user
12 | from api.enums import OpenaiWebChatModels
13 | from utils.logger import get_logger
14 |
15 | router = APIRouter()
16 | logger = get_logger(__name__)
17 |
18 |
19 | @router.get("/status/common", tags=["status"], response_model=CommonStatusSchema)
20 | @cache(expire=60)
21 | async def get_server_status(_user: User = Depends(current_active_user)):
22 | result = await count_active_users()
23 | active_user_in_5m, active_user_in_1h, active_user_in_1d, queueing_count, _ = result
24 | pipeline = [
25 | {
26 | '$facet': {
27 | 'not_found': [
28 | {'$project': {'_id': None, 'total': {'$const': 0}}},
29 | {'$limit': 1}
30 | ],
31 | 'found': [
32 | {'$match': {'time': {'$gte': datetime.utcnow() - timedelta(hours=3)}}},
33 | {'$match': {
34 | 'meta.model': {'$in': [name for name in list(OpenaiWebChatModels) if name.startswith('gpt_4')]},
35 | 'meta.source': 'openai_web'}
36 | },
37 | {'$count': 'total'}
38 | ]
39 | }
40 | },
41 | {
42 | '$replaceRoot': {
43 | 'newRoot': {
44 | '$mergeObjects': [
45 | {'$arrayElemAt': ['$not_found', 0]},
46 | {'$arrayElemAt': ['$found', 0]}
47 | ]
48 | }
49 | }
50 | }
51 | ]
52 | aggregate_result = await AskLogDocument.aggregate(pipeline).to_list(length=1)
53 | gpt4_count_in_3_hours = aggregate_result[0].get('total', 0)
54 |
55 | result = CommonStatusSchema(
56 | active_user_in_5m=active_user_in_5m,
57 | active_user_in_1h=active_user_in_1h,
58 | active_user_in_1d=active_user_in_1d,
59 | is_chatbot_busy=openai_web_manager.is_busy(),
60 | chatbot_waiting_count=queueing_count,
61 | gpt4_count_in_3_hours=gpt4_count_in_3_hours
62 | )
63 | return result
64 |
--------------------------------------------------------------------------------
/backend/api/schemas/__init__.py:
--------------------------------------------------------------------------------
1 | from .system_schemas import *
2 | from .user_schemas import *
3 | from .conversation_schemas import *
4 |
--------------------------------------------------------------------------------
/backend/api/schemas/file_schemas.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from typing import Optional, Literal
3 |
4 | from pydantic import ConfigDict, BaseModel
5 | import uuid
6 |
7 | from api.enums.options import OpenaiWebFileUploadStrategyOption
8 | from api.models.json import UploadedFileOpenaiWebInfo, UploadedFileExtraInfo
9 |
10 |
11 | class UploadedFileInfoSchema(BaseModel):
12 | id: uuid.UUID
13 | original_filename: str
14 | size: int
15 | storage_path: Optional[str] = None
16 | content_type: Optional[str] = None
17 | upload_time: datetime
18 | uploader_id: int
19 | openai_web_info: Optional[UploadedFileOpenaiWebInfo] = None
20 | extra_info: Optional[UploadedFileExtraInfo] = None
21 | model_config = ConfigDict(from_attributes=True)
22 |
23 |
24 | class StartUploadRequestSchema(BaseModel):
25 | file_name: str
26 | file_size: int
27 | width: Optional[int] = None
28 | height: Optional[int] = None
29 | mime_type: Optional[str] = None
30 | use_case: Literal['my_files', 'multimodal'] # Openai Web：图片使用 multimodal，其它使用 my_files
31 |
32 |
33 | class StartUploadResponseSchema(BaseModel):
34 | strategy: OpenaiWebFileUploadStrategyOption
35 | file_max_size: int
36 | upload_file_info: Optional[UploadedFileInfoSchema] = None # 为空意味着后端不暂存文件，前端直接上传到openai
37 |
--------------------------------------------------------------------------------
/backend/api/schemas/status_schemas.py:
--------------------------------------------------------------------------------
1 | from pydantic import BaseModel
2 |
3 |
4 | class CommonStatusSchema(BaseModel):
5 | active_user_in_5m: int = None
6 | active_user_in_1h: int = None
7 | active_user_in_1d: int = None
8 | is_chatbot_busy: bool = None
9 | chatbot_waiting_count: int = None
10 | gpt4_count_in_3_hours: int = None
11 |
--------------------------------------------------------------------------------
/backend/api/schemas/system_schemas.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime, timezone
2 | from typing import Optional, Union, Annotated
3 |
4 | from pydantic import field_validator, ConfigDict, BaseModel, Field, field_serializer
5 |
6 | from api.models.doc import OpenaiWebAskLogMeta, OpenaiApiAskLogMeta
7 |
8 |
9 | class SystemInfo(BaseModel):
10 | startup_time: float
11 | total_user_count: int
12 | total_conversation_count: int
13 | valid_conversation_count: int
14 |
15 |
16 | class LogFilterOptions(BaseModel):
17 | max_lines: int = 100
18 | exclude_keywords: list[str] = None
19 |
20 | @field_validator("max_lines")
21 | @classmethod
22 | def max_lines_must_be_positive(cls, v):
23 | if v <= 0:
24 | raise ValueError("max_lines must be positive")
25 | return v
26 |
27 |
28 | class RequestLogAggregationID(BaseModel):
29 | start_time: Optional[datetime] = None
30 | route_path: Optional[str] = None
31 | method: Optional[str] = None
32 |
33 | @field_serializer("start_time")
34 | def serialize_dt(self, start_time: Optional[datetime], _info):
35 | if start_time:
36 | return start_time.replace(tzinfo=timezone.utc)
37 | return None
38 |
39 |
40 | class RequestLogAggregation(BaseModel):
41 | id: RequestLogAggregationID = Field(alias="_id") # 起始时间
42 | count: int # 时间间隔内的请求数量
43 | user_ids: list[Optional[int]] = [] # 用户ID列表
44 | avg_elapsed_ms: Optional[float] = None
45 |
46 |
47 | class AskLogAggregationID(BaseModel):
48 | start_time: datetime
49 | meta: Optional[Annotated[Union[OpenaiWebAskLogMeta, OpenaiApiAskLogMeta], Field(discriminator='source')]] = None
50 |
51 | @field_serializer("start_time")
52 | def serialize_dt(self, start_time: Optional[datetime], _info):
53 | if start_time:
54 | return start_time.replace(tzinfo=timezone.utc)
55 | return None
56 |
57 |
58 | class AskLogAggregation(BaseModel):
59 | id: Optional[AskLogAggregationID] = Field(None, alias="_id") # 起始时间
60 | count: int # 时间间隔内的请求数量
61 | user_ids: list[Optional[int]] = None # 用户ID列表
62 | total_queueing_time: Optional[float] = None
63 | total_ask_time: Optional[float] = None
64 |
--------------------------------------------------------------------------------
/backend/api/sources/__init__.py:
--------------------------------------------------------------------------------
1 | from .openai_web import *
2 | from .openai_api import *
3 |
--------------------------------------------------------------------------------
/backend/config_templates/config.yaml:
--------------------------------------------------------------------------------
1 | openai_web:
2 | enabled: true
3 | is_plus_account: true
4 | enable_team_subscription: false
5 | team_account_id:
6 | chatgpt_base_url:
7 | proxy:
8 | wss_proxy:
9 | enable_arkose_endpoint: false
10 | arkose_endpoint_base:
11 | common_timeout: 20
12 | ask_timeout: 600
13 | sync_conversations_on_startup: false
14 | sync_conversations_schedule: false
15 | sync_conversations_schedule_interval_hours: 12
16 | enabled_models:
17 | - gpt_3_5
18 | - gpt_4
19 | - gpt_4o
20 | - o1
21 | - o1_mini
22 | model_code_mapping:
23 | gpt_3_5: gpt-4o-mini
24 | gpt_4: gpt-4
25 | gpt_4o: gpt-4o
26 | o1: o1
27 | o1_mini: o1-mini
28 | file_upload_strategy: browser_upload_only
29 | max_completion_concurrency: 1
30 | disable_uploading: false
31 | openai_api:
32 | enabled: true
33 | openai_base_url: https://api.openai.com/v1/
34 | proxy:
35 | connect_timeout: 10
36 | read_timeout: 20
37 | enabled_models:
38 | - gpt_3_5
39 | - gpt_4
40 | - gpt_4o
41 | - o1
42 | - o1_mini
43 | model_code_mapping:
44 | gpt_3_5: gpt-4o-mini
45 | gpt_4: gpt-4
46 | gpt_4o: gpt-4o
47 | o1: o1
48 | o1_mini: o1-mini
49 | common:
50 | print_sql: false
51 | print_traceback: true
52 | create_initial_admin_user: true
53 | initial_admin_user_username: admin
54 | initial_admin_user_password: password
55 | http:
56 | host: 127.0.0.1
57 | port: 8000
58 | cors_allow_origins:
59 | - http://localhost:8000
60 | - http://localhost:5173
61 | - http://127.0.0.1:8000
62 | - http://127.0.0.1:5173
63 | data:
64 | data_dir: ./data
65 | database_url: sqlite+aiosqlite:///data/database.db
66 | mongodb_url: mongodb://cws:password@mongo:27017
67 | mongodb_db_name: cws
68 | run_migration: true
69 | max_file_upload_size: 104857600
70 | auth:
71 | jwt_secret: MODIFY_THIS_TO_RANDOM_SECURE_STRING
72 | jwt_lifetime_seconds: 259200
73 | cookie_max_age: 259200
74 | user_secret: MODIFY_THIS_TO_ANOTHER_RANDOM_SECURE_STRING
75 | stats:
76 | ask_stats_ttl: 7776000
77 | request_stats_ttl: 2592000
78 | request_stats_filter_keywords:
79 | - /status
80 | log:
81 | console_log_level: INFO
82 |
--------------------------------------------------------------------------------
/backend/config_templates/credentials.yaml:
--------------------------------------------------------------------------------
1 | openai_web_access_token:
2 | openai_api_key:
3 |
--------------------------------------------------------------------------------
/backend/logging_config.yaml:
--------------------------------------------------------------------------------
1 | version: 1
2 | formatters:
3 | simple:
4 | format: "%(asctime)s.%(msecs)03d %(levelname)8s: [%(name)s]\t%(message)s"
5 | datefmt: '%Y/%m/%d %H:%M:%S'
6 | proxy-output:
7 | format: "%(message)s"
8 | datefmt: '%Y/%m/%d %H:%M:%S'
9 | colored:
10 | (): colorlog.ColoredFormatter
11 | format: "%(asctime)s.%(msecs)03d %(log_color)s%(levelname)8s%(reset)s: %(cyan)s[%(name)s]%(reset)s %(message)s"
12 | datefmt: '%Y/%m/%d %H:%M:%S'
13 | handlers:
14 | file_handler:
15 | class: logging.handlers.RotatingFileHandler
16 | formatter: simple
17 | encoding: utf-8
18 | level: DEBUG
19 | filename: cws.log
20 | maxBytes: 10485760 # 10MB
21 | console_handler:
22 | class: logging.StreamHandler
23 | formatter: colored
24 | level: DEBUG
25 |
26 | root:
27 | level: DEBUG
28 | handlers: []
29 | loggers:
30 | uvicorn.error:
31 | level: INFO
32 | handlers: [console_handler, file_handler]
33 | uvicorn.access:
34 | level: INFO
35 | handlers: [] # disable uvicorn access log
36 | cws:
37 | level: DEBUG
38 | handlers: [console_handler, file_handler]
39 | sqlalchemy:
40 | level: WARN
41 | handlers: [console_handler, file_handler]
42 | alembic:
43 | level: INFO
44 | handlers: [console_handler, file_handler]
45 |
--------------------------------------------------------------------------------
/backend/pyproject.toml:
--------------------------------------------------------------------------------
1 | [tool.poetry]
2 | name = "chatgpt-share-backend"
3 | version = "0.0.1"
4 | description = ""
5 | authors = ["moeakwak
23 | {{ code }}
24 |
25 |
35 | {{ content }}
36 |
37 |
25 | {{ props.request }}
26 |
27 |
42 | {{ props.response }}
43 |
44 | elements in the document.
60 | const preTags = doc.getElementsByTagName('pre');
61 |
62 | // Loop through the elements and add a