From bda9d73b0fea05fbce9d431cdf26361a94722915 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 00:33:02 +0100 Subject: [PATCH 01/13] created setup.py created the setup.py script witch is used by pypi to create the reposetory --- LICENSE.txt | 10 ++ TableIt.py => TableIt/__init__.py | 272 +++++++++++++++--------------- make.bat | 6 + setup.py | 31 ++++ 4 files changed, 183 insertions(+), 136 deletions(-) create mode 100644 LICENSE.txt rename TableIt.py => TableIt/__init__.py (98%) create mode 100644 make.bat create mode 100644 setup.py diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..c216e79 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,10 @@ +BEAST OPENSOURCE LICENSE +version 1.0, 20 february 2020 + +TERMS AND CONDITIONS + +Any person is hereby granted permission to download, copy, compile, or study the source code for learning purposes. However, no person is +allowed to sell, or distribute this code for any purpose. Modification is allowed as long as it is only for personal use and will never be +redistributed in any way. Permission to use this code within a larger project may be allowed with the written consent of the author of this project which this license is placed upon. + +END OF TERMS AND CONDITIONS \ No newline at end of file diff --git a/TableIt.py b/TableIt/__init__.py similarity index 98% rename from TableIt.py rename to TableIt/__init__.py index 6f6bbb5..4a42328 100644 --- a/TableIt.py +++ b/TableIt/__init__.py @@ -1,136 +1,136 @@ -import os -import math -import random - -def initColors(): - os.system("cls") - -def findLargestElement(rows, cols, lengthArray, matrix): - # Loop through each row - for i in range(rows): - # Loop through each column - for j in range(cols): - lengthArray.append(len(str(matrix[i][j]))) - # Sort the length matrix so that we can find the element with the longest length - lengthArray.sort() - # Store that length - largestElementLength = lengthArray[-1] - - return largestElementLength - - -def createMatrix(rows, cols, matrixToWorkOn, matrix): - # Loop through each row - for i in range(rows): - # Append a row to matrixToWorkOn for each row in the matrix passed in - matrixToWorkOn.append([]) - # Loop through each column - for j in range(cols): - # Add a each column of the current row (in string form) to matrixToWorkOn - matrixToWorkOn[i].append(str(matrix[i][j])) - -def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color): - - # Loop through each row - for i in range(rows): - # Initialize the row that will we work on currently as a blank string - currentRow = "" - # Loop trhough each column - for j in range(cols): - # If we are using colors then do the same thing but as without (below) - if ((color != None) and (j == 0 or i == 0)): - # Only add color if it is in the first column or first row - currentEl = " " + "\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) +"m" + matrixToWorkOn[i][j] + "\033[0m" - # If we are not using colors (or j != 0 or i != 0) just add a space and the element that should be in that position to a variable which will store the current element to work on - else: - currentEl = " " + matrixToWorkOn[i][j] - - # If the raw element is less than the largest length of a raw element (raw element is just the unformatted element passed in) - if (largestElementLength != len(matrixToWorkOn[i][j])): - # If we are using colors then add the amount of spaces that is equal to the difference of the largest element length and the current element (minus the length that is added for the color) - # * The plus two here comes from the one space we would normally need and the fact that we need to account for a space that tbe current element already has - if (color != None): - if (j == 0 or i == 0): - currentEl = currentEl + " " * (largestElementLength - (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m")) + 2) + "|" - # If it is not the first column or first row than it doesn't need to subtract the color length - else: - currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" - # If we are not using color just do the same thing as above when we were using colors for when the row or column is not the first each time - else: - currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" - # If the raw element length us equal to the largest length of a raw element then we don't need to add extra spaces - else: - currentEl = currentEl + " " + "|" - # Now add the current element to the row that we are working on - currentRow += currentEl - # When the entire row that we were working on is done add it as a row to the final table that we will print - finalTable.append("|" + currentRow) - # If we are using color then the length of each row (each row will end up being the same length) equals to the length of the last row (again each row will end up being the same length) minus the length the color will inevitably add if we are using colors - if (color != None): - rowLength = len(currentRow) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m") - # Otherwise (we are not using colors) the length of each row will be equal to the length of the last row (each row will end up being the same length) - else: - rowLength = len(currentRow) - - return rowLength - -def createWrappingRows(rowLength, finalTable): - # Here we deal with the rows that will go on the top and bottom of the table (look like -> +--------------+), we start by initializing an empty string - wrappingRows = "" - # Then for the length of each row minus one (have to account for the plus that comes at the end, not minus two because rowLength doesn't include the | at the beginning) we add a - - for i in range(rowLength - 1): - wrappingRows += "-" - # Add a plus at the beginning - wrappingRows = "+" + wrappingRows - # Add a plus at the end - wrappingRows += "+" - - # Add the two wrapping rows - finalTable.insert(0, wrappingRows) - finalTable.append(wrappingRows) - -def createRowUnderFields(largestElementLength, cols, finalTable): - # Initialize the row that will be created - rowUnderFields = "" - # Loop through each column - for j in range(cols): - # For each column add a plus - currentElUnderField = "+" - # Then add an amount of -'s equal to the length of largest raw element and add 2 for the 2 spaces that will be either side the element - currentElUnderField = currentElUnderField + "-" * (largestElementLength + 2) - # Then add the current element (there will be one for each column) to the final row that will be under the fields - rowUnderFields += currentElUnderField - # Add a final plus at the end of the row - rowUnderFields += "+" - # Insert this row under the first row - finalTable.insert(2, rowUnderFields) - - -def printRowsInTable(finalTable): - # For each row - print it - for row in finalTable: - print(row) - -def printTable(matrix, useFieldNames=False, color=None): - # Rows equal amount of lists inside greater list - rows = len(matrix) - # Cols equal amount of elements inside each list - cols = len(matrix[0]) - # This is the array to sort the length of each element - lengthArray = [] - # This is the variable to store the vakye of the largest length of any element - largestElementLength = None - #This is the variable that will store the length of each row - rowLength = None - # This is the matrix that we will work with throughout this program (main difference between matrix passed in and this matrix is that the matrix that is passed in doesn't always have elements which are all strings) - matrixToWorkOn = [] - #This the list in which each row will be one of the final table to be printed - finalTable = [] - - largestElementLength = findLargestElement(rows, cols, lengthArray, matrix) - createMatrix(rows, cols, matrixToWorkOn, matrix) - rowLength = makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color) - createWrappingRows(rowLength, finalTable) - if (useFieldNames): - createRowUnderFields(largestElementLength, cols, finalTable) - printRowsInTable(finalTable) +import os +import math +import random + +def initColors(): + os.system("cls") + +def findLargestElement(rows, cols, lengthArray, matrix): + # Loop through each row + for i in range(rows): + # Loop through each column + for j in range(cols): + lengthArray.append(len(str(matrix[i][j]))) + # Sort the length matrix so that we can find the element with the longest length + lengthArray.sort() + # Store that length + largestElementLength = lengthArray[-1] + + return largestElementLength + + +def createMatrix(rows, cols, matrixToWorkOn, matrix): + # Loop through each row + for i in range(rows): + # Append a row to matrixToWorkOn for each row in the matrix passed in + matrixToWorkOn.append([]) + # Loop through each column + for j in range(cols): + # Add a each column of the current row (in string form) to matrixToWorkOn + matrixToWorkOn[i].append(str(matrix[i][j])) + +def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color): + + # Loop through each row + for i in range(rows): + # Initialize the row that will we work on currently as a blank string + currentRow = "" + # Loop trhough each column + for j in range(cols): + # If we are using colors then do the same thing but as without (below) + if ((color != None) and (j == 0 or i == 0)): + # Only add color if it is in the first column or first row + currentEl = " " + "\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) +"m" + matrixToWorkOn[i][j] + "\033[0m" + # If we are not using colors (or j != 0 or i != 0) just add a space and the element that should be in that position to a variable which will store the current element to work on + else: + currentEl = " " + matrixToWorkOn[i][j] + + # If the raw element is less than the largest length of a raw element (raw element is just the unformatted element passed in) + if (largestElementLength != len(matrixToWorkOn[i][j])): + # If we are using colors then add the amount of spaces that is equal to the difference of the largest element length and the current element (minus the length that is added for the color) + # * The plus two here comes from the one space we would normally need and the fact that we need to account for a space that tbe current element already has + if (color != None): + if (j == 0 or i == 0): + currentEl = currentEl + " " * (largestElementLength - (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m")) + 2) + "|" + # If it is not the first column or first row than it doesn't need to subtract the color length + else: + currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" + # If we are not using color just do the same thing as above when we were using colors for when the row or column is not the first each time + else: + currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" + # If the raw element length us equal to the largest length of a raw element then we don't need to add extra spaces + else: + currentEl = currentEl + " " + "|" + # Now add the current element to the row that we are working on + currentRow += currentEl + # When the entire row that we were working on is done add it as a row to the final table that we will print + finalTable.append("|" + currentRow) + # If we are using color then the length of each row (each row will end up being the same length) equals to the length of the last row (again each row will end up being the same length) minus the length the color will inevitably add if we are using colors + if (color != None): + rowLength = len(currentRow) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m") + # Otherwise (we are not using colors) the length of each row will be equal to the length of the last row (each row will end up being the same length) + else: + rowLength = len(currentRow) + + return rowLength + +def createWrappingRows(rowLength, finalTable): + # Here we deal with the rows that will go on the top and bottom of the table (look like -> +--------------+), we start by initializing an empty string + wrappingRows = "" + # Then for the length of each row minus one (have to account for the plus that comes at the end, not minus two because rowLength doesn't include the | at the beginning) we add a - + for i in range(rowLength - 1): + wrappingRows += "-" + # Add a plus at the beginning + wrappingRows = "+" + wrappingRows + # Add a plus at the end + wrappingRows += "+" + + # Add the two wrapping rows + finalTable.insert(0, wrappingRows) + finalTable.append(wrappingRows) + +def createRowUnderFields(largestElementLength, cols, finalTable): + # Initialize the row that will be created + rowUnderFields = "" + # Loop through each column + for j in range(cols): + # For each column add a plus + currentElUnderField = "+" + # Then add an amount of -'s equal to the length of largest raw element and add 2 for the 2 spaces that will be either side the element + currentElUnderField = currentElUnderField + "-" * (largestElementLength + 2) + # Then add the current element (there will be one for each column) to the final row that will be under the fields + rowUnderFields += currentElUnderField + # Add a final plus at the end of the row + rowUnderFields += "+" + # Insert this row under the first row + finalTable.insert(2, rowUnderFields) + + +def printRowsInTable(finalTable): + # For each row - print it + for row in finalTable: + print(row) + +def printTable(matrix, useFieldNames=False, color=None): + # Rows equal amount of lists inside greater list + rows = len(matrix) + # Cols equal amount of elements inside each list + cols = len(matrix[0]) + # This is the array to sort the length of each element + lengthArray = [] + # This is the variable to store the vakye of the largest length of any element + largestElementLength = None + #This is the variable that will store the length of each row + rowLength = None + # This is the matrix that we will work with throughout this program (main difference between matrix passed in and this matrix is that the matrix that is passed in doesn't always have elements which are all strings) + matrixToWorkOn = [] + #This the list in which each row will be one of the final table to be printed + finalTable = [] + + largestElementLength = findLargestElement(rows, cols, lengthArray, matrix) + createMatrix(rows, cols, matrixToWorkOn, matrix) + rowLength = makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color) + createWrappingRows(rowLength, finalTable) + if (useFieldNames): + createRowUnderFields(largestElementLength, cols, finalTable) + printRowsInTable(finalTable) diff --git a/make.bat b/make.bat new file mode 100644 index 0000000..5b31dc7 --- /dev/null +++ b/make.bat @@ -0,0 +1,6 @@ +@echo off +call cls +echo.running setup +echo. + +python36 setup.py sdist \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..a73d604 --- /dev/null +++ b/setup.py @@ -0,0 +1,31 @@ +from setuptools import setup, find_packages + +with open("README.md") as mdfile: + long_description = mdfile.read() + +with open("LICENSE.txt") as mdfile: + lisence = mdfile.read() + + +setup( + name = "TableIt", + packages = ["TableIt"], + version="0.0.0", + description="", + long_description = long_description, + author = "SuperMaZingCoder", + url = "https://github.com/SuperMaZingCoder/TableIt", + keywords = ["tables"], + + license=lisence, + + classifiers=[ + "Development Status :: 6 - Mature", + "Framework :: IDLE", + "Intended Audience :: Developers", + "Natural Language :: English", + "Programming Language :: Python :: 3.0", + "Topic :: Printing", + + ] +) \ No newline at end of file From 99a6d849b878133c3db4a19298a0da926a61169a Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 00:40:54 +0100 Subject: [PATCH 02/13] removed LICENSE.txt --- LICENSE.txt | 10 ---------- setup.py | 4 ++-- 2 files changed, 2 insertions(+), 12 deletions(-) delete mode 100644 LICENSE.txt diff --git a/LICENSE.txt b/LICENSE.txt deleted file mode 100644 index c216e79..0000000 --- a/LICENSE.txt +++ /dev/null @@ -1,10 +0,0 @@ -BEAST OPENSOURCE LICENSE -version 1.0, 20 february 2020 - -TERMS AND CONDITIONS - -Any person is hereby granted permission to download, copy, compile, or study the source code for learning purposes. However, no person is -allowed to sell, or distribute this code for any purpose. Modification is allowed as long as it is only for personal use and will never be -redistributed in any way. Permission to use this code within a larger project may be allowed with the written consent of the author of this project which this license is placed upon. - -END OF TERMS AND CONDITIONS \ No newline at end of file diff --git a/setup.py b/setup.py index a73d604..9772040 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ with open("README.md") as mdfile: long_description = mdfile.read() -with open("LICENSE.txt") as mdfile: +with open("LICENSE") as mdfile: lisence = mdfile.read() @@ -26,6 +26,6 @@ "Natural Language :: English", "Programming Language :: Python :: 3.0", "Topic :: Printing", - + ] ) \ No newline at end of file From f94c5f7b9fb2e9cb46a9be1f20631b5842d042a5 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 01:29:45 +0100 Subject: [PATCH 03/13] added 593 default colors --- .gitignore | 4 + TableIt/__init__.py | 1 + TableIt/colors.py | 593 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 598 insertions(+) create mode 100644 TableIt/colors.py diff --git a/.gitignore b/.gitignore index b6e4761..9aa5817 100644 --- a/.gitignore +++ b/.gitignore @@ -127,3 +127,7 @@ dmypy.json # Pyre type checker .pyre/ + +#batches and tests +make.bat +test.py diff --git a/TableIt/__init__.py b/TableIt/__init__.py index 4a42328..0bd9d73 100644 --- a/TableIt/__init__.py +++ b/TableIt/__init__.py @@ -1,6 +1,7 @@ import os import math import random +from . import colors def initColors(): os.system("cls") diff --git a/TableIt/colors.py b/TableIt/colors.py new file mode 100644 index 0000000..9dbcbff --- /dev/null +++ b/TableIt/colors.py @@ -0,0 +1,593 @@ +AliceBlue = (240, 248, 255) +AntiqueWhite = (250, 235, 215) +AntiqueWhite1 = (255, 239, 219) +AntiqueWhite2 = (238, 223, 204) +AntiqueWhite3 = (205, 192, 176) +AntiqueWhite4 = (139, 131, 120) +agua = (0, 255, 255) +aquamarine = (127, 255, 212) +aquamarine1 = (127, 255, 212) +aquamarine2 = (118, 238, 198) +aquamarine3 = (102, 205, 170) +aquamarine4 = (69, 139, 116) +azure = (240, 255, 255) +azure1 = (240, 255, 255) +azure2 = (224, 238, 238) +azure3 = (193, 205, 205) +azure4 = (131, 139, 139) +beige = (245, 245, 220) +bisque = (255, 228, 196) +bisque1 = (255, 228, 196) +bisque2 = (238, 213, 183) +bisque3 = (205, 183, 158) +bisque4 = (139, 125, 107) +black = (0, 0, 0) +BlanchedAlmond = (255, 235, 205) +blue = (0, 0, 255) +blue_violet = (138, 43, 226) +blue1 = (0, 0, 255) +blue2 = (0, 0, 238) +blue3 = (0, 0, 205) +blue4 = (0, 0, 139) +BlueViolet = (138, 43, 226) +brown = (165, 42, 42) +brown1 = (255, 64, 64) +brown2 = (238, 59, 59) +brown3 = (205, 51, 51) +brown4 = (139, 35, 35) +burlywood = (222, 184, 135) +burlywood1 = (255, 211, 155) +burlywood2 = (238, 197, 145) +burlywood3 = (205, 170, 125) +burlywood4 = (139, 115, 85) +cadet_blue = (95, 158, 160) +CadetBlue = (95, 158, 160) +CadetBlue1 = (152, 245, 255) +CadetBlue2 = (142, 229, 238) +CadetBlue3 = (122, 197, 205) +CadetBlue4 = (83, 134, 139) +chartreuse = (127, 255, 0) +chartreuse1 = (127, 255, 0) +chartreuse2 = (118, 238, 0) +chartreuse3 = (102, 205, 0) +chartreuse4 = (69, 139, 0) +chocolate = (210, 105, 30) +chocolate1 = (255, 127, 36) +chocolate2 = (238, 118, 33) +chocolate3 = (205, 102, 29) +chocolate4 = (139, 69, 19) +coral = (255, 127, 80) +coral1 = (255, 114, 86) +coral2 = (238, 106, 80) +coral3 = (205, 91, 69) +coral4 = (139, 62, 47) +cornflower_blue = (100, 149, 237) +CornflowerBlue = (100, 149, 237) +cornsilk = (255, 248, 220) +cornsilk1 = (255, 248, 220) +cornsilk2 = (238, 232, 205) +cornsilk3 = (205, 200, 177) +cornsilk4 = (139, 136, 120) +crymson = (220, 20, 60) +cyan = (0, 255, 255) +cyan1 = (0, 255, 255) +cyan2 = (0, 238, 238) +cyan3 = (0, 205, 205) +cyan4 = (0, 139, 139) +dark_blue = (0, 0, 139) +dark_cyan = (0, 139, 139) +dark_goldenrod = (184, 134, 11) +dark_gray = (169, 169, 169) +dark_green = (0, 100, 0) +dark_grey = (169, 169, 169) +dark_khaki = (189, 183, 107) +dark_magenta = (139, 0, 139) +dark_olive_green = (85, 107, 47) +dark_orange = (255, 140, 0) +dark_orchid = (153, 50, 204) +dark_red = (139, 0, 0) +dark_salmon = (233, 150, 122) +dark_sea_green = (143, 188, 143) +dark_slate_blue = (72, 61, 139) +dark_slate_gray = (47, 79, 79) +dark_slate_grey = (47, 79, 79) +dark_turquoise = (0, 206, 209) +dark_violet = (148, 0, 211) +DarkBlue = (0, 0, 139) +DarkCyan = (0, 139, 139) +DarkGoldenrod = (184, 134, 11) +DarkGoldenrod1 = (255, 185, 15) +DarkGoldenrod2 = (238, 173, 14) +DarkGoldenrod3 = (205, 149, 12) +DarkGoldenrod4 = (139, 101, 8) +DarkGray = (169, 169, 169) +DarkGreen = (0, 100, 0) +DarkGrey = (169, 169, 169) +DarkKhaki = (189, 183, 107) +DarkMagenta = (139, 0, 139) +DarkOliveGreen = (85, 107, 47) +DarkOliveGreen1 = (202, 255, 112) +DarkOliveGreen2 = (188, 238, 104) +DarkOliveGreen3 = (162, 205, 90) +DarkOliveGreen4 = (110, 139, 61) +DarkOrange = (255, 140, 0) +DarkOrange1 = (255, 127, 0) +DarkOrange2 = (238, 118, 0) +DarkOrange3 = (205, 102, 0) +DarkOrange4 = (139, 69, 0) +DarkOrchid = (153, 50, 204) +DarkOrchid1 = (191, 62, 255) +DarkOrchid2 = (178, 58, 238) +DarkOrchid3 = (154, 50, 205) +DarkOrchid4 = (104, 34, 139) +DarkRed = (139, 0, 0) +DarkSalmon = (233, 150, 122) +DarkSeaGreen = (143, 188, 143) +DarkSeaGreen1 = (193, 255, 193) +DarkSeaGreen2 = (180, 238, 180) +DarkSeaGreen3 = (155, 205, 155) +DarkSeaGreen4 = (105, 139, 105) +DarkSlateBlue = (72, 61, 139) +DarkSlateGray = (47, 79, 79) +DarkSlateGray1 = (151, 255, 255) +DarkSlateGray2 = (141, 238, 238) +DarkSlateGray3 = (121, 205, 205) +DarkSlateGray4 = (82, 139, 139) +DarkSlateGrey = (47, 79, 79) +DarkTurquoise = (0, 206, 209) +DarkViolet = (148, 0, 211) +deep_pink = (255, 20, 147) +deep_sky_blue = (0, 191, 255) +DeepPink = (255, 20, 147) +DeepPink1 = (255, 20, 147) +DeepPink2 = (238, 18, 137) +DeepPink3 = (205, 16, 118) +DeepPink4 = (139, 10, 80) +DeepSkyBlue = (0, 191, 255) +DeepSkyBlue1 = (0, 191, 255) +DeepSkyBlue2 = (0, 178, 238) +DeepSkyBlue3 = (0, 154, 205) +DeepSkyBlue4 = (0, 104, 139) +dim_gray = (105, 105, 105) +dim_grey = (105, 105, 105) +DimGray = (105, 105, 105) +DimGrey = (105, 105, 105) +dodger_blue = (30, 144, 255) +DodgerBlue = (30, 144, 255) +DodgerBlue1 = (30, 144, 255) +DodgerBlue2 = (28, 134, 238) +DodgerBlue3 = (24, 116, 205) +DodgerBlue4 = (16, 78, 139) +firebrick = (178, 34, 34) +firebrick1 = (255, 48, 48) +firebrick2 = (238, 44, 44) +firebrick3 = (205, 38, 38) +firebrick4 = (139, 26, 26) +floral_white = (255, 250, 240) +FloralWhite = (255, 250, 240) +forest_green = (34, 139, 34) +ForestGreen = (34, 139, 34) +fuchsia = (255, 0, 255) +gainsboro = (220, 220, 220) +ghost_white = (248, 248, 255) +GhostWhite = (248, 248, 255) +gold = (255, 215, 0) +gold1 = (255, 215, 0) +gold2 = (238, 201, 0) +gold3 = (205, 173, 0) +gold4 = (139, 117, 0) +goldenrod = (218, 165, 32) +goldenrod1 = (255, 193, 37) +goldenrod2 = (238, 180, 34) +goldenrod3 = (205, 155, 29) +goldenrod4 = (139, 105, 20) +gray = (128, 128, 128) +gray0 = (0, 0, 0) +gray1 = (3, 3, 3) +gray2 = (5, 5, 5) +gray3 = (8, 8, 8) +gray4 = (10, 10, 10) +gray5 = (13, 13, 13) +gray6 = (15, 15, 15) +gray7 = (18, 18, 18) +gray8 = (20, 20, 20) +gray9 = (23, 23, 23) +gray10 = (26, 26, 26) +gray11 = (28, 28, 28) +gray12 = (31, 31, 31) +gray13 = (33, 33, 33) +gray14 = (36, 36, 36) +gray15 = (38, 38, 38) +gray16 = (41, 41, 41) +gray17 = (43, 43, 43) +gray18 = (46, 46, 46) +gray19 = (48, 48, 48) +gray20 = (51, 51, 51) +gray21 = (54, 54, 54) +gray22 = (56, 56, 56) +gray23 = (59, 59, 59) +gray24 = (61, 61, 61) +gray25 = (64, 64, 64) +gray26 = (66, 66, 66) +gray27 = (69, 69, 69) +gray28 = (71, 71, 71) +gray29 = (74, 74, 74) +gray30 = (77, 77, 77) +gray31 = (79, 79, 79) +gray32 = (82, 82, 82) +gray33 = (84, 84, 84) +gray34 = (87, 87, 87) +gray35 = (89, 89, 89) +gray36 = (92, 92, 92) +gray37 = (94, 94, 94) +gray38 = (97, 97, 97) +gray39 = (99, 99, 99) +gray40 = (102, 102, 102) +gray41 = (105, 105, 105) +gray42 = (107, 107, 107) +gray43 = (110, 110, 110) +gray44 = (112, 112, 112) +gray45 = (115, 115, 115) +gray46 = (117, 117, 117) +gray47 = (120, 120, 120) +gray48 = (122, 122, 122) +gray49 = (125, 125, 125) +gray50 = (127, 127, 127) +gray51 = (130, 130, 130) +gray52 = (133, 133, 133) +gray53 = (135, 135, 135) +gray54 = (138, 138, 138) +gray55 = (140, 140, 140) +gray56 = (143, 143, 143) +gray57 = (145, 145, 145) +gray58 = (148, 148, 148) +gray59 = (150, 150, 150) +gray60 = (153, 153, 153) +gray61 = (156, 156, 156) +gray62 = (158, 158, 158) +gray63 = (161, 161, 161) +gray64 = (163, 163, 163) +gray65 = (166, 166, 166) +gray66 = (168, 168, 168) +gray67 = (171, 171, 171) +gray68 = (173, 173, 173) +gray69 = (176, 176, 176) +gray70 = (179, 179, 179) +gray71 = (181, 181, 181) +gray72 = (184, 184, 184) +gray73 = (186, 186, 186) +gray74 = (189, 189, 189) +gray75 = (191, 191, 191) +gray76 = (194, 194, 194) +gray77 = (196, 196, 196) +gray78 = (199, 199, 199) +gray79 = (201, 201, 201) +gray80 = (204, 204, 204) +gray81 = (207, 207, 207) +gray82 = (209, 209, 209) +gray83 = (212, 212, 212) +gray84 = (214, 214, 214) +gray85 = (217, 217, 217) +gray86 = (219, 219, 219) +gray87 = (222, 222, 222) +gray88 = (224, 224, 224) +gray89 = (227, 227, 227) +gray90 = (229, 229, 229) +gray91 = (232, 232, 232) +gray92 = (235, 235, 235) +gray93 = (237, 237, 237) +gray94 = (240, 240, 240) +gray95 = (242, 242, 242) +gray96 = (245, 245, 245) +gray97 = (247, 247, 247) +gray98 = (250, 250, 250) +gray99 = (252, 252, 252) +gray100 = (255, 255, 255) +green = (0, 128, 0) +green_yellow = (173, 255, 47) +green1 = (0, 255, 0) +green2 = (0, 238, 0) +green3 = (0, 205, 0) +green4 = (0, 139, 0) +GreenYellow = (173, 255, 47) +grey = (128, 128, 128) +grey0 = (0, 0, 0) +grey1 = (3, 3, 3) +grey2 = (5, 5, 5) +grey3 = (8, 8, 8) +grey4 = (10, 10, 10) +grey5 = (13, 13, 13) +grey6 = (15, 15, 15) +grey7 = (18, 18, 18) +grey8 = (20, 20, 20) +grey9 = (23, 23, 23) +grey10 = (26, 26, 26) +grey11 = (28, 28, 28) +grey12 = (31, 31, 31) +grey13 = (33, 33, 33) +grey14 = (36, 36, 36) +grey15 = (38, 38, 38) +grey16 = (41, 41, 41) +grey17 = (43, 43, 43) +grey18 = (46, 46, 46) +grey19 = (48, 48, 48) +grey20 = (51, 51, 51) +grey21 = (54, 54, 54) +grey22 = (56, 56, 56) +grey23 = (59, 59, 59) +grey24 = (61, 61, 61) +grey25 = (64, 64, 64) +grey26 = (66, 66, 66) +grey27 = (69, 69, 69) +grey28 = (71, 71, 71) +grey29 = (74, 74, 74) +grey30 = (77, 77, 77) +grey31 = (79, 79, 79) +grey32 = (82, 82, 82) +grey33 = (84, 84, 84) +grey34 = (87, 87, 87) +grey35 = (89, 89, 89) +grey36 = (92, 92, 92) +grey37 = (94, 94, 94) +grey38 = (97, 97, 97) +grey39 = (99, 99, 99) +grey40 = (102, 102, 102) +grey41 = (105, 105, 105) +grey42 = (107, 107, 107) +grey43 = (110, 110, 110) +grey44 = (112, 112, 112) +grey45 = (115, 115, 115) +grey46 = (117, 117, 117) +grey47 = (120, 120, 120) +grey48 = (122, 122, 122) +grey49 = (125, 125, 125) +grey50 = (127, 127, 127) +grey51 = (130, 130, 130) +grey52 = (133, 133, 133) +grey53 = (135, 135, 135) +grey54 = (138, 138, 138) +grey55 = (140, 140, 140) +grey56 = (143, 143, 143) +grey57 = (145, 145, 145) +grey58 = (148, 148, 148) +grey59 = (150, 150, 150) +grey60 = (153, 153, 153) +grey61 = (156, 156, 156) +grey62 = (158, 158, 158) +grey63 = (161, 161, 161) +grey64 = (163, 163, 163) +grey65 = (166, 166, 166) +grey66 = (168, 168, 168) +grey67 = (171, 171, 171) +grey68 = (173, 173, 173) +grey69 = (176, 176, 176) +grey70 = (179, 179, 179) +grey71 = (181, 181, 181) +grey72 = (184, 184, 184) +grey73 = (186, 186, 186) +grey74 = (189, 189, 189) +grey75 = (191, 191, 191) +grey76 = (194, 194, 194) +grey77 = (196, 196, 196) +grey78 = (199, 199, 199) +grey79 = (201, 201, 201) +grey80 = (204, 204, 204) +grey81 = (207, 207, 207) +grey82 = (209, 209, 209) +grey83 = (212, 212, 212) +grey84 = (214, 214, 214) +grey85 = (217, 217, 217) +grey86 = (219, 219, 219) +grey87 = (222, 222, 222) +grey88 = (224, 224, 224) +grey89 = (227, 227, 227) +grey90 = (229, 229, 229) +grey91 = (232, 232, 232) +grey92 = (235, 235, 235) +grey93 = (237, 237, 237) +grey94 = (240, 240, 240) +grey95 = (242, 242, 242) +grey96 = (245, 245, 245) +grey97 = (247, 247, 247) +grey98 = (250, 250, 250) +grey99 = (252, 252, 252) +grey100 = (255, 255, 255) +honeydew = (240, 255, 240) +honeydew1 = (240, 255, 240) +honeydew2 = (224, 238, 224) +honeydew3 = (193, 205, 193) +honeydew4 = (131, 139, 131) +hot_pink = (255, 105, 180) +HotPink = (255, 105, 180) +HotPink1 = (255, 110, 180) +HotPink2 = (238, 106, 167) +HotPink3 = (205, 96, 144) +HotPink4 = (139, 58, 98) +indian_red = (205, 92, 92) +IndianRed = (205, 92, 92) +IndianRed1 = (255, 106, 106) +IndianRed2 = (238, 99, 99) +IndianRed3 = (205, 85, 85) +IndianRed4 = (139, 58, 58) +indigo = (75, 0, 130) +ivory = (255, 255, 240) +ivory1 = (255, 255, 240) +ivory2 = (238, 238, 224) +ivory3 = (205, 205, 193) +ivory4 = (139, 139, 131) +khaki = (240, 230, 140) +khaki1 = (255, 246, 143) +khaki2 = (238, 230, 133) +khaki3 = (205, 198, 115) +khaki4 = (139, 134, 78) +lavender = (230, 230, 250) +lavender_blush = (255, 240, 245) +LavenderBlush = (255, 240, 245) +LavenderBlush1 = (255, 240, 245) +LavenderBlush2 = (238, 224, 229) +LavenderBlush3 = (205, 193, 197) +LavenderBlush4 = (139, 131, 134) +lawn_green = (124, 252, 0) +LawnGreen = (124, 252, 0) +lemon_chiffon = (255, 250, 205) +LemonChiffon = (255, 250, 205) +LemonChiffon1 = (255, 250, 205) +LemonChiffon2 = (238, 233, 191) +LemonChiffon3 = (205, 201, 165) +LemonChiffon4 = (139, 137, 112) +light_blue = (173, 216, 230) +light_coral = (240, 128, 128) +light_cyan = (224, 255, 255) +light_goldenrod = (238, 221, 130) +light_goldenrod_yellow = (250, 250, 210) +light_gray = (211, 211, 211) +light_green = (144, 238, 144) +light_grey = (211, 211, 211) +light_pink = (255, 182, 193) +light_salmon = (255, 160, 122) +light_sea_green = (32, 178, 170) +light_sky_blue = (135, 206, 250) +light_slate_blue = (132, 112, 255) +light_slate_gray = (119, 136, 153) +light_slate_grey = (119, 136, 153) +light_steel_blue = (176, 196, 222) +light_yellow = (255, 255, 224) +LightBlue = (173, 216, 230) +LightBlue1 = (191, 239, 255) +LightBlue2 = (178, 223, 238) +LightBlue3 = (154, 192, 205) +LightBlue4 = (104, 131, 139) +LightCoral = (240, 128, 128) +LightCyan = (224, 255, 255) +LightCyan1 = (224, 255, 255) +LightCyan2 = (209, 238, 238) +LightCyan3 = (180, 205, 205) +LightCyan4 = (122, 139, 139) +LightGoldenrod = (238, 221, 130) +LightGoldenrod1 = (255, 236, 139) +LightGoldenrod2 = (238, 220, 130) +LightGoldenrod3 = (205, 190, 112) +LightGoldenrod4 = (139, 129, 76) +LightGoldenrodYellow = (250, 250, 210) +LightGray = (211, 211, 211) +LightGreen = (144, 238, 144) +LightGrey = (211, 211, 211) +LightPink = (255, 182, 193) +LightPink1 = (255, 174, 185) +LightPink2 = (238, 162, 173) +LightPink3 = (205, 140, 149) +LightPink4 = (139, 95, 101) +LightSalmon = (255, 160, 122) +LightSalmon1 = (255, 160, 122) +LightSalmon2 = (238, 149, 114) +LightSalmon3 = (205, 129, 98) +LightSalmon4 = (139, 87, 66) +LightSeaGreen = (32, 178, 170) +LightSkyBlue = (135, 206, 250) +LightSkyBlue1 = (176, 226, 255) +LightSkyBlue2 = (164, 211, 238) +LightSkyBlue3 = (141, 182, 205) +LightSkyBlue4 = (96, 123, 139) +LightSlateBlue = (132, 112, 255) +LightSlateGray = (119, 136, 153) +LightSlateGrey = (119, 136, 153) +LightSteelBlue = (176, 196, 222) +LightSteelBlue1 = (202, 225, 255) +LightSteelBlue2 = (188, 210, 238) +LightSteelBlue3 = (162, 181, 205) +LightSteelBlue4 = (110, 123, 139) +LightYellow = (255, 255, 224) +LightYellow1 = (255, 255, 224) +LightYellow2 = (238, 238, 209) +LightYellow3 = (205, 205, 180) +LightYellow4 = (139, 139, 122) +lime = (0, 255, 0) +lime_green = (50, 205, 50) +LimeGreen = (50, 205, 50) +linen = (250, 240, 230) +magenta = (255, 0, 255) +magenta1 = (255, 0, 255) +magenta2 = (238, 0, 238) +magenta3 = (205, 0, 205) +magenta4 = (139, 0, 139) +maroon = (128, 0, 0) +maroon1 = (255, 52, 179) +maroon2 = (238, 48, 167) +maroon3 = (205, 41, 144) +maroon4 = (139, 28, 98) +medium_aquamarine = (102, 205, 170) +medium_blue = (0, 0, 205) +medium_orchid = (186, 85, 211) +medium_purple = (147, 112, 219) +medium_sea_green = (60, 179, 113) +medium_slate_blue = (123, 104, 238) +medium_spring_green = (0, 250, 154) +medium_turquoise = (72, 209, 204) +medium_violet_red = (199, 21, 133) +MediumAquamarine = (102, 205, 170) +MediumBlue = (0, 0, 205) +MediumOrchid = (186, 85, 211) +MediumOrchid1 = (224, 102, 255) +MediumOrchid2 = (209, 95, 238) +MediumOrchid3 = (180, 82, 205) +MediumOrchid4 = (122, 55, 139) +MediumPurple = (147, 112, 219) +MediumPurple1 = (171, 130, 255) +MediumPurple2 = (159, 121, 238) +MediumPurple3 = (137, 104, 205) +MediumPurple4 = (93, 71, 139) +MediumSeaGreen = (60, 179, 113) +MediumSlateBlue = (123, 104, 238) +MediumSpringGreen = (0, 250, 154) +MediumTurquoise = (72, 209, 204) +MediumVioletRed = (199, 21, 133) +midnight_blue = (25, 25, 112) +MidnightBlue = (25, 25, 112) +mint_cream = (245, 255, 250) +MintCream = (245, 255, 250) +misty_srose = (255, 228, 225) +MistyRose = (255, 228, 225) +MistyRose1 = (255, 228, 225) +MistyRose2 = (238, 213, 210) +MistyRose3 = (205, 183, 181) +MistyRose4 = (139, 125, 123) +moccasin = (255, 228, 181) +navajo_white = (255, 222, 173) +NavajoWhite = (255, 222, 173) +NavajoWhite1 = (255, 222, 173) +NavajoWhite2 = (238, 207, 161) +NavajoWhite3 = (205, 179, 139) +NavajoWhite4 = (139, 121, 94) +navy = (0, 0, 128) +navy_blue = (0, 0, 128) +NavyBlue = (0, 0, 128) +old_lace = (253, 245, 230) +OldLace = (253, 245, 230) +olive = (128, 128, 0) +olive_drab = (107, 142, 35) +OliveDrab = (107, 142, 35) +OliveDrab1 = (192, 255, 62) +OliveDrab2 = (179, 238, 58) +OliveDrab3 = (154, 205, 50) +OliveDrab4 = (105, 139, 34) +orange = (255, 165, 0) +orange_red = (255, 69, 0) +orange1 = (255, 165, 0) +orange2 = (238, 154, 0) +orange3 = (205, 133, 0) +orange4 = (139, 90, 0) +OrangeRed = (255, 69, 0) +OrangeRed1 = (255, 69, 0) +OrangeRed2 = (238, 64, 0) +OrangeRed3 = (205, 55, 0) +OrangeRed4 = (139, 37, 0) +orchid = (218, 112, 214) +orchid1 = (255, 131, 250) +orchid2 = (238, 122, 233) +orchid3 = (205, 105, 201) +orchid4 = (139, 71, 137) +pale_goldenrod = (238, 232, 170) +pale_green = (152, 251, 152) +pale_turquoise = (175, 238, 238) +pale_violet_red = (219, 112, 147) +PaleGoldenrod = (238, 232, 170) From df706ff910223c81e46571e19848bcbe60500823 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 01:40:00 +0100 Subject: [PATCH 04/13] updated readme for default colors --- README.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ed387c1..467c7f2 100644 --- a/README.md +++ b/README.md @@ -127,6 +127,13 @@ You don't have to hard code in the RGB values for the color each time, you can s ```python cyan = (26, 156, 171) ``` +alternativly you can use one of the predifined colors witch can be done by: +```python +TableIt.printTable(myList, useFieldNames=True, color=TableIt.colors.dark_cyan) +``` +As output you get: + +![](ImagesInREADME/TableIt_Colors.png) #### The initColors() function clears all output and should be run before all previous printing. It enables it to work on certain command lines. @@ -157,13 +164,13 @@ This is the list of updates which were not on my goals list or on the issues lis I don't have lots of plans but some things that would definitely be worth considering are: * Adding an option for the elements in the table to be centered * Adding an option to choose whether the colors are on the top, side, or both -* Adding default colors so that you don't have to choose RGB values (defaults like red, shades of blue and green, orange and yellow, etc.) * Complete rewrite of library structure * Complete rewrite of documentation ## Accomplished Goals These are goals that I preiously had which I achieved: * Colors are now an option in the table +* Adding default colors so that you don't have to choose RGB values (defaults like red, shades of blue and green, orange and yellow, etc.) ## Known Issues These are the issues that I know of: From bf23ad35bec0ec664ee2ddc739a11364c03aadac Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:23:51 +0100 Subject: [PATCH 05/13] added alignment --- ImagesInREADME/advancedAlignment.png | Bin 0 -> 7610 bytes ImagesInREADME/simpleCentreAlinement.png | Bin 0 -> 7654 bytes README.md | 22 ++++++++- TableIt/__init__.py | 54 ++++++++++++++++++++--- 4 files changed, 68 insertions(+), 8 deletions(-) create mode 100644 ImagesInREADME/advancedAlignment.png create mode 100644 ImagesInREADME/simpleCentreAlinement.png diff --git a/ImagesInREADME/advancedAlignment.png b/ImagesInREADME/advancedAlignment.png new file mode 100644 index 0000000000000000000000000000000000000000..c6b9db379da9c00d19c49022736e3d804c966e1d GIT binary patch literal 7610 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 u4wH%;|3zl`XDL{lu literal 0 HcmV?d00001 diff --git a/ImagesInREADME/simpleCentreAlinement.png b/ImagesInREADME/simpleCentreAlinement.png new file mode 100644 index 0000000000000000000000000000000000000000..da92d40a98be1a918f323d8e1d3a3768c7050d8b GIT binary patch literal 7654 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 KxhfgckbeW)KyJ+d literal 0 HcmV?d00001 diff --git a/README.md b/README.md index 467c7f2..776af80 100644 --- a/README.md +++ b/README.md @@ -135,6 +135,26 @@ As output you get: ![](ImagesInREADME/TableIt_Colors.png) +## Setting alignment +the `alignment` parameter allows you to specify weather the elements of the table are allined to the left (TableIt.left), the right (TableIt.right) or the centre (TableIt.centre). + +the simplest way of doing so will aline all the elements in the same way like so: +```python +TableIt.printTable(myList, useFieldNames=True, alignment=TableIt.centre) +``` +witch will create the following table: + +![](ImagesInREADME/simpleCentreAlinement.png) + +however you can alsow aline every element indevidualy by passing a list shuld the list ever be out of range the last valid element of the alignment list will be used. shuld the alignment for a given column not be a list the alignment will be used for the entire column. so: +```python +TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre, + [TableIt.left, TableIt.right]])```` +could result in: + +![](ImagesInREADME/advancedAlignment.png) + + #### The initColors() function clears all output and should be run before all previous printing. It enables it to work on certain command lines. ## Uses For TableIt @@ -162,13 +182,13 @@ This is the list of updates which were not on my goals list or on the issues lis ## Future Goals I don't have lots of plans but some things that would definitely be worth considering are: -* Adding an option for the elements in the table to be centered * Adding an option to choose whether the colors are on the top, side, or both * Complete rewrite of library structure * Complete rewrite of documentation ## Accomplished Goals These are goals that I preiously had which I achieved: +* Adding an option for the elements in the table to be centered * Colors are now an option in the table * Adding default colors so that you don't have to choose RGB values (defaults like red, shades of blue and green, orange and yellow, etc.) diff --git a/TableIt/__init__.py b/TableIt/__init__.py index 0bd9d73..db71c1e 100644 --- a/TableIt/__init__.py +++ b/TableIt/__init__.py @@ -3,6 +3,10 @@ import random from . import colors +left = 0 +right = 2 +centre = 1 + def initColors(): os.system("cls") @@ -30,14 +34,47 @@ def createMatrix(rows, cols, matrixToWorkOn, matrix): # Add a each column of the current row (in string form) to matrixToWorkOn matrixToWorkOn[i].append(str(matrix[i][j])) -def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color): +def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color, alinement): + + def getSideSpacings(alinement, largestElementLength, currentEl_length): + "cumpute the left and right spacings for alinement" + if alinement == 0 or alinement == "left": + return 0, (largestElementLength - currentEl_length + 2) + + elif alinement == 2 or alinement == "right": + return (largestElementLength - currentEl_length + 1), 1 + + elif alinement == 1 or alinement == "center": + a = math.floor((largestElementLength - currentEl_length + 1)/2) + b = (largestElementLength - currentEl_length + 1) - a + 1 + return a, b + else: + raise ValueError (f"unknown alinement: alinement must be 'right', 'left' or 'center' not {alinement}") # Loop through each row for i in range(rows): + + if isinstance(alinement, (list, tuple)): + if len(alinement) >= i+1: + rowAlinement = alinement[i] + else: + rowAlinement = alinement[len(alinement)-1] + else: + rowAlinement = alinement + # Initialize the row that will we work on currently as a blank string currentRow = "" # Loop trhough each column for j in range(cols): + + if isinstance(rowAlinement, (list, tuple)): + if len(rowAlinement) >= j+1: + colAlinement = rowAlinement[j] + else: + colAlinement = rowAlinement[len(rowAlinement)-1] + else: + colAlinement = rowAlinement + # If we are using colors then do the same thing but as without (below) if ((color != None) and (j == 0 or i == 0)): # Only add color if it is in the first column or first row @@ -47,18 +84,21 @@ def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalT currentEl = " " + matrixToWorkOn[i][j] # If the raw element is less than the largest length of a raw element (raw element is just the unformatted element passed in) - if (largestElementLength != len(matrixToWorkOn[i][j])): + if (largestElementLength != len(str(matrixToWorkOn[i][j]))): # If we are using colors then add the amount of spaces that is equal to the difference of the largest element length and the current element (minus the length that is added for the color) # * The plus two here comes from the one space we would normally need and the fact that we need to account for a space that tbe current element already has if (color != None): if (j == 0 or i == 0): - currentEl = currentEl + " " * (largestElementLength - (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m")) + 2) + "|" + leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m"))) + currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" # If it is not the first column or first row than it doesn't need to subtract the color length else: - currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" + leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, len(currentEl)) + currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" # If we are not using color just do the same thing as above when we were using colors for when the row or column is not the first each time else: - currentEl = currentEl + " " * (largestElementLength - len(currentEl) + 2) + "|" + leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, len(currentEl)) + currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" # If the raw element length us equal to the largest length of a raw element then we don't need to add extra spaces else: currentEl = currentEl + " " + "|" @@ -112,7 +152,7 @@ def printRowsInTable(finalTable): for row in finalTable: print(row) -def printTable(matrix, useFieldNames=False, color=None): +def printTable(matrix, useFieldNames=False, color=None, alignment=0): # Rows equal amount of lists inside greater list rows = len(matrix) # Cols equal amount of elements inside each list @@ -130,7 +170,7 @@ def printTable(matrix, useFieldNames=False, color=None): largestElementLength = findLargestElement(rows, cols, lengthArray, matrix) createMatrix(rows, cols, matrixToWorkOn, matrix) - rowLength = makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color) + rowLength = makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color, alignment) createWrappingRows(rowLength, finalTable) if (useFieldNames): createRowUnderFields(largestElementLength, cols, finalTable) From 13cb8596189665cdb729ede99be0ea5a92e6ec31 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:27:30 +0100 Subject: [PATCH 06/13] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 776af80..b285b38 100644 --- a/README.md +++ b/README.md @@ -149,7 +149,8 @@ witch will create the following table: however you can alsow aline every element indevidualy by passing a list shuld the list ever be out of range the last valid element of the alignment list will be used. shuld the alignment for a given column not be a list the alignment will be used for the entire column. so: ```python TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre, - [TableIt.left, TableIt.right]])```` + [TableIt.left, TableIt.right]]) + ``` could result in: ![](ImagesInREADME/advancedAlignment.png) From b4d83668ad506378352594cc32f92ffcf3a1b413 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:28:33 +0100 Subject: [PATCH 07/13] Update README.md --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b285b38..f7a4225 100644 --- a/README.md +++ b/README.md @@ -148,9 +148,8 @@ witch will create the following table: however you can alsow aline every element indevidualy by passing a list shuld the list ever be out of range the last valid element of the alignment list will be used. shuld the alignment for a given column not be a list the alignment will be used for the entire column. so: ```python -TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre, - [TableIt.left, TableIt.right]]) - ``` +TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre,[TableIt.left, TableIt.right]]) +``` ``` could result in: ![](ImagesInREADME/advancedAlignment.png) @@ -163,7 +162,9 @@ There are many uses for TableIt. I first created it as an output library for pri ```python import TableIt ``` + and then: + ```python TableIt.printTable(myTable) ``` From d9b8c7c83a2ab9b8e5086c777fc9c5c89735fd62 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:29:38 +0100 Subject: [PATCH 08/13] fixt minor error --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index f7a4225..b35d7e8 100644 --- a/README.md +++ b/README.md @@ -149,7 +149,8 @@ witch will create the following table: however you can alsow aline every element indevidualy by passing a list shuld the list ever be out of range the last valid element of the alignment list will be used. shuld the alignment for a given column not be a list the alignment will be used for the entire column. so: ```python TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre,[TableIt.left, TableIt.right]]) -``` ``` +``` + ``` could result in: ![](ImagesInREADME/advancedAlignment.png) From d45216df2c12691cd066ea9c61f41add4e869207 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:30:04 +0100 Subject: [PATCH 09/13] Delete make.bat --- make.bat | 6 ------ 1 file changed, 6 deletions(-) delete mode 100644 make.bat diff --git a/make.bat b/make.bat deleted file mode 100644 index 5b31dc7..0000000 --- a/make.bat +++ /dev/null @@ -1,6 +0,0 @@ -@echo off -call cls -echo.running setup -echo. - -python36 setup.py sdist \ No newline at end of file From f09adb849be60422cdccf2440e5ebb434ebbd675 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Wed, 17 Feb 2021 17:31:23 +0100 Subject: [PATCH 10/13] removed empty code block --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b35d7e8..46acada 100644 --- a/README.md +++ b/README.md @@ -150,7 +150,7 @@ however you can alsow aline every element indevidualy by passing a list shuld th ```python TableIt.printTable(myList, useFieldNames=True, alignment=[[TableIt.centre,[TableIt.left, TableIt.right]]) ``` - ``` + could result in: ![](ImagesInREADME/advancedAlignment.png) From 8e92df488782e9e2106f2ce77acbbd00d90e3b15 Mon Sep 17 00:00:00 2001 From: JulianWww <38176040+JulianWww@users.noreply.github.com> Date: Thu, 18 Feb 2021 03:35:17 +0100 Subject: [PATCH 11/13] gave finer control over colorings made the colour assignment as close to alignment assignment while not changing the result of older versions --- TableIt/__init__.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/TableIt/__init__.py b/TableIt/__init__.py index db71c1e..0fffcca 100644 --- a/TableIt/__init__.py +++ b/TableIt/__init__.py @@ -34,7 +34,7 @@ def createMatrix(rows, cols, matrixToWorkOn, matrix): # Add a each column of the current row (in string form) to matrixToWorkOn matrixToWorkOn[i].append(str(matrix[i][j])) -def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color, alinement): +def makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, colors, alinement): def getSideSpacings(alinement, largestElementLength, currentEl_length): "cumpute the left and right spacings for alinement" @@ -61,6 +61,11 @@ def getSideSpacings(alinement, largestElementLength, currentEl_length): rowAlinement = alinement[len(alinement)-1] else: rowAlinement = alinement + + if len(colors) >= i+1: + rowColors = colors[i] + else: + rowColors = colors[len(colors)-1] # Initialize the row that will we work on currently as a blank string currentRow = "" @@ -75,8 +80,16 @@ def getSideSpacings(alinement, largestElementLength, currentEl_length): else: colAlinement = rowAlinement + if isinstance(rowColors, (list)): + if len(rowColors) >= j+1: + color = rowColors[j] + else: + color = rowColors[len(rowColors)-1] + else: + color = rowColors + # If we are using colors then do the same thing but as without (below) - if ((color != None) and (j == 0 or i == 0)): + if (color != None): # Only add color if it is in the first column or first row currentEl = " " + "\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) +"m" + matrixToWorkOn[i][j] + "\033[0m" # If we are not using colors (or j != 0 or i != 0) just add a space and the element that should be in that position to a variable which will store the current element to work on @@ -88,13 +101,8 @@ def getSideSpacings(alinement, largestElementLength, currentEl_length): # If we are using colors then add the amount of spaces that is equal to the difference of the largest element length and the current element (minus the length that is added for the color) # * The plus two here comes from the one space we would normally need and the fact that we need to account for a space that tbe current element already has if (color != None): - if (j == 0 or i == 0): - leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m"))) - currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" - # If it is not the first column or first row than it doesn't need to subtract the color length - else: - leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, len(currentEl)) - currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" + leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, (len(currentEl) - len("\033[38;2;" + str(color[0]) + ";" + str(color[1]) + ";" + str(color[2]) + "m" + "\033[0m"))) + currentEl = " " * leftSpace + currentEl + " " * rightSpace + "|" # If we are not using color just do the same thing as above when we were using colors for when the row or column is not the first each time else: leftSpace, rightSpace = getSideSpacings(colAlinement, largestElementLength, len(currentEl)) @@ -168,6 +176,9 @@ def printTable(matrix, useFieldNames=False, color=None, alignment=0): #This the list in which each row will be one of the final table to be printed finalTable = [] + if not isinstance(color, (list)): + color = [[color], [color, None]] + largestElementLength = findLargestElement(rows, cols, lengthArray, matrix) createMatrix(rows, cols, matrixToWorkOn, matrix) rowLength = makeRows(rows, cols, largestElementLength, rowLength, matrixToWorkOn, finalTable, color, alignment) From cb41aadc3a837f678bb284dc93cf495c125af960 Mon Sep 17 00:00:00 2001 From: Julian Wandhoven <38176040+JulianWww@users.noreply.github.com> Date: Thu, 18 Feb 2021 16:38:08 +0100 Subject: [PATCH 12/13] Create versionTest.yml --- .github/workflows/versionTest.yml | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 .github/workflows/versionTest.yml diff --git a/.github/workflows/versionTest.yml b/.github/workflows/versionTest.yml new file mode 100644 index 0000000..3ffd40a --- /dev/null +++ b/.github/workflows/versionTest.yml @@ -0,0 +1,39 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: Python package + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + matrix: + python-version: [3.7, 3.8, 3.9] + + steps: + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install flake8 pytest + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + pytest From 7b0e42c6c84b66be67f0801a18b5bfbb430be6de Mon Sep 17 00:00:00 2001 From: Julian Wandhoven <38176040+JulianWww@users.noreply.github.com> Date: Thu, 18 Feb 2021 16:39:16 +0100 Subject: [PATCH 13/13] Delete .github directory --- .github/workflows/versionTest.yml | 39 ------------------------------- 1 file changed, 39 deletions(-) delete mode 100644 .github/workflows/versionTest.yml diff --git a/.github/workflows/versionTest.yml b/.github/workflows/versionTest.yml deleted file mode 100644 index 3ffd40a..0000000 --- a/.github/workflows/versionTest.yml +++ /dev/null @@ -1,39 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions - -name: Python package - -on: - push: - branches: [ master ] - pull_request: - branches: [ master ] - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - matrix: - python-version: [3.7, 3.8, 3.9] - - steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with pytest - run: | - pytest