(a|b|rc))(?P\d+))?(\.post(?P\d+))?(\.dev(?P\d+))?(\+(?P.+))?
6 | serialize =
7 | {major}.{minor}.{patch}{cycle}{pre}.post{post}.dev{dev}+{local}
8 | {major}.{minor}.{patch}{cycle}{pre}.post{post}.dev{dev}
9 | {major}.{minor}.{patch}{cycle}{pre}.post{post}+{local}
10 | {major}.{minor}.{patch}{cycle}{pre}.post{post}
11 | {major}.{minor}.{patch}{cycle}{pre}.dev{dev}+{local}
12 | {major}.{minor}.{patch}{cycle}{pre}.dev{dev}
13 | {major}.{minor}.{patch}{cycle}{pre}+{local}
14 | {major}.{minor}.{patch}{cycle}{pre}
15 | {major}.{minor}.{patch}.post{post}.dev{dev}+{local}
16 | {major}.{minor}.{patch}.post{post}.dev{dev}
17 | {major}.{minor}.{patch}.post{post}+{local}
18 | {major}.{minor}.{patch}.post{post}
19 | {major}.{minor}.{patch}.dev{dev}+{local}
20 | {major}.{minor}.{patch}.dev{dev}
21 | {major}.{minor}.{patch}+{local}
22 | {major}.{minor}.{patch}
23 |
24 | [bumpversion:part:cycle]
25 | values =
26 | final
27 | a
28 | b
29 | rc
30 |
31 | [bumpversion:file:pyproject.toml]
32 | search = version = "{current_version}"
33 | replace = version = "{new_version}"
34 |
35 | [bumpversion:file:koapy/__init__.py]
36 | search = __version__ = "{current_version}"
37 | replace = __version__ = "{new_version}"
38 |
39 | [bumpversion:file:setup.py]
40 | search = version="{current_version}"
41 | replace = version="{new_version}"
42 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/core/KiwoomOpenApiPlusEventHandlerFunctions.py:
--------------------------------------------------------------------------------
1 | from koapy.utils.notimplemented import notimplemented
2 |
3 |
4 | class KiwoomOpenApiPlusEventHandlerFunctions:
5 | @notimplemented
6 | def OnEventConnect(self, errcode):
7 | raise NotImplementedError
8 |
9 | @notimplemented
10 | def OnReceiveMsg(self, scrnno, rqname, trcode, msg):
11 | raise NotImplementedError
12 |
13 | @notimplemented
14 | def OnReceiveTrData(
15 | self,
16 | scrnno,
17 | rqname,
18 | trcode,
19 | recordname,
20 | prevnext,
21 | datalength,
22 | errorcode,
23 | message,
24 | splmmsg,
25 | ):
26 | raise NotImplementedError
27 |
28 | @notimplemented
29 | def OnReceiveRealData(self, code, realtype, realdata):
30 | raise NotImplementedError
31 |
32 | @notimplemented
33 | def OnReceiveChejanData(self, gubun, itemcnt, fidlist):
34 | raise NotImplementedError
35 |
36 | @notimplemented
37 | def OnReceiveConditionVer(self, ret, msg):
38 | raise NotImplementedError
39 |
40 | @notimplemented
41 | def OnReceiveTrCondition(
42 | self, scrnno, codelist, condition_name, condition_index, prevnext
43 | ):
44 | raise NotImplementedError
45 |
46 | @notimplemented
47 | def OnReceiveRealCondition(
48 | self, code, condition_type, condition_name, condition_index
49 | ):
50 | raise NotImplementedError
51 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_w/core/KiwoomOpenApiWDynamicCallable.py:
--------------------------------------------------------------------------------
1 | from inspect import Signature
2 |
3 | from koapy.backend.kiwoom_open_api_w.core.KiwoomOpenApiWSignature import (
4 | KiwoomOpenApiWDispatchSignature,
5 | )
6 |
7 |
8 | class KiwoomOpenApiWDynamicCallable:
9 | def __init__(self, control, name):
10 | self._control = control
11 | self._name = name
12 | self._signature = KiwoomOpenApiWDispatchSignature.from_name(self._name)
13 | self._function = self._signature.to_pyside2_function_prototype()
14 | self._should_test_return_type = (
15 | self._signature.return_annotation is not Signature.empty
16 | )
17 |
18 | def is_valid_return_type(self, result):
19 | if self._should_test_return_type and not isinstance(
20 | result, self._signature.return_annotation
21 | ):
22 | return False
23 | return True
24 |
25 | def __call__(self, *args, **kwargs):
26 | ba = self._signature.bind(*args, **kwargs)
27 | ba.apply_defaults()
28 | result = self._control.dynamicCall(self._function, list(ba.args))
29 | if not self.is_valid_return_type(result):
30 | raise TypeError(
31 | "Return type of %s was expected for function call %s(...), but %s was found."
32 | % (
33 | self._signature.return_annotation,
34 | self._name,
35 | type(result),
36 | )
37 | )
38 | return result
39 |
--------------------------------------------------------------------------------
/koapy/utils/data/YahooFinanceKrxHistoricalDailyPriceDataDownloader.py:
--------------------------------------------------------------------------------
1 | import io
2 |
3 | import pandas as pd
4 | import requests
5 |
6 |
7 | class YahooFinanceKrxHistoricalDailyPriceDataDownloader:
8 | def __init__(self):
9 | self._headers = {
10 | "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
11 | }
12 |
13 | def download(self, symbol, start_date=None, end_date=None):
14 | if start_date is None:
15 | start_date = pd.Timestamp(1980, 1, 1)
16 | elif not isinstance(start_date, pd.Timestamp):
17 | start_date = pd.Timestamp(start_date)
18 | if end_date is None:
19 | end_date = pd.Timestamp.now().normalize() + pd.Timedelta(1, unit="day")
20 | elif not isinstance(end_date, pd.Timestamp):
21 | end_date = pd.Timestamp(end_date)
22 |
23 | url = (
24 | "https://query1.finance.yahoo.com/v7/finance/download/%s.KS"
25 | % symbol.upper()
26 | )
27 | params = {
28 | "period1": int(start_date.timestamp()),
29 | "period2": int(end_date.timestamp()),
30 | "interval": "1d",
31 | "events": "history",
32 | "includeAdjustedClose": "true",
33 | }
34 | response = requests.get(url, params=params, headers=self._headers)
35 | df = pd.read_csv(
36 | io.BytesIO(response.content), parse_dates=["Date"], index_col="Date"
37 | )
38 |
39 | return df
40 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/account_data/userinfo.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 |
5 |
6 | @click.command(short_help="Get user information.")
7 | @click.option(
8 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
9 | )
10 | @verbose_option()
11 | def userinfo(port):
12 | import pandas as pd
13 |
14 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
15 | KiwoomOpenApiPlusEntrypoint,
16 | )
17 |
18 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
19 | context.EnsureConnected()
20 |
21 | result = {}
22 | result["보유계좌수"] = context.GetLoginInfo("ACCOUNT_CNT")
23 | account_numbers = context.GetLoginInfo("ACCLIST").rstrip(";").split(";")
24 | for i, accno in enumerate(account_numbers):
25 | result["계좌번호 (%d/%s)" % (i + 1, result["보유계좌수"])] = accno
26 | result["사용자 ID"] = context.GetLoginInfo("USER_ID")
27 | result["사용자 명"] = context.GetLoginInfo("USER_NAME")
28 | result["키보드보안 해지 여부"] = {
29 | "0": "정상",
30 | "1": "해지",
31 | }.get(context.GetLoginInfo("KEY_BSECGB"), "알수없음")
32 | result["방화벽 설정 여부"] = {
33 | "0": "미설정",
34 | "1": "설정",
35 | "2": "해지",
36 | }.get(context.GetLoginInfo("FIREW_SECGB"), "알수없음")
37 | result["접속서버 구분"] = {
38 | "1": "모의투자",
39 | }.get(context.GetServerGubun(), "실서버")
40 |
41 | click.echo(pd.Series(result).to_markdown())
42 |
--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
1 | # See https://pre-commit.com/ for usage and config
2 | repos:
3 | - repo: https://github.com/pre-commit/pre-commit-hooks
4 | rev: v3.4.0
5 | hooks:
6 | - id: check-yaml
7 | - id: check-toml
8 | - repo: local
9 | hooks:
10 | - id: pyupgrade
11 | name: pyupgrade
12 | stages: [commit]
13 | language: system
14 | entry: poetry run pyupgrade --keep-runtime-typing
15 | types: [python]
16 | - id: isort
17 | name: isort
18 | stages: [commit]
19 | language: system
20 | entry: poetry run isort
21 | types_or: [cython, pyi, python]
22 | args: [--filter-files]
23 | require_serial: true
24 | - id: black
25 | name: black
26 | stages: [commit]
27 | language: system
28 | entry: poetry run black
29 | types_or: [python, pyi]
30 | require_serial: true
31 | - id: flake8
32 | name: flake8
33 | stages: [manual]
34 | language: system
35 | entry: poetry run flake8
36 | types: [python]
37 | require_serial: true
38 | - id: pylint
39 | name: pylint
40 | stages: [manual]
41 | language: system
42 | entry: poetry run pylint
43 | types: [python]
44 | args: [--errors-only]
45 | require_serial: true
46 | - id: mypy
47 | name: mypy
48 | stages: [manual]
49 | language: system
50 | entry: poetry run mypy
51 | types: [python]
52 | require_serial: true
53 | - id: pytest
54 | name: pytest
55 | stages: [push]
56 | language: system
57 | entry: poetry run pytest --cov
58 | types: [python]
59 | pass_filenames: false
60 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/stock_meta/stockname.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 |
5 |
6 | @click.command(short_help="Get name for stock codes.")
7 | @click.option(
8 | "-c",
9 | "--code",
10 | "codes",
11 | metavar="CODE",
12 | multiple=True,
13 | help="Stock code to get. Can set multiple times.",
14 | )
15 | @click.option(
16 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
17 | )
18 | @verbose_option()
19 | def stockname(codes, port):
20 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
21 | KiwoomOpenApiPlusEntrypoint,
22 | )
23 |
24 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
25 | context.EnsureConnected()
26 |
27 | def get_codes():
28 | if codes:
29 | if "-" in codes:
30 | with click.open_file("-", "r") as f:
31 | for code in f:
32 | yield code.strip()
33 | else:
34 | for code in codes:
35 | yield code
36 | else:
37 | while True:
38 | try:
39 | code = click.prompt("code", prompt_suffix=" >>> ")
40 | code = code.strip()
41 | if code == "exit":
42 | break
43 | if code:
44 | yield code
45 | except EOFError:
46 | break
47 |
48 | for code in get_codes():
49 | name = context.GetMasterCodeName(code)
50 | click.echo(name)
51 |
--------------------------------------------------------------------------------
/koapy/backtrader/examples/kiwoom_data_integration.py:
--------------------------------------------------------------------------------
1 | import logging
2 |
3 | logging.basicConfig(
4 | format="%(asctime)s [%(levelname)s] %(message)s - %(filename)s:%(lineno)d",
5 | level=logging.DEBUG,
6 | )
7 |
8 | import backtrader as bt
9 |
10 | from koapy.backtrader.examples.vanila_quickstart import OrclStrategy
11 | from koapy.backtrader.KiwoomOpenApiPlusBroker import KiwoomOpenApiPlusCommInfo
12 | from koapy.backtrader.KiwoomOpenApiPlusStore import KiwoomOpenApiPlusStore
13 |
14 |
15 | def main():
16 | logging.info("Creating Cerebro")
17 | cerebro = bt.Cerebro() # pylint: disable=unexpected-keyword-arg
18 |
19 | logging.info("Initializing Kiwoom Store")
20 | kiwoomstore = KiwoomOpenApiPlusStore()
21 |
22 | logging.info("Getting data")
23 | historial_data = kiwoomstore.getdata(dataname="005930", historical=True)
24 | realtime_data = kiwoomstore.getdata(
25 | dataname="005930",
26 | backfill_start=False,
27 | timeframe=bt.TimeFrame.Ticks,
28 | compression=1,
29 | )
30 |
31 | logging.info("Adding data")
32 | cerebro.adddata(historial_data)
33 |
34 | logging.info("Configuring others")
35 | cerebro.addsizer(bt.sizers.FixedSize, stake=10)
36 | cerebro.addtz("Asia/Seoul")
37 |
38 | cerebro.broker.setcash(30000000.0)
39 | cerebro.broker.addcommissioninfo(KiwoomOpenApiPlusCommInfo())
40 |
41 | logging.info("Setting strategy")
42 | cerebro.addstrategy(OrclStrategy, printlog=True)
43 |
44 | logging.info("Starting Portfolio Value: %.2f", cerebro.broker.getvalue())
45 | cerebro.run()
46 | logging.info("Final Portfolio Value: %.2f", cerebro.broker.getvalue())
47 |
48 |
49 | if __name__ == "__main__":
50 | main()
51 |
--------------------------------------------------------------------------------
/koapy/cli/commands/update/__init__.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.credentials import get_credentials
4 | from koapy.cli.utils.verbose_option import verbose_option
5 |
6 |
7 | @click.group(short_help="Update openapi module and metadata.")
8 | def update():
9 | pass
10 |
11 |
12 | @update.command(short_help="Update openapi TR metadata.")
13 | @verbose_option()
14 | def trinfo():
15 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusTrInfo import (
16 | KiwoomOpenApiPlusTrInfo,
17 | )
18 |
19 | KiwoomOpenApiPlusTrInfo.dump_trinfo_by_code()
20 |
21 |
22 | @update.command(short_help="Update openapi realtype metadata.")
23 | @verbose_option()
24 | def realtype():
25 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusRealType import (
26 | KiwoomOpenApiPlusRealType,
27 | )
28 |
29 | KiwoomOpenApiPlusRealType.dump_realtype_by_desc()
30 |
31 |
32 | @update.command(short_help="Update openapi module version.")
33 | @click.option(
34 | "-i", "--interactive", is_flag=True, help="Put login information with prompts."
35 | )
36 | @verbose_option(default=5, show_default=True)
37 | def openapi(interactive):
38 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusVersionUpdater import (
39 | KiwoomOpenApiPlusVersionUpdater,
40 | )
41 |
42 | credentials = get_credentials(interactive)
43 | updater = KiwoomOpenApiPlusVersionUpdater(credentials)
44 | updater.update_version_if_necessary()
45 |
46 |
47 | @update.command(short_help="Update gRPC stub files by compiling proto files.")
48 | def proto():
49 | from koapy.backend.kiwoom_open_api_plus.grpc.tools.compile_proto import (
50 | compile_proto,
51 | )
52 |
53 | compile_proto()
54 |
--------------------------------------------------------------------------------
/koapy/utils/store/sqlalchemy/Timestamp.py:
--------------------------------------------------------------------------------
1 | import datetime
2 | import inspect
3 |
4 | import pytz
5 |
6 | from sqlalchemy import DateTime
7 | from sqlalchemy.types import TypeDecorator
8 |
9 |
10 | class Timestamp(TypeDecorator): # pylint: disable=abstract-method
11 |
12 | impl = DateTime
13 | cache_ok = True
14 |
15 | signature = inspect.signature(impl)
16 |
17 | utc = datetime.timezone.utc
18 | local_timezone = datetime.datetime.now().astimezone().tzinfo
19 |
20 | def __init__(self, *args, **kwargs):
21 | self._timezone = self.local_timezone
22 | bound = self.signature.bind(*args, **kwargs)
23 | bound.apply_defaults()
24 | if bound.arguments["timezone"]:
25 | if not isinstance(bound.arguments["timezone"], bool):
26 | self._timezone = bound.arguments["timezone"]
27 | bound.arguments["timezone"] = True
28 | if isinstance(self._timezone, str):
29 | self._timezone = pytz.timezone(self._timezone)
30 | super().__init__(*bound.args, **bound.kwargs)
31 |
32 | @classmethod
33 | def is_naive(cls, value):
34 | return value.tzinfo is None or value.tzinfo.utcoffset(value) is None
35 |
36 | def process_bind_param(self, value, dialect):
37 | if self.is_naive(value):
38 | value = value.replace(tzinfo=self.local_timezone)
39 | return value.astimezone(self.utc)
40 |
41 | def process_result_value(self, value, dialect):
42 | if self.is_naive(value):
43 | value = value.replace(tzinfo=self.utc)
44 | value = value.astimezone(self._timezone)
45 | if not self.timezone:
46 | value = value.replace(tzinfo=None)
47 | return value
48 |
--------------------------------------------------------------------------------
/.github/actions/check-version/action.yml:
--------------------------------------------------------------------------------
1 | name: Check version
2 | description: Chceck version status
3 | inputs:
4 | vcs:
5 | description: vcs
6 | required: true
7 | default: any
8 | metadata:
9 | description: metadata
10 | required: false
11 | no_metadata:
12 | description: no metadata
13 | required: false
14 | dirty:
15 | description: dirty
16 | required: false
17 | tagged_metadata:
18 | description: tagged metadata
19 | required: false
20 | pattern:
21 | description: pattern
22 | required: false
23 | format:
24 | description: format
25 | required: false
26 | style:
27 | description: style
28 | required: false
29 | latest_tag:
30 | description: latest tag
31 | required: false
32 | bump:
33 | description: bump
34 | required: false
35 | tag_dir:
36 | description: tag dir
37 | required: false
38 | is_postrelease:
39 | description: is postrelease
40 | required: false
41 | outputs:
42 | version:
43 | description: version
44 | is_finalrelease:
45 | description: is final release
46 | public:
47 | description: public
48 | base_version:
49 | description: base version
50 | epoch:
51 | description: epoch
52 | release:
53 | description: release
54 | major:
55 | description: major
56 | minor:
57 | description: minor
58 | micro:
59 | description: micro
60 | local:
61 | description: local
62 | pre:
63 | description: pre
64 | is_prerelease:
65 | description: is_prerelease
66 | dev:
67 | description: dev
68 | is_devrelease:
69 | description: is_devrelease
70 | post:
71 | description: post
72 | is_postrelease:
73 | description: is_postrelease
74 | runs:
75 | using: docker
76 | image: Dockerfile
77 |
--------------------------------------------------------------------------------
/koapy/backend/daishin_cybos_plus/proxy/CybosPlusEntrypointProxy.py:
--------------------------------------------------------------------------------
1 | from threading import RLock
2 |
3 | import grpc
4 |
5 | from koapy.backend.daishin_cybos_plus.core.CybosPlusEntrypointMixin import (
6 | CybosPlusEntrypointMixin,
7 | )
8 | from koapy.backend.daishin_cybos_plus.proxy.CybosPlusDispatchProxy import (
9 | CybosPlusDispatchProxy,
10 | )
11 | from koapy.common import DispatchProxyService_pb2, DispatchProxyService_pb2_grpc
12 |
13 |
14 | class CybosPlusEntrypointProxy(CybosPlusEntrypointMixin):
15 | def __init__(self, host=None, port=None):
16 | if host is None:
17 | host = "localhost"
18 | if port is None:
19 | port = 3031
20 |
21 | self._host = host
22 | self._port = port
23 |
24 | self._address = self._host + ":" + str(self._port)
25 | self._channel = grpc.insecure_channel(self._address)
26 | self._stub = DispatchProxyService_pb2_grpc.DispatchProxyServiceStub(
27 | self._channel
28 | )
29 |
30 | grpc.channel_ready_future(self._channel).result(timeout=5)
31 |
32 | self._lock = RLock()
33 | self._dispatch_proxies = {}
34 |
35 | def __getitem__(self, name):
36 | if name not in self._dispatch_proxies:
37 | with self._lock:
38 | if name not in self._dispatch_proxies:
39 | request = DispatchProxyService_pb2.GetDispatchRequest()
40 | request.iid = name
41 | response = self._stub.GetDispatch(request)
42 | iid = response.iid
43 | proxy = CybosPlusDispatchProxy(iid, self._stub)
44 | self._dispatch_proxies[name] = proxy
45 | proxy = self._dispatch_proxies[name]
46 | return proxy
47 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/utils/queue/QueueBasedBufferedIterator.py:
--------------------------------------------------------------------------------
1 | import sys
2 | import threading
3 |
4 | from queue import Queue
5 |
6 | from koapy.backend.kiwoom_open_api_plus.utils.queue.QueueIterator import (
7 | BufferedQueueIterator,
8 | )
9 | from koapy.utils.logging.Logging import Logging
10 |
11 |
12 | class QueueBasedBufferedIterator(BufferedQueueIterator, Logging):
13 |
14 | _check_timeout = 1
15 | _default_maxsize = 10
16 |
17 | def __init__(self, iterator, queue=None, maxsize=None):
18 | if queue is None:
19 | if maxsize is None:
20 | maxsize = self._default_maxsize
21 | queue = Queue(maxsize)
22 |
23 | self._iterator = iterator
24 | self._queue = queue
25 | self._maxsize = maxsize
26 | self._exc_info = None
27 |
28 | super().__init__(self._queue)
29 |
30 | self._thread = threading.Thread(target=self._consume_iterator, daemon=True)
31 | self._thread.start()
32 |
33 | def _consume_iterator(self):
34 | try:
35 | for item in self._iterator:
36 | self._queue.put(item)
37 | except Exception: # pylint: disable=broad-except
38 | self.logger.exception("Exception raised while consuming iterator")
39 | self._exc_info = sys.exc_info()
40 |
41 | def next(self, block=True, timeout=None):
42 | try:
43 | item = super().next(block, timeout)
44 | except StopIteration as e:
45 | if self._exc_info is not None:
46 | raise self._exc_info[1] from e
47 | else:
48 | raise e
49 | else:
50 | if self._exc_info is not None:
51 | raise self._exc_info[1]
52 | return item
53 |
--------------------------------------------------------------------------------
/koapy/cli/utils/pywin32.py:
--------------------------------------------------------------------------------
1 | import os
2 | import subprocess
3 | import sys
4 | import tempfile
5 |
6 | import requests
7 |
8 | from koapy.utils.logging import get_logger
9 |
10 | logger = get_logger(__name__)
11 |
12 |
13 | def get_pywin32_postinstall_script(filepath):
14 | url = (
15 | "https://raw.githubusercontent.com/mhammond/pywin32/main/pywin32_postinstall.py"
16 | )
17 | response = requests.get(url)
18 | with open(filepath, "wb") as f:
19 | f.write(response.content)
20 |
21 |
22 | def install_pywin32(version=None):
23 | if version is None:
24 | version = "304"
25 | cmd = ["pip", "install", "pywin32>={}".format(version)]
26 | logger.info("Running command: %s", subprocess.list2cmdline(cmd))
27 | subprocess.check_call(cmd)
28 | with tempfile.TemporaryDirectory() as tempdir:
29 | script_filename = "pywin32_postinstall.py"
30 | script_filepath = os.path.join(tempdir, script_filename)
31 | get_pywin32_postinstall_script(script_filepath)
32 | cmd = [sys.executable, script_filepath, "-install"]
33 | logger.info("Running command: %s", subprocess.list2cmdline(cmd))
34 | subprocess.check_call(cmd)
35 |
36 |
37 | def uninstall_pywin32():
38 | with tempfile.TemporaryDirectory() as tempdir:
39 | script_filename = "pywin32_postinstall.py"
40 | script_filepath = os.path.join(tempdir, script_filename)
41 | get_pywin32_postinstall_script(script_filepath)
42 | cmd = [sys.executable, script_filepath, "-remove"]
43 | logger.info("Running command: %s", subprocess.list2cmdline(cmd))
44 | subprocess.check_call(cmd)
45 | cmd = ["pip", "uninstall", "pywin32"]
46 | logger.info("Running command: %s", subprocess.list2cmdline(cmd))
47 | subprocess.check_call(cmd)
48 |
--------------------------------------------------------------------------------
/koapy/backend/daishin_cybos_plus/proxy/CybosPlusDispatchProxyService.py:
--------------------------------------------------------------------------------
1 | import sys
2 |
3 | from concurrent.futures import ThreadPoolExecutor
4 |
5 | import grpc
6 | import pythoncom
7 |
8 | from koapy.backend.daishin_cybos_plus.proxy.CybosPlusDispatchProxyServiceServicer import (
9 | CybosPlusDispatchProxyServiceServicer,
10 | )
11 | from koapy.common import DispatchProxyService_pb2_grpc
12 |
13 |
14 | class CybosPlusDispatchProxyService:
15 | def __init__(self, host=None, port=None, max_workers=None):
16 | if host is None:
17 | host = "localhost"
18 | if port is None:
19 | port = 3031
20 |
21 | if max_workers is None:
22 | max_workers = None
23 |
24 | self._host = host
25 | self._port = port
26 | self._max_workers = max_workers
27 |
28 | self._address = self._host + ":" + str(self._port)
29 | self._servicer = CybosPlusDispatchProxyServiceServicer()
30 |
31 | def initializer():
32 | flags = getattr(sys, "coinit_flags", pythoncom.COINIT_MULTITHREADED)
33 | pythoncom.CoInitializeEx(flags)
34 |
35 | self._executor = ThreadPoolExecutor(
36 | max_workers=self._max_workers,
37 | initializer=initializer,
38 | )
39 |
40 | self._server = grpc.server(self._executor)
41 | DispatchProxyService_pb2_grpc.add_DispatchProxyServiceServicer_to_server(
42 | self._servicer, self._server
43 | )
44 | self._server.add_insecure_port(self._address)
45 |
46 | def __getattr__(self, name):
47 | return getattr(self._server, name)
48 |
49 |
50 | def main():
51 | service = CybosPlusDispatchProxyService()
52 | service.start()
53 | service.wait_for_termination()
54 |
55 |
56 | if __name__ == "__main__":
57 | main()
58 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/openapi_meta/realinfo.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 |
5 |
6 | @click.command(short_help="Get real type info.")
7 | @click.option(
8 | "-t",
9 | "--realtype",
10 | "realtypes",
11 | metavar="REALTYPE",
12 | multiple=True,
13 | help="Real type name to get (like 주식시세).",
14 | )
15 | @verbose_option()
16 | def realinfo(realtypes):
17 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusRealType import (
18 | KiwoomOpenApiPlusRealType,
19 | )
20 |
21 | def get_realtypes():
22 | if realtypes:
23 | if "-" in realtypes:
24 | with click.open_file("-", "r") as f:
25 | for realtype in f:
26 | yield realtype.strip()
27 | else:
28 | for realtype in realtypes:
29 | yield realtype
30 | else:
31 | while True:
32 | try:
33 | realtype = click.prompt("realtype", prompt_suffix=" >>> ")
34 | realtype = realtype.strip()
35 | if realtype == "exit":
36 | break
37 | if realtype:
38 | yield realtype
39 | except EOFError:
40 | break
41 |
42 | for realtype in get_realtypes():
43 | fids = KiwoomOpenApiPlusRealType.get_fids_by_realtype_name(realtype)
44 | if fids:
45 | names = [
46 | KiwoomOpenApiPlusRealType.Fid.get_name_by_fid(fid, str(fid))
47 | for fid in fids
48 | ]
49 | for fid, name in zip(fids, names):
50 | click.echo(" [{}] = {}".format(fid, name))
51 | else:
52 | click.echo("Given realtype is invalid")
53 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/grpc/event/KiwoomOpenApiPlusLoginEventHandler.py:
--------------------------------------------------------------------------------
1 | from google.protobuf.json_format import MessageToDict
2 |
3 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusError import (
4 | KiwoomOpenApiPlusError,
5 | KiwoomOpenApiPlusNegativeReturnCodeError,
6 | )
7 | from koapy.backend.kiwoom_open_api_plus.grpc import KiwoomOpenApiPlusService_pb2
8 | from koapy.backend.kiwoom_open_api_plus.grpc.event.KiwoomOpenApiPlusEventHandlerForGrpc import (
9 | KiwoomOpenApiPlusEventHandlerForGrpc,
10 | )
11 |
12 |
13 | class KiwoomOpenApiPlusLoginEventHandler(KiwoomOpenApiPlusEventHandlerForGrpc):
14 | def __init__(self, control, request, context):
15 | super().__init__(control, context)
16 | self._request = request
17 |
18 | if self._request.HasField("credentials"):
19 | self._credentials = self._request.credentials
20 | self._credentials = MessageToDict(
21 | self._credentials, preserving_proto_field_name=True
22 | )
23 | else:
24 | self._credentials = None
25 |
26 | def on_enter(self):
27 | if self._credentials is not None:
28 | self.control.DisableAutoLogin()
29 | KiwoomOpenApiPlusError.try_or_raise(self.control.CommConnect())
30 | self.control.LoginUsingPywinauto(self._credentials)
31 | else:
32 | KiwoomOpenApiPlusError.try_or_raise(self.control.CommConnect())
33 |
34 | def OnEventConnect(self, errcode):
35 | if errcode < 0:
36 | error = KiwoomOpenApiPlusNegativeReturnCodeError(errcode)
37 | self.observer.on_error(error)
38 | response = KiwoomOpenApiPlusService_pb2.ListenResponse()
39 | response.name = "OnEventConnect"
40 | response.arguments.add().long_value = errcode
41 | self.observer.on_next(response)
42 | self.observer.on_completed()
43 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/stock_meta/codelist.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.commands.get.stock_meta.codelist_interactive import codelist_interactive
4 | from koapy.cli.utils.verbose_option import verbose_option
5 |
6 | market_codes = [
7 | "0",
8 | "10",
9 | "3",
10 | "8",
11 | "50",
12 | "4",
13 | "5",
14 | "6",
15 | "9",
16 | "30",
17 | "all",
18 | ]
19 |
20 |
21 | @click.command(short_help="Get stock codes.")
22 | @click.option(
23 | "-m",
24 | "--market",
25 | "markets",
26 | metavar="MARKET",
27 | multiple=True,
28 | type=click.Choice(market_codes, case_sensitive=False),
29 | help="Stock market code to get. Can set multiple times.",
30 | )
31 | @click.option(
32 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
33 | )
34 | @verbose_option()
35 | def codelist(markets, port):
36 | """
37 | \b
38 | Possible market codes are:
39 | 0 : 장내
40 | 10 : 코스닥
41 | 3 : ELW
42 | 8 : ETF
43 | 50 : KONEX
44 | 4 : 뮤추얼펀드
45 | 5 : 신주인수권
46 | 6 : 리츠
47 | 9 : 하이얼펀드
48 | 30 : K-OTC
49 | """
50 |
51 | if not markets and click.get_text_stream("stdin").isatty():
52 | return codelist_interactive()
53 |
54 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
55 | KiwoomOpenApiPlusEntrypoint,
56 | )
57 |
58 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
59 | context.EnsureConnected()
60 | codes = set()
61 | for market in markets:
62 | codes = codes.union(set(context.GetCodeListByMarketAsList(market)))
63 | codes = sorted(list(codes))
64 | for code in codes:
65 | click.echo(code)
66 |
67 |
68 | def main():
69 | codelist() # pylint: disable=no-value-for-parameter
70 |
71 |
72 | if __name__ == "__main__":
73 | main()
74 |
--------------------------------------------------------------------------------
/.github/workflows/documentation.yml:
--------------------------------------------------------------------------------
1 | name: Documentation
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | paths:
8 | - '**.rst'
9 | - 'docs/*'
10 | - '.github/workflows/documentation.yml'
11 | workflow_dispatch:
12 | inputs:
13 | force_orphan:
14 | description: Force orphan
15 | required: false
16 | default: false
17 |
18 | jobs:
19 | build-and-publish:
20 | runs-on: ubuntu-latest
21 | steps:
22 | - uses: actions/checkout@v3
23 | - name: Set up Python
24 | uses: actions/setup-python@v4
25 | id: setup-python
26 | with:
27 | python-version: 3.8
28 | - name: Install poetry
29 | run: |
30 | python -m pip install --upgrade pip
31 | pip install pipx
32 | pipx install poetry
33 | - name: Get poetry cache dir
34 | id: poetry-cache
35 | run: |
36 | echo "::set-output name=dir::$(poetry config cache-dir)"
37 | - name: Restore cache
38 | uses: actions/cache@v3
39 | with:
40 | path: ${{ steps.poetry-cache.outputs.dir }}
41 | key: ${{ runner.os }}-poetry-py${{ steps.setup-python.outputs.python-version }}-x64-${{ hashFiles('poetry.lock') }}
42 | restore-keys: |
43 | ${{ runner.os }}-poetry-py${{ steps.setup-python.outputs.python-version }}-x64-
44 | - name: Install dependencies
45 | run: |
46 | poetry install
47 | sudo apt-get update && sudo apt-get install pandoc
48 | - name: Build documentation
49 | run: |
50 | poetry run make -C docs html
51 | - name: Publish documentaion to Github Pages
52 | uses: peaceiris/actions-gh-pages@v3
53 | with:
54 | github_token: ${{ secrets.GITHUB_TOKEN }}
55 | publish_dir: ./docs/build/html/
56 | force_orphan: ${{ github.event.inputs.force_orphan }}
57 | commit_message: ${{ github.event.head_commit.message }}
58 |
--------------------------------------------------------------------------------
/koapy/backtrader/KrxTradingCalendar.py:
--------------------------------------------------------------------------------
1 | import datetime
2 |
3 | import pytz
4 |
5 | from backtrader.tradingcal import TradingCalendarBase
6 | from backtrader.utils.py3 import string_types
7 | from pandas import DataFrame, DatetimeIndex, Timestamp
8 |
9 |
10 | class ExchangeCalendarsTradingCalendar(TradingCalendarBase):
11 |
12 | # pylint: disable=no-member
13 |
14 | params = (
15 | ("calendar", None),
16 | ("cachesize", 365),
17 | )
18 |
19 | def __init__(self):
20 | super().__init__()
21 |
22 | self._calendar = self.p.calendar
23 |
24 | if isinstance(self._calendar, string_types):
25 | from exchange_calendars import get_calendar
26 |
27 | self._calendar = get_calendar(self._calendar)
28 |
29 | self.dcache = DatetimeIndex([0.0])
30 | self.idcache = DataFrame(index=DatetimeIndex([0.0]))
31 | self.csize = datetime.timedelta(days=self.p.cachesize)
32 |
33 | def _nextday(self, day):
34 | d = day + self._calendar.day
35 | return d, d.isocalendar()
36 |
37 | def schedule(
38 | self, day, tz=None
39 | ): # pylint: disable=arguments-differ,unused-argument
40 | """
41 | day: expecting naive datetime.datetime day in utc timezone
42 | tz: treat/localize internal naive datetimes to this timezone
43 | returns: (opening, closing) naive datetime.datetime pair in utc timezone
44 | """
45 | session = Timestamp(day, tz=pytz.UTC).normalize()
46 | opening, closing = self._calendar.open_and_close_for_session(session)
47 | opening = opening.tz.localize(None).to_pydatetime()
48 | closing = closing.tz.localize(None).to_pydatetime()
49 | return opening, closing
50 |
51 |
52 | class KrxTradingCalendar(ExchangeCalendarsTradingCalendar):
53 |
54 | params = (
55 | ("calendar", "XKRX"),
56 | ("cachesize", 365),
57 | )
58 |
--------------------------------------------------------------------------------
/koapy/utils/recursion.py:
--------------------------------------------------------------------------------
1 | """
2 | """
3 |
4 | """
5 | This is free and unencumbered software released into the public domain.
6 |
7 | Anyone is free to copy, modify, publish, use, compile, sell, or
8 | distribute this software, either in source code form or as a compiled
9 | binary, for any purpose, commercial or non-commercial, and by any
10 | means.
11 |
12 | In jurisdictions that recognize copyright laws, the author or authors
13 | of this software dedicate any and all copyright interest in the
14 | software to the public domain. We make this dedication for the benefit
15 | of the public at large and to the detriment of our heirs and
16 | successors. We intend this dedication to be an overt act of
17 | relinquishment in perpetuity of all present and future rights to this
18 | software under copyright law.
19 |
20 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26 | OTHER DEALINGS IN THE SOFTWARE.
27 |
28 | For more information, please refer to
29 | """
30 |
31 | # https://github.com/andrewp-as-is/recursion-detect.py
32 |
33 | import inspect
34 |
35 |
36 | def depth():
37 | """return recursion depth. 0 if no recursion"""
38 | counter = 0
39 | frames = inspect.getouterframes(inspect.currentframe())[1:]
40 | top_frame = inspect.getframeinfo(frames[0][0])
41 | for frame, _, _, _, _, _ in frames[1:]:
42 | (path, line_number, func_name, lines, index) = inspect.getframeinfo(frame)
43 | if path == top_frame[0] and func_name == top_frame[2]:
44 | counter += 1
45 | return counter
46 |
47 |
48 | __all__ = ["depth"]
49 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: CI
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | pull_request:
8 | branches:
9 | - master
10 | workflow_dispatch:
11 | inputs:
12 |
13 | jobs:
14 | build-and-test:
15 |
16 | runs-on: ${{ matrix.os }}
17 | strategy:
18 | matrix:
19 | os: [ubuntu-latest, windows-latest, macos-latest]
20 | python-version: [3.8, 3.9]
21 | architecture: [x86, x64]
22 | exclude:
23 | - os: ubuntu-latest
24 | - os: macos-latest
25 |
26 | steps:
27 | - uses: actions/checkout@v3
28 | - name: Set up Python
29 | uses: actions/setup-python@v4
30 | id: setup-python
31 | with:
32 | python-version: ${{ matrix.python-version }}
33 | - name: Install poetry
34 | run: |
35 | python -m pip install --upgrade pip
36 | pip install pipx
37 | pipx install poetry
38 | - name: Get poetry cache dir
39 | id: poetry-cache
40 | run: |
41 | echo "::set-output name=dir::$(poetry config cache-dir)"
42 | - name: Restore cache
43 | uses: actions/cache@v3
44 | with:
45 | path: ${{ steps.poetry-cache.outputs.dir }}
46 | key: ${{ runner.os }}-poetry-py${{ steps.setup-python.outputs.python-version }}-${{ matrix.architecture }}-${{ hashFiles('poetry.lock') }}
47 | restore-keys: |
48 | ${{ runner.os }}-poetry-py${{ steps.setup-python.outputs.python-version }}-${{ matrix.architecture }}-
49 | - name: Install dependencies
50 | run: |
51 | poetry install
52 | - name: Test with pytest
53 | run: |
54 | poetry run pytest -n auto --dist loadscope --junit-xml=junit/test-results.xml --cov --cov-report=xml --cov-report=html
55 | - name: Update Codecov coverage report
56 | uses: codecov/codecov-action@v3.1.1
57 | with:
58 | token: ${{ secrets.CODECOV_TOKEN }}
59 | flags: ${{ matrix.os }}-py${{ matrix.python-version }}
60 |
--------------------------------------------------------------------------------
/koapy/examples/10_condition.py:
--------------------------------------------------------------------------------
1 | import threading
2 |
3 | import grpc
4 |
5 | from koapy import KiwoomOpenApiPlusEntrypoint
6 |
7 | with KiwoomOpenApiPlusEntrypoint() as context:
8 | # 로그인 처리
9 | context.EnsureConnected()
10 |
11 | # 조건검색을 사용하기 위해서는 먼저 서버에 저장된 조건들을 불러와야함 (GetConditionLoad)
12 | # 아래 함수는 조건을 불러온적이 없다면 불러오고 성공 이벤트까지 기다렸다 반환함
13 | # 이전 호출여부와 상관없이 강제로 다시 조건을 불러오려면 LoadCondition() 호출
14 | context.EnsureConditionLoaded()
15 |
16 | # 불러온 조건 리스트 확인, (조건번호, 조건이름) 쌍 리스트 반환
17 | conditions = context.GetConditionNameListAsList()
18 | print(conditions)
19 |
20 | # 이후 예시의 정상동작을 위해 아래에서 사용되는 조건들과 같은 이름을 가지는 조건들이 미리 저장되어 있어야함
21 | # - 대형 저평가 우량주
22 | # - 중소형 저평가주
23 |
24 | # 위의 조건식들은 키움에서 예시로 제공하는 추천식들을 그대로 이름을 똑같이 해서 저장한 것들임
25 | # 참고로 조건들을 편집하고 저장하는건 영웅문 HTS 내부에서만 가능함
26 |
27 | # 조건검색을 실행할 첫 조건명
28 | condition_name = "대형 저평가 우량주"
29 |
30 | # 조건을 만족하는 코드 리스트를 바로 반환 (단순 조건검색)
31 | codes, info = context.GetCodeListByCondition(condition_name, with_info=True)
32 | print(codes)
33 | print(info)
34 |
35 | # 조건검색을 다시 실행할 조건명 (같은 조건식은 1분에 1건 제한이므로 예시 실행시 제한을 회피하기 위해서 새로 설정)
36 | condition_name = "중소형 저평가주"
37 |
38 | # 실시간 조건 검색 예시, 편입된/제외된 코드 리스트 쌍을 스트림으로 반환 (실시간 조건 검색)
39 | stream = context.GetCodeListByConditionAsStream(condition_name)
40 |
41 | def stop_listening():
42 | print()
43 | print("Stopping to listen events...")
44 | stream.cancel()
45 |
46 | threading.Timer(10.0, stop_listening).start() # 10초 이후에 gRPC 커넥션 종료하도록 설정
47 |
48 | # (디버깅을 위한) 이벤트 메시지 출력 함수
49 | from pprint import PrettyPrinter
50 |
51 | from google.protobuf.json_format import MessageToDict
52 |
53 | pp = PrettyPrinter()
54 |
55 | def pprint_event(event):
56 | pp.pprint(MessageToDict(event, preserving_proto_field_name=True))
57 |
58 | try:
59 | for event in stream:
60 | pprint_event(event)
61 | except grpc.RpcError as e:
62 | print(e)
63 |
--------------------------------------------------------------------------------
/koapy/compat/pywinauto/importlib.py:
--------------------------------------------------------------------------------
1 | import importlib
2 | import sys
3 | import warnings
4 |
5 | from importlib.abc import Loader, MetaPathFinder
6 |
7 | import pythoncom
8 |
9 |
10 | class PyWinAutoFinder(MetaPathFinder):
11 | def find_spec(self, fullname, path, target=None):
12 | if fullname == "pywinauto":
13 | self.unregister()
14 | spec = importlib.util.find_spec(fullname)
15 | spec.loader = PyWinAutoLoader()
16 | return spec
17 |
18 | @classmethod
19 | def register(cls):
20 | sys.meta_path = [cls()] + sys.meta_path
21 |
22 | @classmethod
23 | def unregister(cls):
24 | sys.meta_path = [x for x in sys.meta_path if not isinstance(x, cls)]
25 |
26 |
27 | class PyWinAutoLoader(Loader):
28 | def __init__(self):
29 | self._original_coinit_flags_defined = False
30 | self._original_coinit_flags = None
31 |
32 | def set_sys_coinit_flags(self):
33 | self._original_coinit_flags_defined = hasattr(sys, "coinit_flags")
34 | self._original_coinit_flags = getattr(sys, "coinit_flags", None)
35 | sys.coinit_flags = pythoncom.COINIT_APARTMENTTHREADED
36 |
37 | def reset_sys_coinit_flags(self):
38 | if not self._original_coinit_flags_defined:
39 | del sys.coinit_flags
40 | else:
41 | sys.coinit_flags = self._original_coinit_flags
42 |
43 | def create_module(self, spec):
44 | # set sys.coinit_flags = 2
45 | # check https://github.com/pywinauto/pywinauto/issues/472 for more information
46 | self.set_sys_coinit_flags()
47 |
48 | # ensure that qt binding is imported before pywinauto import
49 | from koapy.compat import pyside2
50 |
51 | # import pywinauto
52 | with warnings.catch_warnings():
53 | warnings.simplefilter("ignore", UserWarning)
54 | module = importlib.import_module(spec.name)
55 | return module
56 |
57 | def exec_module(self, module):
58 | pass
59 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/utils/queue/QueueBasedIterableObserver.py:
--------------------------------------------------------------------------------
1 | from queue import Empty, Queue
2 |
3 | from rx.core.typing import Observer
4 |
5 | from koapy.backend.kiwoom_open_api_plus.utils.queue.QueueIterator import (
6 | BufferedQueueIterator,
7 | )
8 |
9 |
10 | class QueueBasedIterableObserverIterator(BufferedQueueIterator):
11 | def __init__(self, queue, sentinel):
12 | self._queue = queue
13 | self._sentinel = sentinel
14 | super().__init__(self._queue)
15 |
16 | def next(self, block=True, timeout=None):
17 | value, error = super().next(block, timeout)
18 | if value == self._sentinel:
19 | raise StopIteration
20 | elif error is not None and isinstance(error, Exception):
21 | raise error
22 | return value
23 |
24 | def head(self):
25 | value, error = super().head()
26 | if value == self._sentinel:
27 | raise Empty
28 | elif error is not None and isinstance(error, Exception):
29 | raise error
30 | return value
31 |
32 |
33 | class QueueBasedIterableObserver(Observer):
34 |
35 | _default_maxsize = 0
36 | _queue_get_timeout = 2
37 |
38 | def __init__(self, queue=None, maxsize=None):
39 | if queue is None:
40 | if maxsize is None:
41 | maxsize = self._default_maxsize
42 | queue = Queue(maxsize)
43 |
44 | self._queue = queue
45 | self._maxsize = maxsize
46 | self._sentinel = object()
47 |
48 | self._iterator = QueueBasedIterableObserverIterator(self._queue, self._sentinel)
49 |
50 | @property
51 | def queue(self):
52 | return self._queue
53 |
54 | def on_next(self, value):
55 | self._queue.put((value, None))
56 |
57 | def on_error(self, error):
58 | self._queue.put((None, error))
59 |
60 | def on_completed(self):
61 | self._queue.put((self._sentinel, None))
62 |
63 | def __iter__(self):
64 | return self._iterator
65 |
66 | def stop(self):
67 | return self._iterator.stop()
68 |
--------------------------------------------------------------------------------
/koapy/backend/daishin_cybos_plus/core/CybosPlusError.py:
--------------------------------------------------------------------------------
1 | from functools import wraps
2 |
3 |
4 | class CybosPlusError(Exception):
5 |
6 | pass
7 |
8 |
9 | class CybosPlusRequestError(CybosPlusError):
10 |
11 | """
12 | 아래 문서에서 [BlockRequest/Blockrequest2/Request의 리턴값] 내용 참조
13 | http://cybosplus.github.io/cputil_rtf_1_/cybosplus_interface.htm
14 | """
15 |
16 | ERROR_MESSAGE_BY_CODE = {
17 | 0: "정상요청",
18 | 1: "통신요청 실패",
19 | 2: "주문확인창에서 취소",
20 | 3: "그외의 내부 오류",
21 | 4: "주문요청 제한 개수 초과",
22 | }
23 |
24 | @classmethod
25 | def get_error_message_by_code(cls, code, default=None):
26 | return cls.ERROR_MESSAGE_BY_CODE.get(code, default)
27 |
28 | @classmethod
29 | def check_code_or_raise(cls, code):
30 | if code != 0:
31 | raise cls(code)
32 | return code
33 |
34 | @classmethod
35 | def wrap_to_check_code_or_raise(cls, func):
36 | @wraps(func)
37 | def wrapper(*args, **kwargs):
38 | return cls.check_code_or_raise(func(*args, **kwargs))
39 |
40 | return wrapper
41 |
42 | @classmethod
43 | def try_or_raise(cls, arg):
44 | if isinstance(arg, int):
45 | return cls.check_code_or_raise(arg)
46 | elif callable(arg):
47 | return cls.wrap_to_check_code_or_raise(arg)
48 | else:
49 | raise TypeError("Expected 'int' or 'callable' but %s found" % type(arg))
50 |
51 | def __init__(self, code, message=None):
52 | if message is None:
53 | message = self.get_error_message_by_code(code)
54 |
55 | super().__init__(message)
56 |
57 | self._code = code
58 | self._message = message
59 |
60 | def __str__(self):
61 | return self._message
62 |
63 | def __repr__(self):
64 | return "{}({!r}, {!r})".format(
65 | self.__class__.__name__, self._code, self._message
66 | )
67 |
68 | @property
69 | def code(self):
70 | return self._code
71 |
72 | @property
73 | def message(self):
74 | return self._message
75 |
--------------------------------------------------------------------------------
/koapy/common/DispatchProxyService.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 |
3 | service DispatchProxyService {
4 | rpc GetDispatch(GetDispatchRequest) returns (GetDispatchResponse) {};
5 | rpc GetAttr(GetAttrRequest) returns (GetAttrResponse) {};
6 | rpc SetAttr(SetAttrRequest) returns (SetAttrResponse) {};
7 | rpc CallMethod(CallMethodRequest) returns (CallMethodResponse) {};
8 | rpc ConnectEvent(stream ConnectEventRequest) returns (stream ConnectEventResponse) {};
9 | }
10 |
11 | message GetDispatchRequest {
12 | string iid = 1;
13 | }
14 |
15 | message GetDispatchResponse {
16 | string iid = 1;
17 | }
18 |
19 | message Value {
20 | oneof value {
21 | string string_value = 1;
22 | int32 short_value = 2;
23 | int32 int_value = 3;
24 | int64 long_value = 4;
25 | bool bool_value = 5;
26 | double double_value = 6;
27 | ValueArray list_value = 7;
28 | ValueArray tuple_value = 8;
29 | }
30 | }
31 |
32 | message ValueArray {
33 | repeated Value values = 1;
34 | }
35 |
36 | message GetAttrRequest {
37 | string iid = 1;
38 | string name = 2;
39 | }
40 |
41 | message GetAttrResponse {
42 | Value value = 1;
43 | }
44 |
45 | message SetAttrRequest {
46 | string iid = 1;
47 | string name = 2;
48 | Value value = 3;
49 | }
50 |
51 | message SetAttrResponse {
52 | }
53 |
54 | message Argument {
55 | Value value = 1;
56 | }
57 |
58 | message CallMethodRequest {
59 | string iid = 1;
60 | string name = 2;
61 | repeated Argument arguments = 3;
62 | }
63 |
64 | message CallMethodResponse {
65 | Value return_value = 1;
66 | }
67 |
68 | message ConnectEventEstablishRequest {
69 | string iid = 1;
70 | string name = 2;
71 | }
72 |
73 | message ConnectEventAckRequest {
74 | }
75 |
76 | message ConnectEventRequest {
77 | oneof request {
78 | ConnectEventEstablishRequest establish_request = 1;
79 | ConnectEventAckRequest ack_request = 2;
80 | }
81 | }
82 |
83 | message ConnectEventResponse {
84 | string iid = 1;
85 | string name = 2;
86 | repeated Argument arguments = 3;
87 | }
88 |
--------------------------------------------------------------------------------
/koapy/utils/store/sqlalchemy/Version.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import (
2 | Boolean,
3 | Column,
4 | ForeignKey,
5 | Integer,
6 | PickleType,
7 | String,
8 | UniqueConstraint,
9 | )
10 | from sqlalchemy.orm import object_session, relationship
11 | from sqlalchemy.schema import DropTable, MetaData, Table
12 | from sqlalchemy.sql.functions import current_timestamp
13 |
14 | from .Base import Base
15 | from .Timestamp import Timestamp
16 |
17 |
18 | class Version(Base):
19 | __tablename__ = "versions"
20 |
21 | id = Column(Integer, primary_key=True)
22 | version = Column(Integer, nullable=False)
23 |
24 | table_name = Column(String)
25 | user_metadata = Column(PickleType)
26 | pandas_metadata = Column(PickleType)
27 |
28 | deleted = Column(Boolean, default=False)
29 |
30 | timestamp = Column(Timestamp(timezone=True), server_default=current_timestamp())
31 |
32 | symbol_id = Column(Integer, ForeignKey("symbols.id"))
33 | symbol = relationship("Symbol", back_populates="versions")
34 |
35 | snapshots = relationship("SnapshotAssociation", back_populates="version")
36 |
37 | __table_args__ = (UniqueConstraint("symbol_id", "version"),)
38 |
39 | def get_snapshots(self):
40 | # quick fix fir circular dependency
41 | from .Snapshot import Snapshot
42 | from .SnapshotAssociation import SnapshotAssociation
43 |
44 | session = object_session(self)
45 | snapshots = session.query(SnapshotAssociation).with_parent(self)
46 | snapshots = session.query(Snapshot).join(snapshots.subquery())
47 | snapshots = snapshots.all()
48 | return snapshots
49 |
50 | def delete(self):
51 | session = object_session(self)
52 | if self.table_name is not None:
53 | table_reference_count = (
54 | session.query(Version)
55 | .filter(Version.table_name == self.table_name)
56 | .count()
57 | )
58 | if table_reference_count <= 1:
59 | session.execute(
60 | DropTable(Table(self.table_name, MetaData()), if_exists=True)
61 | )
62 | session.delete(self)
63 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/core/KiwoomOpenApiPlusEventHandlerSignature.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from typing import Dict, List
4 |
5 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEventFunctions import (
6 | KiwoomOpenApiPlusEventFunctions,
7 | )
8 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusSignature import (
9 | KiwoomOpenApiPlusSignature,
10 | )
11 | from koapy.utils.builtin import dir_public
12 |
13 |
14 | class KiwoomOpenApiPlusEventHandlerSignature(KiwoomOpenApiPlusSignature):
15 |
16 | EVENT_HANDLER_SIGNATURES_BY_NAME: Dict[
17 | str, KiwoomOpenApiPlusEventHandlerSignature
18 | ] = {}
19 |
20 | @classmethod
21 | def from_name(cls, name: str) -> KiwoomOpenApiPlusEventHandlerSignature:
22 | signature = cls.EVENT_HANDLER_SIGNATURES_BY_NAME[name]
23 | return signature
24 |
25 | @classmethod
26 | def names(cls) -> List[str]:
27 | names = cls.EVENT_HANDLER_SIGNATURES_BY_NAME.keys()
28 | names = list(names)
29 | if not names:
30 | _names = dir_public(KiwoomOpenApiPlusEventFunctions)
31 | return names
32 |
33 | @classmethod
34 | def _make_event_handler_signatures_by_name(
35 | cls,
36 | ) -> Dict[str, KiwoomOpenApiPlusEventHandlerSignature]:
37 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusTypeLib import (
38 | EVENT_OLE_ITEM,
39 | )
40 |
41 | event = EVENT_OLE_ITEM
42 | event_handler_signatures_by_name: Dict[
43 | str, KiwoomOpenApiPlusEventHandlerSignature
44 | ] = {}
45 | if event:
46 | event_funcs = event.mapFuncs.items()
47 | event_handler_signatures_by_name = {}
48 | for func_name, entry in event_funcs:
49 | signature = cls._from_entry(func_name, entry)
50 | event_handler_signatures_by_name[func_name] = signature
51 | return event_handler_signatures_by_name
52 |
53 | @classmethod
54 | def _initialize(cls):
55 | cls.EVENT_HANDLER_SIGNATURES_BY_NAME = (
56 | cls._make_event_handler_signatures_by_name()
57 | )
58 |
59 |
60 | KiwoomOpenApiPlusEventHandlerSignature._initialize() # pylint: disable=protected-access
61 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/openapi_meta/trinfo.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 |
5 |
6 | @click.command(short_help="Get TR info.")
7 | @click.option(
8 | "-t",
9 | "--trcode",
10 | "trcodes",
11 | metavar="TRCODE",
12 | multiple=True,
13 | help="TR code to get (like opt10001).",
14 | )
15 | @verbose_option()
16 | def trinfo(trcodes):
17 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusTrInfo import (
18 | KiwoomOpenApiPlusTrInfo,
19 | )
20 |
21 | def get_codes():
22 | if trcodes:
23 | if "-" in trcodes:
24 | with click.open_file("-", "r") as f:
25 | for code in f:
26 | yield code.strip()
27 | else:
28 | for code in trcodes:
29 | yield code
30 | else:
31 | while True:
32 | try:
33 | code = click.prompt("trcode", prompt_suffix=" >>> ")
34 | code = code.strip()
35 | if code == "exit":
36 | break
37 | if code:
38 | yield code
39 | except EOFError:
40 | break
41 |
42 | for trcode in get_codes():
43 | tr_info = KiwoomOpenApiPlusTrInfo.get_trinfo_by_code(trcode)
44 | if tr_info is not None:
45 | click.echo("[{}] : [{}]".format(tr_info.tr_code.upper(), tr_info.name))
46 | click.echo(" [INPUT]")
47 | for tr_input in tr_info.inputs:
48 | click.echo(" %s" % tr_input.name)
49 | if tr_info.single_outputs:
50 | click.echo(
51 | " [OUTPUT] [SINGLE DATA] : [%s]" % tr_info.single_outputs_name
52 | )
53 | for output in tr_info.single_outputs:
54 | click.echo(" %s" % output.name)
55 | if tr_info.multi_outputs:
56 | click.echo(
57 | " [OUTPUT] [MULTI DATA] : [%s]" % tr_info.multi_outputs_name
58 | )
59 | for output in tr_info.multi_outputs:
60 | click.echo(" %s" % output.name)
61 | else:
62 | click.echo("Given trcode is invalid")
63 |
--------------------------------------------------------------------------------
/docs/source/_static/css/style.css:
--------------------------------------------------------------------------------
1 | @import url('https://fonts.googleapis.com/css2?family=Noto+Serif+KR:wght@300;400&display=swap');
2 | @import url("https://cdn.jsdelivr.net/gh/wan2land/d2coding/d2coding-full.css");
3 |
4 | /* General */
5 |
6 | body {
7 | padding: 0 !important;
8 | }
9 |
10 | code {
11 | vertical-align: text-bottom;
12 | }
13 |
14 | dl dd {
15 | margin-left: 0;
16 | }
17 |
18 | div.document {
19 | width: auto;
20 | max-width: 1200px;
21 | }
22 |
23 | /* Jupyter notebook related overrides */
24 |
25 | :root {
26 | --jp-ui-font-family: 'Noto Serif KR', Georgia, 'Times New Roman', Times, serif !important;
27 | --jp-content-font-family: 'Noto Serif KR', Georgia, 'Times New Roman', Times, serif !important;
28 | --jp-code-font-family: 'D2Coding', 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace !important;
29 | --jp-content-font-size1: 17px !important;
30 | --jp-code-font-size: 0.9em !important;
31 | }
32 |
33 | .jp-Cell .highlight {
34 | background: transparent;
35 | }
36 |
37 | .jp-Cell pre {
38 | background: transparent;
39 | }
40 |
41 | .jp-Cell .highlight pre {
42 | margin: 1em 0px;
43 | }
44 |
45 | .jp-Notebook {
46 | font-size: var(--jp-content-font-size1);
47 | }
48 |
49 | .jp-InputPrompt {
50 | font-size: 0.7em !important;
51 | }
52 |
53 | .jp-OutputPrompt {
54 | font-size: 0.7em !important;
55 | }
56 |
57 | .jp-Notebook {
58 | letter-spacing: normal !important;
59 | line-height: normal !important;
60 | }
61 |
62 | /* Media query overrides */
63 |
64 | @media screen and (max-width: 875px) {
65 | div.sphinxsidebar {
66 | width: 100%;
67 | margin: 0 !important;
68 | padding: 0 !important;
69 | }
70 |
71 | div.sphinxsidebarwrapper {
72 | padding: 28px 30px !important;
73 | }
74 |
75 | div.documentwrapper {
76 | overflow-x: scroll;
77 | }
78 |
79 | div.body {
80 | padding: 0 30px 20px;
81 | }
82 |
83 | body.jp-Notebook div.body {
84 | margin-left: -30px;
85 | }
86 |
87 | body.jp-Notebook div.body > section > h1 {
88 | margin-left: 30px;
89 | }
90 | }
91 |
92 | @media screen and (max-width: 870px) {
93 | ul, ol {
94 | margin-left: 30px;
95 | padding-left: 0 !important;
96 | }
97 | }
--------------------------------------------------------------------------------
/koapy/cli/commands/generate/openapi/python_stubs.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.backend.kiwoom_open_api_plus.core.tools.generate_python_stubs import (
4 | generate_python_stubs,
5 | )
6 | from koapy.config import default_encoding
7 |
8 | default_dispatch_class_name = "KiwoomOpenApiPlusDispatchFunctionsGenerated"
9 | default_dispatch_file_path = default_dispatch_class_name + ".py"
10 |
11 | default_event_class_name = "KiwoomOpenApiPlusEventFunctionsGenerated"
12 | default_event_file_path = default_event_class_name + ".py"
13 |
14 |
15 | @click.command(
16 | short_help="Generate python stubs for OpenAPI Dispatch and Event.",
17 | )
18 | @click.option(
19 | "--dispatch-class-name",
20 | metavar="NAME",
21 | help="Name for class with Dispatch functions.",
22 | default=default_dispatch_class_name,
23 | show_default=True,
24 | )
25 | @click.option(
26 | "--dispatch-file-path",
27 | type=click.Path(),
28 | help="Path for python-stub with Dispatch functions.",
29 | default=default_dispatch_file_path,
30 | show_default=True,
31 | )
32 | @click.option(
33 | "--event-class-name",
34 | metavar="NAME",
35 | help="Name for class with Event functions.",
36 | default=default_event_class_name,
37 | show_default=True,
38 | )
39 | @click.option(
40 | "--event-file-path",
41 | type=click.Path(),
42 | help="Path for python-stub with Event functions.",
43 | default=default_event_file_path,
44 | show_default=True,
45 | )
46 | @click.option(
47 | "--encoding",
48 | metavar="ENCODING",
49 | help="Encoding for stub files.",
50 | default=default_encoding,
51 | show_default=True,
52 | )
53 | @click.option(
54 | "--force-overwrite",
55 | help="Force overwrite even if target file already exists.",
56 | is_flag=True,
57 | show_default=True,
58 | )
59 | def python_stubs(
60 | dispatch_class_name,
61 | dispatch_file_path,
62 | event_class_name,
63 | event_file_path,
64 | encoding,
65 | force_overwrite,
66 | ):
67 | generate_python_stubs(
68 | dispatch_class_name=dispatch_class_name,
69 | dispatch_file_path=dispatch_file_path,
70 | event_class_name=event_class_name,
71 | event_file_path=event_file_path,
72 | encoding=encoding,
73 | force_overwrite=force_overwrite,
74 | )
75 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/utils/queue/QueueIterator.py:
--------------------------------------------------------------------------------
1 | import atexit
2 |
3 | from queue import Empty
4 |
5 |
6 | class QueueIterator:
7 |
8 | _check_timeout = 1
9 |
10 | def __init__(self, queue):
11 | self._queue = queue
12 | self._should_stop = False
13 |
14 | atexit.register(self.stop)
15 |
16 | def __del__(self):
17 | atexit.unregister(self.stop)
18 |
19 | @property
20 | def queue(self):
21 | return self._queue
22 |
23 | def next(self, block=True, timeout=None):
24 | if block and timeout is None:
25 | timeout = self._check_timeout
26 | while not self._should_stop:
27 | try:
28 | item = self._queue.get(block=block, timeout=timeout)
29 | except Empty:
30 | pass
31 | else:
32 | self._queue.task_done()
33 | return item
34 | raise StopIteration
35 | else:
36 | item = self._queue.get(block=block, timeout=timeout)
37 | self._queue.task_done()
38 | return item
39 |
40 | def next_nowait(self):
41 | return self.next(block=False)
42 |
43 | def has_next(self):
44 | return not self._queue.empty()
45 |
46 | def __iter__(self):
47 | return self
48 |
49 | def __next__(self):
50 | return self.next()
51 |
52 | def stop(self):
53 | self._should_stop = True
54 |
55 | def enable(self):
56 | self._should_stop = False
57 |
58 |
59 | class BufferedQueueIterator(QueueIterator):
60 | def __init__(self, queue):
61 | super().__init__(queue)
62 |
63 | self._none = object()
64 | self._head = self._none
65 |
66 | def next(self, block=True, timeout=None):
67 | if self._head is not self._none:
68 | item = self._head
69 | self._head = self._none
70 | return item
71 | else:
72 | return super().next(block, timeout)
73 |
74 | def has_next(self):
75 | return self._head is not self._none or super().has_next()
76 |
77 | def head(self):
78 | if self._head is not self._none:
79 | return self._head
80 | else:
81 | item = self.next_nowait() # raises queue.Empty if queue is empty
82 | self._head = item
83 | return self._head
84 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/account_data/evaluation.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 | from koapy.utils.logging import get_logger
5 |
6 | logger = get_logger(__name__)
7 |
8 |
9 | @click.command(short_help="Get account evaluation.")
10 | @click.option("-a", "--account", metavar="ACCNO", help="Account number.")
11 | @click.option(
12 | "-d", "--include-delisted", is_flag=True, help="Include delisted.", default=True
13 | )
14 | @click.option("-D", "--exclude-delisted", is_flag=True, help="Exclude delisted.")
15 | @click.option(
16 | "-e", "--for-each", is_flag=True, help="Show individual evaluation.", default=True
17 | )
18 | @click.option("-E", "--as-summary", is_flag=True, help="Show summarized evaluation.")
19 | @click.option(
20 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
21 | )
22 | @verbose_option()
23 | def evaluation(account, include_delisted, exclude_delisted, for_each, as_summary, port):
24 | if account is None:
25 | logger.info("Account not given. Using first account available.")
26 |
27 | if exclude_delisted:
28 | include_delisted = False
29 |
30 | if as_summary:
31 | for_each = False
32 | lookup_type = "1"
33 | elif for_each:
34 | lookup_type = "2"
35 |
36 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
37 | KiwoomOpenApiPlusEntrypoint,
38 | )
39 |
40 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
41 | context.EnsureConnected()
42 |
43 | if account is None:
44 | account = context.GetAccountList()[0]
45 |
46 | single, multi = context.GetAccountEvaluationStatusAsSeriesAndDataFrame(
47 | account, include_delisted
48 | )
49 | click.echo("[계좌평가현황요청] : [계좌평가현황]")
50 | click.echo(single.to_markdown(floatfmt=".2f"))
51 | click.echo()
52 | click.echo("[계좌평가현황요청] : [종목별계좌평가현황]")
53 | click.echo(multi.to_markdown())
54 | click.echo()
55 |
56 | single, multi = context.GetAccountEvaluationBalanceAsSeriesAndDataFrame(
57 | account, lookup_type
58 | )
59 | click.echo("[계좌평가잔고내역요청] : [계좌평가결과]")
60 | click.echo(single.to_markdown(floatfmt=".2f"))
61 | click.echo()
62 | click.echo("[계좌평가잔고내역요청] : [계좌평가잔고개별합산]")
63 | click.echo(multi.to_markdown())
64 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/data/scripts/setup.ps1:
--------------------------------------------------------------------------------
1 | Function New-TemporaryDirectory {
2 | $Parent = [System.IO.Path]::GetTempPath()
3 | [string] $Name = [System.Guid]::NewGuid()
4 | New-Item -ItemType Directory -Path (Join-Path "$Parent" "$Name")
5 | }
6 |
7 | Function Invoke-DownloadFile {
8 | Param (
9 | $Address,
10 | $FilePath
11 | )
12 | (New-Object System.Net.WebClient).DownloadFile("$Address", "$FilePath")
13 | }
14 |
15 | Function Get-OpenAPISetupFile {
16 | Param (
17 | $FilePath
18 | )
19 | $SetupFile = "OpenAPISetup.exe"
20 | $SetupFileURL = "https://download.kiwoom.com/web/openapi/$SetupFile"
21 | Invoke-DownloadFile -Address "$SetupFileURL" -FilePath "$FilePath"
22 | }
23 |
24 | Function Start-OpenAPISetupProcess {
25 | Param (
26 | $ISSFilePath
27 | )
28 | Write-Output "Creating Temporary Directory"
29 | $TempDir = New-TemporaryDirectory
30 | Write-Output "Created Temporary Directory: $TempDir"
31 | Try {
32 | $SetupFile = "OpenAPISetup.exe"
33 | $SetupFilePath = "$TempDir\$SetupFile"
34 | Write-Output "Downloading Installer"
35 | Get-OpenAPISetupFile -FilePath "$SetupFilePath"
36 | Write-Output "Downloaded Installer Location: $SetupFilePath"
37 | If ($ISSFilePath.EndsWith("\install.iss")) {
38 | Write-Output "Installing OpenAPI"
39 | }
40 | ElseIf ($ISSFilePath.EndsWith("\uninstall.iss")) {
41 | Write-Output "Uninstalling OpenAPI"
42 | }
43 | Write-Output "Starting Installer Process with ISSFile: $ISSFilePath"
44 | Start-Process -WorkingDirectory "$TempDir" -FilePath "$SetupFilePath" -ArgumentList "/s /f1`"$ISSFilePath`"" -Wait
45 | Write-Output "Installer Process Finished"
46 | If ($ISSFilePath.EndsWith("\install.iss")) {
47 | Write-Output "Installed OpenAPI"
48 | }
49 | ElseIf ($ISSFilePath.EndsWith("\uninstall.iss")) {
50 | Write-Output "Uninstalled OpenAPI"
51 | }
52 | }
53 | Finally {
54 | Remove-Item "$TempDir" -Recurse -ErrorAction Ignore
55 | }
56 | }
57 |
58 | Function Install-OpenAPI {
59 | Start-OpenAPISetupProcess -ISSFilePath "$PSScriptRoot\install.iss"
60 | }
61 |
62 | Function Uninstall-OpenAPI {
63 | Start-OpenAPISetupProcess -ISSFilePath "$PSScriptRoot\uninstall.iss"
64 | }
65 |
66 | Install-OpenAPI
67 |
--------------------------------------------------------------------------------
/koapy/cli/commands/uninstall/openapi.py:
--------------------------------------------------------------------------------
1 | import contextlib
2 | import os
3 | import shutil
4 | import subprocess
5 | import tempfile
6 |
7 | import click
8 |
9 | from koapy.cli.utils.openapi import (
10 | download_openapi_installer,
11 | prepare_issfile_for_uninstall,
12 | run_installer_with_issfile,
13 | )
14 | from koapy.cli.utils.verbose_option import verbose_option
15 | from koapy.utils.logging import get_logger
16 |
17 | logger = get_logger(__name__)
18 |
19 |
20 | @click.command(short_help="Uninstall openapi module.")
21 | @click.option(
22 | "--reboot/--no-reboot",
23 | default=False,
24 | help="Reboot after uninstall. (default: false)",
25 | )
26 | @click.option(
27 | "--cleanup/--no-cleanup",
28 | default=True,
29 | help="Clean up temporary directory after uninstall. (default: true)",
30 | )
31 | @verbose_option(default=5, show_default=True)
32 | def openapi(reboot, cleanup):
33 | with contextlib.ExitStack() as stack:
34 | tempdir = tempfile.mkdtemp()
35 | logger.info("Created temporary directory: %s", tempdir)
36 | if cleanup:
37 | stack.callback(shutil.rmtree, tempdir)
38 | logger.info("Registered to remove the temporary directory after uninstall.")
39 | installer_filename = "OpenAPISetup.exe"
40 | installer_filepath = os.path.join(tempdir, installer_filename)
41 | logger.info("Downloading installer: %s", installer_filepath)
42 | download_openapi_installer(installer_filepath)
43 | iss_filename = "setup.iss"
44 | iss_filepath = os.path.join(tempdir, iss_filename)
45 | logger.info("Preparing .iss file: %s", iss_filepath)
46 | prepare_issfile_for_uninstall(iss_filepath, reboot)
47 | log_filename = "setup.log"
48 | log_filepath = os.path.join(tempdir, log_filename)
49 | try:
50 | _return_code = run_installer_with_issfile(
51 | installer_filepath, iss_filepath, log_filepath, cwd=tempdir
52 | )
53 | except subprocess.CalledProcessError as e:
54 | logger.exception(
55 | "Failed to uninstall openapi with return code: %d", e.returncode
56 | )
57 | raise RuntimeError(
58 | "Failed to uninstall openapi with return code: %d" % e.returncode
59 | ) from e
60 | else:
61 | logger.info("Succesfully uninstalled openapi.")
62 |
--------------------------------------------------------------------------------
/koapy/config.conf:
--------------------------------------------------------------------------------
1 | {
2 | koapy.qtpy.qt_api = "pyside2"
3 | koapy.python.executable {
4 | 32bit = { conda = "x86" }
5 | 64bit = { path = "python" }
6 | }
7 | koapy.backend.kiwoom_open_api_plus.grpc {
8 | host = "localhost"
9 | port = 5943
10 | server {
11 | host = "localhost"
12 | bind_address = "localhost"
13 | port = 5943
14 | max_workers = 8
15 | channel.credentials.ssl {
16 | key_file = null
17 | cert_file = null
18 | root_certs_file = null
19 | require_client_auth = false
20 | }
21 | }
22 | client {
23 | host = "localhost"
24 | port = 5943
25 | max_workers = 8
26 | is_ready.timeout = 10
27 | channel.credentials.ssl {
28 | enable_ssl = false
29 | require_server_auth = false
30 | key_file = null
31 | cert_file = null
32 | root_certs_file = null
33 | }
34 | }
35 | }
36 | koapy.backend.kiwoom_open_api_plus.credentials {
37 | user_id = ""
38 | user_password = ""
39 | cert_password = ""
40 | is_simulation = true
41 | account_passwords {}
42 | }
43 | koapy.backend.daishin_cybos_plus.credentials {
44 | user_id = ""
45 | user_password = ""
46 | cert_password = ""
47 | auto_account_password = true
48 | auto_cert_password = true
49 | price_check_only = true
50 | account_passwords {}
51 | }
52 | koapy.utils.logging.config {
53 | version = 1
54 | formatters {
55 | default {
56 | format = "%(asctime)s [%(levelname)s] %(message)s - %(filename)s:%(lineno)d"
57 | }
58 | }
59 | handlers {
60 | console {
61 | class = "koapy.utils.logging.tqdm.TqdmStreamHandler.TqdmStreamHandler"
62 | level = "NOTSET"
63 | formatter = "default"
64 | }
65 | }
66 | loggers {
67 | koapy {
68 | level = "DEBUG"
69 | propagate = false
70 | handlers = ["console"]
71 | }
72 | }
73 | incremental = false
74 | disable_existing_loggers = false
75 | }
76 | }
--------------------------------------------------------------------------------
/koapy/examples/12_grpc_server_auth.py:
--------------------------------------------------------------------------------
1 | def generate_tls_certificate(ou, cn):
2 | import random
3 |
4 | import OpenSSL
5 |
6 | cert_seconds_to_expiry = 60 * 60 * 24 * 365 # one year
7 |
8 | key = OpenSSL.crypto.PKey()
9 | key.generate_key(OpenSSL.crypto.TYPE_RSA, 2048)
10 |
11 | cert = OpenSSL.crypto.X509()
12 | cert.get_subject().OU = ou
13 | cert.get_subject().CN = cn
14 | cert.gmtime_adj_notBefore(0)
15 | cert.gmtime_adj_notAfter(cert_seconds_to_expiry)
16 | cert.set_serial_number(random.getrandbits(64))
17 | cert.set_issuer(cert.get_subject())
18 | cert.set_pubkey(key)
19 | cert.sign(key, "sha256")
20 |
21 | with open("server.key", "wb") as f:
22 | f.write(OpenSSL.crypto.dump_privatekey(OpenSSL.crypto.FILETYPE_PEM, key))
23 | with open("server.crt", "wb") as f:
24 | f.write(OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_PEM, cert))
25 |
26 |
27 | def main():
28 | import signal
29 | import sys
30 |
31 | import grpc
32 |
33 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusQAxWidget import (
34 | KiwoomOpenApiPlusQAxWidget,
35 | )
36 | from koapy.backend.kiwoom_open_api_plus.grpc.KiwoomOpenApiPlusServiceServer import (
37 | KiwoomOpenApiPlusServiceServer,
38 | )
39 | from koapy.compat.pyside2.QtWidgets import QApplication
40 |
41 | host = "localhost"
42 | port = 5943
43 |
44 | app = QApplication.instance()
45 |
46 | if not app:
47 | app = QApplication(sys.argv)
48 |
49 | control = KiwoomOpenApiPlusQAxWidget()
50 |
51 | with open("server.key", "rb") as f:
52 | server_key = f.read()
53 | with open("server.crt", "rb") as f:
54 | server_crt = f.read()
55 |
56 | private_key_certificate_chain_pairs = [
57 | (server_key, server_crt),
58 | ]
59 | credentials = grpc.ssl_server_credentials(
60 | private_key_certificate_chain_pairs=private_key_certificate_chain_pairs,
61 | root_certificates=None,
62 | require_client_auth=False,
63 | )
64 |
65 | server = KiwoomOpenApiPlusServiceServer(
66 | control, host=host, port=port, credentials=credentials
67 | )
68 |
69 | # for Ctrl+C to work
70 | signal.signal(signal.SIGINT, signal.SIG_DFL)
71 |
72 | server.start()
73 | app.exec_()
74 |
75 |
76 | if __name__ == "__main__":
77 | generate_tls_certificate("koapy", "localhost")
78 | main()
79 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/chart_data/daily.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.fail_with_usage import fail_with_usage
4 | from koapy.cli.utils.verbose_option import verbose_option
5 | from koapy.utils.logging import get_logger
6 |
7 | logger = get_logger(__name__)
8 |
9 |
10 | @click.command(short_help="Get daily OHLCV of stocks.")
11 | @click.option("-c", "--code", metavar="CODE", help="Stock code to get.")
12 | @click.option(
13 | "-o",
14 | "--output",
15 | metavar="FILENAME",
16 | type=click.Path(),
17 | help="Output filename for code.",
18 | )
19 | @click.option(
20 | "-f",
21 | "--format",
22 | metavar="FORMAT",
23 | type=click.Choice(["xlsx", "sqlite3"], case_sensitive=False),
24 | default="xlsx",
25 | help="Output format. (default: xlsx)",
26 | )
27 | @click.option(
28 | "-s",
29 | "--start-date",
30 | metavar="YYYY-MM-DD",
31 | type=click.DateTime(formats=["%Y-%m-%d", "%Y%m%d"]),
32 | help="Most recent date to get. Defaults to today or yesterday if market is open.",
33 | )
34 | @click.option(
35 | "-e",
36 | "--end-date",
37 | metavar="YYYY-MM-DD",
38 | type=click.DateTime(formats=["%Y-%m-%d", "%Y%m%d"]),
39 | help="Stops if reached, not included (optional).",
40 | )
41 | @click.option(
42 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
43 | )
44 | @verbose_option()
45 | def daily(
46 | code, output, format, start_date, end_date, port
47 | ): # pylint: disable=redefined-builtin
48 | if (code, output, start_date, end_date) == (None, None, None, None):
49 | fail_with_usage()
50 |
51 | if output is None:
52 | output = "{}.{}".format(code, format)
53 |
54 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
55 | KiwoomOpenApiPlusEntrypoint,
56 | )
57 |
58 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
59 | context.EnsureConnected()
60 | df = context.GetDailyStockDataAsDataFrame(code, start_date, end_date)
61 |
62 | if format == "xlsx":
63 | df.to_excel(output)
64 | logger.info("Saved data to file: %s", output)
65 | elif format == "sqlite3":
66 | from sqlalchemy import create_engine
67 |
68 | engine = create_engine("sqlite:///" + output)
69 | tablename = "A" + code
70 | df.to_sql(tablename, engine)
71 | logger.info("Saved data to file %s with tablename %s", output, tablename)
72 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/stock_meta/stockinfo.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.fail_with_usage import fail_with_usage
4 | from koapy.cli.utils.verbose_option import verbose_option
5 | from koapy.config import default_encoding
6 |
7 |
8 | @click.command(short_help="Get basic information of stocks.")
9 | @click.option("-c", "--code", metavar="CODE", help="Stock code to get.")
10 | @click.option(
11 | "-o",
12 | "--output",
13 | metavar="FILENAME",
14 | type=click.Path(),
15 | help="Output filename. Optional for single code (prints to console).",
16 | )
17 | @click.option(
18 | "-f",
19 | "--format",
20 | type=click.Choice(["md", "xlsx", "json"], case_sensitive=False),
21 | help="Output format. (default: md)",
22 | default="md",
23 | show_choices=True,
24 | )
25 | @click.option(
26 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
27 | )
28 | @verbose_option()
29 | def stockinfo(code, output, format, port): # pylint: disable=redefined-builtin
30 | if (code, output) == (None, None):
31 | fail_with_usage()
32 |
33 | if output is None:
34 | if format is None:
35 | format = "md"
36 | else:
37 | if format is None:
38 | format = "xlsx"
39 | if format == "xlsx":
40 | if not output.endswith(".xlsx"):
41 | output += ".xlsx"
42 | elif format == "md":
43 | if not output.endswith(".md"):
44 | output += ".md"
45 | elif format == "json":
46 | if not output.endswith(".json"):
47 | output += ".json"
48 |
49 | import pandas as pd
50 |
51 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
52 | KiwoomOpenApiPlusEntrypoint,
53 | )
54 |
55 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
56 | context.EnsureConnected()
57 | dic = context.GetStockBasicInfoAsDict(code)
58 | series = pd.Series(dic)
59 |
60 | if not output:
61 | if format == "md":
62 | click.echo(series.to_markdown())
63 | elif format == "json":
64 | click.echo(series.to_json())
65 | else:
66 | if format == "xlsx":
67 | series.to_excel(output, header=False)
68 | elif format == "json":
69 | with open(output, "w", encoding=default_encoding) as f:
70 | click.echo(series.to_json(), file=f)
71 |
--------------------------------------------------------------------------------
/koapy/cli/commands/install/openapi.py:
--------------------------------------------------------------------------------
1 | import contextlib
2 | import os
3 | import shutil
4 | import subprocess
5 | import tempfile
6 |
7 | import click
8 |
9 | from koapy.cli.utils.openapi import (
10 | download_openapi_installer,
11 | prepare_issfile_for_install,
12 | run_installer_with_issfile,
13 | )
14 | from koapy.cli.utils.verbose_option import verbose_option
15 | from koapy.utils.logging import get_logger
16 |
17 | logger = get_logger(__name__)
18 |
19 |
20 | @click.command(short_help="Install openapi module.")
21 | @click.option(
22 | "-t",
23 | "--target",
24 | metavar="TARGET",
25 | type=click.Path(),
26 | default="C:\\",
27 | help='Target directory for installation. Will create "OpenAPI" folder under this directory for install. (default: "C:\\")',
28 | )
29 | @click.option(
30 | "--cleanup/--no-cleanup",
31 | default=True,
32 | help="Clean up temporary directory after install. (default: true)",
33 | )
34 | @verbose_option(default=5, show_default=True)
35 | def openapi(target, cleanup):
36 | with contextlib.ExitStack() as stack:
37 | tempdir = tempfile.mkdtemp()
38 | logger.info("Created temporary directory: %s", tempdir)
39 | if cleanup:
40 | stack.callback(shutil.rmtree, tempdir)
41 | logger.info("Registered to remove the temporary directory after install.")
42 | installer_filename = "OpenAPISetup.exe"
43 | installer_filepath = os.path.join(tempdir, installer_filename)
44 | logger.info("Downloading installer: %s", installer_filepath)
45 | download_openapi_installer(installer_filepath)
46 | iss_filename = "setup.iss"
47 | iss_filepath = os.path.join(tempdir, iss_filename)
48 | logger.info("Preparing .iss file: %s", iss_filepath)
49 | prepare_issfile_for_install(iss_filepath, target)
50 | log_filename = "setup.log"
51 | log_filepath = os.path.join(tempdir, log_filename)
52 | try:
53 | _return_code = run_installer_with_issfile(
54 | installer_filepath, iss_filepath, log_filepath, cwd=tempdir
55 | )
56 | except subprocess.CalledProcessError as e:
57 | logger.exception(
58 | "Failed to install openapi with return code: %d", e.returncode
59 | )
60 | raise RuntimeError(
61 | "Failed to install openapi with return code: %d" % e.returncode
62 | ) from e
63 | else:
64 | logger.info("Succesfully installed openapi.")
65 |
--------------------------------------------------------------------------------
/koapy/utils/store/sqlalchemy/Snapshot.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Column, ForeignKey, Integer, String, UniqueConstraint
2 | from sqlalchemy.orm import object_session, relationship
3 | from sqlalchemy.sql.functions import current_timestamp
4 |
5 | from .Base import Base
6 | from .SnapshotAssociation import SnapshotAssociation
7 | from .Symbol import Symbol
8 | from .Timestamp import Timestamp
9 | from .Version import Version
10 |
11 |
12 | class Snapshot(Base):
13 | __tablename__ = "snapshots"
14 |
15 | id = Column(Integer, primary_key=True)
16 | name = Column(String, index=True, nullable=False)
17 |
18 | timestamp = Column(Timestamp(timezone=True), server_default=current_timestamp())
19 |
20 | library_id = Column(Integer, ForeignKey("libraries.id"), nullable=False)
21 | library = relationship("Library", back_populates="snapshots")
22 |
23 | versions = relationship("SnapshotAssociation", back_populates="snapshot")
24 |
25 | __table_args__ = (UniqueConstraint("library_id", "name"),)
26 |
27 | def get_symbols(self):
28 | session = object_session(self)
29 | associations = session.query(SnapshotAssociation).with_parent(self)
30 | versions = session.query(Version).join(associations.subquery())
31 | symbols = session.query(Symbol).join(versions.subquery())
32 | symbols = symbols.all()
33 | return symbols
34 |
35 | def get_versions(self):
36 | session = object_session(self)
37 | associations = session.query(SnapshotAssociation).with_parent(self)
38 | versions = session.query(Version).join(associations.subquery())
39 | versions = versions.all()
40 | return versions
41 |
42 | def get_version_of_symbol(self, symbol):
43 | session = object_session(self)
44 | if isinstance(symbol, str):
45 | symbol = (
46 | session.query(Symbol)
47 | .filter(Symbol.library_id == self.library_id and Symbol.name == symbol)
48 | .one()
49 | )
50 | associations = session.query(SnapshotAssociation).with_parent(self)
51 | version = (
52 | session.query(Version)
53 | .with_parent(symbol)
54 | .join(associations.subquery())
55 | .one()
56 | )
57 | return version
58 |
59 | def delete(self):
60 | session = object_session(self)
61 | associations = session.query(SnapshotAssociation).with_parent(self)
62 | associations.delete()
63 | session.delete(self)
64 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_w/core/KiwoomOpenApiWSignalConnector.py:
--------------------------------------------------------------------------------
1 | import inspect
2 | import threading
3 |
4 | from koapy.backend.kiwoom_open_api_w.core.KiwoomOpenApiWSignature import (
5 | KiwoomOpenApiWEventHandlerSignature,
6 | )
7 | from koapy.compat.pyside2 import PYQT5, PYSIDE2, PythonQtError
8 | from koapy.utils.logging.Logging import Logging
9 |
10 |
11 | class KiwoomOpenApiWSignalConnector(Logging):
12 | def __init__(self, name=None):
13 | super().__init__()
14 |
15 | self._name = name
16 | self._lock = threading.RLock()
17 | self._slots = list()
18 |
19 | self._signature = KiwoomOpenApiWEventHandlerSignature.from_name(self._name)
20 | self._param_types = [
21 | (p.annotation) for p in self._signature.parameters.values()
22 | ]
23 | self._signal = self._signature.to_pyside2_event_signal()
24 |
25 | def is_valid_slot(self, slot):
26 | slot_signature = inspect.signature(slot)
27 | slot_types = [(p.annotation) for p in slot_signature.parameters.values()]
28 | condition = len(self._param_types) == len(
29 | slot_types
30 | ) # currently only check parameter length
31 | return condition
32 |
33 | def connect_to(self, control):
34 | if PYSIDE2:
35 | return control.connect(self._signal, self)
36 | elif PYQT5:
37 | return getattr(control, self._name).connect(self)
38 | else:
39 | raise PythonQtError("Unsupported Qt bindings")
40 |
41 | def connect(self, slot):
42 | if not self.is_valid_slot(slot):
43 | raise TypeError("Invalid slot: %s" % slot)
44 | with self._lock:
45 | if slot not in self._slots:
46 | self._slots.append(slot)
47 |
48 | def disconnect(self, slot=None):
49 | with self._lock:
50 | if slot is None:
51 | self._slots.clear()
52 | elif slot in self._slots:
53 | self._slots.remove(slot)
54 | else:
55 | self.logger.warning("Tried to disconnect a slot that doesn't exist")
56 |
57 | def call(self, *args, **kwargs):
58 | # make a copy in order to prevent modification during iteration problem
59 | with self._lock:
60 | slots = list(self._slots)
61 | # TODO: use Thread with await/join for concurrency?
62 | for slot in slots:
63 | slot(*args, **kwargs)
64 |
65 | def __call__(self, *args, **kwargs):
66 | return self.call(*args, **kwargs)
67 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/core/KiwoomOpenApiPlusDispatchSignature.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from typing import Dict, List
4 |
5 | import pythoncom
6 |
7 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusDispatchFunctions import (
8 | KiwoomOpenApiPlusDispatchFunctions,
9 | )
10 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusSignature import (
11 | KiwoomOpenApiPlusSignature,
12 | )
13 | from koapy.utils.builtin import dir_public
14 |
15 |
16 | class KiwoomOpenApiPlusDispatchSignature(KiwoomOpenApiPlusSignature):
17 |
18 | DISPATCH_SIGNATURES_BY_NAME: Dict[str, KiwoomOpenApiPlusDispatchSignature] = {}
19 |
20 | @classmethod
21 | def from_name(cls, name: str) -> KiwoomOpenApiPlusDispatchSignature:
22 | signature = cls.DISPATCH_SIGNATURES_BY_NAME[name]
23 | return signature
24 |
25 | @classmethod
26 | def names(cls) -> List[str]:
27 | names = cls.DISPATCH_SIGNATURES_BY_NAME.keys()
28 | names = list(names)
29 | if not names:
30 | _names = dir_public(KiwoomOpenApiPlusDispatchFunctions)
31 | return names
32 |
33 | @classmethod
34 | def _make_dispatch_signatures_by_name(
35 | cls,
36 | ) -> Dict[str, KiwoomOpenApiPlusDispatchSignature]:
37 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusTypeLib import (
38 | DISPATCH_OLE_ITEM,
39 | )
40 |
41 | dispatch = DISPATCH_OLE_ITEM
42 | dispatch_signatures_by_name: Dict[str, KiwoomOpenApiPlusDispatchSignature] = {}
43 | if dispatch:
44 | dispatch_funcs = [
45 | (name, entry)
46 | for name, entry in dispatch.mapFuncs.items()
47 | if not any(
48 | [
49 | entry.desc[9] & pythoncom.FUNCFLAG_FRESTRICTED
50 | and entry.desc[0] != pythoncom.DISPID_NEWENUM,
51 | entry.desc[3] != pythoncom.FUNC_DISPATCH,
52 | entry.desc[0] == pythoncom.DISPID_NEWENUM,
53 | ]
54 | )
55 | ]
56 | for func_name, entry in dispatch_funcs:
57 | signature = cls._from_entry(func_name, entry)
58 | dispatch_signatures_by_name[func_name] = signature
59 | return dispatch_signatures_by_name
60 |
61 | @classmethod
62 | def _initialize(cls):
63 | cls.DISPATCH_SIGNATURES_BY_NAME = cls._make_dispatch_signatures_by_name()
64 |
65 |
66 | KiwoomOpenApiPlusDispatchSignature._initialize() # pylint: disable=protected-access
67 |
--------------------------------------------------------------------------------
/koapy/utils/rate_limiting/RateLimiter.py:
--------------------------------------------------------------------------------
1 | import collections
2 | import threading
3 | import time
4 |
5 | from typing import List
6 |
7 | from koapy.utils.logging.Logging import Logging
8 |
9 |
10 | class RateLimiter:
11 | def check_sleep_seconds(self, *args, **kwargs):
12 | return 0
13 |
14 | def add_call_history(self, *args, **kwargs):
15 | pass
16 |
17 | def sleep_if_necessary(self, *args, **kwargs):
18 | sleep_seconds = self.check_sleep_seconds(*args, **kwargs)
19 | if sleep_seconds > 0:
20 | time.sleep(sleep_seconds)
21 |
22 |
23 | class TimeWindowRateLimiter(RateLimiter, Logging):
24 | def __init__(self, period, calls):
25 | super().__init__()
26 |
27 | self._period = period
28 | self._calls = calls
29 |
30 | self._lock = threading.RLock()
31 | self._clock = time.time
32 |
33 | if hasattr(time, "monotonic"):
34 | self._clock = time.monotonic
35 |
36 | self._call_history = collections.deque(maxlen=self._calls)
37 |
38 | def check_sleep_seconds(self, *args, **kwargs):
39 | with self._lock:
40 | if len(self._call_history) < self._calls:
41 | return 0
42 | clock = self._clock()
43 | remaining = self._call_history[0] + self._period - clock
44 | return remaining
45 |
46 | def add_call_history(self, *args, **kwargs):
47 | with self._lock:
48 | return self._call_history.append(self._clock())
49 |
50 | def sleep_if_necessary(self, *args, **kwargs):
51 | with self._lock:
52 | sleep_seconds = self.check_sleep_seconds(*args, **kwargs)
53 | if sleep_seconds > 0:
54 | time.sleep(sleep_seconds)
55 |
56 |
57 | class CompositeTimeWindowRateLimiter(RateLimiter):
58 | def __init__(self, limiters: List[RateLimiter]):
59 | super().__init__()
60 |
61 | self._lock = threading.RLock()
62 | self._limiters = limiters
63 |
64 | def check_sleep_seconds(self, *args, **kwargs):
65 | with self._lock:
66 | return max(
67 | limiter.check_sleep_seconds(*args, **kwargs)
68 | for limiter in self._limiters
69 | )
70 |
71 | def add_call_history(self, *args, **kwargs):
72 | with self._lock:
73 | for limiter in self._limiters:
74 | limiter.add_call_history(*args, **kwargs)
75 |
76 | def sleep_if_necessary(self, *args, **kwargs):
77 | with self._lock:
78 | sleep_seconds = self.check_sleep_seconds(*args, **kwargs)
79 | if sleep_seconds > 0:
80 | time.sleep(sleep_seconds)
81 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/core/KiwoomOpenApiPlusSignature.py:
--------------------------------------------------------------------------------
1 | from inspect import Parameter, Signature
2 | from typing import Dict
3 |
4 | import pythoncom
5 |
6 | from koapy.compat.pyside2 import PYSIDE2
7 |
8 | if PYSIDE2:
9 | from koapy.compat.pyside2.QtCore import SIGNAL
10 |
11 | try:
12 | from types import NoneType
13 | except ImportError:
14 | NoneType = type(None)
15 |
16 |
17 | class KiwoomOpenApiPlusSignature(Signature):
18 |
19 | PYTHONTYPE_TO_QTTYPE = {
20 | int: "int",
21 | str: "const QString&",
22 | }
23 |
24 | COMTYPE_TO_PYTHONTYPE = {
25 | pythoncom.VT_I4: int,
26 | pythoncom.VT_BSTR: str,
27 | pythoncom.VT_VARIANT: Parameter.empty,
28 | pythoncom.VT_VOID: NoneType,
29 | }
30 |
31 | def __init__(
32 | self,
33 | name: str,
34 | parameters: Dict[str, Parameter] = None,
35 | return_annotation=Signature.empty,
36 | ):
37 | self._name = name
38 | super().__init__(parameters, return_annotation=return_annotation)
39 |
40 | @property
41 | def name(self) -> str:
42 | return self._name
43 |
44 | @classmethod
45 | def _pythontype_to_qttype(cls, typ):
46 | return cls.PYTHONTYPE_TO_QTTYPE[typ]
47 |
48 | def to_pyside2_function_prototype(self) -> str:
49 | name = self._name
50 | parameters = self.parameters
51 | parameters = parameters.values()
52 | parameters = [self._pythontype_to_qttype(p.annotation) for p in parameters]
53 | prototype = "{}({})".format(name, ", ".join(parameters))
54 | return prototype
55 |
56 | if PYSIDE2:
57 |
58 | def to_pyside2_event_signal(self) -> str:
59 | return SIGNAL(self.to_pyside2_function_prototype())
60 |
61 | @classmethod
62 | def _comtype_to_pythontype(cls, typ):
63 | return cls.COMTYPE_TO_PYTHONTYPE.get(typ, Parameter.empty)
64 |
65 | @classmethod
66 | def _from_entry(cls, name, entry):
67 | arg_names = entry.names[1:]
68 | arg_types = [typ[0] for typ in entry.desc[2]]
69 | return_type = entry.desc[8][0]
70 | parameters = [
71 | Parameter(
72 | name=arg_name,
73 | kind=Parameter.POSITIONAL_OR_KEYWORD,
74 | annotation=cls._comtype_to_pythontype(arg_type),
75 | )
76 | for arg_name, arg_type in zip(arg_names, arg_types)
77 | ]
78 | return_annotation = cls._comtype_to_pythontype(return_type)
79 | signature = cls(
80 | name=name,
81 | parameters=parameters,
82 | return_annotation=return_annotation,
83 | )
84 | return signature
85 |
--------------------------------------------------------------------------------
/koapy/cli/utils/openapi.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 | import subprocess
4 |
5 | import requests
6 |
7 | from koapy.utils.logging import get_logger
8 | from koapy.utils.subprocess import quote
9 |
10 | logger = get_logger(__name__)
11 |
12 | iss_file_encoding = "euc-kr"
13 |
14 |
15 | def download_openapi_installer(filepath):
16 | url = "https://download.kiwoom.com/web/openapi/OpenAPISetup.exe"
17 | response = requests.get(url)
18 | with open(filepath, "wb") as f:
19 | f.write(response.content)
20 |
21 |
22 | def prepare_issfile_for_install(filepath, target=None):
23 | iss_filedir = os.path.join(
24 | os.path.dirname(__file__),
25 | "../../backend/kiwoom_open_api_plus/data/scripts/",
26 | )
27 | iss_filename = "install.iss"
28 | iss_filepath = os.path.join(iss_filedir, iss_filename)
29 | shutil.copy(iss_filepath, filepath)
30 | if target is not None:
31 | with open(filepath, "r", encoding=iss_file_encoding) as f:
32 | lines = [line for line in f]
33 | for i, line in enumerate(lines):
34 | if line.startswith("szDir="):
35 | lines[i] = "szDir={}\n".format(target)
36 | break
37 | with open(filepath, "w", encoding=iss_file_encoding) as f:
38 | for line in lines:
39 | f.write(line)
40 |
41 |
42 | def prepare_issfile_for_uninstall(filepath, reboot=False):
43 | iss_filedir = os.path.join(
44 | os.path.dirname(__file__),
45 | "../../backend/kiwoom_open_api_plus/data/scripts/",
46 | )
47 | iss_filename = "uninstall.iss"
48 | iss_filepath = os.path.join(iss_filedir, iss_filename)
49 | shutil.copy(iss_filepath, filepath)
50 | if reboot:
51 | with open(filepath, "r", encoding=iss_file_encoding) as f:
52 | lines = [line for line in f]
53 | for i, line in enumerate(lines):
54 | if line.startswith("BootOption="):
55 | boot_option = 3
56 | lines[i] = "BootOption={}\n".format(boot_option)
57 | break
58 | with open(filepath, "w", encoding=iss_file_encoding) as f:
59 | for line in lines:
60 | f.write(line)
61 |
62 |
63 | def run_installer_with_issfile(installer, issfile, logfile=None, cwd=None):
64 | cmd = [quote(installer), "/s", "/f1{}".format(quote(issfile))]
65 | if logfile is not None:
66 | cmd.extend(["/f2{}".format(quote(logfile))])
67 | # should use shell=True in order not to escape quotes in args
68 | logger.info("Running command: %s", " ".join(cmd))
69 | proc = subprocess.run(" ".join(cmd), shell=True, check=False, cwd=cwd)
70 | if proc.returncode < 0:
71 | raise subprocess.CalledProcessError(proc.returncode, " ".join(cmd))
72 | return proc.returncode
73 |
--------------------------------------------------------------------------------
/koapy/cli/commands/get/account_data/orders.py:
--------------------------------------------------------------------------------
1 | import click
2 |
3 | from koapy.cli.utils.verbose_option import verbose_option
4 | from koapy.utils.logging import get_logger
5 |
6 | logger = get_logger(__name__)
7 |
8 |
9 | @click.command(short_help="Get order history of a date.")
10 | @click.option("-a", "--account", metavar="ACCNO", help="Account number.")
11 | @click.option("-d", "--date", metavar="DATE", help="Date to get.")
12 | @click.option("-r", "--reverse", is_flag=True)
13 | @click.option("-e", "--executed-only", is_flag=True)
14 | @click.option("-E", "--not-executed-only", is_flag=True)
15 | @click.option("-S", "--stock-only", is_flag=True)
16 | @click.option("-B", "--bond-only", is_flag=True)
17 | @click.option("-s", "--sell-only", is_flag=True)
18 | @click.option("-b", "--buy-only", is_flag=True)
19 | @click.option("-c", "--code", metavar="CODE", help="Stock code to get.")
20 | @click.option("-o", "--starting-order-no", metavar="ORDERNO", help="Starting order no.")
21 | @click.option(
22 | "-p", "--port", metavar="PORT", help="Port number of grpc server (optional)."
23 | )
24 | @verbose_option()
25 | def orders(
26 | account,
27 | date,
28 | reverse,
29 | executed_only,
30 | not_executed_only,
31 | stock_only,
32 | bond_only,
33 | sell_only,
34 | buy_only,
35 | code,
36 | starting_order_no,
37 | port,
38 | ):
39 | if account is None:
40 | logger.info("Account not given. Using first account available.")
41 |
42 | sort_type = "1"
43 | if reverse:
44 | sort_type = "2"
45 | if executed_only:
46 | sort_type = "3"
47 | if not_executed_only:
48 | sort_type = "4"
49 | asset_type = "0"
50 | if stock_only:
51 | asset_type = "1"
52 | if bond_only:
53 | asset_type = "2"
54 | order_type = "0"
55 | if sell_only:
56 | order_type = "1"
57 | if buy_only:
58 | order_type = "2"
59 |
60 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusEntrypoint import (
61 | KiwoomOpenApiPlusEntrypoint,
62 | )
63 |
64 | with KiwoomOpenApiPlusEntrypoint(port=port) as context:
65 | context.EnsureConnected()
66 | if account is None:
67 | account = context.GetFirstAvailableAccount()
68 | df = context.GetOrderLogAsDataFrame1(account)
69 | click.echo("[실시간미체결요청]")
70 | click.echo(df.to_markdown())
71 | click.echo()
72 | df = context.GetOrderLogAsDataFrame2(account)
73 | click.echo("[실시간체결요청]")
74 | click.echo(df.to_markdown())
75 | click.echo()
76 | df = context.GetOrderLogAsDataFrame3(
77 | account, date, sort_type, asset_type, order_type, code, starting_order_no
78 | )
79 | click.echo("[계좌별주문체결내역상세요청]")
80 | click.echo(df.to_markdown())
81 |
--------------------------------------------------------------------------------
/koapy/utils/store/SQLiteStore.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import create_engine, inspect
2 |
3 | from .sqlalchemy.Base import Base
4 | from .sqlalchemy.Library import Library
5 | from .sqlalchemy.Session import Session
6 | from .SQLiteStoreLibrary import SQLiteStoreLibrary
7 |
8 |
9 | class SQLiteStore:
10 | def __init__(self, filename):
11 | self._filename = filename
12 | self._engine = create_engine("sqlite:///" + self._filename)
13 |
14 | Session.configure(bind=self._engine)
15 |
16 | inspector = inspect(self._engine)
17 | table_names = inspector.get_table_names()
18 |
19 | if len(table_names) == 0:
20 | Base.metadata.create_all(self._engine)
21 | inspector = inspect(self._engine)
22 | table_names = inspector.get_table_names()
23 |
24 | assert all(table_name in table_names for table_name in Base.metadata.tables)
25 |
26 | self._session = Session()
27 | self._library_cache = {}
28 |
29 | def list_libraries(self):
30 | libraries = self._session.query(Library).all()
31 | libraries = [library.name for library in libraries]
32 | return libraries
33 |
34 | def _get_library(self, library):
35 | library = self._session.query(Library).filter(Library.name == library).one()
36 | return library
37 |
38 | def library_exists(self, library):
39 | try:
40 | _library = self._get_library(library)
41 | return True
42 | except:
43 | return False
44 |
45 | def initialize_library(self, library):
46 | library_name = library
47 | if not self.library_exists(library_name):
48 | library = Library(name=library_name)
49 | try:
50 | self._session.add(library)
51 | self._session.commit()
52 | except:
53 | self._session.rollback()
54 | raise
55 |
56 | def get_library(self, library):
57 | library_name = library
58 | if library_name in self._library_cache:
59 | return self._library_cache[library_name]
60 | library = self._get_library(library)
61 | library = SQLiteStoreLibrary(self, library)
62 | self._library_cache[library_name] = library
63 | return library
64 |
65 | def get_or_create_library(self, library):
66 | if not self.library_exists(library):
67 | self.initialize_library(library)
68 | library = self.get_library(library)
69 | return library
70 |
71 | def delete_library(self, library):
72 | library_name = library
73 | library = self._get_library(library_name)
74 | try:
75 | library.delete()
76 | self._session.commit()
77 | except:
78 | self._session.rollback()
79 | raise
80 |
81 | def __getitem__(self, library):
82 | return self.get_library(library)
83 |
--------------------------------------------------------------------------------
/koapy/examples/09_get_historical_data.py:
--------------------------------------------------------------------------------
1 | import logging
2 |
3 | logging.basicConfig(
4 | format="%(asctime)s [%(levelname)s] %(message)s - %(filename)s:%(lineno)d",
5 | level=logging.DEBUG,
6 | )
7 |
8 | import datetime
9 |
10 | from exchange_calendars import get_calendar
11 |
12 | from koapy import KiwoomOpenApiPlusEntrypoint
13 |
14 | krx_calendar = get_calendar("XKRX")
15 |
16 | with KiwoomOpenApiPlusEntrypoint() as context:
17 | # 로그인 처리
18 | context.EnsureConnected()
19 |
20 | # 종목코드
21 | code = "005930"
22 |
23 | # 가장 최근 날짜
24 | start_date = datetime.datetime.now()
25 |
26 | # 날짜 값은 datetime.datetime 타입도 되고 문자열도 됨
27 | # 문자열 포맷은 구체적으로, 일봉위로는 YYYYMMDD 포맷, 분봉아래로는 YYYYMMDDhhmmss 포맷 지원
28 |
29 | # 가장 오래된 날짜 (거래소 개장일 기준 30일 전)
30 | end_date = start_date - 30 * krx_calendar.day
31 |
32 | # 참고로 end_date 은 주어진 시간보다 큰 (같지 않은) 레코드만 가져오도록 구현되어있기 때문에 설정에 주의
33 | # 일반적으로 해당 날짜는 결과에서 제외되는 효과 있음, 구체적인 구간은 [start_date, end_date)
34 |
35 | # 위와 같은 (end_date = start_date - 30 * krx_calendar.day) 코드는 거래소가 열리는 날짜 기준 30일 전 날짜 계산하는데 사용
36 | # 이렇게 설정해서 일봉데이터 가져올 경우 당일 포함되면 30일치, 당일 제외되면 29일치 가져오게 됨
37 | # 참고로 exchange_calendars 는 현재 년도의 말일까지 미리 계산된 휴일정보를 사용하므로 미래시간은 계산이 안됨
38 |
39 | # 만약에 미래 시간에 대한 연산 또한 필요하다면 아래처럼 내부 구현체를 대체재로 사용해 볼 수 잇음
40 | # from koapy.utils.krx.calendar.KrxHolidayCalendar import KrxBusinessDay
41 | # end_date = start_date + KrxBusinessDay(30) # (거래소 개장일 기준 30일 이후)
42 | # 하지만 계산시 일반적인 휴일들을 제외한 임시공휴일, 선거일등은 별도 추가 데이터가 없는 한 반영되지 않으니 주의
43 |
44 | # 일봉 데이터
45 | logging.info("Requesting daily data from %s to %s", end_date, start_date)
46 | data = context.GetDailyStockDataAsDataFrame(code, start_date, end_date)
47 | print(data)
48 |
49 | # 15분봉 데이터
50 | # 분봉과 틱봉은 TR 에서 기준날짜 (기간설정시 최근날짜) 지정이 안되므로
51 | # 가장 최근부터 가져오고 클라이언트에서 따로 추가로 거르는 식으로 구현되어 있음
52 | end_date = start_date - 1 * krx_calendar.day
53 | logging.info("Requesting minute data from %s to %s", end_date, start_date)
54 | data = context.GetMinuteStockDataAsDataFrame(code, 15, start_date, end_date)
55 | print(data)
56 |
57 | # 주봉 데이터
58 | # 참고로 주봉은 각 주의 첫 개장일을 기준일으로 함
59 | end_date = start_date - 30 * krx_calendar.day
60 | logging.info("Requesting weekly data from %s to %s", end_date, start_date)
61 | data = context.GetWeeklyStockDataAsDataFrame(code, start_date, end_date)
62 | print(data)
63 |
64 | # 월봉 데이터
65 | # 참고로 월봉은 각 달의 첫 개장일을 기준일으로 함
66 | end_date = start_date - 180 * krx_calendar.day
67 | logging.info("Requesting monthly data from %s to %s", end_date, start_date)
68 | data = context.GetMonthlyStockDataAsDataFrame(code, start_date, end_date)
69 | print(data)
70 |
71 | # 30틱 데이터
72 | # 분봉과 틱봉은 TR 에서 기준날짜 (기간설정시 최근날짜) 지정이 안되므로
73 | # 가장 최근부터 가져오고 클라이언트에서 따로 추가로 거르는 식으로 구현되어 있음
74 | end_date = start_date - 1 * krx_calendar.day
75 | logging.info("Requesting tick data from %s to %s", end_date, start_date)
76 | data = context.GetTickStockDataAsDataFrame(code, 30, start_date, end_date)
77 | print(data)
78 |
--------------------------------------------------------------------------------
/koapy/backend/kiwoom_open_api_plus/core/KiwoomOpenApiPlusDynamicCallable.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from inspect import Signature
4 | from typing import Any, Callable, List, Sequence
5 |
6 | try:
7 | from typing import ParamSpec, TypeVar
8 | except ImportError:
9 | from typing_extensions import ParamSpec
10 | from typing import TypeVar
11 |
12 | from koapy.backend.kiwoom_open_api_plus.core.KiwoomOpenApiPlusDispatchSignature import (
13 | KiwoomOpenApiPlusDispatchSignature,
14 | )
15 | from koapy.compat.pyside2.QtAxContainer import QAxWidget
16 |
17 | P = ParamSpec("P")
18 | R = TypeVar("R")
19 |
20 |
21 | class KiwoomOpenApiPlusDynamicCallable(Callable[P, R]):
22 | def __init__(
23 | self,
24 | control: QAxWidget,
25 | name: str,
26 | ):
27 | self._control = control
28 | self._name = name
29 |
30 | self._signature = KiwoomOpenApiPlusDispatchSignature.from_name(self._name)
31 | self._function = self._signature.to_pyside2_function_prototype()
32 | self._has_return_value = (
33 | self._signature.return_annotation is not Signature.empty
34 | )
35 |
36 | self.__name__ = self._name
37 | self.__signature__ = self._signature
38 |
39 | def bind_dynamic_call_args(self, *args, **kwargs) -> List[Any]:
40 | try:
41 | ba = self._signature.bind(*args, **kwargs)
42 | except TypeError as e:
43 | raise TypeError(
44 | "Exception while binding arguments for function: %s" % self._name
45 | ) from e
46 | ba.apply_defaults()
47 | args = list(ba.args)
48 | return args
49 |
50 | def is_valid_return_type(self, result: Any) -> bool:
51 | is_valid = True
52 | if self._has_return_value:
53 | if not isinstance(result, self._signature.return_annotation):
54 | is_valid = False
55 | return is_valid
56 |
57 | def check_return_value(self, result: Any):
58 | if not self.is_valid_return_type(result):
59 | raise TypeError(
60 | "Return type of %s was expected for function call %s(...), but %s was found"
61 | % (
62 | self._signature.return_annotation,
63 | self._name,
64 | type(result),
65 | )
66 | )
67 | return result
68 |
69 | def dynamic_call(self, args: Sequence[Any]) -> R:
70 | return self._control.dynamicCall(self._function, args)
71 |
72 | def dynamic_call_and_check(self, args: Sequence[Any]) -> R:
73 | result = self.dynamic_call(args)
74 | self.check_return_value(result)
75 | return result
76 |
77 | def call(self, *args: P.args, **kwargs: P.kwargs) -> R:
78 | args = self.bind_dynamic_call_args(*args, **kwargs)
79 | result = self.dynamic_call_and_check(args)
80 | return result
81 |
82 | def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
83 | return self.call(*args, **kwargs)
84 |
--------------------------------------------------------------------------------