Initial Release

Author: pythonlessons

.gitignore

@@ -1,7 +1,7 @@
 __pycache__/
 *.egg-info
 api.json
-venv
+venv*
 Datasets
 runs
 Models

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "justMyCode": true
+        }
+    ]
+}

CHANGELOG.md

@@ -0,0 +1,8 @@
+## [0.1.0] - 
+### Initial Release:
+- created the project
+- created code to create random sinusoidal price data
+- created `state.State` object, which holds the state of the market
+- created `render.PygameRender` object, which renders the state of the market using `pygame` library
+- created `trading_env.TradingEnv` object, which is the environment for the agent to interact with
+- created `data_feeder.PdDataFeeder` object, which feeds the environment with data from a pandas dataframe

MANIFEST.in

@@ -0,0 +1,2 @@
+global-exclude *.pyc
+include requirements.txt

Tutorials/01_Creating_trading_environment.md

@@ -0,0 +1,93 @@
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+from datetime import datetime, timedelta
+
+def create_sinusoidal_df(
+    amplitude = 2000.0,  # Amplitude of the price variations
+    frequency = 0.01,  # Frequency of the price variations
+    phase = 0.0,  # Phase shift of the price variations
+    num_samples = 10000,  # Number of data samples
+    data_shift = 20000, # shift the data up
+    trendline_down = 5000, # shift the data down
+    plot = False,
+    ):
+    """Create a dataframe with sinusoidal data"""
+
+    # Generate the time axis
+    t = np.linspace(0, 2 * np.pi * frequency * num_samples, num_samples)
+
+    # Get the current datetime
+    now = datetime.now()
+
+    # Set hours, minutes, and seconds to zero
+    now = now.replace(hour=0, minute=0, second=0, microsecond=0)
+
+    # Generate timestamps for each day
+    # timestamps = [now - timedelta(days=i) for i in range(num_samples)]
+    timestamps = [now - timedelta(hours=i*4) for i in range(num_samples)]
+
+    # Convert datetime objects to strings
+    timestamps = [timestamps.strftime('%Y-%m-%d %H:%M:%S') for timestamps in timestamps]
+
+    # Invert the order of the timestamps
+    timestamps = timestamps[::-1]
+
+    # Generate the sinusoidal data for prices
+    sin_data = amplitude * np.sin(t + phase)
+    sin_data += data_shift # shift the data up
+
+    # shiwft sin_data up, to create trendline up
+    sin_data -= np.linspace(0, trendline_down, num_samples)
+
+    # Add random noise
+    noise = np.random.uniform(0.95, 1.05, len(t))  # generate random noise
+    noisy_sin_data = sin_data * noise  # add noise to the original data
+
+    price_range = np.max(noisy_sin_data) - np.min(noisy_sin_data)
+
+    # Generate random low and close prices
+    low_prices = noisy_sin_data - np.random.uniform(0, 0.1 * price_range, len(noisy_sin_data))
+    close_prices = noisy_sin_data + np.random.uniform(-0.05 * price_range, 0.05 * price_range, len(noisy_sin_data))
+
+    # open prices usually are close to the close prices of the previous day
+    open_prices = np.zeros(len(close_prices))
+    open_prices[0] = close_prices[0]
+    open_prices[1:] = close_prices[:-1]
+
+    # high prices are always above open and close prices
+    high_prices = np.maximum(open_prices, close_prices) + np.random.uniform(0, 0.1 * price_range, len(close_prices))
+
+    # low prices are always below open and close prices
+    low_prices = np.minimum(open_prices, close_prices) - np.random.uniform(0, 0.1 * price_range, len(close_prices))
+
+    if plot:
+        # Plot the price data
+        plt.figure(figsize=(10, 6))
+        plt.plot(t, noisy_sin_data, label='Noisy Sinusoidal Data')
+        plt.plot(t, open_prices, label='Open')
+        plt.plot(t, low_prices, label='Low')
+        plt.plot(t, close_prices, label='Close')
+        plt.plot(t, high_prices, label='High')
+        plt.xlabel('Time')
+        plt.ylabel('Price')
+        plt.title('Fake Price Data')
+        plt.legend()
+        plt.grid(True)
+        plt.show()
+
+    # save the data to a CSV file with matplotlib as df[['open', 'high', 'low', 'close']
+    df = pd.DataFrame({'timestamp': timestamps, 'open': open_prices, 'high': high_prices, 'low': low_prices, 'close': close_prices})
+
+    return df
+
+if __name__ == '__main__':
+    # Create a dataframe with sinusoidal data
+    df = create_sinusoidal_df()
+
+    # Create a directory to store the datasets
+    os.makedirs('Datasets', exist_ok=True)
+
+    # Save the dataframe to a CSV file
+    df.to_csv(f'Datasets/random_sinusoid.csv')

bin/create_sinusoid_data.py

@@ -0,0 +1,16 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+df = pd.read_csv('Datasets/random_sinusoid.csv', index_col='timestamp', parse_dates=True)
+df = df[['open', 'high', 'low', 'close']]
+# limit to last 1000 data points
+df = df[-1000:]
+
+# plot the data
+plt.figure(figsize=(10, 6))
+plt.plot(df['close'])
+plt.xlabel('Time')
+plt.ylabel('Price')
+plt.title('random_sinusoid.csv')
+plt.grid(True)
+plt.show()

bin/plot_data.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

finrock/__init__.py

