Upload folder using huggingface_hub

src/app_state.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from litrl import make_multiagent
+from litrl.algo.mcts.agent import MCTSAgent
+from litrl.algo.mcts.mcts_config import MCTSConfig
+from litrl.algo.mcts.rollout import VanillaRollout
+from litrl.algo.sac.agent import OnnxSacDeterministicAgent
+from litrl.common.agent import Agent, RandomMultiAgent
+from litrl.env.connect_four import Board
+from litrl.env.set_state import set_state
+
+from src.typing import AgentType, CpuConfig, RolloutPolicy
+
+
+class AppState:
+    def __init__(self) -> None:
+        self.env = make_multiagent(id="ConnectFour-v3", render_mode="human")
+        self.env.reset(seed=123)
+        self.agent: Agent[Any, Any] | None = None
+        self.cpu_config: CpuConfig | None = None
+
+    def set_board(self, board: Board) -> None:
+        set_state(env=self.env, board=board)
+
+    def set_config(self, cpu_config: CpuConfig) -> None:
+        if (
+            self.agent is None
+            or self.cpu_config is None
+            or cpu_config != self.cpu_config
+        ):
+            self.cpu_config = cpu_config
+            self.set_agent()
+
+    def create_rollout(self) -> Agent[Any, Any]:
+        if self.cpu_config is None:
+            raise ValueError("self.cpu_config is None")
+        match self.cpu_config.rollout_policy:
+            case None:
+                return RandomMultiAgent()
+            case RolloutPolicy.SAC:
+                return OnnxSacDeterministicAgent()
+            case RolloutPolicy.RANDOM:
+                return RandomMultiAgent()
+            case _:
+                raise NotImplementedError(
+                    f"cpu_config.rollout_policy: {self.cpu_config.rollout_policy}"
+                )
+
+    def set_agent(self) -> None:
+        if self.cpu_config is None:
+            raise ValueError("self.cpu_config is None")
+
+        match self.cpu_config.agent_type:
+            case AgentType.MCTS:
+                rollout_agent = self.create_rollout()
+                mcts_config = MCTSConfig(
+                    simulations=self.cpu_config.simulations or 50,
+                    rollout_strategy=VanillaRollout(rollout_agent=rollout_agent),
+                )
+                self.agent = MCTSAgent(cfg=mcts_config)
+            case AgentType.RANDOM:
+                self.agent = RandomMultiAgent()
+            case AgentType.SAC:
+                self.agent = OnnxSacDeterministicAgent()
+            case _:
+                raise NotImplementedError(
+                    f"cpu_config.name: {self.cpu_config.agent_type}"
+                )
+
+    def get_action(self) -> int:
+        if self.agent is None:
+            raise ValueError("self.agent is None")
+        return self.agent.get_action(env=self.env)

