# Sample Codes
## Input:
**Weight Generator**
* **Weight Part**
```python
import pandas as pd
import numpy as np
import itertools
def generate_weights_with_constraints_25(num_weights, num_simulation=70):
possible_values = [0, 0.25, 0.5, 0.75, 1]
simulations = []
# Generate all possible combinations
all_combinations = list(itertools.product(possible_values, repeat=num_weights))
valid_combinations = [combo for combo in all_combinations if np.isclose(sum(combo), 1)]
simulations = np.random.choice(len(valid_combinations), num_simulation, replace=False)
simulations = [valid_combinations[i] for i in simulations]
return simulations
# For 0.25 interval, total number of simulation are 70
num_weights = 5
num_simulation = 70
simulations = generate_weights_with_constraints_25(num_weights, num_simulation)
simulations = pd.DataFrame(simulations
```
* **Allocation Part**
```python
def generate_allcations_with_constraints_10(num_allocations, num_simulation=70):
possible_values = [0, 0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]
simulations = []
# Generate all possible combinations
all_combinations = list(itertools.product(possible_values, repeat=num_allocations))
valid_combinations = [combo for combo in all_combinations if np.isclose(sum(combo), 1)]
simulations = np.random.choice(len(valid_combinations), num_simulation, replace=False)
simulations = [valid_combinations[i] for i in simulations]
return simulations
# For 0.1 interval, total number of allocations are 66
num_allocations = 3
num_simulation = 66
allocations_simulation = generate_allcations_with_constraints_10(num_allocations, num_simulation)
allocations_simulation = pd.DataFrame(allocations_simulation)
```
* **Data Combination**
```python
simulations['Re-Balance Frequence Day'] = 3
allocations_simulation['Re-Balance Frequence Day'] = 3
simulations_df = pd.merge(simulations, allocations_simulation, on='Re-Balance Frequence Day')
simulations_df = simulations_df.reset_index()
simulations_df = simulations_df.rename(columns={'index': 'Simulation ID',
'0_y':'% Allocation for Priority 1',
'1_y':'% Allocation for Priority 2',
'2_y': '% Allocation for Priority 3',
'0_x': 'Previous Funding Rate APR Weight',
'1_x': 'Next Funding Rate APR Weight',
'2_x': '3 Day Cum Funding APR Weight',
3: '7 Day Cum Funding APR Weight',
4: '30 Day Cum Funding APR Weight'
})
simulations_df.to_csv('new_funding_rate_weight_df_2.csv', index=False)
```
**Simulation Configurations Input:**
* **funding rate weights input**
* **allocation weights input**
**Historical Funding Rates Data:**
```python
simulations_df = pd.read_csv('/~path/funding_rate_weight_df.csv')
# Define the weights by properly calling tolist() with parentheses
W3 = simulations_df['3 Day Cum Funding APR Weight'].tolist()
W7 = simulations_df['7 Day Cum Funding APR Weight'].tolist()
W30 = simulations_df['30 Day Cum Funding APR Weight'].tolist()
W_next = simulations_df['Next Funding Rate APR Weight'].tolist()
W_prev = simulations_df['Previous Funding Rate APR Weight'].tolist()
A1 = simulations_df['% Allocation for Priority 1'].tolist()
A2 = simulations_df['% Allocation for Priority 2'].tolist()
A3 = simulations_df['% Allocation for Priority 3'].tolist()
F = simulations_df['Re-Balance Frequence Day'].tolist()
# Global weights for APR calculation
WEIGHTS = [W3, W7, W30, W_prev, W_next]
ALLOCATIONS = [A1, A2, A3]
```
**Creating feasible DataFrame**
```python
# Load the data
with open('historical_funding_rates_0707.json', 'r') as file:
data = json.load(file)
frames = []
for symbol, records in data.items():
df = pd.json_normalize(records)
df['symbol'] = symbol
# Check if 'fundingRate' exists in the dataframe and convert to numeric
if 'fundingRate' in df.columns:
df['fundingRate'] = pd.to_numeric(df['fundingRate'], errors='coerce')
else:
df['fundingRate'] = pd.NA # Assign a missing value indicator if 'fundingRate' is not present
frames.append(df)
# Concatenate all frames into a single DataFrame
df = pd.concat(frames, ignore_index=True)
# Convert 'fundingTime' from milliseconds to a datetime object
df['fundingTime'] = pd.to_datetime(df['fundingTime'], unit='ms')
# Split 'fundingTime' into separate date and time components
df['date'] = df['fundingTime'].dt.date
df['time'] = df['fundingTime'].dt.time
# Drop rows where any column has NaN values
df = df.dropna()
# Sort by 'date' in descending order
df = df.sort_values(by='date', ascending=False)
# Display the first few rows to verify
df = df[['symbol', 'date', 'time', 'fundingRate', 'markPrice']]
```
## Math functions & formulas:
* **Token Scores Function:**
**'token\_score\_func(symbol, simulations\_id, model\_num)'**
* **Simulation Realized APR Function:**
**'simulation\_apr\_func(Tokens\_names, simulations\_id, model\_num)'**
```python
def token_score_func(symbol, simulations_id, model_num):
group = df.loc[df['symbol'] == symbol, 'fundingRate']
i = len(group) % 90 + (model_num - 1) * 9
aprs = [
group.iloc[i : i + 9].mean() * 3 * 360 * 100,
group.iloc[i : 21 + i].mean() * 3 * 360 * 100,
group.iloc[i : 90 + i].mean() * 3 * 360 * 100,
group.iloc[1 + i] * 3 * 360 * 100,
group.iloc[i] * 3 * 360 * 100
]
#simulations_id = simulations_id - 1
weights = [W[simulations_id] for W in WEIGHTS] # Gather weights for each APR based on simulation ID
# Calculate the weighted APR score
apr_score = sum(apr * weight for apr, weight in zip(aprs, weights))
return apr_score
```
```python
def simulation_apr_func(Tokens_names, simulations_id, model_num):
top3_rates = []
for symbol in Tokens_names:
group = df.loc[df['symbol'] == symbol, 'fundingRate']
i = len(group) % 90 + (model_num - 1) * 9
rates = group.iloc[i - 9 : i ].mean()
top3_rates.append(rates)
allocations = [A[simulations_id] for A in ALLOCATIONS]
sim_apr = sum(rate * allocation for rate, allocation in zip(top3_rates, allocations)) * 360 * 3
return sim_apr
```
```python
token_score = {}
simulaiton_id = simulations_df.index.tolist()
model_nums = range(1,11)
token_score_rank = []
simulation_avg_apr = {}
for id in simulaiton_id:
simulation_total_apr = 0
for i in model_nums:
token_score = {}
simulation_apr = {}
for symbol in symbols:
score = token_score_func(symbol, id, i)
token_score[(symbol, id, i)] = score
top3_score = dict(sorted(token_score.items(), key=lambda item: item[1],reverse=True)[:3])
Token_names = [key[0] for key in top3_score.keys()]
cal_apr = simulation_apr_func(Token_names, id, i)
simulation_apr[(f'Model Num {i}', f'Simulation {id}')] = cal_apr
simulation_total_apr += cal_apr
simulation_avg_apr[id] = simulation_total_apr / len(model_nums)
sorted_simulation_avg_apr = dict(sorted(simulation_avg_apr.items(), key=lambda item: item[1], reverse=True))
sorted_simulation_avg_apr
```
## Output
* **Funding rate weight and Portfolio allocation configurations for monitor**
```python
max_realized_apr = [
{'Simulation ID': key, 'Realized APR': value}
for key, value in sorted_simulation_avg_apr.items()
]
max_realized_apr_token = [
{'Simulation ID': key, 'Tokens': value}
for key, value in simulation_top3_token.items()
]
max_realized_apr = pd.DataFrame(max_realized_apr)
max_realized_apr.reset_index(drop=True, inplace=True)
max_realized_apr_token = pd.DataFrame(max_realized_apr_token)
max_realized_apr = pd.merge(max_realized_apr, max_realized_apr_token, on='Simulation ID')
max_realized_apr.to_csv('max_realized_apr_may.csv', index=False)
max_realized_apr
```
max_realized_apr
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.kira.trading/trust/human-error-free-with-ai-automation/simulator/sample-codes.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.