gmo-fx 0.1.0__tar.gz

gmo_fx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RikitoNoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gmo_fx-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: gmo_fx
+Version: 0.1.0
+Summary: GMO社のFX API用Pythonライブラリ
+Home-page: https://github.com/RikitoNoto/gmo-fx-py
+Download-URL: https://github.com/RikitoNoto/gmo-fx-py
+Author: Rikito Noto
+Author-email: rikitonoto@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+
+# gmo-fx-py
+GMOが提供するFX用APIのSDKです。
+GMOのAPIについては[こちら](https://api.coin.z.com/fxdocs/)のリファレンスを参照してください。
+
+## インストール
+```shell
+pip install gmo-fx
+```
+
+## 使い方
+各APIのエンドポイントの頭にgetをつけたメソッドを定義しています。
+そのメソッドを実行することで、APIの呼び出しを行います。
+※例：「KLine情報の取得」APIの場合
+```python
+from gmo_fx import get_klines, KlineInterval, Symbol
+from datetime import datetime
+
+response = get_klines(
+  symbol=Symbol.USD_JPY,
+  price_type="BID",
+  interval=KlineInterval.M1, # 1分足
+  date=datetime.now(),
+)
+print(response.klines)
+```

gmo_fx-0.1.0/README.md

@@ -0,0 +1,25 @@
+# gmo-fx-py
+GMOが提供するFX用APIのSDKです。
+GMOのAPIについては[こちら](https://api.coin.z.com/fxdocs/)のリファレンスを参照してください。
+
+## インストール
+```shell
+pip install gmo-fx
+```
+
+## 使い方
+各APIのエンドポイントの頭にgetをつけたメソッドを定義しています。
+そのメソッドを実行することで、APIの呼び出しを行います。
+※例：「KLine情報の取得」APIの場合
+```python
+from gmo_fx import get_klines, KlineInterval, Symbol
+from datetime import datetime
+
+response = get_klines(
+  symbol=Symbol.USD_JPY,
+  price_type="BID",
+  interval=KlineInterval.M1, # 1分足
+  date=datetime.now(),
+)
+print(response.klines)
+```

gmo_fx-0.1.0/gmo_fx/__init__.py

@@ -0,0 +1,6 @@
+from .errors import *
+from .klines import *
+from .response import *
+from .status import *
+from .symbols import *
+from .ticker import *

gmo_fx-0.1.0/gmo_fx/errors.py

@@ -0,0 +1,76 @@
+from typing import Optional
+
+
+class ApiError(Exception):
+    error_code: str
+
+    __ERR_MAP = {
+        "ERR-143": "規制中のため取引できません。",
+        "ERR-148": "IFD、IFDOCO注文において決済注文数量が新規注文数量を超えています。",
+        "ERR-189": "決済注文において、決済可能保有数量を超えての数量は注文できません。",
+        "ERR-200": "すでに有効注文があり、注文数量が発注可能な数量を超えています。決済注文を行いたい場合は、注文数量を変更するか、有効注文を取消したうえで、再度注文をしてください。",
+        "ERR-201": "取引余力が不足しています。",
+        "ERR-254": "指定された建玉が存在しません。",
+        "ERR-414": "決済注文において指定した銘柄と指定した建玉IDの銘柄が異なっています。",
+        "ERR-423": "決済注文において注文数量が(指定した建玉、もしくは指定銘柄の建玉の)総建玉数量よりも大きい、もしくは総有効注文数量との合計が総建玉数量よりも大きいです。",
+        "ERR-512": "決済注文において同じ建玉IDが2つ以上指定されました。",
+        "ERR-542": "OCO注文変更においてOCO注文以外の親注文IDや顧客注文IDが指定されました。",
+        "ERR-595": "IFD、IFDOCO注文変更においてIFD、IFDOCO注文以外の親注文IDや顧客注文IDが指定されました。",
+        "ERR-635": "有効注文の件数が上限に達しています。新規の注文をするためには、有効注文を取消したうえで、再度注文をしてください。",
+        "ERR-759": "建玉の件数が上限に達している場合、新規注文は行えません。",
+        "ERR-760": "注文変更において変更前と後で注文レートが同じです。",
+        "ERR-761": "指定可能な注文レートの範囲を超えています。",
+        "ERR-769": "注文変更において変更元となる注文の有効期限が切れています。",
+        "ERR-786": "設定した顧客注文IDがご自身の他の有効注文に使用されています。",
+        "ERR-5003": "API呼出上限を越えています。",
+        "ERR-5008": "リクエストヘッダーに設定されているAPI-TIMESTAMPが公開APIのシステム時刻より遅いです。システム時間の更新をお試しください。",
+        "ERR-5009": "リクエストヘッダーに設定されているAPI-TIMESTAMPが公開APIのシステム時刻より早いです。システム時間の更新をお試しください。",
+        "ERR-5010": "リクエストヘッダーに指定されているAPI-SIGN（Signature）に不正があります。認証情報についてご確認ください。",
+        "ERR-5011": "リクエストヘッダーにAPI-KEYが設定されていません。認証情報についてご確認ください。",
+        "ERR-5012": "API-KEYの認証エラーが発生しました。",
+        "ERR-5014": "お客様のご確認、ご同意が必要な処理を実行する際に、お客様に未確認・未同意事項がありました。",
+        "ERR-5106": "パラメーターが不正です。",
+        "ERR-5114": "注文レートが呼値の単位を超えています。取引ルールの呼値をご確認ください。取引ルールは以下よりご確認いただけます。\nhttps://coin.z.com/jp/corp/product/info/fx/?=rule",
+        "ERR-5122": "指定された注文がすでに変更中、取消中、取消済、全量約定、失効のいずれかの状態であるため、注文の変更や取消ができません。",
+        "ERR-5123": "指定された注文番号が存在しません。",
+        "ERR-5125": "APIの取引規制がかかっています。",
+        "ERR-5126": "1回あたりの最大注文数量を超えているもしくは最小注文数量を下回っている、または最大建玉数量を超過しています。以下より取引ルールをご確認ください。\nhttps://coin.z.com/jp/corp/product/info/fx/?=rule",
+        "ERR-5130": "注文情報取得もしくは約定情報取得において指定した注文IDもしくは親注文IDが最大指定数量を超えています。",
+        "ERR-5132": "約定情報取得において指定した約定IDが最大指定数量を超えています。",
+        "ERR-5201": "定期メンテナンス中です。",
+        "ERR-5202": "緊急メンテナンス中です。",
+        "ERR-5204": "APIのURLが不正です。",
+        "ERR-5206": "注文変更を実行時に注文毎の変更可能回数が上限に達しています。上限に達して更に注文変更を行いたい場合は、1度注文キャンセルをしてから新規に注文をしていただくようにお願い致します。",
+        "ERR-5207": "リクエストボディに指定されているsymbol、intervalまたはdateが不正です。",
+        "ERR-5208": "約定情報取得において、orderId/executionIdが両方設定されました。",
+        "ERR-5209": "注文情報取得において、orderId/rootOrderIdが両方設定されました。",
+        "ERR-5210": "注文タイプと limitPrice/stopPriceが一致しません。",
+        "ERR-5211": "売買区分と一致しない lowerBound/upperBound が指定された、もしくは指値や逆指値注文に lowerBound/upperBound が指定されました。",
+        "ERR-5213": "注文IDもしくは親注文IDと顧客注文IDどちらか一方を指定する箇所でどちらも指定されました。",
+        "ERR-5214": "決済注文において、建玉IDを指定している場合に注文数量が指定されました。",
+        "ERR-5218": "取引時間外のため注文が行えません。",
+        "ERR-5219": "注文変更において通常注文以外の注文IDもしくは、顧客注文IDが指定されました。",
+        "ERR-5220": "IFD注文において1次注文レートを2次注文レートより低く設定しなければなりません。",
+        "ERR-5221": "IFD注文において1次注文レートを2次注文レートより高く設定しなければなりません。",
+        "ERR-5222": "IFDOCO注文において1次注文レートを2次指値注文レートより低く設定しなければなりません。",
+        "ERR-5223": "IFDOCO注文において1次注文レートを2次指値注文レートより高く設定しなければなりません。",
+        "ERR-5224": "IFDOCO注文において1次注文レートを2次逆指値注文レートより高く設定しなければなりません。",
+        "ERR-5225": "IFDOCO注文において1次注文レートを2次逆指値注文レートより低く設定しなければなりません。",
+        "ERR-5226": "逆指値の買い注文において、注文レートが現在レートより低いです。",
+        "ERR-5227": "逆指値の売り注文において、注文レートが現在レートより高いです。",
+        "ERR-5228": "OCO売り注文において逆指値注文レートが指値注文レートを超えています。",
+        "ERR-5229": "OCO買い注文において逆指値注文レートが指値注文レートを下回っています。",
+    }
+
+    def __init__(
+        self, error_code: str, *args: object, message: Optional[str] = None
+    ) -> None:
+        super().__init__(*args)
+        self.error_code = error_code
+        self.message = message
+
+    def __str__(self):
+        message = self.__ERR_MAP[self.error_code]
+        if self.message:
+            message += f"\nmessage: {self.message}"
+        return message

gmo_fx-0.1.0/gmo_fx/klines.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+from requests import get, Response
+from gmo_fx.response import Response as ResponseBase
+from gmo_fx.symbols import Symbol
+from gmo_fx.urls import BASE_URL_PUBLIC
+
+
+class KlineInterval(Enum):
+    Min1 = "1min"
+    Min5 = "5min"
+    Min10 = "10min"
+    Min15 = "15min"
+    Min30 = "30min"
+    H1 = "1hour"
+    H4 = "4hour"
+    H8 = "8hour"
+    H12 = "12hour"
+    D1 = "1day"
+    W1 = "1week"
+    M1 = "1month"
+
+
+@dataclass
+class Kline:
+    open_time: datetime
+    open: float
+    high: float
+    low: float
+    close: float
+
+
+class KlinesResponse(ResponseBase):
+    klines: list[Kline]
+
+    def __init__(self, response: dict):
+        super().__init__(response)
+        self.klines = []
+
+        data = response["data"]
+        self.klines = [
+            Kline(
+                open=float(d["open"]),
+                high=float(d["high"]),
+                low=float(d["low"]),
+                close=float(d["close"]),
+                open_time=datetime.fromtimestamp(int(d["openTime"]) / 1000),
+            )
+            for d in data
+        ]
+
+
+def get_klines(
+    symbol: Symbol,
+    price_type: Literal["BID", "ASK"],
+    interval: KlineInterval,
+    date: datetime,
+) -> KlinesResponse:
+    date_str = f"{date.year:04}"
+    if interval in (
+        KlineInterval.Min1,
+        KlineInterval.Min5,
+        KlineInterval.Min10,
+        KlineInterval.Min15,
+        KlineInterval.Min30,
+        KlineInterval.H1,
+    ):
+        date_str += f"{date.month:02}{date.day:02}"
+    base_url = f"{BASE_URL_PUBLIC}/klines"
+    response: Response = get(
+        f"{base_url}?"
+        f"symbol={symbol.value}"
+        f"&priceType={price_type}"
+        f"&interval={interval.value}"
+        f"&date={date_str}"
+    )
+    if response.status_code == 200:
+        response_json = response.json()
+        return KlinesResponse(response_json)
+
+    raise RuntimeError(
+        "Klineが取得できませんでした。\n"
+        f"status code: {response.status_code}\n"
+        f"response: {response.text}"
+    )

gmo_fx-0.1.0/gmo_fx/response.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+from gmo_fx.errors import ApiError
+
+
+class Response:
+    response_status: int
+    response_time: datetime
+
+    def __init__(self, response: dict):
+        self.response_status = response["status"]
+        self.response_time = datetime.strptime(
+            response["responsetime"], "%Y-%m-%dT%H:%M:%S.%fZ"
+        )
+        if self.response_status != 0:
+            err_code = response["messages"][0]["message_code"]
+            message = response["messages"][0]["message_string"]
+            raise ApiError(err_code, message=message)

gmo_fx-0.1.0/gmo_fx/status.py

@@ -0,0 +1,47 @@
+from enum import auto, Enum
+from typing import Type
+from requests import get, Response
+from gmo_fx.response import Response as ResponseBase
+from gmo_fx.urls import BASE_URL_PUBLIC
+
+
+class Status(Enum):
+    """
+    外国為替FXの稼動状態
+    """
+
+    OPEN = auto()  # オープン
+    CLOSE = auto()  # クローズ
+    MAINTENANCE = auto()  # メンテナンス
+
+    @classmethod
+    def from_str(cls, text: str) -> Type["Status"]:
+        match text:
+            case "OPEN":
+                return cls.OPEN
+            case "CLOSE":
+                return cls.CLOSE
+            case "MAINTENANCE":
+                return cls.MAINTENANCE
+        raise ValueError(f"不明なステータスです。: {text}")
+
+
+class StatusResponse(ResponseBase):
+    status: Status
+
+    def __init__(self, response: dict):
+        super().__init__(response)
+        self.status = Status.from_str(response["data"]["status"])
+
+
+def get_status() -> StatusResponse:
+    response: Response = get(f"{BASE_URL_PUBLIC}/status")
+    if response.status_code == 200:
+        response_json = response.json()
+        return StatusResponse(response_json)
+
+    raise RuntimeError(
+        "ステータスが取得できませんでした。\n"
+        f"status code: {response.status_code}\n"
+        f"response: {response.text}"
+    )

gmo_fx-0.1.0/gmo_fx/symbols.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from enum import Enum
+from gmo_fx.response import Response as ResponseBase
+from requests import get, Response
+from gmo_fx.urls import BASE_URL_PUBLIC
+
+
+class Symbol(Enum):
+    USD_JPY = "USD_JPY"
+    EUR_JPY = "EUR_JPY"
+    GBP_JPY = "GBP_JPY"
+    AUD_JPY = "AUD_JPY"
+    NZD_JPY = "NZD_JPY"
+    CAD_JPY = "CAD_JPY"
+    CHF_JPY = "CHF_JPY"
+    TRY_JPY = "TRY_JPY"
+    ZAR_JPY = "ZAR_JPY"
+    MXN_JPY = "MXN_JPY"
+    EUR_USD = "EUR_USD"
+    GBP_USD = "GBP_USD"
+    AUD_USD = "AUD_USD"
+    NZD_USD = "NZD_USD"
+
+
+@dataclass
+class Rule:
+    symbol: Symbol
+    min_open_order_size: int
+    max_order_size: int
+    size_step: int
+    tick_size: float
+
+
+class SymbolsResponse(ResponseBase):
+    rules: list[Rule]
+
+    def __init__(self, response: dict):
+        super().__init__(response)
+        self.rules = []
+
+        data = response["data"]
+        self.rules = [
+            Rule(
+                symbol=Symbol(d["symbol"]),
+                min_open_order_size=int(d["minOpenOrderSize"]),
+                max_order_size=int(d["maxOrderSize"]),
+                size_step=int(d["sizeStep"]),
+                tick_size=float(d["tickSize"]),
+            )
+            for d in data
+        ]
+
+
+def get_symbols() -> SymbolsResponse:
+    response: Response = get(f"{BASE_URL_PUBLIC}/symbols")
+    if response.status_code == 200:
+        response_json = response.json()
+        return SymbolsResponse(response_json)
+
+    raise RuntimeError(
+        "取引ルールが取得できませんでした。\n"
+        f"status code: {response.status_code}\n"
+        f"response: {response.text}"
+    )

gmo_fx-0.1.0/gmo_fx/ticker.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from datetime import datetime
+from requests import get, Response
+from gmo_fx.response import Response as ResponseBase
+from gmo_fx.symbols import Symbol
+from gmo_fx.urls import BASE_URL_PUBLIC
+
+
+@dataclass
+class Ticker:
+    symbol: Symbol
+    ask: float
+    bid: float
+    timestamp: datetime
+    status: str
+
+
+class TickerResponse(ResponseBase):
+    tickers: list[Ticker]
+
+    def __init__(self, response: dict):
+        super().__init__(response)
+        self.tickers = []
+
+        data = response["data"]
+        self.tickers = [
+            Ticker(
+                symbol=Symbol(d["symbol"]),
+                ask=d["ask"],
+                bid=d["bid"],
+                status=d["status"],
+                timestamp=datetime.strptime(d["timestamp"], "%Y-%m-%dT%H:%M:%S.%fZ"),
+            )
+            for d in data
+        ]
+
+
+def get_ticker() -> TickerResponse:
+    response: Response = get(f"{BASE_URL_PUBLIC}/ticker")
+    if response.status_code == 200:
+        response_json = response.json()
+        return TickerResponse(response_json)
+
+    raise RuntimeError(
+        "最新レートが取得できませんでした。\n"
+        f"status code: {response.status_code}\n"
+        f"response: {response.text}"
+    )

gmo_fx-0.1.0/gmo_fx/urls.py

@@ -0,0 +1 @@
+BASE_URL_PUBLIC = "https://forex-api.coin.z.com/public/v1"

gmo_fx-0.1.0/gmo_fx.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: gmo_fx
+Version: 0.1.0
+Summary: GMO社のFX API用Pythonライブラリ
+Home-page: https://github.com/RikitoNoto/gmo-fx-py
+Download-URL: https://github.com/RikitoNoto/gmo-fx-py
+Author: Rikito Noto
+Author-email: rikitonoto@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+
+# gmo-fx-py
+GMOが提供するFX用APIのSDKです。
+GMOのAPIについては[こちら](https://api.coin.z.com/fxdocs/)のリファレンスを参照してください。
+
+## インストール
+```shell
+pip install gmo-fx
+```
+
+## 使い方
+各APIのエンドポイントの頭にgetをつけたメソッドを定義しています。
+そのメソッドを実行することで、APIの呼び出しを行います。
+※例：「KLine情報の取得」APIの場合
+```python
+from gmo_fx import get_klines, KlineInterval, Symbol
+from datetime import datetime
+
+response = get_klines(
+  symbol=Symbol.USD_JPY,
+  price_type="BID",
+  interval=KlineInterval.M1, # 1分足
+  date=datetime.now(),
+)
+print(response.klines)
+```

gmo_fx-0.1.0/gmo_fx.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+setup.py
+gmo_fx/__init__.py
+gmo_fx/errors.py
+gmo_fx/klines.py
+gmo_fx/response.py
+gmo_fx/status.py
+gmo_fx/symbols.py
+gmo_fx/ticker.py
+gmo_fx/urls.py
+gmo_fx.egg-info/PKG-INFO
+gmo_fx.egg-info/SOURCES.txt
+gmo_fx.egg-info/dependency_links.txt
+gmo_fx.egg-info/requires.txt
+gmo_fx.egg-info/top_level.txt
+tests/test_base_response.py
+tests/test_klines.py
+tests/test_status.py
+tests/test_symbols.py
+tests/test_ticker.py

gmo_fx-0.1.0/gmo_fx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gmo_fx-0.1.0/gmo_fx.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.31.0

gmo_fx-0.1.0/gmo_fx.egg-info/top_level.txt

@@ -0,0 +1 @@
+gmo_fx

gmo_fx-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gmo_fx-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+DESCRIPTION = "GMO社のFX API用Pythonライブラリ"
+NAME = "gmo_fx"
+AUTHOR = "Rikito Noto"
+AUTHOR_EMAIL = "rikitonoto@gmail.com"
+URL = "https://github.com/RikitoNoto/gmo-fx-py"
+LICENSE = "MIT"
+DOWNLOAD_URL = "https://github.com/RikitoNoto/gmo-fx-py"
+VERSION = "0.1.0"
+INSTALL_REQUIRES = [
+    "requests>=2.31.0",
+]
+PACKAGES = [
+    "gmo_fx",
+]
+
+with open("README.md", "r") as fp:
+    readme = fp.read()
+
+setup(
+    name=NAME,
+    description=DESCRIPTION,
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=AUTHOR_EMAIL,
+    url=URL,
+    license=LICENSE,
+    download_url=DOWNLOAD_URL,
+    version=VERSION,
+    install_requires=INSTALL_REQUIRES,
+    packages=PACKAGES,
+)

gmo_fx-0.1.0/tests/test_base_response.py

@@ -0,0 +1,120 @@
+import pytest
+from gmo_fx.errors import ApiError
+from gmo_fx.response import Response
+from datetime import datetime
+
+
+class TestBaseResponse:
+    convert_response_testdata = [
+        (0, datetime(2001, 12, 12)),
+        (0, datetime(2010, 3, 1)),
+        (0, datetime(2020, 5, 20)),
+    ]
+
+    @pytest.mark.parametrize("status, time", convert_response_testdata)
+    def test_convert_response(
+        self,
+        status: int,
+        time: datetime,
+    ):
+        data = {
+            "status": status,
+            "responsetime": time.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+        }
+        response = Response(data)
+        assert response.response_status == status
+        assert response.response_time == time
+
+    error_codes = [
+        143,
+        148,
+        189,
+        200,
+        201,
+        254,
+        414,
+        423,
+        512,
+        542,
+        595,
+        635,
+        759,
+        760,
+        761,
+        769,
+        786,
+        5003,
+        5008,
+        5009,
+        5010,
+        5011,
+        5012,
+        5014,
+        5106,
+        5114,
+        5122,
+        5123,
+        5125,
+        5126,
+        5130,
+        5132,
+        5201,
+        5202,
+        5204,
+        5206,
+        5207,
+        5208,
+        5209,
+        5210,
+        5211,
+        5213,
+        5214,
+        5218,
+        5219,
+        5220,
+        5221,
+        5222,
+        5223,
+        5224,
+        5225,
+        5226,
+        5227,
+        5228,
+        5229,
+    ]
+
+    def create_error_data(self, error_code: str, message: str) -> dict:
+        return {
+            "status": 1,
+            "messages": [
+                {
+                    "message_code": error_code,
+                    "message_string": message,
+                }
+            ],
+            "responsetime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+        }
+
+    def test_should_return_error_status_is_not_0(self) -> None:
+        with pytest.raises(ApiError) as e:
+            Response(
+                {
+                    "status": 1,
+                    "messages": [
+                        {
+                            "message_code": "ERR-5011",
+                            "message_string": "API-key format invalid.",
+                        }
+                    ],
+                    "responsetime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                }
+            )
+
+    @pytest.mark.parametrize("error_code", error_codes)
+    def test_error_code_test(self, error_code) -> None:
+        with pytest.raises(ApiError) as e:
+            data = self.create_error_data(
+                f"ERR-{error_code}", "API-key format invalid."
+            )
+            Response(data)
+        assert e.value.error_code == f"ERR-{error_code}"

gmo_fx-0.1.0/tests/test_klines.py

@@ -0,0 +1,195 @@
+import re
+from typing import Callable, Optional
+from unittest.mock import MagicMock, patch
+
+import pytest
+from gmo_fx.klines import get_klines, KlineInterval
+from datetime import datetime
+
+from gmo_fx.symbols import Symbol
+from tests.api_test_base import ApiTestBase
+
+
+class TestKlineApi(ApiTestBase):
+
+    def create_kline(
+        self,
+        open_time: str = "0000000000000",
+        open: float = 0.0,
+        high: float = 0.0,
+        low: float = 0.0,
+        close: float = 0.0,
+    ) -> dict:
+        return {
+            "openTime": open_time,
+            "open": str(open),
+            "high": str(high),
+            "low": str(low),
+            "close": str(close),
+        }
+
+    def create_klines(
+        self, size: int, kline_builder: Optional[Callable[[int], dict]] = None
+    ) -> list[dict]:
+        kline_builder = kline_builder or (lambda i: self.create_kline())
+        return [kline_builder(i) for i in range(size)]
+
+    @patch("gmo_fx.klines.get")
+    def test_klines_error(self, get_mock: MagicMock):
+        self.check_404_error(
+            get_mock,
+            lambda: get_klines(
+                Symbol.USD_JPY,
+                "BID",
+                KlineInterval.Min1,
+                datetime(2024, 1, 1),
+            ),
+        )
+
+    @patch("gmo_fx.klines.get")
+    def test_should_get_klines_from_response_klines_accesser(self, get_mock: MagicMock):
+        expect_klines = [
+            {
+                "openTime": datetime(i + 1980, 1, 1),
+                "open": float(i),
+                "high": float(i),
+                "low": float(i),
+                "close": float(i),
+            }
+            for i in range(100)
+        ]
+        get_mock.return_value = self.create_response(
+            data=self.create_klines(
+                100,
+                lambda i: self.create_kline(
+                    open_time=str(int(expect_klines[i]["openTime"].timestamp()) * 1000),
+                    open=expect_klines[i]["open"],
+                    high=expect_klines[i]["high"],
+                    low=expect_klines[i]["low"],
+                    close=expect_klines[i]["close"],
+                ),
+            )
+        )
+        klines_response = get_klines(
+            Symbol.USD_JPY,
+            "BID",
+            KlineInterval.Min1,
+            datetime(2024, 1, 1),
+        )
+        for i, expect in enumerate(expect_klines):
+            assert klines_response.klines[i].open_time == expect["openTime"]
+            assert klines_response.klines[i].open == expect["open"]
+            assert klines_response.klines[i].high == expect["high"]
+            assert klines_response.klines[i].low == expect["low"]
+            assert klines_response.klines[i].close == expect["close"]
+
+    def check_url_parameter(
+        self,
+        get_mock: MagicMock,
+        symbol: Symbol = Symbol.USD_JPY,
+        symbol_str: str = "USD_JPY",
+        price_type: str = "ASK",
+        price_type_str: str = "ASK",
+        interval=KlineInterval.Min1,
+        interval_str="1min",
+        date: datetime = datetime(2024, 1, 1),
+        date_str: str = "20240101",
+    ) -> None:
+
+        get_mock.return_value = self.create_response(data=self.create_klines(1))
+        get_klines(symbol, price_type, interval, date)
+        param_match = re.search("\?(.*)", get_mock.mock_calls[0].args[0])
+        param = param_match.group(1)
+        assert f"symbol={symbol_str}" in param
+        assert f"priceType={price_type_str}" in param
+        assert f"interval={interval_str}" in param
+        assert f"date={date_str}" in param
+
+    symbol_strs = [
+        (Symbol.USD_JPY, "USD_JPY"),
+        (Symbol.EUR_JPY, "EUR_JPY"),
+        (Symbol.GBP_JPY, "GBP_JPY"),
+        (Symbol.AUD_JPY, "AUD_JPY"),
+        (Symbol.NZD_JPY, "NZD_JPY"),
+        (Symbol.CAD_JPY, "CAD_JPY"),
+        (Symbol.CHF_JPY, "CHF_JPY"),
+        (Symbol.TRY_JPY, "TRY_JPY"),
+        (Symbol.ZAR_JPY, "ZAR_JPY"),
+        (Symbol.MXN_JPY, "MXN_JPY"),
+        (Symbol.EUR_USD, "EUR_USD"),
+        (Symbol.GBP_USD, "GBP_USD"),
+        (Symbol.AUD_USD, "AUD_USD"),
+        (Symbol.NZD_USD, "NZD_USD"),
+    ]
+
+    @pytest.mark.parametrize("symbol, symbol_str", symbol_strs)
+    @patch("gmo_fx.klines.get")
+    def test_should_call_get_with_symbol(
+        self, get_mock: MagicMock, symbol: Symbol, symbol_str: str
+    ):
+        self.check_url_parameter(
+            get_mock,
+            symbol=symbol,
+            symbol_str=symbol_str,
+        )
+
+    price_type_strs = [
+        ("BID", "BID"),
+        ("ASK", "ASK"),
+    ]
+
+    @pytest.mark.parametrize("price_type, price_type_str", price_type_strs)
+    @patch("gmo_fx.klines.get")
+    def test_should_call_get_with_price_type(
+        self, get_mock: MagicMock, price_type: str, price_type_str: str
+    ):
+        self.check_url_parameter(
+            get_mock,
+            price_type=price_type,
+            price_type_str=price_type_str,
+        )
+
+    interval_strs = [
+        (KlineInterval.Min1, "1min"),
+        (KlineInterval.Min5, "5min"),
+        (KlineInterval.Min10, "10min"),
+        (KlineInterval.Min15, "15min"),
+        (KlineInterval.Min30, "30min"),
+        (KlineInterval.H1, "1hour"),
+        (KlineInterval.H4, "4hour"),
+        (KlineInterval.H8, "8hour"),
+        (KlineInterval.H12, "12hour"),
+        (KlineInterval.D1, "1day"),
+        (KlineInterval.W1, "1week"),
+        (KlineInterval.M1, "1month"),
+    ]
+
+    date_strs = [
+        # datetime, interval, string
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.Min1, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.Min5, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.Min10, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.Min15, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.Min30, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.H1, "20240101"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.H4, "2024"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.H8, "2024"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.H12, "2024"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.D1, "2024"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.W1, "2024"),
+        (datetime(2024, 1, 1, 10, 23, 12), KlineInterval.M1, "2024"),
+    ]
+
+    @pytest.mark.parametrize("date, interval, string", date_strs)
+    @patch("gmo_fx.klines.get")
+    def test_should_call_get_with_date(
+        self, get_mock: MagicMock, date: datetime, interval: KlineInterval, string: str
+    ):
+        interval_map = dict(self.interval_strs)
+        self.check_url_parameter(
+            get_mock,
+            interval=interval,
+            interval_str=interval_map[interval],
+            date=date,
+            date_str=string,
+        )

gmo_fx-0.1.0/tests/test_status.py

@@ -0,0 +1,29 @@
+from unittest.mock import MagicMock, patch
+from gmo_fx.status import get_status, Status
+
+from tests.api_test_base import ApiTestBase
+
+
+class TestStatusApi(ApiTestBase):
+
+    @patch("gmo_fx.status.get")
+    def test_status_error(self, get_mock: MagicMock):
+        self.check_404_error(get_mock, lambda: get_status())
+
+    @patch("gmo_fx.status.get")
+    def test_status_open(self, get_mock: MagicMock):
+        get_mock.return_value = self.create_response(data={"status": "OPEN"})
+        actual = get_status()
+        assert actual.status == Status.OPEN
+
+    @patch("gmo_fx.status.get")
+    def test_status_close(self, get_mock: MagicMock):
+        get_mock.return_value = self.create_response(data={"status": "CLOSE"})
+        actual = get_status()
+        assert actual.status == Status.CLOSE
+
+    @patch("gmo_fx.status.get")
+    def test_status_maintenance(self, get_mock: MagicMock):
+        get_mock.return_value = self.create_response(data={"status": "MAINTENANCE"})
+        actual = get_status()
+        assert actual.status == Status.MAINTENANCE

gmo_fx-0.1.0/tests/test_symbols.py

@@ -0,0 +1,149 @@
+from typing import Callable, Optional
+from unittest.mock import MagicMock, patch
+from gmo_fx.symbols import get_symbols, Symbol
+from datetime import datetime
+
+from tests.api_test_base import ApiTestBase
+
+
+class TestSymbolsApi(ApiTestBase):
+    SYMBOLS = [
+        "USD_JPY",
+        "EUR_JPY",
+        "GBP_JPY",
+        "AUD_JPY",
+        "NZD_JPY",
+        "CAD_JPY",
+        "CHF_JPY",
+        "TRY_JPY",
+        "ZAR_JPY",
+        "MXN_JPY",
+        "EUR_USD",
+        "GBP_USD",
+        "AUD_USD",
+        "NZD_USD",
+    ]
+
+    SYMBOLS_TABLE = {
+        Symbol.USD_JPY: "USD_JPY",
+        Symbol.EUR_JPY: "EUR_JPY",
+        Symbol.GBP_JPY: "GBP_JPY",
+        Symbol.AUD_JPY: "AUD_JPY",
+        Symbol.NZD_JPY: "NZD_JPY",
+        Symbol.CAD_JPY: "CAD_JPY",
+        Symbol.CHF_JPY: "CHF_JPY",
+        Symbol.TRY_JPY: "TRY_JPY",
+        Symbol.ZAR_JPY: "ZAR_JPY",
+        Symbol.MXN_JPY: "MXN_JPY",
+        Symbol.EUR_USD: "EUR_USD",
+        Symbol.GBP_USD: "GBP_USD",
+        Symbol.AUD_USD: "AUD_USD",
+        Symbol.NZD_USD: "NZD_USD",
+    }
+
+    def create_symbol_data(
+        self,
+        symbol: str = "USD_JPY",
+        min_open_order_size: int = 0,
+        max_order_size: int = 0,
+        size_step: int = 0,
+        tick_size: float = 0.0,
+    ) -> dict:
+        return {
+            "symbol": symbol,
+            "minOpenOrderSize": str(min_open_order_size),
+            "maxOrderSize": str(max_order_size),
+            "sizeStep": str(size_step),
+            "tickSize": str(tick_size),
+        }
+
+    def create_symbols_data(
+        self, symbols_data_builder: Optional[Callable[[str], dict]] = None
+    ) -> list[dict]:
+        symbols_data_builder = symbols_data_builder or (
+            lambda symbol: self.create_symbol_data(symbol=symbol)
+        )
+        return [symbols_data_builder(symbol) for symbol in self.SYMBOLS]
+
+    @patch("gmo_fx.symbols.get")
+    def test_symbols_error(self, get_mock: MagicMock):
+        self.check_404_error(get_mock, lambda: get_symbols())
+
+    @patch("gmo_fx.symbols.get")
+    def test_should_get_symbols_from_symbols(self, get_mock: MagicMock):
+        get_mock.return_value = self.create_response(data=self.create_symbols_data())
+        symbols_response = get_symbols()
+        symbols = [rule.symbol for rule in symbols_response.rules]
+        for symbol in Symbol:
+            assert symbol in symbols
+            symbols.remove(symbol)
+        else:
+            assert len(symbols) == 0
+
+    @patch("gmo_fx.symbols.get")
+    def test_should_get_min_open_order_size_from_symbols(self, get_mock: MagicMock):
+        def fixture_min_open_order_size(symbol: str):
+            return self.SYMBOLS.index(symbol) * 100
+
+        def fixture_symbols_data(symbol: str) -> dict:
+            size = fixture_min_open_order_size(symbol)
+            return self.create_symbol_data(symbol, min_open_order_size=size)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_symbols_data(symbols_data_builder=fixture_symbols_data)
+        )
+        rules = get_symbols().rules
+        for rule in rules:
+            assert rule.min_open_order_size == fixture_min_open_order_size(
+                self.SYMBOLS_TABLE[rule.symbol]
+            )
+
+    @patch("gmo_fx.symbols.get")
+    def test_should_get_max_order_size_from_symbols(self, get_mock: MagicMock):
+        def fixture_max_order_size(symbol: str):
+            return self.SYMBOLS.index(symbol) * 100
+
+        def fixture_symbols_data(symbol: str) -> dict:
+            size = fixture_max_order_size(symbol)
+            return self.create_symbol_data(symbol, max_order_size=size)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_symbols_data(symbols_data_builder=fixture_symbols_data)
+        )
+        rules = get_symbols().rules
+        for rule in rules:
+            assert rule.max_order_size == fixture_max_order_size(
+                self.SYMBOLS_TABLE[rule.symbol]
+            )
+
+    @patch("gmo_fx.symbols.get")
+    def test_should_get_size_step_from_symbols(self, get_mock: MagicMock):
+        def fixture_size_step(symbol: str):
+            return self.SYMBOLS.index(symbol) * 100
+
+        def fixture_symbols_data(symbol: str) -> dict:
+            step = fixture_size_step(symbol)
+            return self.create_symbol_data(symbol, size_step=step)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_symbols_data(symbols_data_builder=fixture_symbols_data)
+        )
+        rules = get_symbols().rules
+        for rule in rules:
+            assert rule.size_step == fixture_size_step(self.SYMBOLS_TABLE[rule.symbol])
+
+    @patch("gmo_fx.symbols.get")
+    def test_should_get_tick_size_from_symbols(self, get_mock: MagicMock):
+        def fixture_tick_size(symbol: str):
+            return (self.SYMBOLS.index(symbol) / 3) * 100
+
+        def fixture_symbols_data(symbol: str) -> dict:
+            size = fixture_tick_size(symbol)
+            return self.create_symbol_data(symbol, tick_size=size)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_symbols_data(symbols_data_builder=fixture_symbols_data)
+        )
+        rules = get_symbols().rules
+        for rule in rules:
+            assert rule.tick_size == fixture_tick_size(self.SYMBOLS_TABLE[rule.symbol])