src/connect4_backend.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: connect4-backend
+Version: 0.0.1
+Author: Clement Gohlke
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: tensordict@ git+https://github.com/pytorch/tensordict.git@c3caa7612275306ce72697a82d5252681ddae0ab
+Requires-Dist: torchrl@ git+https://github.com/pytorch/rl.git@1bb192e0f3ad9e7b8c6fa769bfa3bb9d82ca4f29
+Requires-Dist: litrl~=0.0.9
+Requires-Dist: fastapi==0.104.1
+Requires-Dist: uvicorn==0.25.0
+Requires-Dist: moviepy==1.0.3
+Provides-Extra: test
+Requires-Dist: pytest==7.4.4; extra == "test"
+Requires-Dist: mypy==1.8.0; extra == "test"
+Requires-Dist: httpx==0.26.0; extra == "test"
+
+---
+title: Connect4
+emoji: 🌐
+colorFrom: blue
+colorTo: yellow
+sdk: docker
+pinned: false
+license: mit
+---
+
+frontend adapted from [github](https://github.com/jprioses/connect-four-game)
+
+Check out the configuration reference at [huggingface](https://huggingface.co/docs/hub/spaces-config-reference)
+
+## TODO
+
+link to github repo
+
+test block forced move
+
+Connect to AWS database https://aws.amazon.com/rds/?p=ft&c=db&z=3
+using alembic and sqlmodel

src/connect4_backend.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/__init__.py
+src/app_state.py
+src/create_app.py
+src/typing.py
+src/connect4_backend.egg-info/PKG-INFO
+src/connect4_backend.egg-info/SOURCES.txt
+src/connect4_backend.egg-info/dependency_links.txt
+src/connect4_backend.egg-info/requires.txt
+src/connect4_backend.egg-info/top_level.txt

src/connect4_backend.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/connect4_backend.egg-info/requires.txt

@@ -0,0 +1,11 @@
+tensordict@ git+https://github.com/pytorch/tensordict.git@c3caa7612275306ce72697a82d5252681ddae0ab
+torchrl@ git+https://github.com/pytorch/rl.git@1bb192e0f3ad9e7b8c6fa769bfa3bb9d82ca4f29
+litrl~=0.0.9
+fastapi==0.104.1
+uvicorn==0.25.0
+moviepy==1.0.3
+
+[test]
+pytest==7.4.4
+mypy==1.8.0
+httpx==0.26.0

src/connect4_backend.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+__init__
+app_state
+create_app
+typing

src/create_app.py

@@ -0,0 +1,113 @@
+from typing import Annotated, Any, Generator
+from pathlib import Path
+from gymnasium.wrappers.record_video import RecordVideo
+from litrl.env.make import make
+from litrl.common.agent import RandomAgent
+from litrl.env.typing import SingleAgentId
+from fastapi import Depends, FastAPI, Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from litrl.env.connect_four import Board
+from loguru import logger
+from fastapi.responses import StreamingResponse, FileResponse
+from moviepy.editor import VideoFileClip
+from src.app_state import AppState
+from src.typing import CpuConfig
+
+
+def create_app() -> FastAPI:
+    app = FastAPI()
+
+    @app.post("/", response_model=int)
+    def bot_action(
+        board: Board,
+        cpuConfig: CpuConfig,
+        app_state: Annotated[AppState, Depends(dependency=AppState)],
+    ) -> int:
+        app_state.set_config(cpu_config=cpuConfig)
+        app_state.set_board(board=board)
+        return app_state.get_action()
+
+    @app.post(path=f"/game", response_model=str)
+    def bot_action(
+        env_id: SingleAgentId,
+    ) -> str:
+        env = make(id=env_id, render_mode="rgb_array")
+        env = RecordVideo(
+            env=env,
+            video_folder="tmp",
+        )
+        env.reset(seed=123)
+        agent = RandomAgent[Any, Any]()
+        terminated, truncated = False, False
+        while not (terminated or truncated):
+            action = agent.get_action(env=env)
+            _, _, terminated, truncated, _ = env.step(action=action)
+            env.render()
+        env.video_recorder.close()
+
+        def iterfile()-> Generator[bytes, Any, None]:  
+            with Path(env.video_recorder.path).open(mode="rb") as env_file:
+                yield from env_file
+
+        return StreamingResponse(content=iterfile(), media_type="video/mp4")
+
+    @app.get(path=f"/gif")
+    def bot_action(
+        env_id: SingleAgentId,
+    ) -> str:
+        env = make(id=env_id, render_mode="rgb_array")
+        env = RecordVideo(
+            env=env,
+            video_folder="tmp",
+        )
+        env.reset(seed=123)
+        agent = RandomAgent[Any, Any]()
+        terminated, truncated = False, False
+        while not (terminated or truncated):
+            action = agent.get_action(env=env)
+            _, _, terminated, truncated, _ = env.step(action=action)
+            env.render()
+        env.video_recorder.close()
+
+        mp4_path = Path(env.video_recorder.path)
+        video_clip = VideoFileClip(str(mp4_path))
+        gif_path = mp4_path.with_suffix(".gif")
+        video_clip.write_gif(str(gif_path))#, fps=30)  # TODO check fps
+        return FileResponse(str(gif_path), media_type="image/gif")
+
+    @app.exception_handler(exc_class_or_status_code=RequestValidationError)
+    async def validation_exception_handler(
+        request: Request, exc: RequestValidationError
+    ) -> JSONResponse:
+        logger.debug(f"url: {request.url}")
+        if hasattr(request, "_body"):
+            logger.debug(f"body: {request._body}")
+        logger.debug(f"header: {request.headers}")
+        logger.error(f"{request}: {exc}")
+        exc_str = f"{exc}".replace("\n", " ").replace("   ", " ")
+        content = {"status_code": 10422, "message": exc_str, "data": None}
+        return JSONResponse(
+            content=content, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+        )
+
+    app.add_middleware(
+        middleware_class=CORSMiddleware,
+        allow_origins="*",
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    return app
+
+if __name__ == "__main__":
+    import uvicorn
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    config = uvicorn.Config(app=create_app(), host=args.host, port=args.port, log_level="info")
+    server = uvicorn.Server(config=config)
+    server.run()

src/huggingface/get_best_mp4.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+def get_mp4_paths(environments: list[str]) -> dict[str, Path]:
+    mp4_paths: dict[str, Path] = {}
+    for env in environments:
+        mp4_paths[env] = get_best_mp4(env)
+    return mp4_paths
+
+
+def get_best_mp4(env: str) -> Path:
+    hf_env_results_path = f"models/{env}/results.yaml"
+    local_env_results_path = hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=hf_env_results_path)
+    with open(local_env_results_path, "r") as f:
+        env_results = yaml.load(f, Loader=yaml.FullLoader)
+    best_model_type = max(env_results, key=lambda model: env_results[model])
+    model_results_path = f"models/{env}/{best_model_type}/results.yaml"
+    local_model_results_path = hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=model_results_path)
+    with open(local_model_results_path, "r") as f:
+        model_results = yaml.load(f, Loader=yaml.FullLoader)
+
+    best_model = max(model_results, key=lambda model: model_results[model])
+    hf_gif_path = f"models/{env}/{best_model_type}/{best_model}/demo.mp4"
+    return Path(hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=hf_gif_path))

