第一次提交

.gitignore

+*-cache
+*.bak
+**/__pycache__
+*.pyc
+/logs/
+/test/
+*.~*
+*-workspace
+*.db
\ No newline at end of file

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/financial-system.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/fast_api" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>
\ No newline at end of file

.idea/inspectionProfiles/Project_Default.xml

+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="39">
+            <item index="0" class="java.lang.String" itemvalue="protobuf" />
+            <item index="1" class="java.lang.String" itemvalue="PyJWT" />
+            <item index="2" class="java.lang.String" itemvalue="tzlocal" />
+            <item index="3" class="java.lang.String" itemvalue="cors" />
+            <item index="4" class="java.lang.String" itemvalue="greenlet" />
+            <item index="5" class="java.lang.String" itemvalue="SQLAlchemy" />
+            <item index="6" class="java.lang.String" itemvalue="cffi" />
+            <item index="7" class="java.lang.String" itemvalue="MarkupSafe" />
+            <item index="8" class="java.lang.String" itemvalue="mysql-connector-python" />
+            <item index="9" class="java.lang.String" itemvalue="redis" />
+            <item index="10" class="java.lang.String" itemvalue="frozenlist" />
+            <item index="11" class="java.lang.String" itemvalue="filelock" />
+            <item index="12" class="java.lang.String" itemvalue="certifi" />
+            <item index="13" class="java.lang.String" itemvalue="gevent" />
+            <item index="14" class="java.lang.String" itemvalue="tldextract" />
+            <item index="15" class="java.lang.String" itemvalue="urllib3" />
+            <item index="16" class="java.lang.String" itemvalue="itsdangerous" />
+            <item index="17" class="java.lang.String" itemvalue="zope.event" />
+            <item index="18" class="java.lang.String" itemvalue="Flask-HTTPAuth" />
+            <item index="19" class="java.lang.String" itemvalue="Flask-WTF" />
+            <item index="20" class="java.lang.String" itemvalue="tzdata" />
+            <item index="21" class="java.lang.String" itemvalue="cryptography" />
+            <item index="22" class="java.lang.String" itemvalue="zope.interface" />
+            <item index="23" class="java.lang.String" itemvalue="attrs" />
+            <item index="24" class="java.lang.String" itemvalue="bcrypt" />
+            <item index="25" class="java.lang.String" itemvalue="WTForms" />
+            <item index="26" class="java.lang.String" itemvalue="paramiko" />
+            <item index="27" class="java.lang.String" itemvalue="Flask-APScheduler" />
+            <item index="28" class="java.lang.String" itemvalue="PySocks" />
+            <item index="29" class="java.lang.String" itemvalue="colorama" />
+            <item index="30" class="java.lang.String" itemvalue="future" />
+            <item index="31" class="java.lang.String" itemvalue="requests-file" />
+            <item index="32" class="java.lang.String" itemvalue="aiohttp" />
+            <item index="33" class="java.lang.String" itemvalue="multidict" />
+            <item index="34" class="java.lang.String" itemvalue="yarl" />
+            <item index="35" class="java.lang.String" itemvalue="pytz" />
+            <item index="36" class="java.lang.String" itemvalue="aiosignal" />
+            <item index="37" class="java.lang.String" itemvalue="idna" />
+            <item index="38" class="java.lang.String" itemvalue="Pillow" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file

.idea/inspectionProfiles/profiles_settings.xml

+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptSettings">
+    <option name="languageLevel" value="ES6" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8 (financial-system)" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/financial-system.iml" filepath="$PROJECT_DIR$/.idea/financial-system.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

app/demo/crud.py

+from sqlalchemy.orm import Session
+
+from . import models, schemas
+
+
+def get_user(db: Session, user_id: int):
+    return db.query(models.User).filter(models.User.id == user_id).first()
+
+
+def get_user_by_email(db: Session, email: str):
+    return db.query(models.User).filter(models.User.email == email).first()
+
+
+def get_users(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.User).offset(skip).limit(limit).all()
+
+
+def create_user(db: Session, user: schemas.UserCreate):
+    fake_hashed_password = user.password + "notreallyhashed"
+    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+
+def get_items(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Item).offset(skip).limit(limit).all()
+
+
+def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
+    db_item = models.Item(**item.dict(), owner_id=user_id)
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    return db_item

app/demo/models.py

+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+from ...core.storage.db import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+
+    items = relationship("Item", back_populates="owner")
+
+
+class Item(Base):
+    __tablename__ = "items"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, index=True)
+    description = Column(String, index=True)
+    owner_id = Column(Integer, ForeignKey("users.id"))
+
+    owner = relationship("User", back_populates="items")
\ No newline at end of file

app/demo/router.py

+from typing import List
+
+from fastapi import Depends, FastAPI, HTTPException
+from sqlalchemy.orm import Session
+
+from . import crud, models, schemas
+from ...core.storage.db import SessionLocal, engine
+
+models.Base.metadata.create_all(bind=engine)
+
+app = FastAPI()
+
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+@app.get("/items/", response_model=List[schemas.Item])
+def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    items = crud.get_items(db, skip=skip, limit=limit)
+    return items

app/demo/schemas.py

+from typing import List, Union
+
+from pydantic import BaseModel
+
+
+class ItemBase(BaseModel):
+    title: str
+    description: Union[str, None] = None
+
+
+class ItemCreate(ItemBase):
+    pass
+
+
+class Item(ItemBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        orm_mode = True
+
+
+class UserBase(BaseModel):
+    email: str
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class User(UserBase):
+    id: int
+    is_active: bool
+    items: List[Item] = []
+
+    class Config:
+        orm_mode = True

app/users/crud.py

+from sqlalchemy.orm import Session
+
+from app.users import models, schemas
+
+
+def get_user(db: Session, user_id: int):
+    return db.query(models.User).filter(models.User.id == user_id).first()
+
+
+def get_user_by_email(db: Session, email: str):
+    return db.query(models.User).filter(models.User.email == email).first()
+
+
+def get_users(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.User).offset(skip).limit(limit).all()
+
+
+def create_user(db: Session, user: schemas.UserCreate):
+    fake_hashed_password = user.password + "notreallyhashed"
+    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+
+def get_items(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Item).offset(skip).limit(limit).all()
+
+
+def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
+    db_item = models.Item(**item.dict(), owner_id=user_id)
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    return db_item

app/users/models.py

+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+from core.storage.db import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+
+    items = relationship("Item", back_populates="owner")
+
+
+class Item(Base):
+    __tablename__ = "items"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, index=True)
+    description = Column(String, index=True)
+    owner_id = Column(Integer, ForeignKey("users.id"))
+
+    owner = relationship("User", back_populates="items")
\ No newline at end of file

app/users/router.py

