Logging updates

app/db_engine.py

@@ -19,11 +19,7 @@ db = SqliteDatabase(
 )
 
 date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=f'logs/database/{date}.log',
-    format='%(asctime)s - database - %(levelname)s - %(message)s',
-    level=logging.INFO
-)
 
 
 """
@@ -69,10 +65,10 @@ def complex_data_to_csv(complex_data: List):
     else:
         data_list = [[x for x in complex_data[0].keys()]]
         for line in complex_data:
-            logging.info(f'line: {line}')
+            logger.info(f'line: {line}')
             this_row = []
             for key in line:
-                logging.info(f'key: {key}')
+                logger.info(f'key: {key}')
                 if line[key] is None:
                     this_row.append('')
 

app/dependencies.py

@@ -5,21 +5,10 @@ import os
 from fastapi.security import OAuth2PasswordBearer
 
 date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
-LOG_DATA = {
+logger = logging.getLogger('discord_app')
-    'filename': f'logs/database/{date}.log',
-    'format': '%(asctime)s - database - %(levelname)s - %(message)s',
-    'log_level': logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
-}
-
-
-logging.basicConfig(
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 # date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
-# log_level = logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
+# log_level = logger.info if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
 # logging.basicConfig(
 #     filename=f'logs/database/{date}.log',
 #     format='%(asctime)s - sba-database - %(levelname)s - %(message)s',

app/main.py

@@ -1,5 +1,6 @@
 import datetime
 import logging
+from logging.handlers import RotatingFileHandler
 import os
 
 from fastapi import Depends, FastAPI, Request
@@ -13,23 +14,36 @@ from .routers_v3 import current, players, results, schedules, standings, teams,
     pitchingstats, fieldingstats, draftpicks, draftlist, managers, awards, draftdata, keepers, stratgame, stratplay, \
     injuries, decisions, divisions
 
-date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
+# date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
-log_level = logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
+log_level = logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else logging.WARNING
-logging.basicConfig(
+# logging.basicConfig(
-    filename=f'logs/database/{date}.log',
+#     filename=f'logs/database/{date}.log',
-    format='%(asctime)s - sba-database - %(levelname)s - %(message)s',
+#     format='%(asctime)s - sba-database - %(levelname)s - %(message)s',
-    level=log_level
+#     level=log_level
+# )
+logger = logging.getLogger('discord_app')
+logger.setLevel(log_level)
+
+handler = RotatingFileHandler(
+    filename='logs/sba-database.log',
+    # encoding='utf-8',
+    maxBytes=32 * 1024 * 1024,  # 32 MiB
+    backupCount=5,  # Rotate through 5 files
 )
 
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
 app = FastAPI(
-    root_path='/api',
+    # root_path='/api',
     responses={404: {'description': 'Not found'}},
     docs_url='/api/docs',
     redoc_url='/api/redoc'
 )
 
 
-logging.info(f'Starting up now...')
+logger.info(f'Starting up now...')
 
 
 app.include_router(current.router)
@@ -54,7 +68,7 @@ app.include_router(injuries.router)
 app.include_router(decisions.router)
 app.include_router(divisions.router)
 
-logging.info(f'Loaded all routers.')
+logger.info(f'Loaded all routers.')
 
 
 @app.get("/api/docs", include_in_schema=False)

app/routers_v3/awards.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Award, Team, Player, Manager, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/awards',
@@ -88,7 +84,7 @@ async def patch_award(
         image: Optional[str] = None, manager1_id: Optional[int] = None, manager2_id: Optional[int] = None,
         player_id: Optional[int] = None, team_id: Optional[int] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_award = Award.get_or_none(Award.id == award_id)
@@ -125,7 +121,7 @@ async def patch_award(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_award(award_list: AwardList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_awards = []
@@ -152,7 +148,7 @@ async def post_award(award_list: AwardList, token: str = Depends(oauth2_scheme))
 @router.delete('/{award_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_award(award_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_award = Award.get_or_none(Award.id == award_id)

app/routers_v3/battingstats.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, BattingStat, Team, Player, Current, model_to_dict, chunked, fn, per_season_weeks
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/battingstats',
@@ -270,7 +266,7 @@ async def get_totalstats(
 @router.patch('/{stat_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def patch_batstats(stat_id: int, new_stats: BatStatModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_batstats - Bad Token: {token}')
+        logger.warning(f'patch_batstats - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if BattingStat.get_or_none(BattingStat.id == stat_id) is None:
@@ -285,7 +281,7 @@ async def patch_batstats(stat_id: int, new_stats: BatStatModel, token: str = Dep
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_batstats(s_list: BatStatList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_batstats - Bad Token: {token}')
+        logger.warning(f'post_batstats - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     all_stats = []

app/routers_v3/current.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Current, model_to_dict
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/current',
@@ -55,7 +51,7 @@ async def patch_current(
         bet_week: Optional[int] = None, trade_deadline: Optional[int] = None, pick_trade_start: Optional[int] = None,
         pick_trade_end: Optional[int] = None, injury_count: Optional[int] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_current - Bad Token: {token}')
+        logger.warning(f'patch_current - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     try:
@@ -98,7 +94,7 @@ async def patch_current(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_current(new_current: CurrentModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_current - Bad Token: {token}')
+        logger.warning(f'patch_current - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_current = Current(**new_current.dict())
@@ -115,7 +111,7 @@ async def post_current(new_current: CurrentModel, token: str = Depends(oauth2_sc
 @router.delete('/{current_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_current(current_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_current - Bad Token: {token}')
+        logger.warning(f'patch_current - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if Current.delete_by_id(current_id) == 1:

app/routers_v3/decisions.py

@@ -5,13 +5,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Decision, StratGame, Player, model_to_dict, chunked, fn, Team
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/decisions',
@@ -132,7 +128,7 @@ async def patch_decision(
         irunners_scored: Optional[int] = None, rest_ip: Optional[int] = None, rest_required: Optional[int] = None,
         token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_decision - Bad Token: {token}')
+        logger.warning(f'patch_decision - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_dec = Decision.get_or_none(Decision.id == decision_id)
@@ -171,7 +167,7 @@ async def patch_decision(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_decisions(dec_list: DecisionList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_decisions - Bad Token: {token}')
+        logger.warning(f'post_decisions - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_dec = []
@@ -194,7 +190,7 @@ async def post_decisions(dec_list: DecisionList, token: str = Depends(oauth2_sch
 @router.delete('/{decision_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_decision(decision_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_decision - Bad Token: {token}')
+        logger.warning(f'delete_decision - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_dec = Decision.get_or_none(Decision.id == decision_id)
@@ -214,7 +210,7 @@ async def delete_decision(decision_id: int, token: str = Depends(oauth2_scheme))
 @router.delete('/game/{game_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_decisions_game(game_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_decisions_game - Bad Token: {token}')
+        logger.warning(f'delete_decisions_game - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_game = StratGame.get_or_none(StratGame.id == game_id)

app/routers_v3/divisions.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Division, Team, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/divisions',
@@ -66,7 +62,7 @@ async def patch_division(
         division_id: int, div_name: Optional[str] = None, div_abbrev: Optional[str] = None,
         lg_name: Optional[str] = None, lg_abbrev: Optional[str] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_division - Bad Token: {token}')
+        logger.warning(f'patch_division - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_div = Division.get_or_none(Division.id == division_id)
@@ -95,7 +91,7 @@ async def patch_division(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_division(new_division: DivisionModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_division - Bad Token: {token}')
+        logger.warning(f'post_division - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_division = Division(**new_division.dict())
@@ -112,7 +108,7 @@ async def post_division(new_division: DivisionModel, token: str = Depends(oauth2
 @router.delete('/{division_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_division(division_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_division - Bad Token: {token}')
+        logger.warning(f'delete_division - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_div = Division.get_or_none(Division.id == division_id)

app/routers_v3/draftdata.py

@@ -6,13 +6,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, DraftData, model_to_dict
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/draftdata',
@@ -24,9 +20,9 @@ class DraftDataModel(pydantic.BaseModel):
     currentpick: int
     timer: bool
     pick_deadline: datetime.datetime
-    result_channel_id = int
+    result_channel_id: int
-    ping_channel_id = int
+    ping_channel_id: int
-    pick_minutes = int
+    pick_minutes: int
 
 
 @router.get('')
@@ -47,7 +43,7 @@ async def patch_draftdata(
         pick_deadline: Optional[datetime.datetime] = None, result_channel: Optional[int] = None,
         ping_channel: Optional[int] = None, pick_minutes: Optional[int] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_draftdata - Bad Token: {token}')
+        logger.warning(f'patch_draftdata - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     draft_data = DraftData.get_or_none(DraftData.id == data_id)

app/routers_v3/draftlist.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, DraftList, Team, model_to_dict, chunked
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/draftlist',
@@ -34,7 +30,7 @@ class DraftListList(pydantic.BaseModel):
 async def get_draftlist(
         season: Optional[int], team_id: list = Query(default=None), token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'get_draftlist - Bad Token: {token}')
+        logger.warning(f'get_draftlist - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     all_list = DraftList.select()
@@ -56,7 +52,7 @@ async def get_draftlist(
 @router.get('/team/{team_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def get_team_draftlist(team_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_draftlist - Bad Token: {token}')
+        logger.warning(f'post_draftlist - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_team = Team.get_or_none(Team.id == team_id)
@@ -76,7 +72,7 @@ async def get_team_draftlist(team_id: int, token: str = Depends(oauth2_scheme)):
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_draftlist(draft_list: DraftListList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_draftlist - Bad Token: {token}')
+        logger.warning(f'post_draftlist - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_list = []

app/routers_v3/draftpicks.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, DraftPick, Team, model_to_dict, chunked
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/draftpicks',
@@ -122,7 +118,7 @@ async def get_one_pick(pick_id: int, short_output: Optional[bool] = False):
 @router.patch('/{pick_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def patch_pick(pick_id: int, new_pick: DraftPickModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_pick - Bad Token: {token}')
+        logger.warning(f'patch_pick - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if DraftPick.get_or_none(DraftPick.id == pick_id) is None:
@@ -137,7 +133,7 @@ async def patch_pick(pick_id: int, new_pick: DraftPickModel, token: str = Depend
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_picks(p_list: DraftPickList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_picks - Bad Token: {token}')
+        logger.warning(f'post_picks - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_picks = []
@@ -163,7 +159,7 @@ async def post_picks(p_list: DraftPickList, token: str = Depends(oauth2_scheme))
 @router.delete('/{pick_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_pick(pick_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_pick - Bad Token: {token}')
+        logger.warning(f'delete_pick - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_pick = DraftPick.get_or_none(DraftPick.id == pick_id)

app/routers_v3/fieldingstats.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, BattingStat, Team, Player, Current, model_to_dict, chunked, fn, per_season_weeks
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA
+from ..dependencies import oauth2_scheme, valid_token
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/fieldingstats',

app/routers_v3/injuries.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Injury, Player, model_to_dict, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/injuries',
@@ -70,7 +66,7 @@ async def get_injuries(
 @router.patch('/{injury_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def patch_injury(injury_id: int, is_active: Optional[bool] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_injury - Bad Token: {token}')
+        logger.warning(f'patch_injury - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_injury = Injury.get_or_none(Injury.id == injury_id)
@@ -93,7 +89,7 @@ async def patch_injury(injury_id: int, is_active: Optional[bool] = None, token:
 @router.post(f'', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_injury(new_injury: InjuryModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_injury - Bad Token: {token}')
+        logger.warning(f'post_injury - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_injury = Injury(**new_injury.dict())
@@ -110,7 +106,7 @@ async def post_injury(new_injury: InjuryModel, token: str = Depends(oauth2_schem
 @router.delete('/{injury_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_injury(injury_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_injury - Bad Token: {token}')
+        logger.warning(f'delete_injury - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_injury = Injury.get_or_none(Injury.id == injury_id)

app/routers_v3/keepers.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Keeper, Player, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/keepers',
@@ -55,7 +51,7 @@ async def patch_keeper(
         keeper_id: int, season: Optional[int] = None, team_id: Optional[int] = None, player_id: Optional[int] = None,
         token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_keeper - Bad Token: {token}')
+        logger.warning(f'patch_keeper - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_keeper = Keeper.get_or_none(Keeper.id == keeper_id)
@@ -81,7 +77,7 @@ async def patch_keeper(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_keepers(k_list: KeeperList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_keepers - Bad Token: {token}')
+        logger.warning(f'post_keepers - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_keepers = []
@@ -99,7 +95,7 @@ async def post_keepers(k_list: KeeperList, token: str = Depends(oauth2_scheme)):
 @router.delete('/{keeper_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_keeper(keeper_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_keeper - Bad Token: {token}')
+        logger.warning(f'delete_keeper - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_keeper = Keeper.get_or_none(Keeper.id == keeper_id)

app/routers_v3/managers.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Manager, Team, Current, model_to_dict, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/managers',
@@ -34,28 +30,28 @@ async def get_managers(
         t_query = t_query.where(
             ~(Team.abbrev.endswith('IL')) & ~(Team.abbrev.endswith('MiL'))
         )
-        logging.info(f'tquery: {t_query}')
+        logger.info(f'tquery: {t_query}')
         a_mgr = []
         i_mgr = []
 
         for x in t_query:
-            logging.info(f'Team: {x.abbrev} / mgr1: {x.manager1} / mgr2: {x.manager2}')
+            logger.info(f'Team: {x.abbrev} / mgr1: {x.manager1} / mgr2: {x.manager2}')
             if x.manager1 is not None:
                 a_mgr.append(x.manager1)
-                logging.info(f'appending {x.manager1.name}')
+                logger.info(f'appending {x.manager1.name}')
             if x.manager2 is not None:
                 a_mgr.append(x.manager2)
-                logging.info(f'appending {x.manager2.name}')
+                logger.info(f'appending {x.manager2.name}')
 
-        logging.info(f'a_mgr: {a_mgr}')
+        logger.info(f'a_mgr: {a_mgr}')
         if active:
             final_mgrs = [model_to_dict(y, recurse=not short_output) for y in a_mgr]
         else:
-            logging.info(f'checking inactive')
+            logger.info(f'checking inactive')
             for z in Manager.select():
-                logging.info(f'checking: {z.name}')
+                logger.info(f'checking: {z.name}')
                 if z not in a_mgr:
-                    logging.info(f'+inactive: {z.name}')
+                    logger.info(f'+inactive: {z.name}')
                     i_mgr.append(z)
             final_mgrs = [model_to_dict(y, recurse=not short_output) for y in i_mgr]
 
@@ -95,7 +91,7 @@ async def patch_manager(
         manager_id: int, name: Optional[str] = None, image: Optional[str] = None, headline: Optional[str] = None,
         bio: Optional[str] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_manager - Bad Token: {token}')
+        logger.warning(f'patch_manager - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_manager = Manager.get_or_none(Manager.id == manager_id)
@@ -124,7 +120,7 @@ async def patch_manager(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_manager(new_manager: ManagerModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_manager - Bad Token: {token}')
+        logger.warning(f'post_manager - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_manager = Manager(**new_manager.dict())
@@ -141,7 +137,7 @@ async def post_manager(new_manager: ManagerModel, token: str = Depends(oauth2_sc
 @router.delete('/{manager_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_manager(manager_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_manager - Bad Token: {token}')
+        logger.warning(f'delete_manager - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_manager = Manager.get_or_none(Manager.id == manager_id)

app/routers_v3/pitchingstats.py

@@ -7,13 +7,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, PitchingStat, Team, Player, Current, model_to_dict, chunked, fn, per_season_weeks
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/pitchingstats',
@@ -235,7 +231,7 @@ async def get_totalstats(
 @router.patch('/{stat_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def patch_pitstats(stat_id: int, new_stats: PitStatModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_pitstats - Bad Token: {token}')
+        logger.warning(f'patch_pitstats - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if PitchingStat.get_or_none(PitchingStat.id == stat_id) is None:
@@ -250,7 +246,7 @@ async def patch_pitstats(stat_id: int, new_stats: PitStatModel, token: str = Dep
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_pitstats(s_list: PitStatList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_pitstats - Bad Token: {token}')
+        logger.warning(f'post_pitstats - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     all_stats = []

app/routers_v3/players.py

@@ -5,13 +5,9 @@ import pydantic
 from pandas import DataFrame
 
 from ..db_engine import db, Player, model_to_dict, chunked, fn, complex_data_to_csv
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/players',
@@ -138,7 +134,7 @@ async def get_one_player(player_id: int, short_output: Optional[bool] = False):
 async def put_player(
         player_id: int, new_player: PlayerModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if Player.get_or_none(Player.id == player_id) is None:
@@ -162,7 +158,7 @@ async def patch_player(
         il_return: Optional[str] = None, demotion_week: Optional[int] = None, strat_code: Optional[str] = None,
         bbref_id: Optional[str] = None, injury_rating: Optional[str] = None):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if Player.get_or_none(Player.id == player_id) is None:
@@ -234,7 +230,7 @@ async def patch_player(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_players(p_list: PlayerList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_players - Bad Token: {token}')
+        logger.warning(f'post_players - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_players = []
@@ -260,7 +256,7 @@ async def post_players(p_list: PlayerList, token: str = Depends(oauth2_scheme)):
 @router.delete('/{player_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_player(player_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_player - Bad Token: {token}')
+        logger.warning(f'delete_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_player = Player.get_or_none(Player.id == player_id)

app/routers_v3/results.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Result, Team, model_to_dict, chunked
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/results',
@@ -96,7 +92,7 @@ async def patch_result(
         home_score: Optional[int] = None, season: Optional[int] = None, scorecard_url: Optional[str] = None,
         token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_result = Result.get_or_none(Result.id == result_id)
@@ -139,7 +135,7 @@ async def patch_result(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_results(result_list: ResultList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_player - Bad Token: {token}')
+        logger.warning(f'patch_player - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_results = []
@@ -162,7 +158,7 @@ async def post_results(result_list: ResultList, token: str = Depends(oauth2_sche
 @router.delete('/{result_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_result(result_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_result - Bad Token: {token}')
+        logger.warning(f'delete_result - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_result = Result.get_or_none(Result.id == result_id)

app/routers_v3/schedules.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Schedule, Team, model_to_dict, chunked
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/schedules',
@@ -90,7 +86,7 @@ async def patch_schedule(
         hometeam_id: Optional[int] = None, gamecount: Optional[int] = None, season: Optional[int] = None,
         token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_schedule - Bad Token: {token}')
+        logger.warning(f'patch_schedule - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_sched = Schedule.get_or_none(Schedule.id == schedule_id)
@@ -124,7 +120,7 @@ async def patch_schedule(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_schedules(sched_list: ScheduleList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_schedules - Bad Token: {token}')
+        logger.warning(f'post_schedules - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_sched = []
@@ -147,7 +143,7 @@ async def post_schedules(sched_list: ScheduleList, token: str = Depends(oauth2_s
 @router.delete('/{schedule_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_schedule(schedule_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_schedule - Bad Token: {token}')
+        logger.warning(f'delete_schedule - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_sched = Schedule.get_or_none(Schedule.id == schedule_id)

app/routers_v3/standings.py

@@ -4,13 +4,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Standings, Team, Division, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/standings',
@@ -72,7 +68,7 @@ async def get_team_standings(team_id: int):
 async def patch_standings(
         stan_id, wins: Optional[int] = None, losses: Optional[int] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_standings - Bad Token: {token}')
+        logger.warning(f'patch_standings - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     try:
@@ -92,10 +88,29 @@ async def patch_standings(
     return model_to_dict(this_stan)
 
 
+@router.post('/s{season}/new', include_in_schema=PRIVATE_IN_SCHEMA)
+async def post_standings(season: int, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logger.warning(f'post_standings - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    new_teams = []
+    all_teams = Team.select().where(Team.season == season)
+    for x in all_teams:
+        new_teams.append(Standings({'team_id': x.id}))
+    
+    with db.atomic():
+        for batch in chunked(new_teams, 16):
+            Standings.insert_many(batch).on_conflict_replace().execute()
+    db.close()
+
+    return f'Inserted {len(new_teams)} standings'
+
+
 @router.post('/s{season}/recalculate', include_in_schema=PRIVATE_IN_SCHEMA)
 async def recalculate_standings(season: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'recalculate_standings - Bad Token: {token}')
+        logger.warning(f'recalculate_standings - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     code = Standings.recalculate(season)

app/routers_v3/stratgame.py

@@ -5,13 +5,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, StratGame, Team, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/games',
@@ -125,7 +121,7 @@ async def patch_game(
         home_score: Optional[int] = None, away_manager_id: Optional[int] = None, home_manager_id: Optional[int] = None,
         token: str = Depends(oauth2_scheme), scorecard_url: Optional[str] = None) -> Any:
     if not valid_token(token):
-        logging.warning(f'patch_game - Bad Token: {token}')
+        logger.warning(f'patch_game - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_game = StratGame.get_or_none(StratGame.id == game_id)
@@ -158,7 +154,7 @@ async def patch_game(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_games(game_list: GameList, token: str = Depends(oauth2_scheme)) -> Any:
     if not valid_token(token):
-        logging.warning(f'post_games - Bad Token: {token}')
+        logger.warning(f'post_games - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_games = []
@@ -181,7 +177,7 @@ async def post_games(game_list: GameList, token: str = Depends(oauth2_scheme)) -
 @router.post('/wipe/{game_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def wipe_game(game_id: int, token: str = Depends(oauth2_scheme)) -> Any:
     if not valid_token(token):
-        logging.warning(f'wipe_game - Bad Token: {token}')
+        logger.warning(f'wipe_game - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_game = StratGame.get_or_none(StratGame.id == game_id)
@@ -207,7 +203,7 @@ async def wipe_game(game_id: int, token: str = Depends(oauth2_scheme)) -> Any:
 @router.delete('/{game_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_game(game_id: int, token: str = Depends(oauth2_scheme)) -> Any:
     if not valid_token(token):
-        logging.warning(f'delete_game - Bad Token: {token}')
+        logger.warning(f'delete_game - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_game = StratGame.get_or_none(StratGame.id == game_id)

app/routers_v3/stratplay.py

@@ -9,13 +9,9 @@ from pydantic import BaseModel, validator
 
 from ..db_engine import db, StratPlay, StratGame, Team, Player, Decision, model_to_dict, chunked, fn, SQL, \
     complex_data_to_csv
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/plays',
@@ -462,8 +458,8 @@ async def get_batting_totals(
         limit = 1
     bat_plays = bat_plays.paginate(page_num, limit)
 
-    logging.info(f'bat_plays query: {bat_plays}')
+    logger.info(f'bat_plays query: {bat_plays}')
-    logging.info(f'run_plays query: {run_plays}')
+    logger.info(f'run_plays query: {run_plays}')
 
     return_stats = {
         'count': bat_plays.count(),
@@ -977,7 +973,7 @@ async def get_fielding_totals(
         limit = 1
     def_plays = def_plays.paginate(page_num, limit)
 
-    logging.info(f'def_plays query: {def_plays}')
+    logger.info(f'def_plays query: {def_plays}')
 
     return_stats = {
         'count': def_plays.count(),
@@ -985,7 +981,7 @@ async def get_fielding_totals(
     }
 
     for x in def_plays:
-        logging.info(f'this_play: {x}')
+        logger.info(f'this_play: {x}')
         # this_cat = cat_plays.where(StratPlay.catcher == x.defender)
         # if this_cat.count() > 0:
         #     sum_sb = this_cat[0].sum_sb
@@ -1079,7 +1075,7 @@ async def get_one_play(play_id: int):
 @router.patch('/{play_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def patch_play(play_id: int, new_play: PlayModel, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_play - Bad Token: {token}')
+        logger.warning(f'patch_play - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     if StratPlay.get_or_none(StratPlay.id == play_id) is None:
@@ -1095,7 +1091,7 @@ async def patch_play(play_id: int, new_play: PlayModel, token: str = Depends(oau
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_plays(p_list: PlayList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_plays - Bad Token: {token}')
+        logger.warning(f'post_plays - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_plays = []
@@ -1134,7 +1130,7 @@ async def post_plays(p_list: PlayList, token: str = Depends(oauth2_scheme)):
 @router.delete('/{play_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_play(play_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_play - Bad Token: {token}')
+        logger.warning(f'delete_play - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_play = StratPlay.get_or_none(StratPlay.id == play_id)
@@ -1154,7 +1150,7 @@ async def delete_play(play_id: int, token: str = Depends(oauth2_scheme)):
 @router.delete('/game/{game_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_plays_game(game_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_plays_game - Bad Token: {token}')
+        logger.warning(f'delete_plays_game - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_game = StratGame.get_or_none(StratGame.id == game_id)
@@ -1174,7 +1170,7 @@ async def delete_plays_game(game_id: int, token: str = Depends(oauth2_scheme)):
 @router.post('/erun-check', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_erun_check(token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_erun_check - Bad Token: {token}')
+        logger.warning(f'post_erun_check - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     all_plays = StratPlay.update(run=1).where((StratPlay.e_run == 1) & (StratPlay.run == 0))

app/routers_v3/teams.py

@@ -5,13 +5,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Team, Manager, Division, model_to_dict, chunked, fn, query_to_csv, Player
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/teams',
@@ -132,7 +128,7 @@ async def patch_team(
         sname: Optional[str] = None, lname: Optional[str] = None, dice_color: Optional[str] = None,
         division_id: Optional[int] = None, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'patch_team - Bad Token: {token}')
+        logger.warning(f'patch_team - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_team = Team.get_or_none(Team.id == team_id)
@@ -205,7 +201,7 @@ async def patch_team(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_team(team_list: TeamList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_team - Bad Token: {token}')
+        logger.warning(f'post_team - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     new_teams = []
@@ -242,7 +238,7 @@ async def post_team(team_list: TeamList, token: str = Depends(oauth2_scheme)):
 @router.get('/{team_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_team(team_id: int, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_team - Bad Token: {token}')
+        logger.warning(f'delete_team - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     this_team = Team.get_or_none(Team.id == team_id)

app/routers_v3/transactions.py

@@ -5,13 +5,9 @@ import logging
 import pydantic
 
 from ..db_engine import db, Transaction, Team, Player, model_to_dict, chunked, fn
-from ..dependencies import oauth2_scheme, valid_token, LOG_DATA, PRIVATE_IN_SCHEMA
+from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA
 
-logging.basicConfig(
+logger = logging.getLogger('discord_app')
-    filename=LOG_DATA['filename'],
-    format=LOG_DATA['format'],
-    level=LOG_DATA['log_level']
-)
 
 router = APIRouter(
     prefix='/api/v3/transactions',
@@ -95,7 +91,7 @@ async def get_transactions(
 async def patch_transactions(
         move_id, token: str = Depends(oauth2_scheme), frozen: Optional[bool] = None, cancelled: Optional[bool] = None):
     if not valid_token(token):
-        logging.warning(f'patch_transactions - Bad Token: {token}')
+        logger.warning(f'patch_transactions - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     these_moves = Transaction.select().where(Transaction.moveid == move_id)
@@ -119,7 +115,7 @@ async def patch_transactions(
 @router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
 async def post_transactions(moves: TransactionList, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'post_transactions - Bad Token: {token}')
+        logger.warning(f'post_transactions - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     all_moves = []
@@ -145,7 +141,7 @@ async def post_transactions(moves: TransactionList, token: str = Depends(oauth2_
 @router.delete('/{move_id}', include_in_schema=PRIVATE_IN_SCHEMA)
 async def delete_transactions(move_id, token: str = Depends(oauth2_scheme)):
     if not valid_token(token):
-        logging.warning(f'delete_transactions - Bad Token: {token}')
+        logger.warning(f'delete_transactions - Bad Token: {token}')
         raise HTTPException(status_code=401, detail='Unauthorized')
 
     delete_query = Transaction.delete().where(Transaction.moveid == move_id)

docker-compose.yml

@@ -0,0 +1,21 @@
+version: '3'
+
+services:
+  database:
+    # build: ./database
+    image: manticorum67/major-domo-database:dev
+    restart: unless-stopped
+    container_name: sba_database
+    volumes:
+      - /home/cal/Development/major-domo/dev-storage:/usr/src/app/storage
+      - /home/cal/Development/major-domo/dev-logs:/usr/src/app/logs
+    ports:
+      - 801:80
+    environment:
+      - TESTING=False
+      - LOG_LEVEL=INFO
+      - API_TOKEN=Tp3aO3jhYve5NJF1IqOmJTmk
+      - TZ=America/Chicago
+      - WORKERS_PER_CORE=1.5
+      - TIMEOUT=120
+      - GRACEFUL_TIMEOUT=120