thisisgini commited on
Commit
e94ebcd
·
verified ·
1 Parent(s): 412ddf9

Delete ecommerce_bot

Browse files
ecommerce_bot/Dockerfile DELETED
@@ -1,21 +0,0 @@
1
- FROM python:3.11-slim
2
-
3
- WORKDIR /app
4
-
5
- # Install system dependencies (needed for some Python packages)
6
- RUN apt-get update && apt-get install -y \
7
- build-essential \
8
- && rm -rf /var/lib/apt/lists/*
9
-
10
- # Copy requirements from your server folder
11
- COPY server/requirements.txt .
12
- RUN pip install --no-cache-dir -r requirements.txt
13
-
14
- # Copy the rest of your files
15
- COPY . .
16
-
17
- # Hugging Face Spaces default port
18
- EXPOSE 7860
19
-
20
- # Point to your app file inside the server folder
21
- CMD ["python", "server/app.py"]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/README.md DELETED
@@ -1,255 +0,0 @@
1
- ---
2
- title: Ecommerce Bot Environment Server
3
- emoji: 🎵
4
- colorFrom: purple
5
- colorTo: green
6
- sdk: docker
7
- pinned: false
8
- app_port: 8000
9
- base_path: /web
10
- tags:
11
- - openenv
12
- ---
13
-
14
- # Ecommerce Bot Environment
15
-
16
- A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
17
-
18
- ## Quick Start
19
-
20
- The simplest way to use the Ecommerce Bot environment is through the `EcommerceBotEnv` class:
21
-
22
- ```python
23
- from ecommerce_bot import EcommerceBotAction, EcommerceBotEnv
24
-
25
- try:
26
- # Create environment from Docker image
27
- ecommerce_botenv = EcommerceBotEnv.from_docker_image("ecommerce_bot-env:latest")
28
-
29
- # Reset
30
- result = ecommerce_botenv.reset()
31
- print(f"Reset: {result.observation.echoed_message}")
32
-
33
- # Send multiple messages
34
- messages = ["Hello, World!", "Testing echo", "Final message"]
35
-
36
- for msg in messages:
37
- result = ecommerce_botenv.step(EcommerceBotAction(message=msg))
38
- print(f"Sent: '{msg}'")
39
- print(f" → Echoed: '{result.observation.echoed_message}'")
40
- print(f" → Length: {result.observation.message_length}")
41
- print(f" → Reward: {result.reward}")
42
-
43
- finally:
44
- # Always clean up
45
- ecommerce_botenv.close()
46
- ```
47
-
48
- That's it! The `EcommerceBotEnv.from_docker_image()` method handles:
49
- - Starting the Docker container
50
- - Waiting for the server to be ready
51
- - Connecting to the environment
52
- - Container cleanup when you call `close()`
53
-
54
- ## Building the Docker Image
55
-
56
- Before using the environment, you need to build the Docker image:
57
-
58
- ```bash
59
- # From project root
60
- docker build -t ecommerce_bot-env:latest -f server/Dockerfile .
61
- ```
62
-
63
- ## Deploying to Hugging Face Spaces
64
-
65
- You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
66
-
67
- ```bash
68
- # From the environment directory (where openenv.yaml is located)
69
- openenv push
70
-
71
- # Or specify options
72
- openenv push --namespace my-org --private
73
- ```
74
-
75
- The `openenv push` command will:
76
- 1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
77
- 2. Prepare a custom build for Hugging Face Docker space (enables web interface)
78
- 3. Upload to Hugging Face (ensuring you're logged in)
79
-
80
- ### Prerequisites
81
-
82
- - Authenticate with Hugging Face: The command will prompt for login if not already authenticated
83
-
84
- ### Options
85
-
86
- - `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
87
- - `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
88
- - `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
89
- - `--private`: Deploy the space as private (default: public)
90
-
91
- ### Examples
92
-
93
- ```bash
94
- # Push to your personal namespace (defaults to username/env-name from openenv.yaml)
95
- openenv push
96
-
97
- # Push to a specific repository
98
- openenv push --repo-id my-org/my-env
99
-
100
- # Push with a custom base image
101
- openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
102
-
103
- # Push as a private space
104
- openenv push --private
105
-
106
- # Combine options
107
- openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
108
- ```
109
-
110
- After deployment, your space will be available at:
111
- `https://huggingface.co/spaces/<repo-id>`
112
-
113
- The deployed space includes:
114
- - **Web Interface** at `/web` - Interactive UI for exploring the environment
115
- - **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
116
- - **Health Check** at `/health` - Container health monitoring
117
- - **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
118
-
119
- ## Environment Details
120
-
121
- ### Action
122
- **EcommerceBotAction**: Contains a single field
123
- - `message` (str) - The message to echo back
124
-
125
- ### Observation
126
- **EcommerceBotObservation**: Contains the echo response and metadata
127
- - `echoed_message` (str) - The message echoed back
128
- - `message_length` (int) - Length of the message
129
- - `reward` (float) - Reward based on message length (length × 0.1)
130
- - `done` (bool) - Always False for echo environment
131
- - `metadata` (dict) - Additional info like step count
132
-
133
- ### Reward
134
- The reward is calculated as: `message_length × 0.1`
135
- - "Hi" → reward: 0.2
136
- - "Hello, World!" → reward: 1.3
137
- - Empty message → reward: 0.0
138
-
139
- ## Advanced Usage
140
-
141
- ### Connecting to an Existing Server
142
-
143
- If you already have a Ecommerce Bot environment server running, you can connect directly:
144
-
145
- ```python
146
- from ecommerce_bot import EcommerceBotEnv
147
-
148
- # Connect to existing server
149
- ecommerce_botenv = EcommerceBotEnv(base_url="<ENV_HTTP_URL_HERE>")
150
-
151
- # Use as normal
152
- result = ecommerce_botenv.reset()
153
- result = ecommerce_botenv.step(EcommerceBotAction(message="Hello!"))
154
- ```
155
-
156
- Note: When connecting to an existing server, `ecommerce_botenv.close()` will NOT stop the server.
157
-
158
- ### Using the Context Manager
159
-
160
- The client supports context manager usage for automatic connection management:
161
-
162
- ```python
163
- from ecommerce_bot import EcommerceBotAction, EcommerceBotEnv
164
-
165
- # Connect with context manager (auto-connects and closes)
166
- with EcommerceBotEnv(base_url="http://localhost:8000") as env:
167
- result = env.reset()
168
- print(f"Reset: {result.observation.echoed_message}")
169
- # Multiple steps with low latency
170
- for msg in ["Hello", "World", "!"]:
171
- result = env.step(EcommerceBotAction(message=msg))
172
- print(f"Echoed: {result.observation.echoed_message}")
173
- ```
174
-
175
- The client uses WebSocket connections for:
176
- - **Lower latency**: No HTTP connection overhead per request
177
- - **Persistent session**: Server maintains your environment state
178
- - **Efficient for episodes**: Better for many sequential steps
179
-
180
- ### Concurrent WebSocket Sessions
181
-
182
- The server supports multiple concurrent WebSocket connections. To enable this,
183
- modify `server/app.py` to use factory mode:
184
-
185
- ```python
186
- # In server/app.py - use factory mode for concurrent sessions
187
- app = create_app(
188
- EcommerceBotEnvironment, # Pass class, not instance
189
- EcommerceBotAction,
190
- EcommerceBotObservation,
191
- max_concurrent_envs=4, # Allow 4 concurrent sessions
192
- )
193
- ```
194
-
195
- Then multiple clients can connect simultaneously:
196
-
197
- ```python
198
- from ecommerce_bot import EcommerceBotAction, EcommerceBotEnv
199
- from concurrent.futures import ThreadPoolExecutor
200
-
201
- def run_episode(client_id: int):
202
- with EcommerceBotEnv(base_url="http://localhost:8000") as env:
203
- result = env.reset()
204
- for i in range(10):
205
- result = env.step(EcommerceBotAction(message=f"Client {client_id}, step {i}"))
206
- return client_id, result.observation.message_length
207
-
208
- # Run 4 episodes concurrently
209
- with ThreadPoolExecutor(max_workers=4) as executor:
210
- results = list(executor.map(run_episode, range(4)))
211
- ```
212
-
213
- ## Development & Testing
214
-
215
- ### Direct Environment Testing
216
-
217
- Test the environment logic directly without starting the HTTP server:
218
-
219
- ```bash
220
- # From the server directory
221
- python3 server/ecommerce_bot_environment.py
222
- ```
223
-
224
- This verifies that:
225
- - Environment resets correctly
226
- - Step executes actions properly
227
- - State tracking works
228
- - Rewards are calculated correctly
229
-
230
- ### Running Locally
231
-
232
- Run the server locally for development:
233
-
234
- ```bash
235
- uvicorn server.app:app --reload
236
- ```
237
-
238
- ## Project Structure
239
-
240
- ```
241
- ecommerce_bot/
242
- ├── .dockerignore # Docker build exclusions
243
- ├── __init__.py # Module exports
244
- ├── README.md # This file
245
- ├── openenv.yaml # OpenEnv manifest
246
- ├── pyproject.toml # Project metadata and dependencies
247
- ├── uv.lock # Locked dependencies (generated)
248
- ├── client.py # EcommerceBotEnv client
249
- ├── models.py # Action and Observation models
250
- └── server/
251
- ├── __init__.py # Server module exports
252
- ├── ecommerce_bot_environment.py # Core environment logic
253
- ├── app.py # FastAPI application (HTTP + WebSocket endpoints)
254
- └── Dockerfile # Container image definition
255
- ```
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/__init__.py DELETED
@@ -1,16 +0,0 @@
1
- # Copyright (c) Meta Platforms, Inc. and affiliates.
2
- # All rights reserved.
3
- #
4
- # This source code is licensed under the BSD-style license found in the
5
- # LICENSE file in the root directory of this source tree.
6
-
7
- """Ecommerce Bot Environment."""
8
-
9
- from .client import EcommerceBotEnv
10
- from .models import EcommerceBotAction, EcommerceBotObservation
11
-
12
- __all__ = [
13
- "EcommerceBotAction",
14
- "EcommerceBotObservation",
15
- "EcommerceBotEnv",
16
- ]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/client.py DELETED
@@ -1,99 +0,0 @@
1
- # Copyright (c) Meta Platforms, Inc. and affiliates.
2
- # All rights reserved.
3
- #
4
- # This source code is licensed under the BSD-style license found in the
5
- # LICENSE file in the root directory of this source tree.
6
-
7
- """Ecommerce Bot Environment Client."""
8
-
9
- from typing import Dict
10
-
11
- from openenv.core import EnvClient
12
- from openenv.core.client_types import StepResult
13
- from openenv.core.env_server.types import State
14
-
15
- from .models import EcommerceBotAction, EcommerceBotObservation
16
-
17
-
18
- class EcommerceBotEnv(
19
- EnvClient[EcommerceBotAction, EcommerceBotObservation, State]
20
- ):
21
- """
22
- Client for the Ecommerce Bot Environment.
23
-
24
- This client maintains a persistent WebSocket connection to the environment server,
25
- enabling efficient multi-step interactions with lower latency.
26
- Each client instance has its own dedicated environment session on the server.
27
-
28
- Example:
29
- >>> # Connect to a running server
30
- >>> with EcommerceBotEnv(base_url="http://localhost:8000") as client:
31
- ... result = client.reset()
32
- ... print(result.observation.echoed_message)
33
- ...
34
- ... result = client.step(EcommerceBotAction(message="Hello!"))
35
- ... print(result.observation.echoed_message)
36
-
37
- Example with Docker:
38
- >>> # Automatically start container and connect
39
- >>> client = EcommerceBotEnv.from_docker_image("ecommerce_bot-env:latest")
40
- >>> try:
41
- ... result = client.reset()
42
- ... result = client.step(EcommerceBotAction(message="Test"))
43
- ... finally:
44
- ... client.close()
45
- """
46
-
47
- def _step_payload(self, action: EcommerceBotAction) -> Dict:
48
- """
49
- Convert EcommerceBotAction to JSON payload for step message.
50
-
51
- Args:
52
- action: EcommerceBotAction instance
53
-
54
- Returns:
55
- Dictionary representation suitable for JSON encoding
56
- """
57
- return {
58
- "message": action.message,
59
- }
60
-
61
- def _parse_result(self, payload: Dict) -> StepResult[EcommerceBotObservation]:
62
- """
63
- Parse server response into StepResult[EcommerceBotObservation].
64
-
65
- Args:
66
- payload: JSON response data from server
67
-
68
- Returns:
69
- StepResult with EcommerceBotObservation
70
- """
71
- obs_data = payload.get("observation", {})
72
- observation = EcommerceBotObservation(
73
- echoed_message=obs_data.get("echoed_message", ""),
74
- message_length=obs_data.get("message_length", 0),
75
- done=payload.get("done", False),
76
- reward=payload.get("reward"),
77
- metadata=obs_data.get("metadata", {}),
78
- )
79
-
80
- return StepResult(
81
- observation=observation,
82
- reward=payload.get("reward"),
83
- done=payload.get("done", False),
84
- )
85
-
86
- def _parse_state(self, payload: Dict) -> State:
87
- """
88
- Parse server response into State object.
89
-
90
- Args:
91
- payload: JSON response from state request
92
-
93
- Returns:
94
- State object with episode_id and step_count
95
- """
96
- return State(
97
- episode_id=payload.get("episode_id"),
98
- step_count=payload.get("step_count", 0),
99
- )
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/inference.py DELETED
@@ -1,86 +0,0 @@
1
- import httpx
2
- import sys
3
-
4
- # Configuration - Updated for OpenEnv
5
- SERVER_URL = "http://127.0.0.1:8000"
6
- TASK_NAME = "ecommerce_lifecycle_v1"
7
- MODEL_NAME = "Gemini-3-Flash"
8
-
9
- def call_env(endpoint, action_type=None, order_id=None, data=None):
10
- """
11
- Handles communication with the OpenEnv API.
12
- Unpacks the 'observation' automatically for the logic checks.
13
- """
14
- url = f"{SERVER_URL}/{endpoint}"
15
- payload = {
16
- "action_type": action_type,
17
- "order_id": order_id,
18
- "data": data
19
- }
20
- try:
21
- if endpoint == "reset":
22
- response = httpx.post(url, timeout=5.0)
23
- return response.json() # Returns raw observation
24
-
25
- # For /step, we get {observation, reward, done, info}
26
- response = httpx.post(url, json=payload, timeout=5.0)
27
- return response.json()
28
- except httpx.ConnectError:
29
- print("ERROR: Server offline. Run: python -m uvicorn server.app:app")
30
- sys.exit(1)
31
-
32
- def run_suite():
33
- # MANDATORY HACKATHON LOG START
34
- print(f"[START] task={TASK_NAME} env=ecommerce_bot model={MODEL_NAME}")
35
-
36
- # --- RESET ---
37
- call_env("reset")
38
-
39
- # --- STEP 1: CREATE ORDER ---
40
- res1 = call_env("step", "create_order", "MU-VOLLEY-01", "Mumbai University,2000.0")
41
- obs1 = res1.get("observation", {})
42
- print(f"[STEP] step=1 action=create_order reward={res1.get('reward')} done={res1.get('done')}")
43
- print(f" Result: {'SUCCESS' if obs1.get('success') else 'FAILED'} | Msg: {obs1.get('status_msg')}")
44
-
45
- # --- STEP 2: UPDATE ADDRESS ---
46
- res2 = call_env("step", "update_address", "MU-VOLLEY-01", "Hostel Block A, Marine Drive")
47
- obs2 = res2.get("observation", {})
48
- print(f"[STEP] step=2 action=update_address reward={res2.get('reward')} done={res2.get('done')}")
49
-
50
- # --- STEP 3: QUERY & REASONING ---
51
- q_data = call_env("step", "query_order", "103")
52
- obs3 = q_data.get("observation", {})
53
- if obs3.get("success"):
54
- price = obs3['order_details']['price']
55
- # Automated reasoning for refund
56
- ref_res = call_env("step", "issue_refund", "103", str(price * 0.5))
57
- print(f"[STEP] step=3 action=issue_refund reward={ref_res.get('reward')} done={ref_res.get('done')}")
58
-
59
- # --- STEP 4: HITL TRIGGER ---
60
- risk_data = call_env("step", "issue_refund", "101", "450.0")
61
- obs4 = risk_data.get("observation", {})
62
- msg4 = obs4.get("status_msg", "")
63
-
64
- print(f"[STEP] step=4 action=high_risk_refund reward={risk_data.get('reward')} done={risk_data.get('done')}")
65
- if "escalated" in (msg4 or "").lower():
66
- print(f" Safety: {msg4} (HITL TRIGGERED)")
67
-
68
- # --- STEP 5: LOCK VERIFICATION ---
69
- lock_data = call_env("step", "update_address", "101", "Worli Sea Face")
70
- obs5 = lock_data.get("observation", {})
71
- print(f"[STEP] step=5 action=verify_lock reward={lock_data.get('reward')} done={lock_data.get('done')}")
72
- if not obs5.get("success"):
73
- print(f" Policy: {obs5.get('status_msg')} (PASSED)")
74
-
75
- # --- STEP 6: LOGISTICS ---
76
- ship_data = call_env("step", "update_address", "102", "Dharavi")
77
- obs6 = ship_data.get("observation", {})
78
- print(f"[STEP] step=6 action=logistics_check reward={ship_data.get('reward')} done={ship_data.get('done')}")
79
-
80
-
81
- # Total score calculation for the demo
82
- final_score = 1.0 # Assuming all guardrails passed
83
- print(f"[END] success=True steps=6 score={final_score}")
84
-
85
- if __name__ == "__main__":
86
- run_suite()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/models.py DELETED
@@ -1,14 +0,0 @@
1
- from pydantic import BaseModel, Field
2
- from typing import Optional
3
-
4
- class Action(BaseModel):
5
- # This tells the LLM what tools it has
6
- action_type: str = Field(description="One of: query_order, update_address, issue_refund")
7
- order_id: str = Field(description="The 3-digit order ID")
8
- data: Optional[str] = Field(description="New address or reason for refund", default=None)
9
-
10
- class Observation(BaseModel):
11
- # This is what the LLM 'sees' after an action
12
- status_msg: str
13
- order_details: Optional[dict] = None
14
- success: bool
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/openenv.yaml DELETED
@@ -1,38 +0,0 @@
1
- spec_version: "1.0"
2
- name: "ecommerce_bot"
3
- version: "0.1.0"
4
- description: "An AI agent for managing e-commerce order updates and support triage."
5
-
6
- # CRITICAL: Tells the validator where your FastAPI app lives
7
- entry_point: "server.app:app"
8
-
9
- # Defining the 3 required tasks (Easy, Medium, Hard)
10
- tasks:
11
- - id: "address_update_101"
12
- name: "Update Order Address"
13
- difficulty: "easy"
14
- description: "Update shipping address for order 101 to '789 Bandra West'."
15
- goal: "Set address of 101 to '789 Bandra West'"
16
- grader: "programmatic" # Tells the system to look for your internal scoring logic
17
-
18
- - id: "status_check_102"
19
- name: "Order Status Query"
20
- difficulty: "medium"
21
- description: "Retrieve current status for order 102."
22
- goal: "Verify order 102 status is 'Shipped'"
23
- grader: "programmatic"
24
-
25
- - id: "refund_processing_103"
26
- name: "Partial Refund"
27
- difficulty: "hard"
28
- description: "Issue a 50% refund (250) for the delayed order 103."
29
- goal: "Process 250 refund and update status to 'Refunded'"
30
- grader: "programmatic"
31
-
32
- # Infrastructure constraints (Matches Hackathon Limits)
33
- runtime:
34
- type: "docker"
35
- image: "ecommerce_bot_env:latest"
36
- resources:
37
- cpu: 2
38
- memory: "8GB"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/pyproject.toml DELETED
@@ -1,34 +0,0 @@
1
- # Copyright (c) Meta Platforms, Inc. and affiliates.
2
- # All rights reserved.
3
-
4
- [build-system]
5
- requires = ["setuptools>=45", "wheel"]
6
- build-backend = "setuptools.build_meta"
7
-
8
- [project]
9
- name = "openenv-ecommerce_bot"
10
- version = "0.1.0"
11
- description = "Ecommerce Bot environment for OpenEnv"
12
- requires-python = ">=3.10"
13
- dependencies = [
14
- "openenv-core[core]>=0.2.2",
15
- "fastapi",
16
- "uvicorn",
17
- "python-multipart"
18
- ]
19
-
20
- [project.optional-dependencies]
21
- dev = [
22
- "pytest>=8.0.0",
23
- "pytest-cov>=4.0.0",
24
- ]
25
-
26
- [project.scripts]
27
- # This points directly to your app.py inside the server folder
28
- server = "server.app:main"
29
-
30
- [tool.setuptools]
31
- include-package-data = true
32
- # We are telling the system to just look at the 'server' folder we created
33
- packages = ["server"]
34
- package-dir = { "" = "." }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/server/__init__.py DELETED
@@ -1,11 +0,0 @@
1
- # Copyright (c) Meta Platforms, Inc. and affiliates.
2
- # All rights reserved.
3
- #
4
- # This source code is licensed under the BSD-style license found in the
5
- # LICENSE file in the root directory of this source tree.
6
-
7
- """Ecommerce Bot environment server components."""
8
-
9
- from .ecommerce_bot_environment import EcommerceBotEnvironment
10
-
11
- __all__ = ["EcommerceBotEnvironment"]
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/server/app.py DELETED
@@ -1,108 +0,0 @@
1
- import sys
2
- import os
3
- from pathlib import Path
4
- from fastapi import FastAPI
5
- from fastapi.middleware.cors import CORSMiddleware
6
- from typing import Dict, Any
7
-
8
- # 1. Path Management: Ensure models.py is findable
9
- # We look one level up from the /server folder
10
- BASE_DIR = Path(__file__).parent.parent
11
- sys.path.append(str(BASE_DIR))
12
-
13
- try:
14
- from models import Action, Observation
15
- from .ecommerce_bot_environment import EcommerceBotEnvironment
16
- except ImportError as e:
17
- print(f"CRITICAL ERROR: Missing modules. Check your folder structure. {e}")
18
- sys.exit(1)
19
-
20
- # 2. Initialize FastAPI
21
- app = FastAPI(
22
- title="Meta x Scalar: OpenEnv Ecommerce Bot",
23
- description="Agentic System for Real-World E-commerce Automation",
24
- version="1.0.0"
25
- )
26
-
27
- # 3. Add CORS (Allows the Hugging Face UI to talk to your API)
28
- app.add_middleware(
29
- CORSMiddleware,
30
- allow_origins=["*"],
31
- allow_methods=["*"],
32
- allow_headers=["*"],
33
- )
34
-
35
- # 4. Initialize the Environment
36
- # This triggers the SQLite connection in your EcommerceBotEnvironment class
37
- env = EcommerceBotEnvironment()
38
-
39
- # --- ROUTES ---
40
-
41
- @app.get("/")
42
- async def root():
43
- """Entry point for Hugging Face Spaces UI."""
44
- return {
45
- "message": "E-commerce Bot API is running",
46
- "status": "online",
47
- "spec": "OpenEnv v1.0",
48
- "university": "Mumbai University Campus"
49
- }
50
-
51
- @app.get("/health")
52
- async def health():
53
- """
54
- DOCKER HEALTHCHECK:
55
- Matches the 'CMD curl' in your Dockerfile to ensure container status is 'Healthy'.
56
- """
57
- return {"status": "healthy", "database": "connected"}
58
-
59
- @app.get("/state")
60
- async def get_state():
61
- """
62
- MANDATORY OPENENV ENDPOINT:
63
- Used by 'openenv validate' to check readiness before testing starts.
64
- """
65
- return {
66
- "status": "ready",
67
- "tasks": ["create_order", "update_address", "issue_refund"],
68
- "persistance": "sqlite3"
69
- }
70
-
71
- @app.post("/reset")
72
- async def reset():
73
- """
74
- Standard OpenEnv Reset.
75
- Clears local memory (but keeps the SQLite DB persistent).
76
- """
77
- observation = env.reset()
78
- return observation
79
-
80
- @app.post("/step")
81
- async def step(action: Action):
82
- """
83
- Standard OpenEnv Step.
84
- Returns the mandatory 4-part tuple (obs, reward, done, info).
85
- """
86
- # Unpack the environment logic
87
- observation, reward, done, info = env.step(action)
88
-
89
- # Cast values to ensure JSON compatibility for the grader
90
- return {
91
- "observation": observation,
92
- "reward": float(reward),
93
- "done": bool(done),
94
- "info": info
95
- }
96
-
97
- # 5. Clean Shutdown
98
- @app.on_event("shutdown")
99
- def shutdown_event():
100
- """Closes connections when the container stops."""
101
- print("Shutting down E-commerce Bot Server...")
102
-
103
- # 6. Local Debugging Support
104
- if __name__ == "__main__":
105
- import uvicorn
106
- # Use environment port if available (for HF Spaces), otherwise default to 8000
107
- port = int(os.environ.get("PORT", 8000))
108
- uvicorn.run(app, host="0.0.0.0", port=port)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/server/ecommerce_bot_environment.py DELETED
@@ -1,169 +0,0 @@
1
- import logging
2
- import sqlite3
3
- import sys
4
- from pathlib import Path
5
- from typing import Tuple, Dict, Any
6
-
7
- # 1. Professional Logger Setup
8
- logging.basicConfig(
9
- filename='bot_activity.log',
10
- level=logging.INFO,
11
- format='%(asctime)s - %(levelname)s - %(message)s'
12
- )
13
-
14
- # Add project root to path to ensure models can be imported
15
- sys.path.append(str(Path(__file__).parent.parent))
16
- from models import Action, Observation
17
-
18
- DB_PATH = "orders.db"
19
-
20
- def init_db():
21
- """Initializes the database with advanced state tracking columns."""
22
- conn = sqlite3.connect(DB_PATH)
23
- cursor = conn.cursor()
24
- cursor.execute('''
25
- CREATE TABLE IF NOT EXISTS orders (
26
- id TEXT PRIMARY KEY,
27
- status TEXT,
28
- address TEXT,
29
- price REAL,
30
- requires_human INTEGER DEFAULT 0
31
- )
32
- ''')
33
-
34
- # Seed data strictly aligned with openenv.yaml tasks
35
- seed_data = [
36
- ('101', 'Processing', '123 Mumbai St', 500.0, 0),
37
- ('102', 'Shipped', '456 Delhi Rd', 1200.0, 0),
38
- ('103', 'Delayed', '789 Bandra West', 500.0, 0)
39
- ]
40
- cursor.executemany("INSERT OR IGNORE INTO orders VALUES (?, ?, ?, ?, ?)", seed_data)
41
- conn.commit()
42
- conn.close()
43
-
44
- init_db()
45
-
46
- class EcommerceBotEnvironment:
47
- def _get_connection(self):
48
- return sqlite3.connect(DB_PATH)
49
-
50
- def reset(self) -> Observation:
51
- """Standard OpenEnv Reset Protocol."""
52
- logging.info("System Reset: Database state verified.")
53
- return Observation(status_msg="Database Connected & Ready", success=True)
54
-
55
- def step(self, action: Action) -> Tuple[Observation, float, bool, Dict[str, Any]]:
56
- """
57
- OpenEnv Compliant Step Function.
58
- Returns: (Observation, reward, done, info)
59
- """
60
- conn = self._get_connection()
61
- cursor = conn.cursor()
62
-
63
- # Initialize OpenEnv tracking variables
64
- reward = 0.0
65
- done = False
66
- info = {"task_id": action.order_id}
67
-
68
- logging.info(f"EXECUTION: {action.action_type} on Order {action.order_id}")
69
-
70
- # --- TASK 0: DYNAMIC ONBOARDING (Registration) ---
71
- if action.action_type == "create_order":
72
- try:
73
- addr, prc = action.data.split(",")
74
- cursor.execute(
75
- "INSERT INTO orders (id, status, address, price, requires_human) VALUES (?, ?, ?, ?, ?)",
76
- (action.order_id, "Processing", addr, float(prc), 0)
77
- )
78
- conn.commit()
79
- conn.close()
80
- return Observation(status_msg="Order Created", success=True), 1.0, True, info
81
- except Exception as e:
82
- conn.close()
83
- return Observation(status_msg=str(e), success=False), 0.0, False, info
84
-
85
- # Validate Order Existence
86
- cursor.execute("SELECT status, address, price, requires_human FROM orders WHERE id = ?", (action.order_id,))
87
- row = cursor.fetchone()
88
-
89
- if not row:
90
- conn.close()
91
- return Observation(status_msg="Order Not Found", success=False), 0.0, False, info
92
-
93
- status, address, price, requires_human = row
94
-
95
- # --- SAFETY GUARDRAIL: HITL LOCK ---
96
- if requires_human == 1 and action.action_type != "query_order":
97
- conn.close()
98
- # Penalize for ignoring a security lock
99
- return Observation(status_msg="Order locked for Human Review.", success=False), -0.5, True, info
100
-
101
- # --- TASK 1 (MEDIUM): STATUS QUERY ---
102
- if action.action_type == "query_order":
103
- conn.close()
104
- details = {"status": status, "address": address, "price": price}
105
- # Partial reward for information retrieval
106
- if action.order_id == "102" and status == "Shipped":
107
- reward = 1.0
108
- done = True
109
- else:
110
- reward = 0.2
111
- return Observation(status_msg="Found", order_details=details, success=True), reward, done, info
112
-
113
- # --- TASK 2 (EASY): ADDRESS UPDATE ---
114
- if action.action_type == "update_address":
115
- # Guardrail: Non-manipulatable state
116
- if status == "Shipped":
117
- conn.close()
118
- return Observation(status_msg="Cannot update shipped order", success=False), 0.0, True, info
119
-
120
- # Guardrail: Logistics Constraints
121
- restricted = ["International", "Restricted", "No-Go Zone"]
122
- if any(zone.lower() in action.data.lower() for zone in restricted):
123
- conn.close()
124
- # Reward for identifying a boundary correctly
125
- return Observation(status_msg="Restricted Area detected", success=False), 0.5, True, info
126
-
127
- cursor.execute("UPDATE orders SET address = ? WHERE id = ?", (action.data, action.order_id))
128
- conn.commit()
129
- conn.close()
130
-
131
- # Grader: Match goal in openenv.yaml
132
- if action.order_id == "101" and action.data == "789 Bandra West":
133
- reward = 1.0
134
- done = True
135
- else:
136
- reward = 0.5
137
- return Observation(status_msg="Address Updated", success=True), reward, done, info
138
-
139
- # --- TASK 3 (HARD): REFUND PROCESSING ---
140
- if action.action_type == "issue_refund":
141
- try:
142
- refund_amt = float(action.data)
143
- limit = price * 0.5
144
-
145
- # Grader: Escalation Logic
146
- if refund_amt > limit:
147
- cursor.execute("UPDATE orders SET requires_human = 1 WHERE id = ?", (action.order_id,))
148
- conn.commit()
149
- conn.close()
150
- # Reward for identifying high-risk correctly
151
- return Observation(status_msg="Escalated to Human", success=True), 0.8, True, info
152
-
153
- cursor.execute("UPDATE orders SET status = 'Refunded' WHERE id = ?", (action.order_id,))
154
- conn.commit()
155
- conn.close()
156
-
157
- # Grader: Task Goal
158
- if action.order_id == "103" and refund_amt == 250.0:
159
- reward = 1.0
160
- done = True
161
- else:
162
- reward = 0.4
163
- return Observation(status_msg="Refund Processed", success=True), reward, done, info
164
- except ValueError:
165
- conn.close()
166
- return Observation(status_msg="Invalid Amount", success=False), 0.0, False, info
167
-
168
- conn.close()
169
- return Observation(status_msg="Unknown Action", success=False), 0.0, False, info
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ecommerce_bot/server/placeholder.txt DELETED
File without changes
ecommerce_bot/server/requirements.txt DELETED
@@ -1,6 +0,0 @@
1
- openenv[core]>=0.2.0
2
- fastapi>=0.115.0
3
- uvicorn>=0.24.0
4
-
5
-
6
-
 
 
 
 
 
 
 
ecommerce_bot/view_db.py DELETED
@@ -1,22 +0,0 @@
1
- import sqlite3
2
- import pandas as pd # Optional: if you have pandas installed
3
-
4
- def check_my_data():
5
- conn = sqlite3.connect("orders.db")
6
- cursor = conn.cursor()
7
-
8
- print("\n--- CURRENT DATABASE STATE ---")
9
- cursor.execute("SELECT * FROM orders")
10
- rows = cursor.fetchall()
11
-
12
- # Column Headers for clarity
13
- print(f"{'ID':<15} | {'Status':<15} | {'Address':<30} | {'Price':<10} | {'HITL Lock'}")
14
- print("-" * 85)
15
-
16
- for row in rows:
17
- print(f"{row[0]:<15} | {row[1]:<15} | {row[2]:<30} | {row[3]:<10} | {row[4]}")
18
-
19
- conn.close()
20
-
21
- if __name__ == "__main__":
22
- check_my_data()