+from typing import List
+
+from fastapi import Depends, APIRouter, HTTPException
+from sqlalchemy.orm import Session
+
+from app.users import crud, models, schemas
+from core.storage.db import SessionLocal, engine
+from core.dependencies.auth_dependen import check_token
+
+models.Base.metadata.create_all(bind=engine)
+
+router = APIRouter(prefix='/users',dependencies=[Depends(check_token)])
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.post("/", response_model=schemas.User)
+def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
+    db_user = crud.get_user_by_email(db, email=user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return crud.create_user(db=db, user=user)
+
+
+@router.get("/", response_model=List[schemas.User])
+def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    users = crud.get_users(db, skip=skip, limit=limit)
+    return users
+
+
+@router.get("/{user_id}", response_model=schemas.User)
+def read_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = crud.get_user(db, user_id=user_id)
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return db_user
+
+
+@router.post("/{user_id}/items/", response_model=schemas.Item)
+def create_item_for_user(
+    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
+):
+    return crud.create_user_item(db=db, item=item, user_id=user_id)
+

app/users/schemas.py

+from typing import List, Union
+
+from pydantic import BaseModel
+
+
+class ItemBase(BaseModel):
+    title: str
+    description: Union[str, None] = None
+
+
+class ItemCreate(ItemBase):
+    pass
+
+
+class Item(ItemBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        orm_mode = True
+
+
+class UserBase(BaseModel):
+    email: str
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class User(UserBase):
+    id: int
+    is_active: bool
+    items: List[Item] = []
+
+    class Config:
+        orm_mode = True

core/config/env.py

+""" 
+环境变量配置文件 env.py 
+切换环境，修改文档后面的命令 env = ...
+
+"""
+
+from pydantic import BaseSettings
+
+
+class Env(BaseSettings):
+    DEBUG: bool = False
+    TESTING: bool = False
+    DATABASE_URI: str = 'sqlite://:memory:'
+    DATABASE_USER: str = ''
+    DATABASE_PWD: str = ''
+
+
+class DevelopmentEnv(Env):
+    '''
+    开发环境配置
+    '''
+    DEBUG: bool = True
+
+class TestingEnv(Env):
+    '''
+    测试环境配置
+    '''
+    TESTING: bool = True
+
+class PrehubEnv(Env):
+    '''
+    预发布环境配置
+    '''
+    DATABASE_URI: str = 'mysql://user@localhost/foo'
+
+
+class ProdEnv(Env):
+    '''
+    生产环境配置
+    '''
+    DATABASE_URI: str = 'mysql://user@localhost/foo'
+    DATABASE_USER: str = ''
+    DATABASE_PWD: str = ''
+
+
+env = DevelopmentEnv()  # 开发环境
+# env = TestingEnv()      # 测试环境
+# env = PrehubEnv()       # 预发布环境
+# env = ProdEnv()         # 生产环境
+
+
+
+
+

core/dependencies/auth_dependen.py

+# 导入相关的模块
+from datetime import datetime, timedelta
+from typing import Union,Optional
+
+from fastapi import Depends, APIRouter, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from pydantic import BaseModel
+
+'''定义关于token的相关常量
+SECRET_KEY : 用于加密解密的密钥,只允许服务器知道,打死不告诉别人
+            可以执行 openssl rand -hex 32 获取一串随机的字符
+ALGORITHM  : 定义加密解密所使用的算法
+ACCESS_TOKEN_EXPIRE_MINUTES : token的有效期  
+'''
+SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# 这里定义一个字典,来模拟数据库中的数据,示例：fastapi/secret
+fake_users_db = {
+    "johndoe": {
+        "username": "johndoe",
+        "full_name": "John Doe",
+        "email": "johndoe@example.com",
+        "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
+        "disabled": False,
+    },
+    "fastapi": {
+        "username": "fastapi",
+        "full_name": "fast api",
+        "email": "fastapi@example.com",
+        "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
+        "disabled": False,
+    }
+}
+
+
+class Token(BaseModel):
+    '''定义token的数据模型'''
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    username: Union[str, None] = None
+
+
+class User(BaseModel):
+    '''定义用户的数据模型'''
+    username: str
+    email: Union[str, None] = None
+    full_name: Union[str, None] = None
+    disabled: Union[bool, None] = None
+
+
+class UserInDB(User):
+    hashed_password: str
+
+# 创建一个加密解密上下文环境
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# OAuth2PasswordBearer 是接收 URL 作为参数的一个类
+# 客户端会向该 URL 发送 username 和 password 参数（通过表单的格式发送），然后得到一个 token 值 
+# OAuth2PasswordBearer 并不会创建相应的 URL 路径操作，只是指明了客户端用来获取 token 的目标 URL
+# 客户端发送请求的时候，FastAPI 会检查请求的 Authorization 头信息，如果没有找到 Authorization 头信息
+# 或者头信息的内容不是 Bearer token，它会返回 401 状态码( UNAUTHORIZED )
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+router = APIRouter()
+
+def verify_password(plain_password, hashed_password):
+    '''验证密码是否正确
+    :param plain_password: 明文
+    :param hashed_password: 明文hash值
+    :return:
+    '''
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    '''获取密码的hash值
+    :param password: 欲获取hash的明文密码
+    :return: 返回一个hash字符串
+    '''
+    return pwd_context.hash(password)
+
+def get_user(db, username: str):
+    '''查询用户
+    :param db: 模拟的数据库
+    :param username: 用户名
+    :return: 返回一个用户的BaseModel(其实就是字典的BaseModel对象,二者可互相转换)
+    '''
+    if username in db:
+        user_dict = db[username]
+        return UserInDB(**user_dict)
+
+def authenticate_user(fake_db, username: str, password: str):
+    '''验证用户
+    :param fake_db: 存储用户的数据库（这里是上面用字典模拟的）
+    :param username: 用户名
+    :param password: 密码
+    :return:
+    '''
+    # 从数据库获取用户信息
+    user = get_user(fake_db, username)
+    # 如果获取为空,返回False
+    if not user:
+        return False
+    # 如果密码不正确,也是返回False
+    if not verify_password(password, user.hashed_password):
+        return False
+    # 如果存在此用户,且密码也正确,则返回此用户信息
+    return user
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    '''创建tokens函数
+    :param data: 对用JWT的Payload字段,这里是tokens的载荷,在这里就是用户的信息
+    :param expires_delta: 缺省参数,截止时间
+    :return:
+    '''
+    # 深拷贝data
+    to_encode = data.copy()
+    # 如果携带了截至时间,就单独设置tokens的过期时间
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        # 否则的话,就默认用15分钟
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({'exp': expire})
+    # 编码,至此 JWT tokens诞生
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    '''获取当前用户信息,实际上是一个解密token的过程
+    :param token: 携带的token
+    :return:
+    '''
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail='Could not validate credentials',
+        headers={'WWW-Authenticate': 'Bearer'},
+    )
+    try:
+        # 解密tokens
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        # 从tokens的载荷payload中获取用户名
+        username: str = payload.get('sub')
+        # 如果没有获取到,抛出异常
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    # 从数据库查询用户信息
+    user = get_user(fake_users_db, username=token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user
+
+async def get_current_active_user(current_user: User = Depends(get_current_user)):
+    '''获取当前用户信息,实际上是作为依赖,注入其他路由以使用。
+    :param current_user:
+    :return:
+    '''
+    # 如果用户被禁,抛出异常
+    if current_user.disabled:
+        raise HTTPException(status_code=400, detail='Inactive user')
+    return current_user
+
+async def check_token(current_user: User = Depends(get_current_user)):
+    '''获取当前用户信息,实际上是作为依赖,注入其他路由以使用。
+    :param current_user:
+    :return:
+    '''
+    # 如果用户被禁,抛出异常
+    if current_user.disabled:
+        raise HTTPException(status_code=400, detail='Inactive user')
+    return current_user
+
+@router.post("/token", response_model=Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    '''这里定义了一个接口,路径为 /token, 用于用户申请tokens
+    :param form_data:
+    :return:
+    '''
+    # 首先对用户做出检查
+    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    # 定义tokens过期时间
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    # 创建token
+    access_token = create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    # 返回token信息,JavaScript接收并存储,用于下次访问
+    return {"access_token": access_token, "token_type": "bearer"}
\ No newline at end of file

core/dependencies/base_dependen.py

+from fastapi import Header, HTTPException
+
+
+async def get_token_header(x_token: str = Header()):
+    if x_token != "fake-super-secret-token":
+        raise HTTPException(status_code=400, detail="X-Token header invalid")
+
+
+async def get_query_token(token: str):
+    if token != "jessica":
+        raise HTTPException(status_code=400, detail="No Jessica token provided")
\ No newline at end of file

core/storage/db.py

+# encoding:utf-8
+'''
+创建数据库连接引擎
+'''
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+from core.config.env import env
+
+modul_path = os.path.dirname(os.path.abspath(__file__))  # 此模块所在的绝对路径
+
+# 使用 sqlite 数据库
+SQLALCHEMY_DATABASE_URL = f'sqlite:///{modul_path}/sql_app.db'
+
+# 使用 mysql 数据库
+# SQLALCHEMY_DATABASE_URL = f'mysql://{env.DATABASE_USER}:{env.DATABASE_PWD}@{env.DATABASE_URI}'
+
+# connect_args={'check_same_thread': False} 仅仅在使用 sqlite数据库时有用
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, encoding='utf-8', echo=True, connect_args={'check_same_thread': False}
+)
+
+# 数据库 session 类，用于创建 session 实例
+# autoflush 是指发送数据库语句到数据库，但数据库不一定执行写入到磁盘
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# 创建 Base 类，用于 ORM 模型的继承
+Base = declarative_base()

fast_api/Include/site/python3.8/greenlet/greenlet.h

+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include <Python.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+    PyObject_HEAD
+    PyObject* weakreflist;
+    PyObject* dict;
+    implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+#    define PyGreenlet_Type \
+        (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+#    define PyExc_GreenletError \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+#    define PyExc_GreenletExit \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+#    define PyGreenlet_New                                        \
+        (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+             _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+#    define PyGreenlet_GetCurrent \
+        (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ *         PyGreenlet *greenlet,
+ *         PyObject *typ,
+ *         PyObject *val,
+ *         PyObject *tb)
+ *
+ * g.throw(...)
+ */
+#    define PyGreenlet_Throw                 \
+        (*(PyObject * (*)(PyGreenlet * self, \
+                          PyObject * typ,    \
+                          PyObject * val,    \
+                          PyObject * tb))    \
+             _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+#    define PyGreenlet_Switch                                              \
+        (*(PyObject *                                                      \
+           (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+             _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+#    define PyGreenlet_SetParent                                 \
+        (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+             _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+#     define PyGreenlet_GetParent                                    \
+    (*(PyGreenlet* (*)(PyGreenlet*))                                 \
+     _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+#     define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+#     define PyGreenlet_MAIN                                         \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+#     define PyGreenlet_STARTED                                      \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+#     define PyGreenlet_ACTIVE                                       \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+   keep the older definition to be sure older code that might have a copy of
+   the header still works. */
+#    define PyGreenlet_Import()                                               \
+        {                                                                     \
+            _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+        }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */

fast_api/Lib/site-packages/SQLAlchemy-2.0.0.dist-info/INSTALLER

+pip

fast_api/Lib/site-packages/SQLAlchemy-2.0.0.dist-info/LICENSE

+Copyright 2005-2023 SQLAlchemy authors and contributors <see AUTHORS file>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fast_api/Lib/site-packages/SQLAlchemy-2.0.0.dist-info/METADATA

+Metadata-Version: 2.1
+Name: SQLAlchemy
+Version: 2.0.0
+Summary: Database Abstraction Library
+Home-page: https://www.sqlalchemy.org
+Author: Mike Bayer
+Author-email: mike_mp@zzzcomputing.com
+License: MIT
+Project-URL: Documentation, https://docs.sqlalchemy.org
+Project-URL: Issue Tracker, https://github.com/sqlalchemy/sqlalchemy/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions (>=4.2.0)
+Requires-Dist: greenlet (!=0.4.17) ; platform_machine == "aarch64" or (platform_machine == "ppc64le" or (platform_machine == "x86_64" or (platform_machine == "amd64" or (platform_machine == "AMD64" or (platform_machine == "win32" or platform_machine == "WIN32")))))
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+Provides-Extra: aiomysql
+Requires-Dist: greenlet (!=0.4.17) ; extra == 'aiomysql'
+Requires-Dist: aiomysql ; extra == 'aiomysql'
+Provides-Extra: aiosqlite
+Requires-Dist: greenlet (!=0.4.17) ; extra == 'aiosqlite'
+Requires-Dist: aiosqlite ; extra == 'aiosqlite'
+Requires-Dist: typing-extensions (!=3.10.0.1) ; extra == 'aiosqlite'
+Provides-Extra: asyncio
+Requires-Dist: greenlet (!=0.4.17) ; extra == 'asyncio'
+Provides-Extra: asyncmy
+Requires-Dist: greenlet (!=0.4.17) ; extra == 'asyncmy'
+Requires-Dist: asyncmy (!=0.2.4,>=0.2.3) ; extra == 'asyncmy'
+Provides-Extra: mariadb_connector
+Requires-Dist: mariadb (!=1.1.2,!=1.1.5,>=1.0.1) ; extra == 'mariadb_connector'
+Provides-Extra: mssql
+Requires-Dist: pyodbc ; extra == 'mssql'
+Provides-Extra: mssql_pymssql
+Requires-Dist: pymssql ; extra == 'mssql_pymssql'
+Provides-Extra: mssql_pyodbc
+Requires-Dist: pyodbc ; extra == 'mssql_pyodbc'
+Provides-Extra: mypy
+Requires-Dist: mypy (>=0.910) ; extra == 'mypy'
+Provides-Extra: mysql
+Requires-Dist: mysqlclient (>=1.4.0) ; extra == 'mysql'
+Provides-Extra: mysql_connector
+Requires-Dist: mysql-connector-python ; extra == 'mysql_connector'
+Provides-Extra: oracle
+Requires-Dist: cx-oracle (>=7) ; extra == 'oracle'
+Provides-Extra: oracle_oracledb
+Requires-Dist: oracledb (>=1.0.1) ; extra == 'oracle_oracledb'
+Provides-Extra: postgresql
+Requires-Dist: psycopg2 (>=2.7) ; extra == 'postgresql'
+Provides-Extra: postgresql_asyncpg
+Requires-Dist: greenlet (!=0.4.17) ; extra == 'postgresql_asyncpg'
+Requires-Dist: asyncpg ; extra == 'postgresql_asyncpg'
+Provides-Extra: postgresql_pg8000
+Requires-Dist: pg8000 (>=1.29.1) ; extra == 'postgresql_pg8000'
+Provides-Extra: postgresql_psycopg
+Requires-Dist: psycopg (>=3.0.7) ; extra == 'postgresql_psycopg'
+Provides-Extra: postgresql_psycopg2binary
+Requires-Dist: psycopg2-binary ; extra == 'postgresql_psycopg2binary'
+Provides-Extra: postgresql_psycopg2cffi
+Requires-Dist: psycopg2cffi ; extra == 'postgresql_psycopg2cffi'
+Provides-Extra: pymysql
+Requires-Dist: pymysql ; extra == 'pymysql'
+Provides-Extra: sqlcipher
+Requires-Dist: sqlcipher3-binary ; extra == 'sqlcipher'
+
+SQLAlchemy
+==========
+
+|PyPI| |Python| |Downloads|
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/sqlalchemy
+    :target: https://pypi.org/project/sqlalchemy
+    :alt: PyPI
+
+.. |Python| image:: https://img.shields.io/pypi/pyversions/sqlalchemy
+    :target: https://pypi.org/project/sqlalchemy
+    :alt: PyPI - Python Version
+
+.. |Downloads| image:: https://img.shields.io/pypi/dm/sqlalchemy
+    :target: https://pypi.org/project/sqlalchemy
+    :alt: PyPI - Downloads
+
+
+The Python SQL Toolkit and Object Relational Mapper
+
+Introduction
+-------------
+
+SQLAlchemy is the Python SQL toolkit and Object Relational Mapper
+that gives application developers the full power and
+flexibility of SQL. SQLAlchemy provides a full suite
+of well known enterprise-level persistence patterns,
+designed for efficient and high-performing database
+access, adapted into a simple and Pythonic domain
+language.
+
+Major SQLAlchemy features include:
+
+* An industrial strength ORM, built
+  from the core on the identity map, unit of work,
+  and data mapper patterns.   These patterns
+  allow transparent persistence of objects
+  using a declarative configuration system.
+  Domain models
+  can be constructed and manipulated naturally,
+  and changes are synchronized with the
+  current transaction automatically.
+* A relationally-oriented query system, exposing
+  the full range of SQL's capabilities
+  explicitly, including joins, subqueries,
+  correlation, and most everything else,
+  in terms of the object model.
+  Writing queries with the ORM uses the same
+  techniques of relational composition you use
+  when writing SQL.  While you can drop into
+  literal SQL at any time, it's virtually never
+  needed.
+* A comprehensive and flexible system
+  of eager loading for related collections and objects.
+  Collections are cached within a session,
+  and can be loaded on individual access, all
+  at once using joins, or by query per collection
+  across the full result set.
+* A Core SQL construction system and DBAPI
+  interaction layer.  The SQLAlchemy Core is
+  separate from the ORM and is a full database
+  abstraction layer in its own right, and includes
+  an extensible Python-based SQL expression
+  language, schema metadata, connection pooling,
+  type coercion, and custom types.
+* All primary and foreign key constraints are
+  assumed to be composite and natural.  Surrogate
+  integer primary keys are of course still the
+  norm, but SQLAlchemy never assumes or hardcodes
+  to this model.
+* Database introspection and generation.  Database
+  schemas can be "reflected" in one step into
+  Python structures representing database metadata;
+  those same structures can then generate
+  CREATE statements right back out - all within
+  the Core, independent of the ORM.
+
+SQLAlchemy's philosophy:
+
+* SQL databases behave less and less like object
+  collections the more size and performance start to
+  matter; object collections behave less and less like
+  tables and rows the more abstraction starts to matter.
+  SQLAlchemy aims to accommodate both of these
+  principles.
+* An ORM doesn't need to hide the "R".   A relational
+  database provides rich, set-based functionality
+  that should be fully exposed.   SQLAlchemy's
+  ORM provides an open-ended set of patterns
+  that allow a developer to construct a custom
+  mediation layer between a domain model and
+  a relational schema, turning the so-called
+  "object relational impedance" issue into
+  a distant memory.
+* The developer, in all cases, makes all decisions
+  regarding the design, structure, and naming conventions
+  of both the object model as well as the relational
+  schema.   SQLAlchemy only provides the means
+  to automate the execution of these decisions.
+* With SQLAlchemy, there's no such thing as
+  "the ORM generated a bad query" - you
+  retain full control over the structure of
+  queries, including how joins are organized,
+  how subqueries and correlation is used, what
+  columns are requested.  Everything SQLAlchemy
+  does is ultimately the result of a developer-initiated 
+  decision.
+* Don't use an ORM if the problem doesn't need one.
+  SQLAlchemy consists of a Core and separate ORM
+  component.   The Core offers a full SQL expression
+  language that allows Pythonic construction
+  of SQL constructs that render directly to SQL
+  strings for a target database, returning
+  result sets that are essentially enhanced DBAPI
+  cursors.
+* Transactions should be the norm.  With SQLAlchemy's
+  ORM, nothing goes to permanent storage until
+  commit() is called.  SQLAlchemy encourages applications
+  to create a consistent means of delineating
+  the start and end of a series of operations.
+* Never render a literal value in a SQL statement.
+  Bound parameters are used to the greatest degree
+  possible, allowing query optimizers to cache
+  query plans effectively and making SQL injection
+  attacks a non-issue.
+
+Documentation
+-------------
+
+Latest documentation is at:
+
+https://www.sqlalchemy.org/docs/
+
+Installation / Requirements
+---------------------------
+
+Full documentation for installation is at
+`Installation <https://www.sqlalchemy.org/docs/intro.html#installation>`_.
+
+Getting Help / Development / Bug reporting
+------------------------------------------
+
+Please refer to the `SQLAlchemy Community Guide <https://www.sqlalchemy.org/support.html>`_.
+
+Code of Conduct
+---------------
+
+Above all, SQLAlchemy places great emphasis on polite, thoughtful, and
+constructive communication between users and developers.
+Please see our current Code of Conduct at
+`Code of Conduct <https://www.sqlalchemy.org/codeofconduct.html>`_.
+
+License
+-------
+
+SQLAlchemy is distributed under the `MIT license
+<https://www.opensource.org/licenses/mit-license.php>`_.
+

fast_api/Lib/site-packages/SQLAlchemy-2.0.0.dist-info/WHEEL

+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: false
+Tag: cp38-cp38-win_amd64
+

fast_api/Lib/site-packages/SQLAlchemy-2.0.0.dist-info/top_level.txt

+sqlalchemy

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/INSTALLER

+pip

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/METADATA

+Metadata-Version: 2.1
+Name: anyio
+Version: 3.6.2
+Summary: High level compatibility layer for multiple asynchronous event loop implementations
+Author: Alex Grönholm
+Author-email: alex.gronholm@nextday.fi
+License: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AnyIO
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6.2
+License-File: LICENSE
+Requires-Dist: idna (>=2.8)
+Requires-Dist: sniffio (>=1.1)
+Requires-Dist: contextvars ; python_version < "3.7"
+Requires-Dist: dataclasses ; python_version < "3.7"
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: doc
+Requires-Dist: packaging ; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
+Requires-Dist: sphinx-autodoc-typehints (>=1.2.0) ; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: coverage[toml] (>=4.5) ; extra == 'test'
+Requires-Dist: hypothesis (>=4.0) ; extra == 'test'
+Requires-Dist: pytest (>=7.0) ; extra == 'test'
+Requires-Dist: pytest-mock (>=3.6.1) ; extra == 'test'
+Requires-Dist: trustme ; extra == 'test'
+Requires-Dist: contextlib2 ; (python_version < "3.7") and extra == 'test'
+Requires-Dist: uvloop (<0.15) ; (python_version < "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Requires-Dist: mock (>=4) ; (python_version < "3.8") and extra == 'test'
+Requires-Dist: uvloop (>=0.15) ; (python_version >= "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Provides-Extra: trio
+Requires-Dist: trio (<0.22,>=0.16) ; extra == 'trio'
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+trio_. It implements trio-like `structured concurrency`_ (SC) on top of asyncio, and works in harmony
+with the native SC of trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with native libraries of your chosen backend.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _Hypothesis: https://hypothesis.works/

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/RECORD

+anyio-3.6.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-3.6.2.dist-info/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-3.6.2.dist-info/METADATA,sha256=30LcHBTF6U8AO5jpASPwKp9dqHL3t0MuCADwSLWMFrc,4660
+anyio-3.6.2.dist-info/RECORD,,
+anyio-3.6.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+anyio-3.6.2.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-3.6.2.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=M2R8dk6L5gL5lXHArzpSfEn2oH5jMyUKhzyrkRiv2AM,4037
+anyio/__pycache__/__init__.cpython-38.pyc,,
+anyio/__pycache__/from_thread.cpython-38.pyc,,
+anyio/__pycache__/lowlevel.cpython-38.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-38.pyc,,
+anyio/__pycache__/to_process.cpython-38.pyc,,
+anyio/__pycache__/to_thread.cpython-38.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-38.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-38.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-38.pyc,,
+anyio/_backends/_asyncio.py,sha256=ZJDvRwfS4wv9WWcqWledNJyl8hx8A8-m9-gSKAJ6nBM,69238
+anyio/_backends/_trio.py,sha256=CebCaqr8Szi6uCnUzwtBRLfUitR5OnDT_wfH-KiqvBQ,29696
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-38.pyc,,
+anyio/_core/__pycache__/_compat.cpython-38.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-38.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-38.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-38.pyc,,
+anyio/_core/__pycache__/_resources.cpython-38.pyc,,
+anyio/_core/__pycache__/_signals.cpython-38.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-38.pyc,,
+anyio/_core/__pycache__/_streams.cpython-38.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-38.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-38.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-38.pyc,,
+anyio/_core/__pycache__/_testing.cpython-38.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-38.pyc,,
+anyio/_core/_compat.py,sha256=X99W70r-O-JLdkKNtbddcIY5H2Nyg3Nk34oUYE9WZRs,5790
+anyio/_core/_eventloop.py,sha256=DRn_hy679LtsJFsPX7dXjDv72bLtSFkTnWY9WVVfgCQ,4108
+anyio/_core/_exceptions.py,sha256=1wqraNldZroYkoyB0HZStAruz_7yDCBaW-4zYwsKj8s,2904
+anyio/_core/_fileio.py,sha256=au82uZXZX4fia8EoZq_E-JDwZFKe6ZtI0J6IkxK8FmQ,18298
+anyio/_core/_resources.py,sha256=M_uN-90N8eSsWuvo-0xluWU_OG2BTyccAgsQ7XtHxzs,399
+anyio/_core/_signals.py,sha256=D4btJN527tAADspKBeNKaCds-ZcEZJP8LWM_MjVuQRA,827
+anyio/_core/_sockets.py,sha256=fW_Cbg6kfw4xgYuVuWbcWrAYspOcDSEjwxVATMzf2fo,19820
+anyio/_core/_streams.py,sha256=gjT5xChJ1OoV8nNinljSv1yW4nqUS-QzZzIydQz3exQ,1494
+anyio/_core/_subprocesses.py,sha256=pcchMI2OII0QSjiVxRiTEz4M0B7TlQPzGurfCuka-xc,5049
+anyio/_core/_synchronization.py,sha256=xOOG4hF9783N6E2IcD3YKiukguA5bPrj6BodDsKNaJY,16822
+anyio/_core/_tasks.py,sha256=ebGLjHvwL6I9aGyPwvCig1drebSVYFzvY3pnN3TsB4o,5273
+anyio/_core/_testing.py,sha256=VZka_yebIhJ6mJ6Vo_ilO3Nbz53ieqg0WBijwciMwdY,2196
+anyio/_core/_typedattr.py,sha256=k5-wBvMlDlKHIpn18INVnXAlGwI3CrAvPmWoceHjnOQ,2534
+anyio/abc/__init__.py,sha256=hMa47CMs5O1twC2bBcSbzwX-3Q08BAgAPTRekQobb3E,2123
+anyio/abc/__pycache__/__init__.cpython-38.pyc,,
+anyio/abc/__pycache__/_resources.cpython-38.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-38.pyc,,
+anyio/abc/__pycache__/_streams.cpython-38.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-38.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-38.pyc,,
+anyio/abc/__pycache__/_testing.cpython-38.pyc,,
+anyio/abc/_resources.py,sha256=js737mWPG6IW0fH8W4Tz9eNWLztse7dKxEC61z934Vk,752
+anyio/abc/_sockets.py,sha256=i1VdcJTLAuRlYeZoL6s5RBSWbX62Cu6ln5YZBL2YrWk,5754
+anyio/abc/_streams.py,sha256=0g70fhKAzbnK0KKmWwRgwmKdApBwduAcVj4TpjSzjzU,6501
+anyio/abc/_subprocesses.py,sha256=iREP_YQ91it88lDU4XIcI3HZ9HUvV5UmjQk_sSPonrw,2071
+anyio/abc/_tasks.py,sha256=mQQd1DANqpySKyehVVPdMfi_UEG49zZUJpt5blunOjg,3119
+anyio/abc/_testing.py,sha256=ifKCUPzcQdHAEGO-weu2GQvzjMQPPIWO24mQ0z6zkdU,1928
+anyio/from_thread.py,sha256=nSq6mafYMqwxKmzdJyISg8cp-AyBj9rxZPMt_b7klSM,16497
+anyio/lowlevel.py,sha256=W4ydshns7f86YuSESFc2igTf46AWMXnGPQGsY_Esl2E,4679
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=kWj2B8BJehePJd1sztRBmJBRh8O4hk1oGSYQRlX5Gr8,5134
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-38.pyc,,
+anyio/streams/__pycache__/buffered.cpython-38.pyc,,
+anyio/streams/__pycache__/file.cpython-38.pyc,,
+anyio/streams/__pycache__/memory.cpython-38.pyc,,
+anyio/streams/__pycache__/stapled.cpython-38.pyc,,
+anyio/streams/__pycache__/text.cpython-38.pyc,,
+anyio/streams/__pycache__/tls.cpython-38.pyc,,
+anyio/streams/buffered.py,sha256=FegOSO4Xcxa5SaDfU1A3ZkTTxaPrv6G435Y_giZ8k44,4437
+anyio/streams/file.py,sha256=pujJ-m6BX-gOLnVoZwkE5kh-YDs5Vx9eJFVkvliQ0S4,4353
+anyio/streams/memory.py,sha256=3RGeZoevoGIgBWfD2_X1cqxIPOz-BqQkRf6lUcOnBYc,9209
+anyio/streams/stapled.py,sha256=0E0V15v8M5GVelpHe5RT0S33tQ9hGe4ZCXo_KJEjtt4,4258
+anyio/streams/text.py,sha256=WRFyjsRpBjQKdCmR4ZuzYTEAJqGx2s5oTJmGI1C6Ng0,5014
+anyio/streams/tls.py,sha256=-WXGsMV14XHXAxc38WpBvGusjuY7e449g4UCEHIlnWw,12040
+anyio/to_process.py,sha256=hu0ES3HJC-VEjcdPJMzAzjyTaekaCNToO3coj3jvnus,9247
+anyio/to_thread.py,sha256=VeMQoo8Va2zz0WFk2p123QikDpqk2wYZGw20COC3wqw,2124

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/WHEEL

+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/entry_points.txt

+[pytest11]
+anyio = anyio.pytest_plugin

fast_api/Lib/site-packages/anyio-3.6.2.dist-info/top_level.txt

+anyio

fast_api/Lib/site-packages/anyio/__init__.py

+__all__ = (
+    "maybe_async",
+    "maybe_async_cm",
+    "run",
+    "sleep",
+    "sleep_forever",
+    "sleep_until",
+    "current_time",
+    "get_all_backends",
+    "get_cancelled_exc_class",
+    "BrokenResourceError",
+    "BrokenWorkerProcess",
+    "BusyResourceError",
+    "ClosedResourceError",
+    "DelimiterNotFound",
+    "EndOfStream",
+    "ExceptionGroup",
+    "IncompleteRead",
+    "TypedAttributeLookupError",
+    "WouldBlock",
+    "AsyncFile",
+    "Path",
+    "open_file",
+    "wrap_file",
+    "aclose_forcefully",
+    "open_signal_receiver",
+    "connect_tcp",
+    "connect_unix",
+    "create_tcp_listener",
+    "create_unix_listener",
+    "create_udp_socket",
+    "create_connected_udp_socket",
+    "getaddrinfo",
+    "getnameinfo",
+    "wait_socket_readable",
+    "wait_socket_writable",
+    "create_memory_object_stream",
+    "run_process",
+    "open_process",
+    "create_lock",
+    "CapacityLimiter",
+    "CapacityLimiterStatistics",
+    "Condition",
+    "ConditionStatistics",
+    "Event",
+    "EventStatistics",
+    "Lock",
+    "LockStatistics",
+    "Semaphore",
+    "SemaphoreStatistics",
+    "create_condition",
+    "create_event",
+    "create_semaphore",
+    "create_capacity_limiter",
+    "open_cancel_scope",
+    "fail_after",
+    "move_on_after",
+    "current_effective_deadline",
+    "TASK_STATUS_IGNORED",
+    "CancelScope",
+    "create_task_group",
+    "TaskInfo",
+    "get_current_task",
+    "get_running_tasks",
+    "wait_all_tasks_blocked",
+    "run_sync_in_worker_thread",
+    "run_async_from_thread",
+    "run_sync_from_thread",
+    "current_default_worker_thread_limiter",
+    "create_blocking_portal",
+    "start_blocking_portal",
+    "typed_attribute",
+    "TypedAttributeSet",
+    "TypedAttributeProvider",
+)
+
+from typing import Any
+
+from ._core._compat import maybe_async, maybe_async_cm
+from ._core._eventloop import (
+    current_time,
+    get_all_backends,
+    get_cancelled_exc_class,
+    run,
+    sleep,
+    sleep_forever,
+    sleep_until,
+)
+from ._core._exceptions import (
+    BrokenResourceError,
+    BrokenWorkerProcess,
+    BusyResourceError,
+    ClosedResourceError,
+    DelimiterNotFound,
+    EndOfStream,
+    ExceptionGroup,
+    IncompleteRead,
+    TypedAttributeLookupError,
+    WouldBlock,
+)
+from ._core._fileio import AsyncFile, Path, open_file, wrap_file
+from ._core._resources import aclose_forcefully
+from ._core._signals import open_signal_receiver
+from ._core._sockets import (
+    connect_tcp,
+    connect_unix,
+    create_connected_udp_socket,
+    create_tcp_listener,
+    create_udp_socket,
+    create_unix_listener,
+    getaddrinfo,
+    getnameinfo,
+    wait_socket_readable,
+    wait_socket_writable,
+)
+from ._core._streams import create_memory_object_stream
+from ._core._subprocesses import open_process, run_process
+from ._core._synchronization import (
+    CapacityLimiter,
+    CapacityLimiterStatistics,
+    Condition,
+    ConditionStatistics,
+    Event,
+    EventStatistics,
+    Lock,
+    LockStatistics,
+    Semaphore,
+    SemaphoreStatistics,
+    create_capacity_limiter,
+    create_condition,
+    create_event,
+    create_lock,
+    create_semaphore,
+)
+from ._core._tasks import (
+    TASK_STATUS_IGNORED,
+    CancelScope,
+    create_task_group,
+    current_effective_deadline,
+    fail_after,
+    move_on_after,
+    open_cancel_scope,
+)
+from ._core._testing import (
+    TaskInfo,
+    get_current_task,
+    get_running_tasks,
+    wait_all_tasks_blocked,
+)
+from ._core._typedattr import TypedAttributeProvider, TypedAttributeSet, typed_attribute
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .to_thread import current_default_worker_thread_limiter, run_sync_in_worker_thread
+from .from_thread import (
+    create_blocking_portal,
+    run_async_from_thread,
+    run_sync_from_thread,
+    start_blocking_portal,
+)
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio."):
+        value.__module__ = __name__

fast_api/Lib/site-packages/anyio/_core/_compat.py

+from abc import ABCMeta, abstractmethod
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from warnings import warn
+
+if TYPE_CHECKING:
+    from ._testing import TaskInfo
+else:
+    TaskInfo = object
+
+T = TypeVar("T")
+AnyDeprecatedAwaitable = Union[
+    "DeprecatedAwaitable",
+    "DeprecatedAwaitableFloat",
+    "DeprecatedAwaitableList[T]",
+    TaskInfo,
+]
+
+
+@overload
+async def maybe_async(__obj: TaskInfo) -> TaskInfo:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableFloat") -> float:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableList[T]") -> List[T]:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitable") -> None:
+    ...
+
+
+async def maybe_async(
+    __obj: "AnyDeprecatedAwaitable[T]",
+) -> Union[TaskInfo, float, List[T], None]:
+    """
+    Await on the given object if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were converted from coroutine functions into regular functions.
+
+    Do **not** try to use this for any other purpose!
+
+    :return: the result of awaiting on the object if coroutine, or the object itself otherwise
+
+    .. versionadded:: 2.2
+
+    """
+    return __obj._unwrap()
+
+
+class _ContextManagerWrapper:
+    def __init__(self, cm: ContextManager[T]):
+        self._cm = cm
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+
+def maybe_async_cm(
+    cm: Union[ContextManager[T], AsyncContextManager[T]]
+) -> AsyncContextManager[T]:
+    """
+    Wrap a regular context manager as an async one if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were changed to return regular context managers instead of async ones.
+
+    :param cm: a regular or async context manager
+    :return: an async context manager
+
+    .. versionadded:: 2.2
+
+    """
+    if not isinstance(cm, AbstractContextManager):
+        raise TypeError("Given object is not an context manager")
+
+    return _ContextManagerWrapper(cm)
+
+
+def _warn_deprecation(
+    awaitable: "AnyDeprecatedAwaitable[Any]", stacklevel: int = 1
+) -> None:
+    warn(
+        f'Awaiting on {awaitable._name}() is deprecated. Use "await '
+        f"anyio.maybe_async({awaitable._name}(...)) if you have to support both AnyIO 2.x "
+        f'and 3.x, or just remove the "await" if you are completely migrating to AnyIO 3+.',
+        DeprecationWarning,
+        stacklevel=stacklevel + 1,
+    )
+
+
+class DeprecatedAwaitable:
+    def __init__(self, func: Callable[..., "DeprecatedAwaitable"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, None]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+    def __reduce__(self) -> Tuple[Type[None], Tuple[()]]:
+        return type(None), ()
+
+    def _unwrap(self) -> None:
+        return None
+
+
+class DeprecatedAwaitableFloat(float):
+    def __new__(
+        cls, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]
+    ) -> "DeprecatedAwaitableFloat":
+        return super().__new__(cls, x)
+
+    def __init__(self, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, float]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return float(self)
+
+    def __reduce__(self) -> Tuple[Type[float], Tuple[float]]:
+        return float, (float(self),)
+
+    def _unwrap(self) -> float:
+        return float(self)
+
+
+class DeprecatedAwaitableList(List[T]):
+    def __init__(
+        self,
+        iterable: Iterable[T] = (),
+        *,
+        func: Callable[..., "DeprecatedAwaitableList[T]"],
+    ):
+        super().__init__(iterable)
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, List[T]]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return list(self)
+
+    def __reduce__(self) -> Tuple[Type[List[T]], Tuple[List[T]]]:
+        return list, (list(self),)
+
+    def _unwrap(self) -> List[T]:
+        return list(self)
+
+
+class DeprecatedAsyncContextManager(Generic[T], metaclass=ABCMeta):
+    @abstractmethod
+    def __enter__(self) -> T:
+        pass
+
+    @abstractmethod
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        pass
+
+    async def __aenter__(self) -> T:
+        warn(
+            f"Using {self.__class__.__name__} as an async context manager has been deprecated. "
+            f'Use "async with anyio.maybe_async_cm(yourcontextmanager) as foo:" if you have to '
+            f'support both AnyIO 2.x and 3.x, or just remove the "async" from "async with" if '
+            f"you are completely migrating to AnyIO 3+.",
+            DeprecationWarning,
+        )
+        return self.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self.__exit__(exc_type, exc_val, exc_tb)

fast_api/Lib/site-packages/anyio/_core/_eventloop.py

+import math
+import sys
+import threading
+from contextlib import contextmanager
+from importlib import import_module
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
+
+import sniffio
+
+# This must be updated when new backends are introduced
+from ._compat import DeprecatedAwaitableFloat
+
+BACKENDS = "asyncio", "trio"
+
+T_Retval = TypeVar("T_Retval")
+threadlocals = threading.local()
+
+
+def run(
+    func: Callable[..., Coroutine[Any, Any, T_Retval]],
+    *args: object,
+    backend: str = "asyncio",
+    backend_options: Optional[Dict[str, Any]] = None,
+) -> T_Retval:
+    """
+    Run the given coroutine function in an asynchronous event loop.
+
+    The current thread must not be already running an event loop.
+
+    :param func: a coroutine function
+    :param args: positional arguments to ``func``
+    :param backend: name of the asynchronous event loop implementation – currently either
+        ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()`` implementation with
+        (documented :ref:`here <backend options>`)
+    :return: the return value of the coroutine function
+    :raises RuntimeError: if an asynchronous event loop is already running in this thread
+    :raises LookupError: if the named backend is not found
+
+    """
+    try:
+        asynclib_name = sniffio.current_async_library()
+    except sniffio.AsyncLibraryNotFoundError:
+        pass
+    else:
+        raise RuntimeError(f"Already running {asynclib_name} in this thread")
+
+    try:
+        asynclib = import_module(f"..._backends._{backend}", package=__name__)
+    except ImportError as exc:
+        raise LookupError(f"No such backend: {backend}") from exc
+
+    token = None
+    if sniffio.current_async_library_cvar.get(None) is None:
+        # Since we're in control of the event loop, we can cache the name of the async library
+        token = sniffio.current_async_library_cvar.set(backend)
+
+    try:
+        backend_options = backend_options or {}
+        return asynclib.run(func, *args, **backend_options)
+    finally:
+        if token:
+            sniffio.current_async_library_cvar.reset(token)
+
+
+async def sleep(delay: float) -> None:
+    """
+    Pause the current task for the specified duration.
+
+    :param delay: the duration, in seconds
+
+    """
+    return await get_asynclib().sleep(delay)
+
+
+async def sleep_forever() -> None:
+    """
+    Pause the current task until it's cancelled.
+
+    This is a shortcut for ``sleep(math.inf)``.
+
+    .. versionadded:: 3.1
+
+    """
+    await sleep(math.inf)
+
+
+async def sleep_until(deadline: float) -> None:
+    """
+    Pause the current task until the given time.
+
+    :param deadline: the absolute time to wake up at (according to the internal monotonic clock of
+        the event loop)
+
+    .. versionadded:: 3.1
+
+    """
+    now = current_time()
+    await sleep(max(deadline - now, 0))
+
+
+def current_time() -> DeprecatedAwaitableFloat:
+    """
+    Return the current value of the event loop's internal clock.
+
+    :return: the clock value (seconds)
+
+    """
+    return DeprecatedAwaitableFloat(get_asynclib().current_time(), current_time)
+
+
+def get_all_backends() -> Tuple[str, ...]:
+    """Return a tuple of the names of all built-in backends."""
+    return BACKENDS
+
+
+def get_cancelled_exc_class() -> Type[BaseException]:
+    """Return the current async library's cancellation exception class."""
+    return get_asynclib().CancelledError
+
+
+#
+# Private API
+#
+
+
+@contextmanager
+def claim_worker_thread(backend: str) -> Generator[Any, None, None]:
+    module = sys.modules["anyio._backends._" + backend]
+    threadlocals.current_async_module = module
+    try:
+        yield
+    finally:
+        del threadlocals.current_async_module
+
+
+def get_asynclib(asynclib_name: Optional[str] = None) -> Any:
+    if asynclib_name is None:
+        asynclib_name = sniffio.current_async_library()
+
+    modulename = "anyio._backends._" + asynclib_name
+    try:
+        return sys.modules[modulename]
+    except KeyError:
+        return import_module(modulename)

fast_api/Lib/site-packages/anyio/_core/_exceptions.py

+from traceback import format_exception
+from typing import List
+
+
+class BrokenResourceError(Exception):
+    """
+    Raised when trying to use a resource that has been rendered unusable due to external causes
+    (e.g. a send stream whose peer has disconnected).
+    """
+
+
+class BrokenWorkerProcess(Exception):
+    """
+    Raised by :func:`run_sync_in_process` if the worker process terminates abruptly or otherwise
+    misbehaves.
+    """
+
+
+class BusyResourceError(Exception):
+    """Raised when two tasks are trying to read from or write to the same resource concurrently."""
+
+    def __init__(self, action: str):
+        super().__init__(f"Another task is already {action} this resource")
+
+
+class ClosedResourceError(Exception):
+    """Raised when trying to use a resource that has been closed."""
+
+
+class DelimiterNotFound(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    maximum number of bytes has been read without the delimiter being found.
+    """
+
+    def __init__(self, max_bytes: int) -> None:
+        super().__init__(
+            f"The delimiter was not found among the first {max_bytes} bytes"
+        )
+
+
+class EndOfStream(Exception):
+    """Raised when trying to read from a stream that has been closed from the other end."""
+
+
+class ExceptionGroup(BaseException):
+    """
+    Raised when multiple exceptions have been raised in a task group.
+
+    :var ~typing.Sequence[BaseException] exceptions: the sequence of exceptions raised together
+    """
+
+    SEPARATOR = "----------------------------\n"
+
+    exceptions: List[BaseException]
+
+    def __str__(self) -> str:
+        tracebacks = [
+            "".join(format_exception(type(exc), exc, exc.__traceback__))
+            for exc in self.exceptions
+        ]
+        return (
+            f"{len(self.exceptions)} exceptions were raised in the task group:\n"
+            f"{self.SEPARATOR}{self.SEPARATOR.join(tracebacks)}"
+        )
+
+    def __repr__(self) -> str:
+        exception_reprs = ", ".join(repr(exc) for exc in self.exceptions)
+        return f"<{self.__class__.__name__}: {exception_reprs}>"
+
+
+class IncompleteRead(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    connection is closed before the requested amount of bytes has been read.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The stream was closed before the read operation could be completed"
+        )
+
+
+class TypedAttributeLookupError(LookupError):
+    """
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute is not
+    found and no default value has been given.
+    """
+
+
+class WouldBlock(Exception):
+    """Raised by ``X_nowait`` functions if ``X()`` would block."""

fast_api/Lib/site-packages/anyio/_core/_resources.py

+from ..abc import AsyncResource
+from ._tasks import CancelScope
+
+
+async def aclose_forcefully(resource: AsyncResource) -> None:
+    """
+    Close an asynchronous resource in a cancelled scope.
+
+    Doing this closes the resource without waiting on anything.
+
+    :param resource: the resource to close
+
+    """
+    with CancelScope() as scope:
+        scope.cancel()
+        await resource.aclose()

fast_api/Lib/site-packages/anyio/_core/_signals.py

+from typing import AsyncIterator
+
+from ._compat import DeprecatedAsyncContextManager
+from ._eventloop import get_asynclib
+
+
+def open_signal_receiver(
+    *signals: int,
+) -> DeprecatedAsyncContextManager[AsyncIterator[int]]:
+    """
+    Start receiving operating system signals.
+
+    :param signals: signals to receive (e.g. ``signal.SIGINT``)
+    :return: an asynchronous context manager for an asynchronous iterator which yields signal
+        numbers
+
+    .. warning:: Windows does not support signals natively so it is best to avoid relying on this
+        in cross-platform applications.
+
+    .. warning:: On asyncio, this permanently replaces any previous signal handler for the given
+        signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
+
+    """
+    return get_asynclib().open_signal_receiver(*signals)

fast_api/Lib/site-packages/anyio/_core/_streams.py

+import math
+from typing import Any, Optional, Tuple, Type, TypeVar, overload
+
+from ..streams.memory import (
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+    MemoryObjectStreamState,
+)
+
+T_Item = TypeVar("T_Item")
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float, item_type: Type[T_Item]
+) -> Tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
+    ...
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float = 0,
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    ...
+
+
+def create_memory_object_stream(
+    max_buffer_size: float = 0, item_type: Optional[Type[T_Item]] = None
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    """
+    Create a memory object stream.
+
+    :param max_buffer_size: number of items held in the buffer until ``send()`` starts blocking
+    :param item_type: type of item, for marking the streams with the right generic type for
+        static typing (not used at run time)
+    :return: a tuple of (send stream, receive stream)
+
+    """
+    if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
+        raise ValueError("max_buffer_size must be either an integer or math.inf")
+    if max_buffer_size < 0:
+        raise ValueError("max_buffer_size cannot be negative")
+
+    state: MemoryObjectStreamState = MemoryObjectStreamState(max_buffer_size)
+    return MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)

fast_api/Lib/site-packages/anyio/_core/_subprocesses.py

+from io import BytesIO
+from os import PathLike
+from subprocess import DEVNULL, PIPE, CalledProcessError, CompletedProcess
+from typing import (
+    IO,
+    Any,
+    AsyncIterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from ..abc import Process
+from ._eventloop import get_asynclib
+from ._tasks import create_task_group
+
+
+async def run_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    input: Optional[bytes] = None,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    check: bool = True,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> "CompletedProcess[bytes]":
+    """
+    Run an external command in a subprocess and wait until it completes.
+
+    .. seealso:: :func:`subprocess.run`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param input: bytes passed to the standard input of the subprocess
+    :param stdout: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL` or
+        :data:`subprocess.STDOUT`
+    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the process
+        terminates with a return code other than 0
+    :param cwd: If not ``None``, change the working directory to this before running the command
+    :param env: if not ``None``, this mapping replaces the inherited environment variables from the
+        parent process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an object representing the completed process
+    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process exits with a
+        nonzero return code
+
+    """
+
+    async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
+        buffer = BytesIO()
+        async for chunk in stream:
+            buffer.write(chunk)
+
+        stream_contents[index] = buffer.getvalue()
+
+    async with await open_process(
+        command,
+        stdin=PIPE if input else DEVNULL,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    ) as process:
+        stream_contents: List[Optional[bytes]] = [None, None]
+        try:
+            async with create_task_group() as tg:
+                if process.stdout:
+                    tg.start_soon(drain_stream, process.stdout, 0)
+                if process.stderr:
+                    tg.start_soon(drain_stream, process.stderr, 1)
+                if process.stdin and input:
+                    await process.stdin.send(input)
+                    await process.stdin.aclose()
+
+                await process.wait()
+        except BaseException:
+            process.kill()
+            raise
+
+    output, errors = stream_contents
+    if check and process.returncode != 0:
+        raise CalledProcessError(cast(int, process.returncode), command, output, errors)
+
+    return CompletedProcess(command, cast(int, process.returncode), output, errors)
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    stdin: Union[int, IO[Any], None] = PIPE,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    """
+    Start an external command in a subprocess.
+
+    .. seealso:: :class:`subprocess.Popen`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
+        file-like object, or ``None``
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or ``None``
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or ``None``
+    :param cwd: If not ``None``, the working directory is changed before executing
+    :param env: If env is not ``None``, it must be a mapping that defines the environment
+        variables for the new process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an asynchronous process object
+
+    """
+    shell = isinstance(command, str)
+    return await get_asynclib().open_process(
+        command,
+        shell=shell,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    )

fast_api/Lib/site-packages/anyio/_core/_testing.py

+from typing import Any, Awaitable, Generator, Optional, Union
+
+from ._compat import DeprecatedAwaitableList, _warn_deprecation
+from ._eventloop import get_asynclib
+
+
+class TaskInfo:
+    """
+    Represents an asynchronous task.
+
+    :ivar int id: the unique identifier of the task
+    :ivar parent_id: the identifier of the parent task, if any
+    :vartype parent_id: Optional[int]
+    :ivar str name: the description of the task (if any)
+    :ivar ~collections.abc.Coroutine coro: the coroutine object of the task
+    """
+
+    __slots__ = "_name", "id", "parent_id", "name", "coro"
+
+    def __init__(
+        self,
+        id: int,
+        parent_id: Optional[int],
+        name: Optional[str],
+        coro: Union[Generator, Awaitable[Any]],
+    ):
+        func = get_current_task
+        self._name = f"{func.__module__}.{func.__qualname__}"
+        self.id: int = id
+        self.parent_id: Optional[int] = parent_id
+        self.name: Optional[str] = name
+        self.coro: Union[Generator, Awaitable[Any]] = coro
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, TaskInfo):
+            return self.id == other.id
+
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
+
+    def __await__(self) -> Generator[None, None, "TaskInfo"]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return self
+
+    def _unwrap(self) -> "TaskInfo":
+        return self
+
+
+def get_current_task() -> TaskInfo:
+    """
+    Return the current task.
+
+    :return: a representation of the current task
+
+    """
+    return get_asynclib().get_current_task()
+
+
+def get_running_tasks() -> DeprecatedAwaitableList[TaskInfo]:
+    """
+    Return a list of running tasks in the current event loop.
+
+    :return: a list of task info objects
+
+    """
+    tasks = get_asynclib().get_running_tasks()
+    return DeprecatedAwaitableList(tasks, func=get_running_tasks)
+
+
+async def wait_all_tasks_blocked() -> None:
+    """Wait until all other tasks are waiting for something."""
+    await get_asynclib().wait_all_tasks_blocked()

fast_api/Lib/site-packages/anyio/abc/_resources.py

+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+class AsyncResource(metaclass=ABCMeta):
+    """
+    Abstract base class for all closeable asynchronous resources.
+
+    Works as an asynchronous context manager which returns the instance itself on enter, and calls
+    :meth:`aclose` on exit.
+    """
+
+    async def __aenter__(self: T) -> T:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    @abstractmethod
+    async def aclose(self) -> None:
+        """Close the resource."""

fast_api/Lib/site-packages/click-8.1.3.dist-info/INSTALLER

+pip

fast_api/Lib/site-packages/click-8.1.3.dist-info/WHEEL

+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fast_api/Lib/site-packages/click-8.1.3.dist-info/top_level.txt

+click