Stock price: jumping out and in of dividend stocks around ex dividend dates

import pandas as pd
# The importing can be made in two ways. By download, the file and read by pd.read_csv, 
# or read directly by pandas from the website. Awareness: when many attempts is made to 
# the page, it may cause an internal error. It can be suspected of spam action.
# df = pd.read_csv("acp_d.csv")
df = pd.read_csv('https://stooq.pl/q/d/l/?s=acp&i=d&o=0001000')

def rename_df_stock_prices(df: pd.DataFrame) -> pd.DataFrame:
    """
    Change headers language to polish.
    
    Input:
        df pd.DataFrame
    Output: 
        df pd.DataFrame
    """
    df = df.rename(columns={"Data": "Date", 
                            "Otwarcie": "Opening", 
                            "Najwyzszy": "Highest", 
                            "Zamkniecie":"Closing", 
                            "Najnizszy": "Lowest", 
                            "Wolumen": "Volume"})
    df['Date'] = pd.to_datetime(df['Date'], format='%Y-%m-%d')
    return df

df = rename_df_stock_prices(df)

df

# Get the information of dividend payments
import requests
from bs4 import BeautifulSoup

page = requests.get("https://stooq.pl/q/m/?s=acp")

def parse_request(page) -> pd.DataFrame:
    """
    Parse request into pd.DataFrame
    
    Input:
        request
    Output:
        df_list: pd.DataFrame
    """
    soup = BeautifulSoup(page.content, 'html.parser')
    df_list = pd.read_html(page.text)
    return df_list
    
df_list = parse_request(page)
df_list[0]

# Process into pandas and convert into format='%d-%m-%Y'
df_list = pd.read_html(page.text, encoding='utf-8')

def clean_df_stock(df_list: pd.DataFrame) -> pd.DataFrame:
    """
    Cleaning df: extract date aby the regex and convert into format='%d-%m-%Y'.
    Additionally, change headers' language to English.
    
    Input: 
        df_list pd.DataFrame
    Output:
        cleaned_df: pd.DataFrame
    
    """
    # Remove rows with NaNs
    cleaned_df = df_list[0].copy().dropna(thresh=2)
    cleaned_df = cleaned_df.rename(columns={"Data": "Date", 
                                            "Zdarzenie": "Event", 
                                            "Nominalnie": "Nominal", 
                                            "Dzielnik": "Divider"})
    date_dict = {
    "sty": "01",
    "lut": "02",
    "mar":"03",
    "kwi": "04",
    "maj":"05",
    "cze":"06",
    "lip":"07",
    "sie":"08",
    "wrz":"09",
    "paź":"10",
    "lis":"11",
    "gru":"12"}
    
    # Extract date from the Data column
    cleaned_df.loc[:,'Date'] = cleaned_df.loc[:,'Date'].str.extract('(\d+\s\w+\s\d+)', expand=False).str.strip()
    cleaned_df.loc[:,'Date'] = cleaned_df.loc[:,'Date'].replace(date_dict, regex=True)
    cleaned_df.loc[:,'Date'] = cleaned_df.loc[:,'Date'].replace(' ', '-', regex=True)
    cleaned_df.loc[:,'Date'] = pd.to_datetime(cleaned_df.loc[:,'Date'], format='%d-%m-%Y')

    return cleaned_df

cleaned_df = clean_df_stock(df_list)

cleaned_df

def get_only_dividend_event(cleaned_df: pd.DataFrame) -> pd.DataFrame:
    """
    Get only divident (pl: Dywidenda) event from dataframe
    
    Input:
        cleaned_df pd.DataFrame
    Return: 
        cleaned_df pd.DataFrame
    
    """
    cleaned_df[cleaned_df['Event'].str.contains("Dywidenda")]
    return cleaned_df

cleaned_df = get_only_dividend_event(cleaned_df)

import numpy as np
import matplotlib.pyplot as plt

from datetime import date  
from sklearn.preprocessing import MinMaxScaler

# Set setting for plot of the transform stock price
%matplotlib inline
plt.rcParams['figure.figsize'] = [15, 10]
plt.style.use('seaborn-whitegrid')
fig = plt.figure()
ax = plt.axes()

# Create numpy range for 10 days before dividend, dividend day, and 10 days after
x = np.arange(0, 21, 1)
k=0

list_of_profits = []
list_of_minmaxscaled = []
list_of_scaled = []
list_of_noscaled = []

pd.options.mode.chained_assignment = None

