Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/gsy0911/kabutobashi
related to stock analysis
https://github.com/gsy0911/kabutobashi
Last synced: 24 days ago
JSON representation
related to stock analysis
- Host: GitHub
- URL: https://github.com/gsy0911/kabutobashi
- Owner: gsy0911
- License: mit
- Created: 2020-02-03T13:30:49.000Z (about 5 years ago)
- Default Branch: main
- Last Pushed: 2024-12-23T14:25:14.000Z (about 2 months ago)
- Last Synced: 2024-12-23T15:29:13.466Z (about 2 months ago)
- Language: Python
- Homepage:
- Size: 14.9 MB
- Stars: 0
- Watchers: 3
- Forks: 0
- Open Issues: 19
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# kabutobashi
[](https://github.com/gsy0911/kabutobashi/actions?query=workflow%3Apytest)
[](https://codecov.io/gh/gsy0911/kabutobashi)
[](https://github.com/psf/black)
[](https://pycqa.github.io/isort/)
[](http://mypy-lang.org/)
[](https://pypi.org/project/kabutobashi/)
[](https://pypi.org/project/kabutobashi/)
[](https://kabutobashi.readthedocs.io/en/latest/?badge=latest)
# Core Concept
`@block`-decorator and `Flow`-class is important.
`@block` automatically generates input and output functions, allowing you to focus solely on the processing.
`Flow` allows you to focus solely on the process flow and input parameters.
## About `@block`-decorator
simple decorator is like below.
```python
def simple_decorator(func):
def wrap_func() -> str:
res = func()
return f"Hello, {res}"
return wrap_func
@simple_decorator
def world() -> str:
return "world"
world() # => "Hello, world"
```
A `decorator` is something that dynamically generates and adds processes to functions or classes, similar to its name.
First, prepare a function as follows and decorate it with `@block`.
```python
from kabutobashi import block
@block()
class UdfBlock:
term: int = 10
def _process(self):
return {"doubled_term": self.term * 2}
```
The classes above is equivalent to the following class definition.
```python
import pandas as pd
from kabutobashi.domain.entity.blocks import BlockGlue
class UdfBlock:
series: pd.DataFrame = None
params: dict = None
term: int = 10
block_name: str = "udf_block"
def _process(self) -> dict:
return {"doubled_term": self.term * 2}
def process(self) -> BlockGlue:
# _process() method can be Tuple[Optional[dict], Optional[pd.DataFrame]]
res = self._process()
return BlockGlue(params=res, series=None, block_outputs={})
def factory(self, glue: BlockGlue) -> "UdfBlock":
# Omitted. In reality, processes are described.
...
def _factory(self, glue: BlockGlue) -> dict:
# Omitted. In reality, processes are described.
...
def glue(self, glue: BlockGlue) -> BlockGlue:
# Omitted. In reality, processes are described.
...
```
In classes decorated with `@block`, it is not recommended to execute the `__init__()` method. Instead, it is recommended to use the `factory()` class-method.
`factory()` method description.
`process()` method description.
`glue()` method description.
```mermaid
sequenceDiagram
autonumber
participant G as glue()
participant UC as UdfBlock::class
create participant S1 as factory()
UC->>S1: create
create participant S2 as _factory()
UC->>S2: create or defined by user
create participant P1 as process()
UC->>P1: create
create participant P2 as _process()
UC->>P2: create or defined by user
Note over S1: Generate udf_block_instance
G->>+S1: Request
S1->>+S2: Request
Note over S2: User can modify _factory()
S2-->>S2: get params from glue
S2-->>S2: get series from glue
S2-->>-S1: params and series
create participant UI as UdfBlock::instance
S1->>UI: UdfBlock(params, series)
S1->>UI: setattr params to udf_block_instance
S1-->>-G: udf_block_instance
G->>+UI: udf_block_instance.process()
UI->>+P1: process()
Note over P1: execute process()
P1->>P2: Request
Note over P2: execute user defined function
P2-->>P1: params or series
P1-->>-UI: BlockGlue(params, series)
UI-->>-G: block_glue_instance
```
Up to this point, the use of the `@block` decorator with classes such as UdfClass has described, but using the Block class on its own is not intended. Please read the following explanation of the `Flow` class for more details.
## About `Flow`-class
> Blocks are meant to be combined.
Processes always consist of combinations of multiple simple operations. And the only tedious part is aligning their inputs and outputs.
Therefore, in `Flow`-class, it automatically resolves the sequence of those processes for users, as long as you provide the initial values.
## usage
```python
import kabutobashi as kb
# n日前までの営業日の日付リストを取得する関数
target_date = "2020-01-01"
date_list = kb.get_past_n_days(target_date, n=40)
```
## initialize Database
```python
import kabutobashi as kb
kb.KabutobashiDatabase().initialize()
# add data
kb.crawl_info_multiple(code="1375", page="1", database_dir="...")
kb.crawl_info_multiple(code="1375", page="2", database_dir="...")
kb.crawl_info_multiple(code="1375", page="etc...", database_dir="...")
# add data daily
kb.crawl_info(code="1375", database_dir="...")
# analysis and add data
kb.analysis(code="1375", database_dir="...")
```