refactor(doc): update docs static

gallery/easel/depends/api.py

@@ -1,9 +1,17 @@
+from fastapi import HTTPException, status
+
 from gallery.easel.core import AppRequest
 from gallery.sketch.api import API
 
 
 def api_resolver(api_type: type[API]):
-    def get_api(request: AppRequest, provider: str | None = None) -> API:
+    def get_api(request: AppRequest, provider: str) -> API:
+        providers = request.app.state.api.get_api_providers(api_type)
+        if provider not in providers:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={"provider": f"'{provider}' not in {providers}"},
+            )
         return request.app.state.api.get_api(api_type, provider)
 
     return get_api

gallery/easel/route/api/schedule.py

@@ -3,18 +3,25 @@ import datetime
 from fastapi import APIRouter
 
 from gallery.easel.core import AppRequest
+from gallery.easel.depends.schedule import ScheduleApiDepends
+from gallery.sketch.schedule.api import ScheduleApi
 from gallery.sketch.schedule.model import Channel, Schedule
 
 router = APIRouter(prefix="/schedule")
 
 
-@router.get("/channels")
+@router.get("/providers")
-async def get_api_schedule_channels(request: AppRequest) -> list[Channel]:
+async def get_api_weather_providers(request: AppRequest) -> list[str]:
-    schedule_api = request.app.state.api.schedule
+    return request.app.state.api.get_api_providers(ScheduleApi)
-    return await schedule_api.get_channels()
 
 
-@router.get("/{channel}/{date}")
+@router.get("/{provider}/channels")
-async def get_api_schedule_channel_schedule(request: AppRequest, channel: str, date: datetime.date) -> Schedule:
+async def find_api_schedule_channels(schedule_api: ScheduleApiDepends, query: str) -> list[Channel]:
-    schedule_api = request.app.state.api.schedule
+    return await schedule_api.find_channels(query)
-    return await schedule_api.get_channel_schedule(ChannelId(channel), date)
+
+
+@router.get("/{provider}/{channel}/{date}")
+async def get_api_schedule_channel_schedule(
+    schedule_api: ScheduleApiDepends, channel: str, date: datetime.date
+) -> Schedule:
+    return await schedule_api.get_schedule(channel, date)

gallery/easel/route/api/weather.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter
 
 from gallery.easel.core import AppRequest
 from gallery.easel.depends.weather import WeatherApiDepends
+from gallery.sketch.weather.api import WeatherApi
 from gallery.sketch.weather.model import Location, WeatherResponse
 
 router = APIRouter(prefix="/weather")
@@ -11,11 +12,11 @@ router = APIRouter(prefix="/weather")
 
 @router.get("/providers")
 async def get_api_weather_providers(request: AppRequest) -> list[str]:
-    return request.app.state.api.get_api_providers("weather")
+    return request.app.state.api.get_api_providers(WeatherApi)
 
 
 @router.get("/{provider}/locations")
-async def get_api_weather_locations(weather_api: WeatherApiDepends, query: str) -> list[Location]:
+async def find_api_weather_locations(weather_api: WeatherApiDepends, query: str) -> list[Location]:
     return await weather_api.find_locations(query)
 
 

gallery/easel/route/view/__init__.py

@@ -5,7 +5,7 @@ from .schedule import router as schedule_router
 from .translation import set_language
 from .weather import router as weather_router
 
-router = APIRouter(tags=["view"], dependencies=[Depends(set_language)])
+router = APIRouter(tags=["view"], dependencies=[Depends(set_language)], include_in_schema=False)
 router.include_router(root_router)
 router.include_router(weather_router)
 router.include_router(schedule_router)

gallery/easel/route/view/schedule/__init__.py

@@ -15,7 +15,7 @@ from .filters import timedelta_format
 
 def context_procesor(request: AppRequest) -> dict:
     return {
-        "providers": request.app.state.api.get_api_providers(ScheduleApi.TYPE),
+        "providers": request.app.state.api.get_api_providers(ScheduleApi),
     }
 
 

gallery/easel/route/view/weather/__init__.py

@@ -16,7 +16,7 @@ from .filters import cloudness_icon, wind_direction_icon
 
 def context_procesor(request: AppRequest) -> dict:
     return {
-        "providers": request.app.state.api.get_api_providers(WeatherApi.TYPE),
+        "providers": request.app.state.api.get_api_providers(WeatherApi),
     }
 
 

gallery/painting/openweather/api.py

@@ -53,7 +53,7 @@ class OpenWeatherApi(WeatherApi):
                 lon=item.lon,
                 country=item.country,
                 country_code=item.country.lower(),
-                district=item.state,
+                district=item.state or "",
                 subdistrict="",
             )
             for item in result

gallery/painting/openweather/openweather.py

@@ -69,11 +69,11 @@ class Forecast(Model):
 
 class Location(Model):
     name: str
-    local_names: dict[str, str] | None = None
     lat: float
     lon: float
     country: str
-    state: str
+    state: str | None = None
+    local_names: dict[str, str] | None = None
 
 
 class OpenWeather:

gallery/painting/yandextv/api.py

@@ -46,7 +46,10 @@ class YandexTvApi(ScheduleApi):
     SOURCE = ApiSource("https://tv.yandex.ru", headers=HEADERS)
 
     async def find_channels(self, query: str) -> list[Channel]:
-        url = f"https://suggest-multi.yandex.ru/suggest-tv2?v=4&uil=ru&lr=10&count_channels=4&count_programs=4&sn=50&part={query}"
+        url = (
+            "https://suggest-multi.yandex.ru/suggest-tv2?"
+            f"v=4&uil=ru&lr=10&count_channels=4&count_programs=4&sn=50&part={query}"
+        )
         _, values = json.loads(await self.SOURCE.request(url))
         result = []
         for _, name, content in values:

gallery/sketch/bundle.py

@@ -6,16 +6,16 @@ class ApiBundle:
         self._values = values
         self._by_provider = {value.provider: value for value in values}
 
-    def get_api_providers(self, api_type: str) -> list[str]:
+    def get_api_providers(self, api_type: type[API]) -> list[str]:
         result = []
         for value in self._values:
-            if value.type == api_type:
+            if isinstance(value, api_type):
                 result.append(value.provider)
         return result
 
-    def get_api(self, api_type: type[API], provider: str | None = None) -> API:
+    def get_api(self, api_type: type[API], provider: str) -> API:
         for value in self._values:
             if isinstance(value, api_type):
-                if provider is None or provider == value.provider:
+                if provider == value.provider:
                     return value
         raise ValueError(api_type, provider)