@@ -0,0 +1,36 @@
+import pandas as pd
+
+from finrock.state import State
+
+class PdDataFeeder:
+    def __init__(self, df: pd.DataFrame):
+        self._df = df
+
+        assert isinstance(self._df, pd.DataFrame) == True
+        assert 'timestamp' in self._df.columns
+        assert 'open' in self._df.columns
+        assert 'high' in self._df.columns
+        assert 'low' in self._df.columns
+        assert 'close' in self._df.columns
+
+    def __len__(self) -> int:
+        return len(self._df)
+    
+    def __getitem__(self, idx: int) -> State:
+        data = self._df.iloc[idx]
+
+        state = State(
+            timestamp=data['timestamp'],
+            open=data['open'],
+            high=data['high'],
+            low=data['low'],
+            close=data['close'],
+            volume=data.get('volume', 0.0)
+        )
+
+        return state
+    
+    def __iter__(self) -> State:
+        """ Create a generator that iterate over the Sequence."""
+        for index in range(len(self)):
+            yield self[index]

finrock/data_feeder.py

@@ -0,0 +1,133 @@
+from .state import State
+
+class ColorTheme:
+    black = (0, 0, 0)
+    white = (255, 255, 255)
+    red = (255, 10, 0)
+    lightblue = (100, 100, 255)
+    green = (0, 240, 0)
+
+    background = black
+    up_candle = green
+    down_candle = red
+    wick = white
+    text = white
+
+class PygameRender:
+    def __init__(
+            self,
+            window_size: int=100,
+            screen_width: int=1024,
+            screen_height: int=768,
+            top_bottom_offset: int=25,
+            candle_spacing: int=1,
+            color_theme = ColorTheme(),
+            frame_rate: int=30,
+        ):
+
+        # pygame window settings
+        self.screen_width = screen_width
+        self.screen_height = screen_height
+        self.top_bottom_offset = top_bottom_offset
+        self.candle_spacing = candle_spacing
+        self.window_size = window_size
+        self.color_theme = color_theme
+        self.frame_rate = frame_rate
+
+        self.candle_width = self.screen_width // self.window_size - self.candle_spacing
+        self.chart_height = self.screen_height - 2 * self.top_bottom_offset
+
+        self._states = []
+
+        try:
+            import pygame
+            self.pygame = pygame
+        except ImportError:
+            raise ImportError('Please install pygame (pip install pygame)')
+        
+        self.pygame.init()
+        self.pygame.display.init()
+        self.screen_shape = (self.screen_width, self.screen_height)
+        self.window = self.pygame.display.set_mode(self.screen_shape, self.pygame.RESIZABLE)
+        self.clock = self.pygame.time.Clock()
+
+    def reset(self):
+        self._states = []
+
+    def _map_price_to_window(self, price, max_low, max_high):
+        max_range = max_high - max_low
+        value = int(self.chart_height - (price - max_low) / max_range * self.chart_height) + self.top_bottom_offset
+        return value
+    
+    def _prerender(func):
+        """ Decorator for input data validation and pygame window rendering"""
+        def wrapper(self, info: dict, rgb_array: bool=False):
+            self._states += info.get('states', [])
+
+            if not self._states or not bool(self.window._pixels_address):
+                return
+
+            for event in self.pygame.event.get():
+                if event.type == self.pygame.QUIT:
+                    self.pygame.quit()
+                    return
+
+                if event.type == self.pygame.VIDEORESIZE:
+                    self.screen_shape = (event.w, event.h)
+
+            # self.screen.fill(self.color_theme.background)
+            canvas = func(self, info)
+            canvas = self.pygame.transform.scale(canvas, self.screen_shape)
+            # The following line copies our drawings from `canvas` to the visible window
+            self.window.blit(canvas, canvas.get_rect())
+            self.pygame.display.update()
+            self.clock.tick(self.frame_rate)
+
+            if rgb_array:
+                return self.pygame.surfarray.array3d(canvas)
+
+        return wrapper
+
+    @_prerender
+    def render(self, info: dict):
+
+        canvas = self.pygame.Surface((self.screen_width , self.screen_height))
+        canvas.fill(self.color_theme.background)
+        
+        max_high = max([state.high for state in self._states])
+        max_low = min([state.low for state in self._states])
+
+        candle_offset = self.candle_spacing
+
+        for state in self._states[-self.window_size:]:
+
+            assert isinstance(state, State) == True # check if state is a State object
+
+            # Calculate candle coordinates
+            candle_y_open = self._map_price_to_window(state.open, max_low, max_high)
+            candle_y_close = self._map_price_to_window(state.close, max_low, max_high)
+            candle_y_high = self._map_price_to_window(state.high, max_low, max_high)
+            candle_y_low = self._map_price_to_window(state.low, max_low, max_high)
+
+            # Determine candle color
+            if state.open < state.close:
+                # up candle
+                candle_color = self.color_theme.up_candle
+                candle_body_y = candle_y_close
+                candle_body_height = candle_y_open - candle_y_close
+            else:
+                # down candle
+                candle_color = self.color_theme.down_candle
+                candle_body_y = candle_y_open
+                candle_body_height = candle_y_close - candle_y_open
+
+            # Draw candlestick wicks
+            self.pygame.draw.line(canvas, self.color_theme.wick, (candle_offset + self.candle_width // 2, candle_y_high), (candle_offset + self.candle_width // 2, candle_y_low))
+
+            # Draw candlestick body
+            self.pygame.draw.rect(canvas, candle_color, (candle_offset, candle_body_y, self.candle_width, candle_body_height))
+
+            # Move to the next candle
+            candle_offset += self.candle_width + self.candle_spacing
+
+        return canvas