src/huggingface/get_environments.py

@@ -0,0 +1,11 @@
+
+
+def get_environments() -> list[str]:
+    environments: list[str] = []
+    files = hf_api.list_repo_files(MODEL_REPO, repo_type=MODEL_REPO_TYPE)
+    for file in files:
+        vals = file.split("/")
+        # e.g. ['models', 'CartPole-v1', 'results.yaml']
+        if len(vals) == ENV_RESULTS_FILE_DEPTH and vals[2] == "results.yaml" and vals[0] == "models":
+            environments.append(vals[1])
+    return environments

src/huggingface/get_gif.py

@@ -0,0 +1,22 @@
+def get_best_gif(env: str) -> Path:
+    hf_env_results_path = f"models/{env}/results.yaml"
+    local_env_results_path = hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=hf_env_results_path)
+    with open(local_env_results_path, "r") as f:
+        env_results = yaml.load(f, Loader=yaml.FullLoader)
+    best_model_type = max(env_results, key=lambda model: env_results[model])
+    model_results_path = f"models/{env}/{best_model_type}/results.yaml"
+    local_model_results_path = hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=model_results_path)
+    with open(local_model_results_path, "r") as f:
+        model_results = yaml.load(f, Loader=yaml.FullLoader)
+
+    best_model = max(model_results, key=lambda model: model_results[model])
+    hf_gif_path = f"models/{env}/{best_model_type}/{best_model}/demo.gif"
+    return Path(hf_hub_download(repo_id=MODEL_REPO, repo_type=MODEL_REPO_TYPE, filename=hf_gif_path))
+
+
+
+def get_gif_paths(environments: list[str]) -> dict[str, Path]:
+    gif_paths: dict[str, Path] = {}
+    for env in environments:
+        gif_paths[env] = get_best_gif(env)
+    return gif_paths

src/huggingface/huggingface_client.py

@@ -0,0 +1,34 @@
+from huggingface_hub import hf_hub_download
+from huggingface_hub import HfApi, login
+import os
+import yaml
+from pathlib import Path
+from loguru import logger
+from PIL import Image
+from .get_best_mp4 import get_mp4_paths
+
+SPACE_REPO = "c-gohlke/litrl"
+SPACE_REPO_TYPE = "space"
+MODEL_REPO = "c-gohlke/litrl"
+MODEL_REPO_TYPE = "model"
+
+ENV_RESULTS_FILE_DEPTH = 3
+
+
+class HugingFaceClient:
+    def __init__(self) -> None:
+        login(  # type: ignore[no-untyped-call]
+            token=os.environ.get("HUGGINGFACE_TOKEN"),
+            add_to_git_credential=True,
+            new_session=False,
+        )
+        self.hf_api = HfApi()
+        self.mp4_paths = get_mp4_paths()
+        
+
+    def api_predict(self, env_id: str)-> bytes|None:
+        if env_id not in self.mp4_paths:
+            logger.error(f"Environment {env_id} not found in {self.mp4_paths}")
+            return None
+        with open(self.mp4_paths[env_id], "rb") as f:
+            return f.read()

src/typing.py

@@ -0,0 +1,24 @@
+import enum
+
+from pydantic import BaseModel
+
+
+class AgentType(enum.Enum):
+    RANDOM = "random"
+    MCTS = "mcts"
+    SAC = "sac"
+
+
+class RolloutPolicy(enum.Enum):
+    RANDOM = "random"
+    SAC = "sac"
+
+
+class CpuConfig(BaseModel):
+    agent_type: AgentType
+    simulations: int | None = None
+    rollout_policy: RolloutPolicy | None = None
+
+    # def __format__(self, __format_spec: str) -> str:
+    #     raise ValueError(f"__format__ not implemented for {self.__class__.__name__}")
+    #     return super().__format__(__format_spec)