insighta-sdk 0.1.0__py3-none-any.whl

insighta_sdk/__init__.py

@@ -0,0 +1,41 @@
+"""Insighta Cloud SDK - API client and data models."""
+
+from .client import InsightaClient
+from .models import (
+    Credentials,
+    UploadConfig,
+    OrderGroup,
+    CashDeposit,
+    Trade,
+    Holding,
+    Deposit,
+    RateEntry,
+    Dirs,
+)
+from .utils import (
+    load_order_groups,
+    load_cash_deposits,
+    merge_and_sort_groups,
+    fetch_ticker_info,
+    load_rate_file,
+    lookup_rate,
+)
+
+__all__ = [
+    "InsightaClient",
+    "Credentials",
+    "UploadConfig",
+    "OrderGroup",
+    "CashDeposit",
+    "Trade",
+    "Holding",
+    "Deposit",
+    "RateEntry",
+    "Dirs",
+    "load_order_groups",
+    "load_cash_deposits",
+    "merge_and_sort_groups",
+    "fetch_ticker_info",
+    "load_rate_file",
+    "lookup_rate",
+]

insighta_sdk/client.py

@@ -0,0 +1,144 @@
+"""Insighta OpenAPI client."""
+
+import json as _json
+import logging
+import os
+
+import requests
+
+from .models import Credentials, OrderGroup, UploadConfig
+
+log = logging.getLogger(__name__)
+
+
+class InsightaClient:
+    """Insighta OpenAPI client."""
+
+    def __init__(self, credentials: Credentials, output_dir: str = "output"):
+        self.endpoint = credentials.endpoint
+        self.output_dir = output_dir
+        self.headers = {
+            "Authorization": f"Bearer {credentials.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def _request(self, method: str, path: str, **kwargs) -> requests.Response:
+        url = f"{self.endpoint}{path}"
+        payload = kwargs.get("json")
+        if payload is not None:
+            self._last_payload = payload
+            payload_str = _json.dumps(payload, indent=2, ensure_ascii=False)
+            log.debug("%s %s\n%s", method, url, payload_str)
+            log_path = os.path.join(self.output_dir, "request_payload.log")
+            with open(log_path, "a", encoding="utf-8") as lf:
+                lf.write(f"=== {method} {url} ===\n{payload_str}\n\n")
+        else:
+            log.debug("%s %s", method, url)
+        resp = requests.request(method, url, headers=self.headers, timeout=30, **kwargs)
+        log.debug("Response %s: %s", resp.status_code, resp.text)
+        resp.raise_for_status()
+        return resp
+
+    def create_portfolio(self, config: UploadConfig) -> str:
+        """POST /portfolios → portfolio_id 반환."""
+        items = [
+            {
+                "ticker": str(item["ticker"]),
+                "type": str(item.get("type", "stock")),
+                "quantity": float(item.get("quantity", 0)),
+                "ratio": float(item.get("ratio", 0)),
+                "price": float(item.get("price", 0)),
+                "sector": str(item.get("sector", "N/A")),
+                "industry": str(item.get("industry", "N/A")),
+            }
+            for item in config.items
+        ]
+        body = {
+            "name": config.name,
+            "description": config.description,
+            "type": config.portfolio_type,
+            "currency": config.currency,
+            "budget": float(config.budget),
+            "target_return": config.target_return,
+            "start_date": config.start_date,
+            "target_date": config.target_date,
+            "items": items,
+        }
+        if config.settings:
+            body["settings"] = config.settings
+        resp = self._request("POST", "/portfolios", json=body)
+        return resp.json()["portfolio_id"]
+
+    def get_portfolios(self) -> list[dict]:
+        """GET /portfolios → return caller's own portfolios."""
+        resp = self._request("GET", "/portfolios")
+        return resp.json()
+
+    def search_portfolios(
+        self,
+        search: str | None = None,
+        country: str | None = None,
+        sort_by: str | None = None,
+        last_item: str | None = None,
+    ) -> dict:
+        """GET /portfolios with search params."""
+        params = {k: v for k, v in {
+            "search": search, "country": country,
+            "sort_by": sort_by, "last_item": last_item,
+        }.items() if v is not None}
+        resp = self._request("GET", "/portfolios", params=params)
+        return resp.json()
+
+    def delete_portfolio(self, portfolio_id: str) -> None:
+        """DELETE /portfolios/{portfolio_id}."""
+        self._request("DELETE", f"/portfolios/{portfolio_id}")
+
+    def get_nav_history(self, portfolio_id: str) -> dict:
+        """GET /portfolios/{portfolio_id}/nav-history."""
+        resp = self._request("GET", f"/portfolios/{portfolio_id}/nav-history")
+        return resp.json()
+
+    def get_metrics_history(
+        self,
+        portfolio_id: str,
+        metrics: str = "twr",
+        from_t: int | None = None,
+        to_t: int | None = None,
+    ) -> dict:
+        """GET /portfolios/{portfolio_id}/metrics-history."""
+        params: dict = {"metrics": metrics}
+        if from_t is not None:
+            params["from_t"] = str(from_t)
+        if to_t is not None:
+            params["to_t"] = str(to_t)
+        resp = self._request(
+            "GET", f"/portfolios/{portfolio_id}/metrics-history",
+            params=params)
+        return resp.json()
+
+    def send_order(self, portfolio_id: str, order_group: OrderGroup, portfolio_currency: str) -> dict:
+        """POST /orders → 주문 그룹 하나 전송."""
+        body = {
+            "portfolio_id": portfolio_id,
+            "currency": portfolio_currency,
+            "payment_currency": order_group.currency,
+            "items": order_group.items,
+        }
+        if order_group.memo:
+            body["memo"] = order_group.memo
+        if order_group.exchange_rate:
+            body["custom_exchange_rate"] = order_group.exchange_rate
+            body["is_custom_exchange_rate"] = True
+        if order_group.cash_deposits:
+            body["cash_deposits"] = [
+                {k: v for k, v in {
+                    "type": d.type,
+                    "amount": d.amount,
+                    "currency": d.currency,
+                    "ticker": d.ticker,
+                    "timestamp": d.timestamp,
+                }.items() if v is not None}
+                for d in order_group.cash_deposits
+            ]
+        resp = self._request("POST", "/orders", json=body)
+        return resp.json() if resp.text else {}

insighta_sdk/models.py

@@ -0,0 +1,212 @@
+"""Data models for Insighta SDK."""
+
+import csv
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+
+import yaml
+
+WORKSPACES_DIR = "workspaces"
+JST = timezone(timedelta(hours=9))
+
+
+@dataclass
+class Credentials:
+    api_key: str
+    endpoint: str
+
+    @property
+    def masked_key(self) -> str:
+        if len(self.api_key) <= 8:
+            return "****"
+        return self.api_key[:4] + "****" + self.api_key[-4:]
+
+    @classmethod
+    def from_file(cls, path: str) -> "Credentials":
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        return cls(api_key=data["api_key"], endpoint=data["endpoint"].rstrip("/"))
+
+
+@dataclass
+class UploadConfig:
+    name: str
+    description: str
+    portfolio_type: str
+    currency: str
+    budget: Decimal
+    balance: Decimal
+    order_file: str
+    target_return: float = 0.0
+    start_date: str = ""
+    target_date: str = ""
+    items: list = field(default_factory=list)
+    cash_deposits_file: str | None = None
+    memo_file: str | None = None
+    settings: dict | None = None
+
+    @classmethod
+    def from_file(cls, path: str) -> "UploadConfig":
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        p = data["portfolio"]
+        files = data.get("files", {})
+        return cls(
+            name=p["name"],
+            description=p.get("description", ""),
+            portfolio_type=p["type"],
+            currency=p["currency"],
+            budget=Decimal(str(p["budget"])),
+            balance=Decimal(str(p["budget"])),
+            target_return=float(p.get("target_return", 0)),
+            start_date=p.get("start_date", ""),
+            target_date=p.get("target_date", ""),
+            items=p.get("items", []),
+            order_file=files["order"],
+            cash_deposits_file=files.get("cash_deposits"),
+            memo_file=files.get("memo"),
+            settings=p.get("settings"),
+        )
+
+
+@dataclass
+class CashDeposit:
+    type: str       # budget | dividend
+    amount: float
+    currency: str | None = None
+    ticker: str | None = None
+    timestamp: int | None = None
+
+
+@dataclass
+class OrderGroup:
+    group_id: str
+    currency: str
+    items: list = field(default_factory=list)
+    cash_deposits: list[CashDeposit] = field(default_factory=list)
+    exchange_rate: float | None = None
+    memo: str = ""
+
+
+@dataclass
+class Trade:
+    dt: str          # ISO 8601 JST
+    ticker: str
+    qty: int
+    acct: str
+    price: Decimal
+    avg: Decimal
+    cur: str         # 決済通貨 (JPY or USD)
+    base: str = "USD"  # 銘柄の基準通貨
+
+
+@dataclass
+class Holding:
+    ticker: str
+    acct: str
+    qty: int
+    cost: Decimal = Decimal("0")
+    price: Decimal = Decimal("0")
+    pnl: Decimal = Decimal("0")
+
+
+@dataclass
+class Deposit:
+    dt: str          # ISO 8601 JST or raw datetime
+    amount: Decimal
+    cur: str
+    type: str = "budget"  # budget | dividend
+    ticker: str = ""
+    rate: Decimal | None = None
+
+
+@dataclass
+class RateEntry:
+    start: str
+    end: str
+    pair: str
+    rate: Decimal
+
+
+@dataclass
+class Dirs:
+    """作業ディレクトリ設定。--work オプションで切り替え可能。"""
+    work: str = ""
+
+    @classmethod
+    def from_work(cls, work: str = "") -> "Dirs":
+        return cls(work=work)
+
+    @property
+    def _base(self) -> str:
+        return os.path.join(WORKSPACES_DIR, self.work) if self.work else ""
+
+    @property
+    def input(self) -> str:
+        return os.path.join(self._base, "input") if self._base else "input"
+
+    @property
+    def output(self) -> str:
+        return os.path.join(self._base, "output") if self._base else "output"
+
+    @property
+    def history(self) -> str:
+        return os.path.join(self.input, "history")
+
+    @property
+    def summary(self) -> str:
+        return os.path.join(self.input, "summary")
+
+    @property
+    def seed(self) -> str:
+        return os.path.join(self.input, "seed")
+
+    @property
+    def deposit(self) -> str:
+        return os.path.join(self.input, "deposit")
+
+    @property
+    def exchange(self) -> str:
+        return os.path.join(self.input, "currency_exchange")
+
+    @property
+    def manual(self) -> str:
+        return os.path.join(self.input, "manual")
+
+    @property
+    def rate_csv(self) -> str:
+        return os.path.join(self.input, "rate.csv")
+
+    @property
+    def ratio_csv(self) -> str:
+        return os.path.join(self.input, "ratio.csv")
+
+    @property
+    def history_csv(self) -> str:
+        return os.path.join(self.output, "history.csv")
+
+    @property
+    def order_csv(self) -> str:
+        return os.path.join(self.output, "order.csv")
+
+    @property
+    def upload_yaml(self) -> str:
+        return os.path.join(self.output, "upload.yaml")
+
+    @property
+    def memo_csv(self) -> str:
+        return os.path.join(self.output, "memo.csv")
+
+    @property
+    def cash_deposits_csv(self) -> str:
+        return os.path.join(self.output, "cash_deposits.csv")
+
+    @property
+    def request_payload_log(self) -> str:
+        return os.path.join(self.output, "request_payload.log")
+
+    def ensure_output(self):
+        """output ディレクトリを作成する。"""
+        os.makedirs(self.output, exist_ok=True)

insighta_sdk/utils.py

@@ -0,0 +1,148 @@
+"""Utility functions for Insighta SDK."""
+
+import csv
+from collections import OrderedDict
+from datetime import datetime, timezone
+from decimal import Decimal
+
+import requests
+
+from .models import CashDeposit, OrderGroup, RateEntry
+
+
+def _parse_timestamp(val: str) -> int | None:
+    if not val:
+        return None
+    try:
+        return int(val)
+    except ValueError:
+        pass
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M"):
+        try:
+            return int(datetime.strptime(val, fmt).replace(tzinfo=timezone.utc).timestamp() * 1000)
+        except ValueError:
+            continue
+    return None
+
+
+def load_order_groups(filepath: str) -> list[OrderGroup]:
+    """order.csv를 읽어서 group_dt별로 묶어 반환."""
+    groups: OrderedDict[str, OrderGroup] = OrderedDict()
+    with open(filepath, "r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            gdt = row["group_dt"]
+            rate_val = row.get("rate", "").strip() if row.get("rate") else ""
+            if gdt not in groups:
+                groups[gdt] = OrderGroup(
+                    group_id=gdt,
+                    currency=row.get("settle_currency", row["currency"]),
+                    exchange_rate=float(rate_val) if rate_val else None,
+                )
+            groups[gdt].items.append({
+                "id": row["ticker"],
+                "ticker": row["ticker"],
+                "quantity": float(row["quantity"]),
+                "price": float(row["price"]),
+                "currency": row["currency"],
+                "price_type": row["price_type"],
+                "timestamp": _parse_timestamp(row.get("timestamp", "")),
+            })
+    return list(groups.values())
+
+
+def load_cash_deposits(filepath: str) -> dict[str, list[CashDeposit]]:
+    """cash_deposits.csv를 읽어서 group_dt별로 묶어 반환."""
+    groups: dict[str, list[CashDeposit]] = {}
+    with open(filepath, "r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            gdt = row["group_dt"]
+            groups.setdefault(gdt, []).append(CashDeposit(
+                type=row["type"],
+                amount=float(row["amount"]),
+                currency=row.get("currency") or None,
+                ticker=row.get("ticker") or None,
+                timestamp=_parse_timestamp(row.get("timestamp", "")),
+            ))
+    return groups
+
+
+def merge_and_sort_groups(
+    orders: list[OrderGroup],
+    deposits_by_gdt: dict[str, list[CashDeposit]],
+    memos: dict[str, str],
+) -> list[OrderGroup]:
+    """order + deposit을 group_dt 기준으로 머지하고 시간순 정렬."""
+    existing_gdts = {g.group_id for g in orders}
+    for gdt, deps in deposits_by_gdt.items():
+        if gdt not in existing_gdts:
+            cur = deps[0].currency or "USD"
+            orders.append(OrderGroup(group_id=gdt, currency=cur))
+    deps_map = dict(deposits_by_gdt)
+    for g in orders:
+        if g.group_id in deps_map:
+            g.cash_deposits = deps_map[g.group_id]
+
+    def _sort_key(g: OrderGroup):
+        ts = _parse_timestamp(g.group_id)
+        return ts if ts is not None else float("inf")
+    orders.sort(key=_sort_key)
+    for i, g in enumerate(orders, 1):
+        g.group_id = str(i)
+    for g in orders:
+        if g.group_id in memos:
+            g.memo = memos[g.group_id]
+    return orders
+
+
+def fetch_ticker_info(tickers: list[str]) -> dict[str, dict]:
+    """Insighta /tickers/info API로 sector/industry/type 조회."""
+    if not tickers:
+        return {}
+    resp = requests.get(
+        "https://api.insighta.cloud/tickers/info",
+        params={"tickers": ",".join(tickers), "conditions": "sector,industry,type"},
+        timeout=10,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def load_rate_file(filepath: str) -> list[RateEntry]:
+    """為替レートCSVを読み込む。
+
+    CSV format:
+        from,to,pair,rate
+        2024/01/01,2024/12/31,USD/JPY,155.50
+    """
+    entries: list[RateEntry] = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            entries.append(RateEntry(
+                start=row["from"].strip(),
+                end=row["to"].strip(),
+                pair=row["pair"].strip(),
+                rate=Decimal(row["rate"].strip()),
+            ))
+    return entries
+
+
+def _normalize_dt(val: str) -> str:
+    return val if " " in val else f"{val} 00:00"
+
+
+def _normalize_dt_end(val: str) -> str:
+    return val if " " in val else f"{val} 23:59"
+
+
+def lookup_rate(entries: list[RateEntry], dt: str, cur: str, base: str) -> Decimal | None:
+    """決済通貨と基準通貨が異なる場合のみ該当期間のレートを返す。"""
+    if cur == base:
+        return None
+    trade_dt = dt[:16].replace("-", "/").replace("T", " ") if dt else ""
+    pair = f"{base}/{cur}"
+    for e in entries:
+        start = _normalize_dt(e.start)
+        end = _normalize_dt_end(e.end)
+        if e.pair == pair and start <= trade_dt <= end:
+            return e.rate
+    return None

insighta_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: insighta-sdk
+Version: 0.1.0
+Summary: Insighta Cloud SDK - API client and data models
+Project-URL: Homepage, https://insighta.cloud
+Author: insighta cloud Inc.
+License-Expression: CC-BY-NC-4.0
+License-File: LICENSE
+Keywords: api-client,insighta,investment,portfolio,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.28.0
+Description-Content-Type: text/markdown
+
+# insighta-sdk
+
+Insighta Cloud SDK — API client and data models for portfolio management.
+
+## Installation
+
+```bash
+pip install insighta-sdk
+```
+
+## Quick Start
+
+```python
+from insighta_sdk import Credentials, InsightaClient
+
+creds = Credentials.from_file("credentials.yaml")
+client = InsightaClient(creds)
+
+# List portfolios
+portfolios = client.get_portfolios()
+
+# Create a portfolio
+from insighta_sdk import UploadConfig
+config = UploadConfig.from_file("upload.yaml")
+portfolio_id = client.create_portfolio(config)
+```
+
+## Features
+
+- **API Client** — Full coverage of Insighta OpenAPI (portfolios, orders, metrics)
+- **Data Models** — `Trade`, `Holding`, `Deposit`, `OrderGroup`, `CashDeposit`, `RateEntry`
+- **Utilities** — Rate lookup, order grouping, deposit merging
+- **Workspace Management** — `Dirs` class for consistent file path resolution
+
+## API Reference
+
+### Client
+
+| Method | Description |
+|--------|-------------|
+| `create_portfolio(config)` | Create a new portfolio |
+| `get_portfolios()` | List own portfolios |
+| `search_portfolios(...)` | Search public portfolios |
+| `delete_portfolio(id)` | Delete a portfolio |
+| `send_order(portfolio_id, group, currency)` | Submit an order group |
+| `get_nav_history(id)` | Get NAV history |
+| `get_metrics_history(id, ...)` | Get metrics (TWR, etc.) |
+
+### Utilities
+
+| Function | Description |
+|----------|-------------|
+| `load_order_groups(path)` | Parse order.csv into OrderGroup list |
+| `load_cash_deposits(path)` | Parse cash_deposits.csv |
+| `merge_and_sort_groups(orders, deposits, memos)` | Merge and sequence order groups |
+| `load_rate_file(path)` | Load exchange rate CSV |
+| `lookup_rate(entries, dt, cur, base)` | Find applicable rate for a trade |
+| `fetch_ticker_info(tickers)` | Query ticker metadata from API |
+
+## API Endpoints
+
+| Environment | Base URL |
+|-------------|----------|
+| Production | `https://openapi.insighta.cloud` |
+| Development | `https://dev.openapi.insighta.cloud` |
+
+OpenAPI spec: [`insighta-app/openapi-docs/`](https://github.com/insighta-cloud/insighta/tree/main/insighta-app/openapi-docs)
+
+## Development
+
+```bash
+pip install -e .
+pytest
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+CC-BY-NC-4.0 — See [LICENSE](LICENSE)

insighta_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+insighta_sdk/__init__.py,sha256=O-Mb_GJmDk0gyP6gFsM6S0_c1kS5AkPCJluYdwjMsy0,733
+insighta_sdk/client.py,sha256=juCH5LDHkdUYGh-KBuX1nRPnsFwB9o5OuiHoO11loos,5410
+insighta_sdk/models.py,sha256=7zLmqyDiJROf2pqrXFK3cWXUYBxlnFIajImcjeBBIfo,5308
+insighta_sdk/utils.py,sha256=QaQU1K962Yo3vCbXf4A1Rx9_0q12X_1AXaXtL85jJe0,5015
+insighta_sdk-0.1.0.dist-info/METADATA,sha256=HuulJU140OjxAaDztFmesd-51rEXtt08gGK73B2bL7g,3142
+insighta_sdk-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+insighta_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=WPu_gaVv4rw7ucpTiIFHcubHh0VS_s5PI6RQJAz98l0,712
+insighta_sdk-0.1.0.dist-info/RECORD,,

insighta_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

insighta_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Creative Commons Attribution-NonCommercial 4.0 International
+
+Copyright (c) 2026 Insighta Cloud Inc.
+
+You are free to:
+
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+
+  Attribution — You must give appropriate credit, provide a link to the
+  license, and indicate if changes were made.
+
+  NonCommercial — You may not use the material for commercial purposes.
+
+  No additional restrictions — You may not apply legal terms or technological
+  measures that legally restrict others from doing anything the license permits.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode