def __validate(self):
# left must ONLY be int, float or None
if (not isinstance(self.left, int)
and not isinstance(self.left, float)
and self.left is not None):
raise TypeError(
"arguments 'left' and 'right' can only be of type 'int', 'float', or None"
)
# right must ONLY be int, float or None
if (not isinstance(self.right, int)
and not isinstance(self.right, float)
and self.right is not None):
raise TypeError(
"arguments 'left' and 'right' can only be of type 'int', 'float', or None"
)
# left value should be less than right value.
if ((isinstance(self.left, float) or isinstance(self.left, int)) and
(isinstance(self.right, int) or isinstance(self.right, float))):
if (self.left > self.right):
raise ValueError("argument 'left' must be less than 'right'")
# left and right cannot BOTH be false.
if (self.left == False and self.right == False):
raise ValueError(
"only one out of arguments 'left' and 'right can be 'False'")
# inclusive left must only be bool
if (not isinstance(self.inclusive_left, bool)):
raise TypeError("argument 'inclusive_left' must be of type 'bool'")
# inclusive right must only be bool
if (not isinstance(self.inclusive_right, bool)):
raise TypeError(
"argument 'inclusive_right' must be of type 'bool'")
# label must be specified
if (self.label == ""):
raise TypeError(
"required argument 'label' must be specified, and must be of type 'str'"
)
# label must only be string.
if (not isinstance(self.label, str)):
raise TypeError("argument 'label' must be of type 'str'")
# color, if specified, must be a valid hex, or color string
if (self.color is not None):
if (not Themes().is_rgb_hex(self.color)
and not Themes().is_color_name(self.color)):
raise TypeError(
"argument 'color' must be color hex string, or valid color name"
)
def test_generate_alpha_rgb_bicolor_B(self): rgb1 = (170,0,0) rgb2 = (255,102,0) alpha = 0.3 rgb_out = (230,72,0) self.assertEqual( Themes().generate_alpha_rgb_bicolor(rgb1,rgb2,alpha), rgb_out)
def test_generate_alpha_rgb_bicolor_F(self): rgb1 = (170,0,136) rgb2 = (229,128,255) alpha = 1.0 rgb_out = (170,0,136) self.assertEqual( Themes().generate_alpha_rgb_bicolor(rgb1,rgb2,alpha), rgb_out)
def test_generate_alpha_rgb_bicolor_H(self): rgb1 = (0,128,0) rgb2 = (0,255,102) alpha = 0.0 rgb_out = (0,255,102) self.assertEqual( Themes().generate_alpha_rgb_bicolor(rgb1,rgb2,alpha), rgb_out)
def test_generate_alpha_rgb_bicolor_A(self): rgb1 = (0,0,128) rgb2 = (0,255,255) alpha = 0.5 rgb_out = (0,128,192) self.assertEqual( Themes().generate_alpha_rgb_bicolor(rgb1,rgb2,alpha), rgb_out)
def test_generate_alpha_rgb_bicolor_I(self): rgb1 = (255,0,0) rgb2 = (255,204,0) alpha = 0.0 rgb_out = (255,204,0) self.assertEqual( Themes().generate_alpha_rgb_bicolor(rgb1,rgb2,alpha), rgb_out)
def __init__(self, options):
'''Initialize a single Tile object '''
# ensure options passed is a dictionary
if (not isinstance(options, dict)):
raise TypeError(
"required argument 'options' must be of type 'dict'")
# ensure validity of 'value' in options
if ('value' not in options):
raise TypeError("required argument 'value' \
not specified")
elif (not isinstance(options['value'], int)
and not isinstance(options['value'], float)):
raise TypeError("argument 'value' must be \
of type 'int' or 'float'")
# ensure validity of 'alpha' in options
elif ('alpha' not in options):
raise TypeError("required argument 'alpha' \
not specified")
elif (not isinstance(options['alpha'], int)
and not isinstance(options['alpha'], float)):
raise TypeError("argument 'alpha' must be \
of type 'int' or 'float'")
elif (options['alpha'] < 0 or options['alpha'] > 1):
raise ValueError("argument 'alpha' must be \
between 0-1 inclusively")
# ensure validity of 'rgb' in options
elif ('rgb' not in options):
raise TypeError("required argument 'rgb' not \
specified")
elif (not isinstance(options['rgb'], str)):
raise TypeError("argument 'rgb' must be of type 'str'")
elif (not Themes().is_rgb_hex(options['rgb'])):
raise ValueError("argument 'rgb' must be \
between #000000 to \
#ffffff, and preceded with '#'")
# ensure validity of 'label' in options if it is ever passed.
elif ('label' not in options):
self.__label = None
elif ('label' in options):
if (not isinstance(options['label'], str)
and options['label'] is not None):
raise TypeError("argument 'label' must be of type 'str'")
self.__label = options['label']
self.__value = options['value']
self.__alpha = options['alpha']
self.__rgb = options['rgb']
self.__options = options
def __init__(self,
left,
right,
inclusive_left=True,
inclusive_right=False,
label="",
color=None):
# define class variables.
self.left = left
self.right = right
self.inclusive_left = inclusive_left
self.inclusive_right = inclusive_right
self.label = label
self.color = color
# validate all arguments.
self.__validate()
# convert color to hex where necessary.
if (Themes().is_rgb_hex(self.color)):
self.color = color
elif (Themes().is_color_name(self.color)):
self.color = Themes().colors[self.color]
def test_themes_B(self):
themes = dict()
default = dict()
default['primary'] = '#0044aa'
default['secondary'] = '#aaccff'
default['on-primary'] = '#d7eef4'
default['on-secondary'] = '#f9f9f9'
sun = dict()
sun['primary'] = '#d45500'
sun['secondary'] = '#ffccaa'
sun['on-primary'] = '#ffccaa'
sun['on-secondary'] = '#000000'
themes['default'] = default
themes['sun'] = sun
self.assertEqual(Themes().themes,
themes)
def test_colors_B(self): colors = dict() colors['default'] = '#000000' colors['black'] = '#000000' colors['white'] = '#ffffff' colors['red'] = '#ff0000' colors['lime'] = '#00ff00' colors['blue'] = '#0000ff' colors['yellow'] = '#ffff00' colors['cyan'] = '#00ffff' colors['aqua'] = '#00ffff' colors['magenta'] = '#ff00ff' colors['fuchsia'] = '#ff00ff' colors['silver'] = '#c0c0c0' colors['gray'] = '#808080' colors['grey'] = '#808080' colors['maroon'] = '#800000' colors['olive'] = '#808000' colors['green'] = '#008000' colors['purple'] = '#800080' colors['teal'] = '#008080' colors['navy'] = '#000080' self.assertEqual(Themes().colors, colors)
def test_is_rgb_hex_C(self): test_rgb_hex = '#1c1caa' self.assertTrue( Themes().is_rgb_hex(test_rgb_hex))
def test_is_rgb_hex_B(self): test_rgb_hex = '#4411bb' self.assertTrue( Themes().is_rgb_hex(test_rgb_hex))
def test___init__A(self): self.assertIsInstance( Themes(), Themes)
def test_is_color_name_G(self): color_name = "pink" self.assertFalse( Themes().is_color_name(color_name))
def test_colors_A(self): self.assertIsInstance( Themes().colors, dict)
def test_is_color_name_F(self): color_name = 897429 self.assertFalse( Themes().is_color_name(color_name))
def test_is_color_name_E(self): color_name = "lightgray" self.assertFalse( Themes().is_color_name(color_name))
def test_is_rgb_hex_F(self): test_rgb_hex = 'color1' self.assertFalse( Themes().is_rgb_hex(test_rgb_hex))
def generate_tile(self, data_item, min_value, max_value, theme):
''' generates a new tile of type Tile '''
# set some colors to use.
highColor = theme.palette["primary"]
lowColor = theme.palette["secondary"]
highColorDec = Themes().rgb_hex_to_decimal(highColor)
lowColorDec = Themes().rgb_hex_to_decimal(lowColor)
label = None
thereAreGroupings = self.grouping is not None
groupingHasColor = False
tileInGroup = False
if(thereAreGroupings):
tileInGroup = self.grouping.group(data_item.value) is not None
if(thereAreGroupings and tileInGroup):
groupingHasColor = self.grouping.group(data_item.value).color is not None
label = self.grouping.group(data_item.value).label
# first, check if tile groups available, with colors specified.
if(thereAreGroupings):
# there are groupings
if(tileInGroup):
# Current Tile is in group
if(groupingHasColor):
# grouping has color so just use specified color.
rgb = self.grouping.group(data_item.value).color
alpha = 1.0
else:
# grouping has no color, so use generated color
# based on the group's alpha.
alpha = self.grouping.alpha(data_item.value)
alpha_color = Themes().generate_alpha_rgb_bicolor(
highColorDec, lowColorDec, alpha)
rgb = Themes().decimal_to_rgb_hex(alpha_color)
else:
# there are no groupings, so generate alpha color
# as usual. This is the typical behavior.
alpha_color = Themes().generate_alpha_rgb_bicolor(
highColorDec,lowColorDec,self.calculate_rgb_alpha(
data_item.value, min_value, max_value))
rgb = Themes().decimal_to_rgb_hex(alpha_color)
alpha = self.calculate_rgb_alpha(data_item.value,
min_value, max_value)
elif(not thereAreGroupings):
# there are no groupings, so generate alpha color
# as usual. This is the typical behavior.
alpha_color = Themes().generate_alpha_rgb_bicolor(
highColorDec,lowColorDec,self.calculate_rgb_alpha(
data_item.value, min_value, max_value))
rgb = Themes().decimal_to_rgb_hex(alpha_color)
alpha = self.calculate_rgb_alpha(data_item.value,
min_value, max_value)
# create a dictionary for all Tile options.
tile_options = {
'value': data_item.value,
'alpha': alpha,
'rgb': rgb,
'label': label
}
# return a Tile object, passing the options too.
return Tile(tile_options)
def test_is_rgb_hex_D(self): test_rgb_hex = '#f190ac' self.assertTrue( Themes().is_rgb_hex(test_rgb_hex))
def test_decimal_to_rgb_hex_E(self): rgb_hex = "#aa44abc" self.assertRaises(TypeError, Themes().decimal_to_rgb_hex, rgb_hex)
def test_decimal_to_rgb_hex_F(self): rgb_hex = "aa44ff" self.assertRaises(TypeError, Themes().decimal_to_rgb_hex, rgb_hex)
def test_decimal_to_rgb_hex_G(self): rgb_hex = "blue" self.assertRaises(TypeError, Themes().decimal_to_rgb_hex, rgb_hex)
def test_decimal_to_rgb_hex_H(self): rgb_hex = 190 self.assertRaises(TypeError, Themes().decimal_to_rgb_hex, rgb_hex)
def test_is_rgb_hex_E(self): test_rgb_hex = '#45acbb' self.assertTrue( Themes().is_rgb_hex(test_rgb_hex))
def test_is_color_name_A(self): color_name = "green" self.assertTrue( Themes().is_color_name(color_name))
def test_is_rgb_hex_G(self): test_rgb_hex = '9018' self.assertFalse( Themes().is_rgb_hex(test_rgb_hex))
def test_is_color_name_C(self): color_name = "black" self.assertTrue( Themes().is_color_name(color_name))
def __init__(self, options=dict()):
''' Initialize a new engine '''
# determine the validity of arguments passed.
if('source' not in options):
raise TypeError("required argument 'source' \
not specified")
elif('title' not in options):
raise TypeError("required argument 'title' \
not specified")
elif(not isinstance("title", str)):
raise TypeError("argument 'title' must be \
of type 'str'")
elif('subtitle' not in options):
raise TypeError("required argument 'subtitle' \
not specified")
elif(not isinstance("subtitle", str)):
raise TypeError("argument 'subtitle' must \
be of type 'str'")
# determine data input source type and source
self.__source = options["source"]
self.__sourcetype = ""
# check if source is a filename
if(isinstance(self.__source,str) and len(
self.__source.split('.'))>1):
# check what type of file it is based on file
# type suffix '.'
filetype = self.__source.split('.')[-1]
if(filetype == "csv"):
self.__sourcetype = "csv"
else:
raise ValueError("source file type \
'"+filetype+"' not supported")
# check if source is a data grid
elif(isinstance(self.__source, DataGrid)):
self.__sourcetype = 'datagrid'
else:
# the source is not supported so raise exception.
raise TypeError("source type '"+\
type(self.__source)+"' not supported")
# set title and subtitle values
self.__title = options["title"]
self.__subtitle = options["subtitle"]
# set the optional arguments and their values.
# theme settings
if('theme' in options):
self.__theme = options["theme"]
else:
self.__theme = Theme()
# stylesheet settings
if('stylesheet' in options):
self.__stylesheet = options["stylesheet"]
else:
self.__stylesheet = StyleSheet()
# xaxis_title settings
if("xaxis_title" in options):
self.__xaxistitle = options["xaxis_title"]
else:
self.__xaxistitle = ""
# yaxis_title settings
if("yaxis_title" in options):
self.__yaxistitle = options["yaxis_title"]
else:
self.__yaxistitle = ""
# xaxis_labels settings
if("xaxis_labels" in options):
self.__xaxislabels = options['xaxis_labels']
else:
self.__xaxislabels = None
# yaxis_labels settings
if("yaxis_labels" in options):
self.__yaxislabels = options['yaxis_labels']
else:
self.__yaxislabels = None
# rowcol_headers settings
if("rowcol_headers" in options):
self.__rowcolheaders = options["rowcol_headers"]
else:
self.__rowcolheaders = True
# data_formatter settings
if("data_formatter" in options):
if(not isinstance(options["data_formatter"],
DataFormatter)):
raise TypeError("argument 'data_formatter' must be of type 'DataFormatter'")
self.__data_formatter = options["data_formatter"]
else:
self.__data_formatter = None
# grouping settings.
if('grouping' in options):
if(not isinstance(options['grouping'], TileGroups)):
raise TypeError("argument 'grouping' must be of type 'TileGroup'")
else:
self.__grouping = options['grouping']
else:
self.__grouping = None
# set dictionary of available colors and themes
# for reference.
self.__colors = Themes().colors
self.__themes = Themes().themes
def test_is_color_name_D(self): color_name = "purple" self.assertTrue( Themes().is_color_name(color_name))