# On the robot (aarch64) — recommended, broadest capability coverage
pip install wheels/ff_sdk-0.1.0a0-cp310-cp310-linux_aarch64.whl

# On a Linux dev machine (x86_64)
pip install wheels/ff_sdk-0.1.0a0-cp310-cp310-linux_x86_64.whl

python -c "import ff_sdk; print(ff_sdk.__version__)"

import asyncio, ff_sdk

async def main():
    async with await ff_sdk.connect("A2-DEMO") as robot:
        print(robot.diagnose())                       # health check first
        print(robot.capabilities())                   # see which capabilities are supported

        await robot.motion.stand()                    # stand up
        await robot.display.show_expression("smile")  # smile expression
        await robot.audio.say("Hello, I'm Futurist")  # TTS playback

        battery = await robot.state.battery()
        print(f"battery {battery.percent:.0%}")

        frame = await robot.vision.frame()            # grab one frame from the head camera
        with open("snapshot.jpg", "wb") as f:
            f.write(frame.data)

        await robot.motion.do_preset("stand_up")      # preset action (only stand_up / damping are live; wave is dry-run-only)

asyncio.run(main())

from ff_sdk import Config

cfg = Config.from_env()          # read from environment variables
cfg.transport_timeout = 8.0      # or change it in code
robot = await ff_sdk.connect("A2-DEMO", config=cfg)

async with await ff_sdk.connect("A2-DEMO") as robot:
    await robot.motion.stand()
# leaving the with block auto-calls close(); the connection won't leak even on exceptions

import math

def q_func(t: float) -> list[float]:
    # return the target joint position array (radians); t is seconds since the stream started
    return [0.3 * math.sin(2 * math.pi * 0.5 * t)]

async for tick in robot.motion.joint_stream(
        q_func, rate_hz=50.0, duration_s=5.0,
        joint_names=["right_shoulder_pitch"]):
    pass   # tick holds the per-frame dispatch receipt

from ff_sdk.core.exceptions import StateError

status = await robot.state.status()
battery = await robot.state.battery()

if battery.is_charging:
    print("charging — motion commands will be rejected with StateError; leave the dock first")
else:
    await robot.motion.stand()

await robot.audio.say("Welcome, I'm Futurist")   # ✅ live

# volume() / play_wav() are not yet integrated on A2 (raise CapabilityNotSupported):
# await robot.audio.volume(0.7)
# with open("chime.wav", "rb") as f:
#     await robot.audio.play_wav(f.read())

frame = await robot.vision.frame()
with open("snap.jpg", "wb") as f:
    f.write(frame.data)

# data is standard JPEG — feed it straight to OpenCV / PIL / your detection model
# import cv2, numpy as np
# img = cv2.imdecode(np.frombuffer(frame.data, np.uint8), cv2.IMREAD_COLOR)

names = await robot.display.list_expressions()
print(names)            # ('smile', 'blink', 'thinking', ...)

await robot.display.show_expression("smile")

from ff_sdk.capabilities.arm import ArmJointAngles

await robot.arm.pose_arm(
    ArmJointAngles(angles=(0.0, -0.4, 0.0, 1.2, 0.0, 0.0, 0.0), arm="right"),
    duration_s=2.0,
)
await robot.arm.grasp(arm="right")
await asyncio.sleep(1)
await robot.arm.release(arm="right")

frame = await robot.vision.frame()
result = await robot.checkin.recognize(frame.data)

if result.name:
    await robot.audio.say(f"Hello, {result.name}")
    await robot.display.show_expression("smile")
else:
    await robot.audio.say("Nice to meet you, may I have your name?")

from ff_sdk import skills

await skills.wave(robot)                  # on Futurist → do_preset("wave")
await skills.bow(robot)                   # → do_preset("bow")
await skills.greet(robot, "Mr. Wang", language="zh")
# greet = wave + TTS greeting (Futurist supports both, for the most complete effect)

report = robot.diagnose()
print(report)
# whether control / telemetry / audio / vision links are online — always check the health report first when troubleshooting