gmo_fx-0.1.0/tests/test_ticker.py

@@ -0,0 +1,138 @@
+from typing import Callable, Optional
+from unittest.mock import MagicMock, patch
+from gmo_fx.symbols import Symbol
+from gmo_fx.ticker import get_ticker
+from datetime import datetime
+
+from tests.api_test_base import ApiTestBase
+
+
+class TestTickerApi(ApiTestBase):
+    SYMBOLS = [
+        "USD_JPY",
+        "EUR_JPY",
+        "GBP_JPY",
+        "AUD_JPY",
+        "NZD_JPY",
+        "CAD_JPY",
+        "CHF_JPY",
+        "TRY_JPY",
+        "ZAR_JPY",
+        "MXN_JPY",
+        "EUR_USD",
+        "GBP_USD",
+        "AUD_USD",
+        "NZD_USD",
+    ]
+
+    SYMBOLS_TABLE = {
+        Symbol.USD_JPY: "USD_JPY",
+        Symbol.EUR_JPY: "EUR_JPY",
+        Symbol.GBP_JPY: "GBP_JPY",
+        Symbol.AUD_JPY: "AUD_JPY",
+        Symbol.NZD_JPY: "NZD_JPY",
+        Symbol.CAD_JPY: "CAD_JPY",
+        Symbol.CHF_JPY: "CHF_JPY",
+        Symbol.TRY_JPY: "TRY_JPY",
+        Symbol.ZAR_JPY: "ZAR_JPY",
+        Symbol.MXN_JPY: "MXN_JPY",
+        Symbol.EUR_USD: "EUR_USD",
+        Symbol.GBP_USD: "GBP_USD",
+        Symbol.AUD_USD: "AUD_USD",
+        Symbol.NZD_USD: "NZD_USD",
+    }
+
+    def create_ticker_data(
+        self,
+        symbol: str,
+        status: str = "OPEN",
+        ask: float = 0.0,
+        bid: float = 0.0,
+        timestamp: Optional[datetime] = None,
+    ) -> dict:
+        return {
+            "symbol": symbol,
+            "ask": ask,
+            "bid": bid,
+            "timestamp": (timestamp or datetime.now()).strftime(
+                "%Y-%m-%dT%H:%M:%S.%fZ"
+            ),
+            "status": status,
+        }
+
+    def create_tickers_data(
+        self, exchange_data_builder: Optional[Callable[[str], dict]] = None
+    ) -> list[dict]:
+        exchange_data_builder = exchange_data_builder or self.create_ticker_data
+        return [exchange_data_builder(symbol) for symbol in self.SYMBOLS]
+
+    @patch("gmo_fx.ticker.get")
+    def test_ticker_error(self, get_mock: MagicMock):
+        self.check_404_error(get_mock, lambda: get_ticker())
+
+    @patch("gmo_fx.ticker.get")
+    def test_should_get_symbols_from_ticker(self, get_mock: MagicMock):
+        get_mock.return_value = self.create_response(data=self.create_tickers_data())
+        ticker_response = get_ticker()
+        symbols = [ticker.symbol for ticker in ticker_response.tickers]
+        for symbol in Symbol:
+            assert symbol in symbols
+            symbols.remove(symbol)
+        else:
+            assert len(symbols) == 0
+
+    @patch("gmo_fx.ticker.get")
+    def test_should_get_bid_ask_from_ticker(self, get_mock: MagicMock):
+        def fixture_ask_bid(symbol: str):
+            return self.SYMBOLS.index(symbol), self.SYMBOLS.index(symbol) * 100
+
+        def fixture_ticker_data(symbol: str) -> dict:
+            ask, bid = fixture_ask_bid(symbol)
+            return self.create_ticker_data(symbol, ask=ask, bid=bid)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_tickers_data(exchange_data_builder=fixture_ticker_data)
+        )
+        rates = get_ticker().tickers
+        for rate in rates:
+            assert rate.ask == fixture_ask_bid(self.SYMBOLS_TABLE[rate.symbol])[0]
+            assert rate.bid == fixture_ask_bid(self.SYMBOLS_TABLE[rate.symbol])[1]
+
+    @patch("gmo_fx.ticker.get")
+    def test_should_get_timestamp_from_ticker(self, get_mock: MagicMock):
+        def fixture_timestamp(symbol: str):
+            return datetime(2000, 12, self.SYMBOLS.index(symbol) + 1)  # 0日はないので
+
+        def fixture_ticker_data(symbol: str) -> dict:
+            timestamp = fixture_timestamp(symbol)
+            return self.create_ticker_data(symbol, timestamp=timestamp)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_tickers_data(exchange_data_builder=fixture_ticker_data)
+        )
+        rates = get_ticker().tickers
+        for rate in rates:
+            assert rate.timestamp == fixture_timestamp(self.SYMBOLS_TABLE[rate.symbol])
+
+    @patch("gmo_fx.ticker.get")
+    def test_should_get_status_from_ticker(self, get_mock: MagicMock):
+        def fixture_status(symbol: str):
+            statuses = ["OPEN", "CLOSE"]
+            return statuses[self.SYMBOLS.index(symbol) % len(statuses)]
+
+        def fixture_ticker_data(symbol: str) -> dict:
+            status = fixture_status(symbol)
+            return self.create_ticker_data(symbol, status=status)
+
+        get_mock.return_value = self.create_response(
+            data=self.create_tickers_data(exchange_data_builder=fixture_ticker_data)
+        )
+        rates = get_ticker().tickers
+        for rate in rates:
+            status_str = fixture_status(self.SYMBOLS_TABLE[rate.symbol])
+            for status in ["OPEN", "CLOSE"]:
+                if status == status_str:
+                    assert rate.status == status
+                    break
+            else:
+                assert False