Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,21 @@
+# syntax=docker/dockerfile:1.6
+
+FROM python:3.11-slim AS runtime
+
+WORKDIR /app/env
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . .
+
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -e .
+
+EXPOSE 8000
+
+ENV PYTHONUNBUFFERED=1 \
+    ENABLE_WEB_INTERFACE=true
+
+CMD ["python", "-m", "uvicorn", "connect4_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,55 @@
 ---
-title: Connect4 Exp
-emoji: 🌍
-colorFrom: blue
-colorTo: green
+title: Connect4 Environment Server
+emoji: 🔴
+colorFrom: red
+colorTo: pink
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - games
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Connect4 Environment
+
+This repository packages the classic Connect4 board game as a standalone OpenEnv
+environment. It exposes a FastAPI server compatible with the OpenEnv CLI and
+provides a Python client for interacting with the environment programmatically.
+
+## Quick Start
+
+```bash
+# Install dependencies (editable mode for local development)
+uv pip install -e .
+
+# Launch the server locally
+uv run server
+```
+
+Once running, visit `http://localhost:8000/docs` to explore the OpenAPI schema.
+
+## Python Usage
+
+```python
+from connect4_env import Connect4Env, Connect4Action
+
+env = Connect4Env.from_docker_image("connect4-env:latest")
+result = env.reset()
+print(result.observation.board)
+
+result = env.step(Connect4Action(column=3))
+print(result.reward, result.done)
+
+env.close()
+```
+
+## Deploy
+
+- **Validate:** `openenv validate`
+- **Build Docker image:** `openenv build`
+- **Push to Hugging Face / Docker Hub:** `openenv push`
+
+Customize the Docker build or deployment metadata through environment variables
+as needed. The default server listens on port `8000`.

__init__.py

@@ -0,0 +1,30 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Connect4 Environment for OpenEnv.
+
+This module provides OpenEnv integration for the classic Connect4 board game.
+
+Example:
+    >>> from connect4_env import Connect4Env, Connect4Action
+    >>>
+    >>> # Connect to a running server or start via Docker
+    >>> env = Connect4Env.from_docker_image("connect4-env:latest")
+    >>>
+    >>> # Reset and interact
+    >>> result = env.reset()
+    >>> result = env.step(Connect4Action(column=2))
+    >>> print(result.reward, result.done)
+    >>>
+    >>> # Cleanup
+    >>> env.close()
+"""
+
+from .client import Connect4Env
+from .models import Connect4Action, Connect4Observation, Connect4State
+
+__all__ = ["Connect4Env", "Connect4Action", "Connect4Observation", "Connect4State"]

client.py

@@ -0,0 +1,98 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Connect4 Environment HTTP Client.
+
+This module provides the client for connecting to a Connect4 Environment server
+over HTTP.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from openenv_core.http_env_client import HTTPEnvClient, StepResult
+
+from .models import Connect4Action, Connect4Observation, Connect4State
+
+if TYPE_CHECKING:
+    from openenv_core.containers.runtime import ContainerProvider
+
+
+class Connect4Env(HTTPEnvClient[Connect4Action, Connect4Observation]):
+    """
+    HTTP client for Connect4 Environment.
+
+    This client connects to a Connect4Environment HTTP server and provides
+    methods to interact with it: reset(), step(), and state access.
+
+    Example:
+        >>> client = Connect4Env(base_url="http://localhost:8000")
+        >>> result = client.reset()
+        >>> print(result.observation.board)
+        >>>
+        >>> # Take an action
+        >>> result = client.step(Connect4Action(column=3))
+        >>> print(result.reward, result.done)
+    """
+
+    def _step_payload(self, action: Connect4Action) -> Dict[str, Any]:
+        """
+        Convert Connect4Action to JSON payload for step request.
+
+        Args:
+            action: Connect4Action instance.
+
+        Returns:
+            Dictionary representation suitable for JSON encoding.
+        """
+        return {
+            "column": action.column,  # column index to drop piece
+        }
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[Connect4Observation]:
+        """
+        Parse server response into StepResult[Connect4Observation].
+
+        Args:
+            payload: JSON response from server.
+
+        Returns:
+            StepResult with Connect4Observation.
+        """
+        obs_data = payload.get("observation", {})
+
+        observation = Connect4Observation(
+            board=obs_data.get("board", [[0] * 7 for _ in range(6)]),
+            legal_actions=obs_data.get("legal_actions", []),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> Connect4State:
+        """
+        Parse server response into Connect4State object.
+
+        Args:
+            payload: JSON response from /state endpoint.
+
+        Returns:
+            Connect4State object with environment state information.
+        """
+        return Connect4State(
+            episode_id=payload.get("episode_id", ""),
+            board=payload.get("board", [[0] * 7 for _ in range(6)]),
+            next_player=payload.get("next_player", 1),
+            step_count=payload.get("step_count", 0),
+        )

models.py

@@ -0,0 +1,69 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for Connect4 Environment.
+
+This module defines the Action, Observation, and State types for Connect4 games
+via the OpenEnv interface.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+import numpy as np
+from typing import List
+
+from openenv_core.env_server.types import Action, Observation, State
+
+
+@dataclass
+class Connect4Action(Action):
+    """
+    Action for Connect4 environment.
+
+    Attributes:
+        column: The column index (0 to 6) where the piece will be placed.
+    """
+
+    column: int
+
+
+@dataclass(kw_only=True)
+class Connect4Observation(Observation):
+    """
+    Observation for Connect4 environment.
+
+    Attributes:
+        board: The current board as a 2D list (6 rows x 7 columns).
+               1 = current player, -1 = opponent, 0 = empty.
+        legal_actions: List of column indices that are valid moves.
+        done: Whether the game is over.
+        reward: Reward for the last action.
+    """
+
+    board: List[List[int]]
+    legal_actions: List[int]
+    done: bool = False
+    reward: float = 0.0
+    metadata: dict = field(default_factory=dict)
+
+
+@dataclass(kw_only=True)
+class Connect4State(State):
+    """
+    State for Connect4 environment.
+
+    Attributes:
+        episode_id: Unique ID for the current game.
+        board: Current board state (rows x columns), 0 = empty, 1 = player, -1 = opponent.
+        next_player: Whose turn it is (1 or -1).
+        step_count: Number of steps taken in the game.
+    """
+
+    episode_id: str
+    board: List[List[int]] = field(default_factory=lambda: np.zeros((6, 7), dtype=int).tolist())
+    next_player: int = 1
+    step_count: int = 0

openenv.yaml

@@ -0,0 +1,5 @@
+name: connect4_env
+version: "0.1.0"
+description: "Connect4 environment for OpenEnv"
+action: Connect4Action
+observation: Connect4Observation

openenv_connect4.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: openenv-connect4
+Version: 0.1.0
+Summary: Connect4 environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core@ git+https://github.com/meta-pytorch/OpenEnv.git@main#subdirectory=src/core
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn>=0.24.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: gymnasium>=0.29.0
+Requires-Dist: ale-py>=0.8.0
+Requires-Dist: numpy>=1.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: ipykernel>=6.29.5; extra == "dev"

openenv_connect4.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+__init__.py
+client.py
+models.py
+openenv.yaml
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+./openenv.yaml
+openenv_connect4.egg-info/PKG-INFO
+openenv_connect4.egg-info/SOURCES.txt
+openenv_connect4.egg-info/dependency_links.txt
+openenv_connect4.egg-info/entry_points.txt
+openenv_connect4.egg-info/requires.txt
+openenv_connect4.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/connect4_environment.py

openenv_connect4.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_connect4.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = connect4_env.server.app:main

openenv_connect4.egg-info/requires.txt

@@ -0,0 +1,13 @@
+openenv-core@ git+https://github.com/meta-pytorch/OpenEnv.git@main#subdirectory=src/core
+fastapi>=0.115.0
+pydantic>=2.0.0
+uvicorn>=0.24.0
+requests>=2.25.0
+gymnasium>=0.29.0
+ale-py>=0.8.0
+numpy>=1.24.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0
+ipykernel>=6.29.5

openenv_connect4.egg-info/top_level.txt

@@ -0,0 +1 @@
+connect4_env

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-connect4"
+version = "0.1.0"
+description = "Connect4 environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core @ git+https://github.com/meta-pytorch/OpenEnv.git@main#subdirectory=src/core",
+    "fastapi>=0.115.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.25.0",
+    # Add your environment-specific dependencies here
+    "gymnasium>=0.29.0",
+    "ale-py>=0.8.0",
+    "numpy>=1.24.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+    "ipykernel>=6.29.5",
+]
+
+[project.scripts]
+server = "connect4_env.server.app:main"
+
+[tool.setuptools]
+packages = ["connect4_env", "connect4_env.server"]
+package-dir = { "connect4_env" = ".", "connect4_env.server" = "server" }
+
+[tool.setuptools.package-data]
+connect4_env = ["**/*.yaml", "**/*.yml"]

server/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+connect4 Environment Server.
+
+Server-side implementation of connect4 environment for OpenEnv.
+"""
+
+from .connect4_environment import Connect4Environment
+
+__all__ = ["Connect4Environment"]

server/app.py

@@ -0,0 +1,27 @@
+from openenv_core.env_server.http_server import create_app
+
+from ..models import Connect4Action, Connect4Observation
+from .connect4_environment import Connect4Environment
+
+env = Connect4Environment()
+app = create_app(
+    env,
+    Connect4Action,
+    Connect4Observation,
+    env_name="connect4_env",
+)
+
+
+def main(port: int = 8000):
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(args.port)

server/connect4_environment.py

@@ -0,0 +1,89 @@
+import uuid
+
+import numpy as np
+from openenv_core.env_server.interfaces import Environment
+
+from ..models import Connect4Action, Connect4Observation, Connect4State
+
+
+class Connect4Environment(Environment):
+    ROWS = 6
+    COLUMNS = 7
+
+    def __init__(self, opponent=None):
+        super().__init__()
+        self._opponent = opponent
+        self.reset()
+
+    def reset(self):
+        self.board = np.zeros((self.ROWS, self.COLUMNS), dtype=np.int8)
+        self.next_player = 1
+        self.invalid_move_played = False
+
+        self._state = Connect4State(
+            board=self.board.copy().tolist(), next_player=self.next_player, episode_id=str(uuid.uuid4()), step_count=0
+        )
+        return self._make_observation()
+
+    def step(self, action: Connect4Action):
+        col = action.column
+        # reward = 0.0
+        done = False
+
+        # check action validity
+        if col < 0 or col >= self.COLUMNS or self.board[0, col] != 0:
+            self.invalid_move_played = True
+            reward = -1  # penalty for invalid move
+            done = True
+        else:
+            # drop piece
+            for row in range(self.ROWS - 1, -1, -1):
+                if self.board[row, col] == 0:
+                    self.board[row, col] = self.next_player
+                    break
+
+            # check win / full board
+            reward, done = self._check_win_or_draw(row, col)
+
+        self.next_player *= -1
+
+        self._state = Connect4State(
+            board=self.board.copy().tolist(),
+            next_player=self.next_player,
+            episode_id=self._state.episode_id,
+            step_count=self._state.step_count + 1,
+        )
+
+        return self._make_observation(reward, done)
+
+    def _make_observation(self, reward=0.0, done=False):
+        legal_actions = [c for c in range(self.COLUMNS) if self.board[0, c] == 0]
+        return Connect4Observation(
+            board=self.board.copy().tolist(),
+            legal_actions=legal_actions,
+            reward=reward,
+            done=done,
+            metadata={"next_player": self.next_player},
+        )
+
+    def _check_win_or_draw(self, row, col):
+        # Implement 4-in-a-row check (like your Gymnasium code)
+        player = self.board[row, col]
+        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
+        for dr, dc in directions:
+            count = 0
+            for step in range(-3, 4):
+                r, c = row + step * dr, col + step * dc
+                if 0 <= r < self.ROWS and 0 <= c < self.COLUMNS and self.board[r, c] == player:
+                    count += 1
+                    if count >= 4:
+                        return 1.0, True
+                else:
+                    count = 0
+        if np.all(self.board != 0):
+            return 0.0, True
+        return 0.0, False
+
+    @property
+    def state(self):
+        return self._state