1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
import pandas as pd
import tkinter as tk
from tkinter import ttk
from tkinter.filedialog import askopenfilename, asksaveasfilename
class CompanySelector:
def __init__(self, master):
self.master = master
self.master.title("Company Selector")
self.select_file_button = tk.Button(self.master, text="Select Excel File", command=self.load_file)
self.select_file_button.pack()
def load_file(self):
file_path = askopenfilename(filetypes=[("Excel files", "*.xlsx *.xls")])
if not file_path:
return
self.df = pd.read_excel(file_path)
self.show_companies()
def show_companies(self):
self.select_file_button.pack_forget()
self.company_listbox = tk.Listbox(self.master, selectmode=tk.MULTIPLE, exportselection=False)
self.company_listbox.pack()
for company in self.df["Company Name"]:
self.company_listbox.insert(tk.END, company)
self.create_pyramid_button = tk.Button(self.master, text="Create Pyramid", command=self.create_pyramid)
self.create_pyramid_button.pack()
def create_pyramid(self):
selected_companies = [self.company_listbox.get(index) for index in self.company_listbox.curselection()]
selected_df = self.df[self.df["Company Name"].isin(selected_companies)].sort_values(by="Weighting", ascending=False)
pyramid_file_path = asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx *.xls")])
if not pyramid_file_path:
return
with pd.ExcelWriter(pyramid_file_path) as writer:
selected_df.to_excel(writer, index=False)
image_file_path = asksaveasfilename(defaultextension=".png", filetypes=[("Image files","*.png")])
company_scores = {}
# For each 'Company Name', company_scores[company] = 'Weighting' for that company
for company, ticker, weighting in zip(selected_df["Company Name"], selected_df["Symbol"], selected_df["Weighting"]):
company_scores[f'{company} ({ticker})'] = weighting
from PIL import Image, ImageDraw, ImageFont
import math
# Sort the dictionary by score in ascending order
company_scores = {k: v for k, v in sorted(company_scores.items(), key=lambda item: item[1])}
# Group the companies by their scores
pyramid = {i: [] for i in range(1, 7)}
for company, score in company_scores.items():
pyramid[score].append(company)
# Initialize some parameters
img_width = 3300
img_height = 2550
block_color = (0, 0, 255) # Blue color
font_color = (255, 255, 255) # White color
padding = 10 # Padding around blocks
radius = 20
# Group the companies by their scores
pyramid = {}
for company, score in company_scores.items():
if score not in pyramid:
pyramid[score] = []
pyramid[score].append(company)
# Sort the pyramid keys in ascending order to have a pyramid shape
sorted_keys = sorted(pyramid.keys())
# Calculate the maximum number of companies in a group (this will be the width of your pyramid)
max_companies = max(len(v) for v in pyramid.values())
# Calculate the total number of groups (the height of your pyramid)
total_groups = len(pyramid)
# Calculate the total number of groups (the height of your pyramid)
total_groups = len(pyramid)
# Calculate the size of each block based on the width and height of the image and the number of blocks
block_size = min((img_width - padding) // max_companies - padding, (img_height - padding) // total_groups - padding)
# Calculate the size of each block based on the width and height of the image and the number of blocks
block_width = (img_width - padding) // max_companies - padding
block_height = (img_height - padding) // total_groups - padding
# Calculate the total width and height of the blocks (including padding)
total_width = max_companies * (block_width + padding)
total_height = total_groups * (block_height + padding)
# Calculate the starting position for the first block
start_x = (img_width - total_width) // 2
start_y = (img_height - total_height) // 2
# Create an image big enough to hold the pyramid
img = Image.new('RGB', (img_width, img_height), "white")
d = ImageDraw.Draw(img)
def wrap_text(text, max_length):
words = text.split()
lines = []
current_line = []
for word in words:
if len(' '.join(current_line + [word])) <= max_length:
current_line.append(word)
else:
lines.append(' '.join(current_line))
current_line = [word]
lines.append(' '.join(current_line))
return '\n'.join(lines)
# Loop over each level of the pyramid
for i, score in enumerate(sorted_keys):
companies = pyramid[score]
for j, company in enumerate(companies):
# Calculate the position of the block
x = start_x + j * (block_width + padding) + (total_width - len(companies) * (block_width + padding)) // 2
y = start_y + i * (block_size + padding)
# Draw the block
d.rounded_rectangle([x, y, x + block_width, y + block_height], fill=block_color, radius=radius)
# Adjust font size based on the length of the company name and block size
font_size = min(block_width // (len(company) // 2 + 1), block_height // 2)
fnt = ImageFont.truetype('./assets/arial.ttf', font_size)
# Implement word wrap for the company name
wrapped_company = wrap_text(company, block_width // font_size)
# Draw the company name
bbox = d.textbbox((x, y), wrapped_company, font=fnt)
text_width = bbox[2] - bbox[0]
text_height = bbox[3] - bbox[1]
text_x = x + (block_width - text_width) // 2
text_y = y + (block_height - text_height) // 2
d.text((text_x, text_y), wrapped_company, font=fnt, fill=font_color)
# Save the image
if not image_file_path:
return
img.save(image_file_path)
self.master.quit()
if __name__ == "__main__":
root = tk.Tk()
app = CompanySelector(root)
root.mainloop()
|