for index, row in cleaned_df.iterrows():
    try:
        dividend_day = pd.to_datetime(row['Date'], format='%Y-%m-%d')
        idx = df[df.Date == dividend_day].index

        # Get the stock prices 10 session before dividend and 10 after
        filtered_idx = (idx - 10).union(idx+10)
        filtered_idx = filtered_idx[filtered_idx > 0]
        df_index_range = df.iloc[filtered_idx].reset_index() 
        
        # Based on filtering condition get only data between the range
        df_range_date = df.loc[(df["Date"] >= df_index_range['Date'][0]) & 
                        (df['Date'] <= df_index_range['Date'][1])]
        
        list_of_noscaled.append(df_range_date.copy())
        
        list_of_scaled.append(df_range_date)
        list_of_scaled[k].loc[df_range_date.Date<str(dividend_day), 
                              ['Opening', 'Highest', 'Lowest', 'Closing']] += float(row['Nominal'])

        maximum = list_of_scaled[k].loc[list_of_scaled[k].Date<str(dividend_day), ['Highest']].max()
        minimum = list_of_scaled[k].loc[list_of_scaled[k].Date>=str(dividend_day), ['Lowest']].min()

        profit = (maximum.values-minimum.values)-maximum.values*0.0038-minimum.values*0.0038-float(row['Nominal'])    
        list_of_profits.append(profit)
        
        # Use MinMaxScaler for better visual changes in the stock prices
        scaler = MinMaxScaler()
        df_range_date = scaler.fit_transform(df_range_date[['Closing']]).T
        list_of_minmaxscaled.append(df_range_date)
        
        plt.plot(x, df_range_date.ravel())
    
        k+=1
        
    except IndexError:
        print("Insufficient data information. Probably the dataset doesn't have ten days after payment dividend")
    
plt.show()

counts, bins = np.histogram(list_of_profits)
plt.hist(bins[:-1], bins, weights=counts)

def calculate_adjusted_profit(cleaned_df: pd.DataFrame, df: pd.DataFrame) -> list:
    """
    Calculate adjusted profit:
    mean from the highest and lowest share's price per day
    
    Input:
        cleaned_df: pd.DataFrame
        df: pd.DataFrame
    Output:
        list_of_profits: list
    
    """
    # Create numpy range for 10 days before dividend, dividend day, and 10 days after
    x = np.arange(0, 21, 1)
    k=0

    list_of_profits = []
    list_of_minmaxscaled = []
    list_of_scaled = []
    list_of_noscaled = []

    for index, row in cleaned_df.iterrows():
        try:
            dividend_day = pd.to_datetime(row['Date'], format='%Y-%m-%d')
            idx = df[df.Date == dividend_day].index

            # Get the stock prices 10 session before dividend and 10 after
            filtered_idx = (idx - 10).union(idx+10)
            filtered_idx = filtered_idx[filtered_idx > 0]
            df_index_range = df.iloc[filtered_idx].reset_index() 
            
            # Based on filtering condition get only data between the range
            df_range_date = df.loc[(df["Date"] >= df_index_range['Date'][0]) & 
                            (df['Date'] <= df_index_range['Date'][1])]

            list_of_noscaled.append(df_range_date.copy())

            list_of_scaled.append(df_range_date)
            list_of_scaled[k].loc[df_range_date.Date<str(dividend_day), 
                                  ['Opening', 'Highest', 'Lowest', 'Closing']] += float(row['Nominal'])

            maximum = list_of_scaled[k].loc[list_of_scaled[k].Date<str(dividend_day), ['Highest', 'Lowest']]
            maximum = ((maximum.Highest+maximum.Lowest)/2).max()

            minimum = list_of_scaled[k].loc[list_of_scaled[k].Date>=str(dividend_day), ['Highest', 'Lowest']]
            minimum = ((minimum.Highest+minimum.Lowest)/2).min()

            profit = (maximum-minimum)-maximum*0.0038-minimum*0.0038-float(row['Nominal'])      
            list_of_profits.append(profit)
            
            # Use MinMaxScaler for better visual changes in the stock prices
            scaler = MinMaxScaler()
            df_range_date = scaler.fit_transform(df_range_date[['Closing']]).T
            list_of_minmaxscaled.append(df_range_date)

            plt.plot(x, df_range_date.ravel())

            k+=1
            
        except IndexError:
            print("Insufficient data information. Probably the dataset doesn't have ten days after payment dividend")
        except KeyError:
            print("Missing data")
            # it occurs in ASE company, where the file doesn't contain all data
            
    return list_of_profits
        
list_of_profits = calculate_adjusted_profit(cleaned_df, df)

counts, bins = np.histogram(list_of_profits)
plt.hist(bins[:-1], bins, weights=counts)

stock_list_company=['ska', 'neu', 'dom', 'wwl', 'uni', 'abs', 'ase', 'amb']
data_profit = pd.DataFrame()

for company in stock_list_company:
    df = pd.read_csv('https://stooq.pl/q/d/l/?s='+company+'&i=d&o=0001000')
    df = rename_df_stock_prices(df)
    
    page = requests.get("https://stooq.pl/q/m/?s="+company)
    df_list = parse_request(page)
    
    cleaned_df = clean_df_stock(df_list)
    cleaned_df = get_only_dividend_event(cleaned_df)  
    profits = calculate_adjusted_profit(cleaned_df, df)
    
    data_profit = data_profit.append([profits.copy()])

data_profit = data_profit.transpose()
data_profit.columns = stock_list_company
data_profit = data_profit.round(2)
data_profit.describe()