moss-mop 0.1.0__py3-none-any.whl

mop/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.0"
+__author__ = "puras"
+__email__ = "puras.he@gmail.com"

mop/conf/__init__.py

@@ -0,0 +1 @@
+from .settings import *

mop/conf/settings.py

@@ -0,0 +1,133 @@
+import os
+from enum import Enum
+from typing import List
+
+from pydantic.v1 import BaseSettings
+
+
+class Environment(str, Enum):
+    DEVELOPMENT = "dev"
+    PRODUCTION = "prod"
+    TEST = "test"
+
+def get_environment() -> Environment:
+    match os.getenv("APP_ENV", "development").lower():
+        case "prod" | "production":
+            return Environment.PRODUCTION
+        case "test":
+            return Environment.TEST
+        case _:
+            return Environment.DEVELOPMENT
+
+class Settings(BaseSettings):
+    # 基础配置
+    PROJECT_NAME: str = "MOSS"
+    PROJECT_DESCRIPTION: str = ""
+    VERSION: str = "0.1.0"
+    DEBUG: bool = True
+    ENVIRONMENT = get_environment()
+
+    # API配置
+    API_V1_STR: str = "/api/v1"
+    HOST: str = os.getenv("HOST", "0.0.0.0")
+    PORT: int = os.getenv("PORT", 8000)
+    WORKERS: int = 4
+
+    # 日志配置
+    LOG_DIR: str =os.getenv(
+        "LOG_DIR",
+        "logs"
+    )
+    LOG_LEVEL: str = os.getenv(
+        "LOG_LEVEL",
+        "INFO"
+    )
+    LOG_FORMAT: str = os.getenv(
+        "LOG_FORMAT",
+        "json"
+    ) # json or console
+
+    # 安全配置
+    ALLOWED_ORIGINS: List[str] = [
+        "*",
+    ]
+
+    # 数据库配置
+    SNOWFLAKE_DATACENTER_ID: int = os.getenv("SNOWFLAKE_DATACENTER_ID", 0)
+
+    DATABASE_URI: str = os.getenv(
+        "DATABASE_URI",
+        "sqlite:///./instance/moss.db"  # 使用异步SQLite驱动
+    )
+
+    ASYNC_DATABASE_URI: str = os.getenv(
+        "ASYNC_DATABASE_URI",
+        "sqlite+aiosqlite:///./instance/moss.db"  # 使用异步SQLite驱动
+    )
+    DB_TABLE_PREFIX = os.getenv(
+        "DB_TABLE_PREFIX",
+        "mo_"
+    )
+
+    MINIO_ENDPOINT: str = os.getenv(
+        "MINIO_ENDPOINT",
+        "http://127.0.0.1:9000"
+    )
+
+    MINIO_SHARE_ENDPOINT: str = os.getenv(
+        "MINIO_SHARE_ENDPOINT",
+        "http://127.0.0.1:9000/minio"
+    )
+
+    MINIO_ACCESS_KEY: str = os.getenv(
+        "MINIO_ACCESS_KEY",
+        ""
+    )
+
+    MINIO_SECRET_KEY: str = os.getenv(
+        "MINIO_SECRET_KEY",
+        ""
+    )
+
+    MINIO_DEFAULT_BUCKET: str = os.getenv(
+        "MINIO_DEFAULT_BUCKET",
+        "mo"
+    )
+
+    STORAGE_TYPE: str = os.getenv(
+        "STORAGE_TYPE",
+        "local"
+    )
+
+    OPENDAL_SCHEME: str = os.getenv(
+        "OPENDAL_SCHEME",
+        "fs"
+    )
+    OPENDAL_FS_ROOT: str = os.getenv(
+        "OPENDAL_FS_ROOT",
+        "storage"
+    )
+
+    TEMP_DIR: str = os.getenv(
+        "TEMP_DIR",
+        "temp"
+    )
+
+    AUTH_SECRET_KEY: str = os.getenv(
+        "AUTH_SECRET_KEY",
+        "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+    )
+    AUTH_SECRET_ALGORITHM: str = os.getenv(
+        "AUTH_SECRET_ALGORITHM",
+        "HS256"
+    )
+    AUTH_ACCESS_TOKEN_EXPIRE: int = os.getenv(
+        "AUTH_ACCESS_TOKEN_EXPIRE",
+        30
+    )
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()

mop/crud/__init__.py

@@ -0,0 +1,2 @@
+from .page import *
+from .crud import *

mop/crud/crud.py

@@ -0,0 +1,164 @@
+from typing import Generic, TypeVar
+
+from sqlalchemy import select, func
+
+from .page import ListSlice
+from mop.db import AsyncSessionLocal, SessionLocal
+from mop.entity import BaseEntity
+from mop.error import DATA_NOT_FOUND, BizError
+
+T = TypeVar("T", bound=BaseEntity)
+
+
+class CrudBiz(Generic[T]):
+    def __init__(self, model: type[T]):
+        self.model = model
+
+    def sync_find_all(self, **kwargs):
+        filters = [self.model.deleted == False]
+
+        for key, value in kwargs.items():
+            if hasattr(self.model, key):
+                filters.append(getattr(self.model, key) == value)
+
+        with SessionLocal() as db:
+            try:
+                ret = db.execute(select(self.model).where(*filters))
+                items = ret.scalars().all()
+                return items
+            finally:
+                db.close()
+
+    def sync_find_by_id(self, item_id: str):
+        filters = [self.model.id == item_id, self.model.deleted == False]
+        with SessionLocal() as db:
+            try:
+                ret = db.execute(select(self.model).where(*filters))
+                ret = ret.scalars().first()
+                if not ret:
+                    raise BizError.init(DATA_NOT_FOUND)
+                return ret
+            finally:
+                db.close()
+
+    async def find_all(self, **kwargs):
+        filters = [self.model.deleted == False]
+
+        for key, value in kwargs.items():
+            if hasattr(self.model, key):
+                filters.append(getattr(self.model, key) == value)
+
+        async with AsyncSessionLocal() as db:
+            try:
+                ret = await db.execute(select(self.model).where(*filters))
+                items = ret.scalars().all()
+                return items
+            finally:
+                await db.close()
+
+    async def count_by(self, **kwargs):
+        filters = [self.model.deleted == False]
+        for key, value in kwargs.items():
+            if hasattr(self.model, key):
+                filters.append(getattr(self.model, key) == value)
+        primary_column = self.model.__mapper__.primary_key[0]
+        async with AsyncSessionLocal() as db:
+            try:
+                cnt = await db.execute(select(func.count(primary_column)).where(*filters))
+                return cnt.scalar()
+            finally:
+                await db.close()
+
+    async def _count_by(self, db: AsyncSessionLocal, *filters):
+        primary_column = self.model.__mapper__.primary_key[0]
+        cnt = await db.execute(select(func.count(primary_column)).where(*filters))
+        return cnt.scalar()
+
+    async def find_by(self, page_num: int = 1, page_size: int = 100, **kwargs):
+        filters = [self.model.deleted == False]
+
+        for key, value in kwargs.items():
+            if hasattr(self.model, key):
+                filters.append(getattr(self.model, key) == value)
+
+        skip = (page_num - 1) * page_size
+        async with AsyncSessionLocal() as db:
+            try:
+                print(filters)
+                total = await self._count_by(db, *filters)
+                ret = await db.execute(
+                    select(self.model).where(*filters).offset(skip).limit(page_size)
+                )
+                items = ret.scalars().all()
+                return ListSlice(
+                    items=items, total=total, page_num=page_num, page_size=page_size
+                )
+            finally:
+                await db.close()
+
+    async def find_by_id(self, item_id: str):
+        filters = [self.model.id == item_id, self.model.deleted == False]
+        async with AsyncSessionLocal() as db:
+            try:
+                ret = await db.execute(select(self.model).where(*filters))
+                ret = ret.scalars().first()
+                if not ret:
+                    raise BizError.init(DATA_NOT_FOUND)
+                return ret
+            finally:
+                await db.close()
+
+    async def find_one(self, **kwargs):
+        filters = [self.model.deleted == False]
+
+        for key, value in kwargs.items():
+            if hasattr(self.model, key):
+                filters.append(getattr(self.model, key) == value)
+
+        async with AsyncSessionLocal() as db:
+            try:
+                ret = await db.execute(select(self.model).where(*filters))
+                item = ret.scalars().first()
+                return item
+            finally:
+                await db.close()
+
+    async def create(self, **kwargs):
+        item = self.model(**kwargs)
+        item.default_created()
+        async with AsyncSessionLocal() as db:
+            try:
+                db.add(item)
+                await db.commit()
+                await db.refresh(item)
+                return item
+            finally:
+                await db.close()
+
+    async def update(self, item_id: str, **kwargs):
+        item = await self.find_by_id(item_id)
+
+        other = self.model(**kwargs)
+        item.update_attrs(other)
+
+        async with AsyncSessionLocal() as db:
+            try:
+                db.add(item)
+                await db.commit()
+                await db.refresh(item)
+                return item
+            finally:
+                await db.close()
+
+    async def delete(self, item_id: str) -> bool:
+        item = await self.find_by_id(item_id)
+        item.default_deleted()
+        async with AsyncSessionLocal() as db:
+            try:
+                db.add(item)
+                await db.commit()
+                await db.refresh(item)
+                return True
+            finally:
+                await db.close()
+        return False

mop/crud/page.py

@@ -0,0 +1,11 @@
+from typing import List, TypeVar, Generic
+
+from pydantic import BaseModel, Field
+
+T  = TypeVar("T")
+
+class ListSlice(BaseModel, Generic[T]):
+    items: List[T] = Field(description="当前页的数据集合")
+    total: int = Field(description="总记录数")
+    page_num: int = Field(1, description="当前页面， 默认为1")
+    page_size: int = Field(10, description="每页的数据量，默认为10")

mop/db/__init__.py

@@ -0,0 +1,3 @@
+from .base import *
+from .session import *
+from .async_session import *

mop/db/async_session.py

@@ -0,0 +1,33 @@
+from typing import AsyncGenerator, Annotated
+
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+from mop.conf import settings
+
+async_engine = create_async_engine(
+    settings.ASYNC_DATABASE_URI,
+    echo=settings.DEBUG
+)
+
+AsyncSessionLocal = sessionmaker(
+    async_engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    """
+    获取数据库会话依赖
+    :return:
+    """
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+AsyncSessionDep = Annotated[AsyncSession, Depends(get_async_session)]

mop/db/base.py

@@ -0,0 +1,12 @@
+from sqlalchemy.orm import declared_attr, declarative_base
+
+from mop.conf import settings
+from mop.util.strings import to_underline
+
+
+class Base:
+    @declared_attr
+    def __tablename__(self):
+        return f"{settings.DB_TABLE_PREFIX}{to_underline(self.__name__)}"
+
+Base = declarative_base(cls=Base)

mop/db/session.py

@@ -0,0 +1,29 @@
+from typing import Annotated
+
+from fastapi import Depends
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+
+from mop.conf import settings
+
+engine = create_engine(
+    settings.DATABASE_URI,
+    echo=settings.DEBUG
+)
+
+SessionLocal = sessionmaker(
+    engine,
+    class_=Session,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+def get_session():
+    with SessionLocal() as session:
+        try:
+            yield session
+        finally:
+            session.close()
+
+SessionDep = Annotated[Session, Depends(get_session)]

mop/entity/__init__.py

@@ -0,0 +1 @@
+from .entity import *

mop/entity/entity.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from sqlalchemy import Column, String, Boolean, DateTime, text, Integer
+
+from mop.db import Base
+from mop.snowflake import IDWorker
+
+
+class BaseEntity(Base):
+    __abstract__ = True
+    id = Column(Integer, primary_key=True, index=True)
+    tenant_id = Column(String(32), nullable=False)
+    deleted = Column(Boolean, nullable=False, server_default=text("false"))
+    created_by = Column(String(32), nullable=True)
+    created_at = Column(DateTime, nullable=True, default=datetime.now)
+    updated_by = Column(String(32), nullable=True)
+    updated_at = Column(DateTime, nullable=True, default=datetime.now)
+    deleted_by = Column(String(32), nullable=True)
+    deleted_at = Column(DateTime, nullable=True)
+
+    def default_created(self):
+        self.id = IDWorker.gen_id()
+        self.tenant_id = '000000'
+
+    def update_attrs(self, other):
+        for attr in other.__dict__.keys():
+            if hasattr(self, attr) and attr != 'id' and attr != '_sa_instance_state':
+                setattr(self, attr, getattr(other, attr))
+        self.updated_at = datetime.now()
+
+    def default_deleted(self):
+        self.deleted = True
+        self.deleted_at = datetime.now()
+
+
+

mop/error/__init__.py

@@ -0,0 +1,2 @@
+from .err_code import *
+from .biz_error import *

mop/error/biz_error.py

@@ -0,0 +1,13 @@
+from .err_code import ErrCode
+
+class BizError(Exception):
+    def __init__(self, code: str, message: str):
+        self.code = code
+        self.message = message
+
+    def __str__(self):
+        return self.code
+
+    @classmethod
+    def init(cls, errCode: ErrCode):
+        return cls(errCode.code, errCode.message)

mop/error/err_code.py

@@ -0,0 +1,28 @@
+class ErrCode:
+    def __init__(self, code: str = "0", message: str = ""):
+        self.code = code
+        self.message = message
+
+UNAUTHORIZED = ErrCode("Unauthorized", "未经授权")
+FORBIDDEN = ErrCode("Forbidden", "无操作权限")
+AUTH_FAILED = ErrCode("AuthFailed", "鉴权失败")
+DATA_NOT_FOUND = ErrCode("DataNotFound", "数据未找到")
+SERVER_EXCEPTION = ErrCode("ServerException", "服务端异常")
+BIND_ERROR = ErrCode("BindError", "数据绑定错误")
+DATA_IS_EXIST = ErrCode("DataIsExist", "同类数据已存在")
+DATA_NOT_EDITABLE = ErrCode("DataNotEditable", "数据不可编辑")
+DATA_CHECK_FAILURE = ErrCode("DataCheckFailure", "数据检查失败")
+DATA_IS_RELATION = ErrCode("DataIsRelation", "数据被引用")
+DATA_PARSE_FAILURE = ErrCode("DataParseFailure", "数据解析失败")
+DATA_ENCODE_FAILURE = ErrCode("DataEncodeFailure", "数据编码失败")
+DATA_DECODE_FAILURE = ErrCode("DataDecodeFailure", "数据解码失败")
+BUSINESS_ERROR = ErrCode("BusinessError", "业务逻辑错误")
+INTERNAL_ERROR = ErrCode("InternalError", "服务端异常")
+INVALID_PARAM = ErrCode("InvalidParameter", "无效的请求参数")
+INVALID_JSON = ErrCode("InvalidJson", "无效的JSON请求串")
+INVALID_TOKEN = ErrCode("InvalidToken", "无效的令牌")
+OPERATION_FAILURE = ErrCode("OperationFailure", "操作失败")
+REMOTE_CALL_ERROR = ErrCode("RemoteCallError", "远程调用失败")
+REQUEST_METHOD_NOT_SUPPORTED = ErrCode("RequestMethodNotSupported", "请求的HTTP方法不支持")
+METHOD_NOT_SUPPORTED = ErrCode("MethodNotSupported", "方法不支持")
+

mop/logging/__init__.py

@@ -0,0 +1 @@
+from .logging import *

mop/logging/logging.py

@@ -0,0 +1,152 @@
+import json
+import sys
+from datetime import datetime
+
+import logging
+import os
+from pathlib import Path
+from typing import List, Any
+
+import structlog
+
+from mop.conf import settings, Environment
+
+if not os.path.exists(settings.LOG_DIR):
+    os.makedirs(settings.LOG_DIR)
+
+
+def get_log_file_path() -> Path:
+    env_prefix = settings.ENVIRONMENT.value
+    return Path(settings.LOG_DIR) / f"app-{env_prefix}-{datetime.now().strftime('%Y-%m-%d')}.log"
+
+
+class JsonlFileHandler(logging.Handler):
+    def __init__(self, file_path: Path):
+        super().__init__()
+        self.file_path = file_path
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            log_entry = {
+                "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+                "level": record.levelname,
+                "message": record.getMessage(),
+                "module": record.module,
+                "function": record.funcName,
+                "filename": record.filename,
+                "line": record.lineno,
+                "environment": settings.ENVIRONMENT.value,
+            }
+            if hasattr(record, "extra"):
+                log_entry.update(record.extra)
+            with open(self.file_path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        super().close()
+
+
+def get_structlog_processors(include_file_info: bool = True) -> List[Any]:
+    processors = [
+        structlog.stdlib.filter_by_level,
+        # structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if include_file_info:
+        processors.append(
+            structlog.processors.CallsiteParameterAdder(
+                {
+                    structlog.processors.CallsiteParameter.FILENAME,
+                    structlog.processors.CallsiteParameter.FUNC_NAME,
+                    structlog.processors.CallsiteParameter.LINENO,
+                    structlog.processors.CallsiteParameter.MODULE,
+                    structlog.processors.CallsiteParameter.PATHNAME,
+                }
+            )
+        )
+
+    processors.append(lambda _, __, event_dict: {**event_dict})
+
+    return processors
+
+
+def setup_logging():
+    # 确保日志目录存在
+    file_handler = JsonlFileHandler(get_log_file_path())
+    file_handler.setLevel(settings.LOG_LEVEL)
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(settings.LOG_LEVEL)
+
+    shared_processors = get_structlog_processors(
+        include_file_info=settings.ENVIRONMENT not in [Environment.PRODUCTION, Environment.TEST])
+
+    logging.basicConfig(
+        format="%(message)s",
+        level=settings.LOG_LEVEL,
+        handlers=[file_handler, console_handler],
+    )
+
+    if settings.LOG_FORMAT == "console":
+        structlog.configure(
+            processors=[
+                *shared_processors,
+                structlog.dev.ConsoleRenderer(),
+            ],
+            wrapper_class=structlog.stdlib.BoundLogger,
+            logger_factory=structlog.stdlib.LoggerFactory(),
+            cache_logger_on_first_use=True,
+        )
+    else:
+        structlog.configure(
+            processors=[
+                *shared_processors,
+                structlog.processors.JSONRenderer(),
+            ],
+            wrapper_class=structlog.stdlib.BoundLogger,
+            logger_factory=structlog.stdlib.LoggerFactory(),
+            cache_logger_on_first_use=True,
+        )
+
+    # # 配置日志格式
+    # formatter = logging.Formatter(
+    #     "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    # )
+
+    # # 文件处理器
+    # file_handler = RotatingFileHandler(
+    #     os.path.join(log_dir, "app.log"),
+    #     maxBytes=10 * 1024 * 1024,  # 10MB
+    #     backupCount=5
+    # )
+    # file_handler.setFormatter(formatter)
+    # file_handler.setLevel(logging.INFO)
+    #
+    # # 控制台处理器
+    # console_handler = logging.StreamHandler()
+    # console_handler.setFormatter(formatter)
+    # console_handler.setLevel(logging.DEBUG)
+    #
+    # # 配置根日志器
+    # root_logger = logging.getLogger()
+    # root_logger.setLevel(logging.INFO)
+    # root_logger.addHandler(file_handler)
+    # root_logger.addHandler(console_handler)
+
+    # 设置其他库的日志级别
+    logging.getLogger("uvicorn").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+
+setup_logging()
+
+logger = structlog.get_logger()
+logger.info("logging_initialized", log_format=settings.LOG_FORMAT)

mop/response/__init__.py

@@ -0,0 +1 @@
+from .response import *

mop/response/response.py

@@ -0,0 +1,38 @@
+from typing import Optional, Any, TypeVar, Generic
+
+from pydantic import BaseModel, ConfigDict
+
+from mop.error import ErrCode, BizError
+
+DataT = TypeVar("DataT")
+
+class Response(BaseModel, Generic[DataT]):
+    model_config = ConfigDict(from_attributes=True)
+
+    code: str
+    message: str
+    data: Optional[DataT] = None
+
+class SuccessResponse(Response[Any]):
+    pass
+
+class ErrorResponse(Response[None]):
+    pass
+
+def res_success(data: Any = None, code: str = "0", message: str = "success") -> Response:
+    return Response(code=code, message=message, data=data)
+
+def res_ok(data: Any = None, code: str = "0", message: str = "ok") -> Response:
+    return res_success(data=data, code=code, message=message)
+
+def res_err(code: str = "0", message: str = "error") -> Response:
+    return Response(code=code, message=message, data=None)
+
+def res_errcode(code: ErrCode) -> Response:
+    return Response(code=code.code, message=code.message, data=None)
+
+def res_ex(err: BizError) -> Response:
+    return Response(code=err.code, message=err.message, data=None)
+
+def res_err_json(code: str = "0", message: str = "error"):
+    return res_err(code=code, message=message).model_dump()

mop/snowflake.py

@@ -0,0 +1,192 @@
+"""
+雪花算法：https://github.com/twitter-archive/snowflake
+参考：https://github.com/cablehead/python-snowflake
+     https://github.com/falcondai/python-snowflake
+     https://zhuanlan.zhihu.com/p/85837641  其中的python写法
+其核心思想是：
+- 第一位 占用1bit，其值始终是0，没有任何意义。在计算机的表示中，第一位是符号位，0表示整数，第一位如果是1则表示负数，我们用的ID默认就是正数，所以默认就是0，那么这一位默认就没有意义。
+- 时间戳占用41位，具体到毫秒，41位的二进制可以使用69年，因为时间理论上永恒递增，所以根据这个排序是可以的。
+- 机器标识占用10位，可以全部用作机器ID，也可以用来标识机房ID + 机器ID，10位最多可以表示1024台机器。
+- 递增计数序列号占用12位，也就是同一台机器上同一时间，理论上还可以同时生成不同的ID。每个节点每毫秒从0开始不断累加，最多可以累加到4095，一共可以产生4096个ID。
+
+雪花算法的优点
+- 有业务含义，并且可自定义。 雪花算法的 ID 每一位都有特殊的含义，我们从 ID 的不同位数就可以推断出对应的含义。此外，我们还可根据自身需要，自行增删每个部分的位数，从而实现自定义的雪花算法。
+- ID 单调增加，有利于提高写入性能。 雪花算法的 ID 最后部分是递增的序列号，因此其生成的 ID 是递增的，将其作为数据库主键 ID 时可以实现顺序写入，从而提高写入性能。
+- 不依赖第三方系统。 雪花算法的生成方式，不依赖第三方系统或中间件，因此其稳定性较高。
+- 解决了安全问题。 雪花算法生成的 ID 是单调递增的，但其递增步长又不是确定的，因此无法从 ID 的差值推断出生成的数量，从而可以保护业务隐私。
+
+雪花算法的缺点
+- 强依赖机器时间
+
+雪花算法的一些问题处理
+1. 69年时限问题
+由于算法中用长度41位来表示时间戳，我们的时间计算通常是从1970年开始的，只能使用69年，为了不浪费，其实我们可以用时间的相对值，也就是以项目开始的时间为基准时间，往后可以使用69年，比如现在是2023年，那么往后推69年，就可以使用到2092年。获取唯一ID的服务，对处理速度要求比较高，所以我们全部使用位运算以及位移操作。
+2. 时间回拨问题
+在获取时间的时候，可能会出现`时间回拨`的问题，什么是时间回拨问题呢？就是服务器上的时间突然倒退到之前的时间。
+1. 人为原因，把系统环境的时间改了。
+2. 有时候不同的机器上需要同步时间，可能不同机器之间存在误差，那么可能会出现时间回拨问题。
+
+解决方案
+- 回拨时间小的时候，不生成 ID，循环等待到时间点到达。
+- 上面的方案只适合时钟回拨较小的，如果间隔过大，阻塞等待，肯定是不可取的，因此
+  - 要么超过一定大小的回拨直接报错，拒绝服务，
+  - 另一种方案是利用拓展位，回拨之后在拓展位上加1就可以了，这样ID依然可以保持唯一。但是这个要求我们提前预留出位数，要么从机器id中，要么从序列号中，腾出一定的位，在时间回拨的时候，这个位置 `+1`。
+
+雪花算法
+结合以上理论知识，以及项目的情况，64位做一下调整
+
+- 首位不变，保持为0
+- 时间戳占用41位，具体到毫秒，
+- 机器标识占用8位，其中数据中心1位，机器id 7位
+- 时间回拨占用2位
+- 递增计数序列号占用12位
+所以结构为
+0{41-时间戳}{1-数据中心}{7-机器id}{2-时间回拨}{12-递增计数序列号}
+"""
+import os
+import pathlib
+import time
+
+from mop.conf import settings
+
+# 64位ID的划分，其中有22位自由分配
+WORKER_ID_BITS = 7  # 机器标识，7bit
+DATACENTER_ID_BITS = 1  # 数据中心，1bit
+FIX_SYSTEM_CLOCK_BITS = 2  # 时间回拨拓展位，2bit
+SEQUENCE_ID_BITS = 12  # 累计序列号，12bit
+
+# 最大取值计算
+MAX_WORKER_ID = -1 ^ (-1 << WORKER_ID_BITS)  # 最大机器数，2**7-1 0b1111111, 0b代表正数，-0b代表负数
+MAX_DATACENTER_ID = -1 ^ (-1 << DATACENTER_ID_BITS)  # 最大数据中心，2**1-1 0b1
+MAX_FIX_SYSTEM_CLOCK = -1 ^ (-1 << FIX_SYSTEM_CLOCK_BITS)  # 最大支持的时钟回拨次数，2**2-1 0b11
+SEQUENCE_MASK = MAX_SEQUENCE_ID = -1 ^ (-1 << SEQUENCE_ID_BITS)  # 最大序列号，2**12-1， 总共可以表示4096个ID
+
+# 移位偏移计算
+WORKER_ID_SHIFT = SEQUENCE_ID_BITS
+FIX_SYSTEM_CLOCK_SHIFT = SEQUENCE_ID_BITS + FIX_SYSTEM_CLOCK_BITS
+DATACENTER_ID_SHIFT = SEQUENCE_ID_BITS + FIX_SYSTEM_CLOCK_BITS + WORKER_ID_BITS
+TIMESTAMP_LEFT_SHIFT = SEQUENCE_ID_BITS + FIX_SYSTEM_CLOCK_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS
+
+# 开始时间截 (2023-01-01)
+TWEPOCH = 1672531200000
+root_path = pathlib.Path(__file__).parent.parent.resolve()  # 使用绝对路径，防止环境不同导致的异常
+
+
+class SnowflakeGenerator(object):
+    """
+    用于生成IDs
+    """
+    def __init__(self, datacenter_id, worker_id, sequence=0, fix_system_clock=0):
+        """
+        初始化
+        :param datacenter_id: 数据中心（机器区域）ID
+        :param worker_id: 机器ID
+        :param sequence: 递增序号
+        :param fix_system_clock: 时钟回拨的次数
+        """
+        if worker_id > MAX_WORKER_ID or worker_id < 0:
+            raise ValueError(f'worker_id:{worker_id}越界,支持 0 - {MAX_WORKER_ID}')
+
+        if datacenter_id > MAX_DATACENTER_ID or datacenter_id < 0:
+            raise ValueError(f'datacenter_id:{datacenter_id}越界,支持 0 - {MAX_DATACENTER_ID}')
+
+        self.worker_id = worker_id
+        self.datacenter_id = datacenter_id
+        self.sequence = sequence
+        self.fix_system_clock = fix_system_clock
+
+        self.last_timestamp = self._read_last_timestamp()  # 上次计算的时间戳
+
+        self._save_last_timestamp(self._gen_timestamp())  # 实例启动时写入当前时间
+
+    @staticmethod
+    def _save_last_timestamp(_last_timestamp):
+        """
+        上次的时间戳写入文件
+        :return:int timestamp
+        """
+        file_path = root_path.parent.joinpath("last_timestamp.txt")
+        with open(file_path, 'w') as file:  # 覆盖写
+            file.write(str(_last_timestamp))
+
+    @staticmethod
+    def _read_last_timestamp():
+        """
+        从文件读取上次的时间戳
+        :return:int timestamp
+        """
+        try:
+            version_path = root_path.parent.joinpath("last_timestamp.txt")
+            with open(version_path, 'r') as file:
+                _last_timestamp = int(file.read().rstrip())
+        except Exception as e:
+            print(f"读取last_timestamp.txt失败，{str(e)}")
+            _last_timestamp = -1  # 默认值为-1，则一定可以生成
+        return _last_timestamp
+
+    @staticmethod
+    def _gen_timestamp():
+        """
+        生成整数时间戳
+        :return:int timestamp
+        """
+        return int(time.time() * 1000)
+
+    def gen_id(self, current_timestamp: int = None):
+        """
+        获取新ID
+        :return:
+        """
+        timestamp = current_timestamp or self._gen_timestamp()
+
+        if timestamp > self.last_timestamp:
+            self.sequence = 0
+        else:
+            if timestamp < self.last_timestamp:  # 时钟回拨
+                self.fix_system_clock = (self.fix_system_clock + 1) & MAX_FIX_SYSTEM_CLOCK
+                print(f"系统时钟回拨，fix_system_clock 加 1： {self.fix_system_clock}")
+                if self.fix_system_clock == 0:  # 时钟回拨位到达上限;此时，计数不变，时间等待到下一毫秒，保证id唯一
+                    timestamp = self._til_next_millis(self.last_timestamp)
+
+            self.sequence = (self.sequence + 1) & SEQUENCE_MASK
+            if self.sequence == 0:  # 序列号到达上限;此时，计数不变，时间等待到下一毫秒，保证id唯一
+                timestamp = self._til_next_millis(self.last_timestamp)
+
+        self.last_timestamp = timestamp
+
+        new_id = ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) | (self.datacenter_id << DATACENTER_ID_SHIFT) | \
+                 (self.worker_id << WORKER_ID_SHIFT) | self.fix_system_clock << FIX_SYSTEM_CLOCK_SHIFT | self.sequence
+        return new_id
+
+    def _til_next_millis(self, last_timestamp):
+        """
+        等到下一毫秒
+        """
+        timestamp = self._gen_timestamp()
+        while timestamp <= last_timestamp:
+            timestamp = self._gen_timestamp()
+        return timestamp
+
+    def melt(self, snowflake_id, twepoch=TWEPOCH):
+        """
+        翻译id个部分组成的明文
+        """
+        sequence_id = snowflake_id & MAX_SEQUENCE_ID
+        fix_system_clock_id = (snowflake_id >> SEQUENCE_ID_BITS) & MAX_FIX_SYSTEM_CLOCK
+        worker_id = (snowflake_id >> SEQUENCE_ID_BITS >> FIX_SYSTEM_CLOCK_BITS) & MAX_WORKER_ID
+        datacenter_id = (snowflake_id >> SEQUENCE_ID_BITS >> FIX_SYSTEM_CLOCK_BITS >> WORKER_ID_BITS) & MAX_DATACENTER_ID
+        timestamp_ms = snowflake_id >> SEQUENCE_ID_BITS >> FIX_SYSTEM_CLOCK_BITS >> WORKER_ID_BITS >> DATACENTER_ID_BITS
+        timestamp_ms += twepoch
+
+        return timestamp_ms, int(datacenter_id), int(worker_id), int(fix_system_clock_id), int(sequence_id)
+
+
+def local_datetime(timestamp_ms):
+    import datetime
+    """convert millisecond timestamp to local datetime object."""
+    return datetime.datetime.fromtimestamp(timestamp_ms / 1000)
+
+
+# 数据中心id由配置文件获取，默认是0
+# 机器id取进程id的最后2位
+IDWorker = SnowflakeGenerator(settings.SNOWFLAKE_DATACENTER_ID, int(str(os.getpid())[-2:]))

mop/util/__init__.py

@@ -0,0 +1 @@
+from .util import *

mop/util/dates.py

@@ -0,0 +1,5 @@
+import datetime
+
+
+def naive_utc_now() -> datetime.datetime:
+    return datetime.datetime.now(datetime.UTC).replace(tzinfo=None)

mop/util/encoder.py

@@ -0,0 +1,178 @@
+import dataclasses
+import datetime
+from collections import deque
+from decimal import Decimal
+from enum import Enum
+from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network, IPv4Interface, IPv6Interface
+from pathlib import PurePath, Path
+from types import GeneratorType
+from typing import Any, Optional, Callable, Literal, Union, Pattern
+from uuid import UUID
+
+from fastapi.encoders import encoders_by_class_tuples
+from pydantic import BaseModel, NameEmail, SecretBytes, SecretStr, AnyUrl
+from pydantic_core import Url
+
+
+def _model_dump(model: BaseModel, mode: Literal["json", "python"] = "json", **kwargs):
+    return model.model_dump(mode=mode, **kwargs)
+
+def isoformat(o: Union[datetime.date, datetime.time]) -> str:
+    return o.isoformat()
+
+def decimal_encoder(dec_value: Decimal) -> Union[int, float]:
+    if dec_value.as_tuple().exponent >= 0:
+        return int(dec_value)
+    return float(dec_value)
+
+ENCODERS_BY_TYPE: dict[type[Any], Callable[[Any], Any]] = {
+    bytes: lambda x: x.decode(),
+    # Color: str,
+    datetime.date: isoformat,
+    datetime.datetime: isoformat,
+    datetime.timedelta: lambda x: x.total_seconds(),
+    Decimal: decimal_encoder,
+    Enum: lambda x: x.value,
+    frozenset: list,
+    deque: list,
+    GeneratorType: list,
+    IPv4Address: str,
+    IPv4Interface: str,
+    IPv4Network: str,
+    IPv6Address: str,
+    IPv6Interface: str,
+    IPv6Network: str,
+    NameEmail: str,
+    Path: str,
+    Pattern: lambda x: x.pattern,
+    SecretBytes: str,
+    SecretStr: str,
+    set: list,
+    UUID: str,
+    Url: str,
+    AnyUrl: str,
+}
+
+def jsonable_encoder(
+        obj: Any,
+        by_alias: bool = True,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        custom_encoder: Optional[dict[Any, Callable[[Any], Any]]] = None,
+        sqlalchemy_safe: bool = True,
+):
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, BaseModel):
+        obj_dict = _model_dump(
+            obj,
+            mode="json",
+            include=None,
+            exclude=None,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+        )
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(
+            obj_dict,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+
+    if dataclasses.is_dataclass(obj):
+        if not isinstance(obj, type):
+            obj_dict = dataclasses.asdict(obj)
+            return jsonable_encoder(
+                obj_dict,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_encoder=custom_encoder,
+                sqlalchemy_safe=sqlalchemy_safe,
+            )
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, str | int | float | type(None)):
+        return obj
+    if isinstance(obj, Decimal):
+        return format(obj, "f")
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        for key, value in obj.items():
+            if (not sqlalchemy_safe or (not isinstance(key, str)) or (not key.startswith("_sa"))) and (value is not None or not exclude_none):
+                encoded_key = jsonable_encoder(
+                    key,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_value = jsonable_encoder(
+                    value,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, list | set | frozenset | GeneratorType | tuple | deque):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(
+                jsonable_encoder(
+                    item,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+            )
+        return encoded_list
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as ex:
+        errors: list[Exception] = []
+        errors.append(ex)
+        try:
+            data = vars(obj)
+        except Exception as ex:
+            errors.append(ex)
+            raise ValueError(errors) from ex
+
+    return jsonable_encoder(
+        data,
+        by_alias=by_alias,
+        exclude_unset=exclude_unset,
+        exclude_defaults=exclude_defaults,
+        exclude_none=exclude_none,
+        custom_encoder=custom_encoder,
+        sqlalchemy_safe=sqlalchemy_safe,
+    )
+

mop/util/files.py

@@ -0,0 +1,27 @@
+import os
+import sys
+
+from ascii_colors import ASCIIColors
+
+
+def file_size_format(size: int) -> str:
+    power = 2 ** 10
+    n = 0
+    power_labels = {0: '', 1: 'K', 2: 'M', 3: 'G', 4: 'T'}
+    while size > power:
+        size /= power
+        n += 1
+    return f"{size:.2f} {power_labels[n]}B"
+
+
+def check_env_file():
+    if not os.path.exists('.env'):
+        warning_msg = "Warning: Startup directory must contain .env file for multi-instance support."
+        ASCIIColors.yellow(warning_msg)
+
+        if sys.stdin.isatty():
+            response = input("Do you want to continue? [y/N]: ")
+            if response.lower() != "y":
+                ASCIIColors.red("Server startup cancelled")
+                return False
+    return True

mop/util/strings.py

@@ -0,0 +1,10 @@
+import re
+
+
+def to_underline(camel: str) -> str:
+    """
+    将驼峰转为下划线
+    :param camel: 驼峰字符串
+    :return:
+    """
+    return re.sub('(?<=[a-z])[A-Z]|(?<!^)[A-Z](?=[a-z])', '_\g<0>', camel).lower()

mop/util/util.py

@@ -0,0 +1,43 @@
+import argparse
+
+from ascii_colors import ASCIIColors
+
+from mop.conf import settings
+from mop import __version__ as core_version
+
+
+def parse_args(is_uvicorn_mode: bool=False):
+    parser = argparse.ArgumentParser(
+        description="FastAPI Server with separate working and input directories"
+    )
+
+    parser.add_argument(
+        "--host",
+        default=settings.HOST,
+        help="Server host (default: from env or 0.0.0.0)"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=settings.PORT,
+        help="Server port (default: from env or 8000)"
+    )
+    args = parser.parse_args()
+    return args
+
+def display_splash_screen(args: argparse.Namespace):
+    ASCIIColors.cyan(f"""
+        ╔══════════════════════════════════════════════════════════════╗
+        ║                   🚀 MoP Server v{core_version}                      ║
+        ║          -------------------------------------------         ║
+        ╚══════════════════════════════════════════════════════════════╝
+        """)
+    ASCIIColors.magenta("\n📡 Server Configuration:")
+    ASCIIColors.white("    ├─ Host: ", end="")
+    ASCIIColors.yellow(f"{args.host}")
+    ASCIIColors.white("    ├─ Port: ", end="")
+    ASCIIColors.yellow(f"{args.port}")
+    ASCIIColors.white("    ├─ Address: ", end="")
+    ASCIIColors.yellow(f"http://{args.host}:{args.port}")
+    ASCIIColors.white("    ├─ Docs: ", end="")
+    ASCIIColors.yellow(f"http://{args.host}:{args.port}/api/v1/docs")

moss_mop-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: moss-mop
+Version: 0.1.0
+Summary: Lightweight FastAPI + SQLAlchemy backend toolkit with logging, CRUD, and utilities
+Requires-Python: >=3.12
+Requires-Dist: ascii-colors>=0.11.6
+Requires-Dist: fastapi>=0.124.4
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: sqlalchemy>=2.0.45
+Requires-Dist: structlog>=25.5.0

moss_mop-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+mop/__init__.py,sha256=sPqG1eteHPPEAyaj0yF6UkpZhYXQF2Zfdu-5nVromUE,75
+mop/snowflake.py,sha256=J86ViNazFa1HxZ2PHlBlL9WRF_pHNxzqL13Y9yrtgSw,9776
+mop/conf/__init__.py,sha256=LeIvAa1BS1_-Zd0PN1cUepAEEmyFaaBT_QVWHd0HS_c,23
+mop/conf/settings.py,sha256=2f_YO0LwlasgiKrw0ABZVXfVyNaSGbUhIk2fbjt2aFs,2891
+mop/crud/__init__.py,sha256=3help3fmgxYVRMMogfvo9WITwLuGB95Hsk-EHHWIxzw,39
+mop/crud/crud.py,sha256=27eFPTl_Zu2jxMQGpqChjBUmdLXwBFuxFhewKBUlo1A,5571
+mop/crud/page.py,sha256=ZfqDF86lzkeTSYTtHstCTJ-O_hNRA2cb5MMJeHRAn6A,408
+mop/db/__init__.py,sha256=BResfFTBPcTsH0QryV1fWHhTDXH0F876WM8OMt4wqUY,71
+mop/db/async_session.py,sha256=OEYUb_keQ0E9QmFpL01iFAun2EEYE7b8nX86iMLWc0U,800
+mop/db/base.py,sha256=Ys1qN-Aw6bwUxrzw5MJ0chYSBYfubkq0TQLipn_PhVw,302
+mop/db/session.py,sha256=zl1fh5hPlWdLs2T9_Cr6djwaziv9xyoCCKLVDNr8Ato,582
+mop/entity/__init__.py,sha256=8xDz5NhH7UqKGzFsksUNRn989EXS14WX3s7jXXl1c3E,21
+mop/entity/entity.py,sha256=K0KTfXVz3i5rH1ntn0x__MFVXigwr_naXgrd1m3wNUE,1209
+mop/error/__init__.py,sha256=oBh5truG69yWujbw_9z741yMGIW9-_g013wWQByCeQc,48
+mop/error/biz_error.py,sha256=jHRBxnPU1BxjIzEDv1LY691jq3XnCf3uzzy1Om_WLwc,316
+mop/error/err_code.py,sha256=jPThTaKr9PIWosc46PaVf6Zvbm3oAMAmfXoiJsL6EW8,1580
+mop/logging/__init__.py,sha256=n3gPZp-5JMkNwlaWF7GyDwk40E-QYlIeLNruo6MB7B0,22
+mop/logging/logging.py,sha256=JFH6sC8mqitVE6ligLv9u0iEju1aQJKxoI89m2f02wM,4843
+mop/response/__init__.py,sha256=pohzkvpThf_VonwWU0HgJIGkJ3xl6M5ejVMKFHwWBhg,23
+mop/response/response.py,sha256=RepIafmXu4QAKkTqhyWVOIw0vpsg4EnJZeewQWFnh8Y,1177
+mop/util/__init__.py,sha256=4g0apI8-3diyfdBaBOt6VKY0WGXTK8FpybbNTMHNR2o,19
+mop/util/dates.py,sha256=p5PYGs3ZcE81Goblu-uvmpbN4FqziPGAy7_2gArWMbA,127
+mop/util/encoder.py,sha256=EQ1vSVW819YDQ0wPPq9rWcMmgiGWS7eytn5DSpRc6-o,5900
+mop/util/files.py,sha256=bpTrVmM45i8yD0OxSPvKrTVFXrTqOEnxP_lcjtnhJNs,737
+mop/util/strings.py,sha256=bBt2p-VnQcuu8mysLfUfZlqtya7uadmLU8NSf1uylGc,223
+mop/util/util.py,sha256=MJj-JRAUi7zFnJ1sI8GyQb_eQsVDe103nUXgsX87CQg,1768
+moss_mop-0.1.0.dist-info/METADATA,sha256=IzIKmtYw1lneZKCCukE5KWJqCBGTvgkJ4jEmeQn3lbo,335
+moss_mop-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moss_mop-0.1.0.dist-info/top_level.txt,sha256=4y0z_w1bQ9rx4tDt1scq6AUB1N0WAqHm98kjNjy1xDQ,4
+moss_mop-0.1.0.dist-info/RECORD,,

moss_mop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moss_mop-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mop