fere-sdk 0.4.0.dev33__tar.gz → 0.5.0.dev35__tar.gz

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/.gitignore

@@ -8,6 +8,8 @@ __pycache__
 # Devcontainer local env (contains secrets)
 .devcontainer/.env.local
 .devcontainer/.env.local.override
+.devcontainer/.env.runtime.local
+.devcontainer/.env.runtime.*.local
 .devcontainer/.env.gitpod
 
 # Bruno gateway collection (GATEWAY_AGENT_ID / GATEWAY_PRIVATE_KEY_B64)
@@ -43,6 +45,7 @@ dev/logs/*
 # Cursor SEO skill — regenerated report JSON (not source)
 .cursor/skills/seo-agent/artifacts/
 .cursor/skills/docker-images-cve-scan/artifacts/
+docs/plans/artifacts/
 
 # Skills installed locally by the skills package manager (see skills-lock.json)
 .claude/skills/stripe-best-practices
@@ -52,6 +55,7 @@ dev/logs/*
 
 # agentmemory iii state (SQLite + streams under .agentmemory/data/)
 .agentmemory/data/
+.devcontainer/agentmemory-mcp/node_modules/
 
 # Local GEO upstream reference (optional clone; not part of the product tree)
 geo-seo/

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fere-sdk
-Version: 0.4.0.dev33
+Version: 0.5.0.dev35
 Summary: Python SDK for the FereAI Gateway API
 Author-email: Fere AI <info@fere.ai>
 License-Expression: MIT

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fere-sdk"
-version = "0.4.0.dev33"
+version = "0.5.0.dev35"
 description = "Python SDK for the FereAI Gateway API"
 readme = "README.md"
 requires-python = ">=3.10"

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/src/fere_sdk/client.py

@@ -22,6 +22,11 @@ from .models import (
     DepositRequest,
     HooksRequest,
     LimitOrderRequest,
+    PerpCancelRequest,
+    PerpCloseRequest,
+    PerpFundRequest,
+    PerpOpenRequest,
+    PerpWithdrawRequest,
     SecurityCheckResponse,
     SwapRequest,
     TokenToCheck,
@@ -274,10 +279,124 @@ class FereClient:
         req = WithdrawRequest(position_id=position_id, amount_usdc=amount_usdc)
         return await self._api.withdraw(req, wait=True, timeout=timeout)
 
+    # ----------------------------------------------------------
+    # Perp — venue-neutral perpetual futures (blocks until complete)
+    # ----------------------------------------------------------
+
+    async def perp_open(
+        self,
+        asset: str,
+        is_buy: bool,
+        size: float,
+        leverage: int = 1,
+        is_cross: bool = True,
+        order_type: str = "market",
+        limit_price: float | None = None,
+        slippage_pct: float = 0.5,
+        reduce_only: bool = False,
+        tp_price: float | None = None,
+        sl_price: float | None = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Open a perpetual position and wait for completion.
+
+        ``size`` is in contracts (not smallest units).
+        """
+        req = PerpOpenRequest(
+            asset=asset,
+            is_buy=is_buy,
+            size=size,
+            leverage=leverage,
+            is_cross=is_cross,
+            order_type=order_type,
+            limit_price=limit_price,
+            slippage_pct=slippage_pct,
+            reduce_only=reduce_only,
+            tp_price=tp_price,
+            sl_price=sl_price,
+        )
+        return await self._api.perp_open(req, wait=True, timeout=timeout)
+
+    async def perp_close(
+        self,
+        asset: str,
+        size: float | None = None,
+        slippage_pct: float = 0.5,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Close a perpetual position and wait for completion."""
+        req = PerpCloseRequest(
+            asset=asset, size=size, slippage_pct=slippage_pct
+        )
+        return await self._api.perp_close(req, wait=True, timeout=timeout)
+
+    async def perp_cancel_order(
+        self,
+        asset: str,
+        order_id: int,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Cancel an open perp order and wait for completion."""
+        req = PerpCancelRequest(asset=asset, order_id=order_id)
+        return await self._api.perp_cancel_order(
+            req, wait=True, timeout=timeout
+        )
+
+    async def perp_setup(
+        self,
+        force_rerun: bool = False,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Provision perp trading and wait for completion."""
+        return await self._api.perp_setup(
+            force_rerun=force_rerun, wait=True, timeout=timeout
+        )
+
+    async def perp_fund(
+        self,
+        amount: str,
+        source_chain_id: int,
+        source_token: str | None = None,
+        display_amount_usd: float | None = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Fund the perp account and wait for completion."""
+        req = PerpFundRequest(
+            amount=amount,
+            source_chain_id=source_chain_id,
+            source_token=source_token,
+            display_amount_usd=display_amount_usd,
+        )
+        return await self._api.perp_fund(req, wait=True, timeout=timeout)
+
+    async def perp_withdraw(
+        self,
+        amount_usd: float,
+        destination_chain_id: int,
+        destination_token: str | None = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> dict:
+        """Withdraw perp collateral and wait for completion."""
+        req = PerpWithdrawRequest(
+            amount_usd=amount_usd,
+            destination_chain_id=destination_chain_id,
+            destination_token=destination_token,
+        )
+        return await self._api.perp_withdraw(req, wait=True, timeout=timeout)
+
     # ----------------------------------------------------------
     # Read-only (pass-through)
     # ----------------------------------------------------------
 
+    async def get_perp_markets(self, search_text: str | None = None) -> dict:
+        return await self._api.get_perp_markets(search_text=search_text)
+
+    async def get_perp_setup_status(self) -> dict:
+        return await self._api.get_perp_setup_status()
+
+    async def get_perp_orders(self) -> dict:
+        return await self._api.get_perp_orders()
+
     async def get_wallets(self) -> dict:
         return await self._api.get_wallets()
 

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/src/fere_sdk/low_level.py

@@ -16,6 +16,11 @@ from .models import (
     DepositRequest,
     HooksRequest,
     LimitOrderRequest,
+    PerpCancelRequest,
+    PerpCloseRequest,
+    PerpFundRequest,
+    PerpOpenRequest,
+    PerpWithdrawRequest,
     SecurityCheckResponse,
     SecurityCheckSummary,
     SwapRequest,
@@ -420,6 +425,111 @@ class FereAPI:
         """GET /v1/earn/positions"""
         return await self._authed_get("/v1/earn/positions")
 
+    # ----------------------------------------------------------
+    # Perp (venue-neutral perpetual futures)
+    # ----------------------------------------------------------
+
+    async def get_perp_markets(self, search_text: str | None = None) -> dict:
+        """GET /v1/perp/markets"""
+        params = {}
+        if search_text:
+            params["search_text"] = search_text
+        return await self._authed_get("/v1/perp/markets", params=params)
+
+    async def get_perp_setup_status(self) -> dict:
+        """GET /v1/perp/setup"""
+        return await self._authed_get("/v1/perp/setup")
+
+    async def get_perp_orders(self) -> dict:
+        """GET /v1/perp/orders"""
+        return await self._authed_get("/v1/perp/orders")
+
+    async def perp_setup(
+        self,
+        force_rerun: bool = False,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/setup"""
+        return await self._perp_task(
+            "/v1/perp/setup", {"force_rerun": force_rerun}, wait, timeout
+        )
+
+    async def perp_open(
+        self,
+        request: PerpOpenRequest,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/open"""
+        return await self._perp_task(
+            "/v1/perp/open", request.to_dict(), wait, timeout
+        )
+
+    async def perp_close(
+        self,
+        request: PerpCloseRequest,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/close"""
+        return await self._perp_task(
+            "/v1/perp/close", request.to_dict(), wait, timeout
+        )
+
+    async def perp_cancel_order(
+        self,
+        request: PerpCancelRequest,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/orders/cancel"""
+        return await self._perp_task(
+            "/v1/perp/orders/cancel", request.to_dict(), wait, timeout
+        )
+
+    async def perp_fund(
+        self,
+        request: PerpFundRequest,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/fund"""
+        return await self._perp_task(
+            "/v1/perp/fund", request.to_dict(), wait, timeout
+        )
+
+    async def perp_withdraw(
+        self,
+        request: PerpWithdrawRequest,
+        wait: bool = False,
+        timeout: int = 120,
+    ) -> TaskResponse | dict:
+        """POST /v1/perp/withdraw"""
+        return await self._perp_task(
+            "/v1/perp/withdraw", request.to_dict(), wait, timeout
+        )
+
+    async def _perp_task(
+        self,
+        path: str,
+        body: dict,
+        wait: bool,
+        timeout: int,
+    ) -> TaskResponse | dict:
+        params = {}
+        if wait:
+            params = {"wait": "true", "timeout": str(timeout)}
+        data = await self._authed_post(path, body, params=params)
+        if wait:
+            return data
+        return TaskResponse(
+            task_id=data["task_id"],
+            status=data.get("status", "queued"),
+            poll_url=data.get("poll_url"),
+            notification_stream=data.get("notification_stream"),
+        )
+
     # ----------------------------------------------------------
     # Tasks
     # ----------------------------------------------------------

{fere_sdk-0.4.0.dev33 → fere_sdk-0.5.0.dev35}/src/fere_sdk/models.py

@@ -5,6 +5,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
+# Perp models live in their own module; re-exported here for back-compat.
+from .perp_models import (  # noqa: E402,F401
+    PerpCancelRequest,
+    PerpCloseRequest,
+    PerpFundRequest,
+    PerpOpenRequest,
+    PerpWithdrawRequest,
+)
+
 __all__ = [
     "TaskResponse",
     "TaskStatusResponse",
@@ -18,6 +27,11 @@ __all__ = [
     "HooksRequest",
     "DepositRequest",
     "WithdrawRequest",
+    "PerpOpenRequest",
+    "PerpCloseRequest",
+    "PerpCancelRequest",
+    "PerpFundRequest",
+    "PerpWithdrawRequest",
     "TokenToCheck",
     "TokenSecurityResult",
     "SecurityCheckSummary",

fere_sdk-0.5.0.dev35/src/fere_sdk/perp_models.py

@@ -0,0 +1,115 @@
+"""Venue-neutral perpetual-futures request models.
+
+Kept in a dedicated module (rather than appended to ``models.py``) per the
+team convention of giving new model groups their own file. Re-exported from
+``models.py`` for backwards-compatible imports.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+__all__ = [
+    "PerpOpenRequest",
+    "PerpCloseRequest",
+    "PerpCancelRequest",
+    "PerpFundRequest",
+    "PerpWithdrawRequest",
+]
+
+
+@dataclass
+class PerpOpenRequest:
+    """Open a venue-neutral perpetual position. size is in contracts."""
+
+    asset: str
+    is_buy: bool
+    size: float
+    leverage: int = 1
+    is_cross: bool = True
+    order_type: str = "market"
+    limit_price: float | None = None
+    slippage_pct: float = 0.5
+    reduce_only: bool = False
+    tp_price: float | None = None
+    sl_price: float | None = None
+    tp_is_market: bool = True
+    sl_is_market: bool = True
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "asset": self.asset,
+            "is_buy": self.is_buy,
+            "size": self.size,
+            "leverage": self.leverage,
+            "is_cross": self.is_cross,
+            "order_type": self.order_type,
+            "slippage_pct": self.slippage_pct,
+            "reduce_only": self.reduce_only,
+            "tp_is_market": self.tp_is_market,
+            "sl_is_market": self.sl_is_market,
+        }
+        if self.limit_price is not None:
+            d["limit_price"] = self.limit_price
+        if self.tp_price is not None:
+            d["tp_price"] = self.tp_price
+        if self.sl_price is not None:
+            d["sl_price"] = self.sl_price
+        return d
+
+
+@dataclass
+class PerpCloseRequest:
+    asset: str
+    size: float | None = None
+    slippage_pct: float = 0.5
+
+    def to_dict(self) -> dict:
+        d: dict = {"asset": self.asset, "slippage_pct": self.slippage_pct}
+        if self.size is not None:
+            d["size"] = self.size
+        return d
+
+
+@dataclass
+class PerpCancelRequest:
+    asset: str
+    order_id: int
+
+    def to_dict(self) -> dict:
+        return {"asset": self.asset, "order_id": self.order_id}
+
+
+@dataclass
+class PerpFundRequest:
+    amount: str
+    source_chain_id: int
+    source_token: str | None = None
+    display_amount_usd: float | None = None
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "amount": self.amount,
+            "source_chain_id": self.source_chain_id,
+        }
+        if self.source_token is not None:
+            d["source_token"] = self.source_token
+        if self.display_amount_usd is not None:
+            d["display_amount_usd"] = self.display_amount_usd
+        return d
+
+
+@dataclass
+class PerpWithdrawRequest:
+    amount_usd: float
+    destination_chain_id: int
+    destination_token: str | None = None
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "amount_usd": self.amount_usd,
+            "destination_chain_id": self.destination_chain_id,
+        }
+        if self.destination_token is not None:
+            d["destination_token"] = self.destination_token
+        return d