def test_sort(self):
# Sort on this column
# ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
bf = BatFrame(DatasetTest.dataset_url)
sort = bf.sort("Weight") # ascending=True is default
rows = sort.rows
expected_rows =[
"Wonder Woman",
"Catwoman",
"Joker",
"Flash",
"Batman",
"Superman"]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
values = sort["Weight"].values
expected_values = [130, 133, 183, 190, 210, 235]
for value, e_value in zip(values, expected_values):
self.assertEqual(value, e_value)
# Reverse sort aka descending
sort = bf.sort("Weight", ascending=False)
rows = sort.rows
for row, e_row in zip(rows, reversed(expected_rows)):
self.assertEqual(row, e_row)
values = sort["Weight"].values
for value, e_value in zip(values, reversed(expected_values)):
self.assertEqual(value, e_value)
# Sort on those column
# ⇓ ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
bf = BatFrame(DatasetTest.dataset_url)
sort = bf.sort(["Height", "Weight"]) # ascending=True is default
rows = sort.rows
expected_rows = [
"Catwoman",
"Wonder Woman",
"Joker",
"Flash",
"Batman",
"Superman"]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [170, 183, 183, 183, 188, 190.5]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [133, 130, 183, 190, 210, 235]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
# Reverse sort aka descending. Both are descending
sort = bf.sort(["Height", "Weight"], ascending=False)
rows = sort.rows
for row, e_row in zip(rows, reversed(expected_rows)):
self.assertEqual(row, e_row)
heights = sort["Height"].values
for height, e_height in zip(heights, reversed(expected_height)):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
for weight, e_weight in zip(weights, reversed(expected_weight)):
self.assertEqual(weight, e_weight)
# Different sorting order
sort = bf.sort(["Height", "Weight"], [True, False])
rows = sort.rows
expected_rows = [
"Catwoman",
"Flash",
"Joker",
"Wonder Woman",
"Batman",
"Superman"]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [170, 183, 183, 183, 188, 190.5]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [133, 190, 183, 130, 210, 235]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
# Sort on this column
# ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
sort = bf.sort("Skin")
rows = sort.rows
expected_rows = [
"Superman",
"Wonder Woman",
"Catwoman",
"Batman",
"Flash",
"Joker"]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [190.5, 183, 170, 188, 183, 183]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [235, 130, 133, 210, 190, 183]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
def test_sort(self):
# Sort on this column
# ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
bf = BatFrame(DatasetTest.dataset_url)
sort = bf.sort("Weight") # ascending=True is default
rows = sort.rows
expected_rows = [
"Wonder Woman", "Catwoman", "Joker", "Flash", "Batman", "Superman"
]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
values = sort["Weight"].values
expected_values = [130, 133, 183, 190, 210, 235]
for value, e_value in zip(values, expected_values):
self.assertEqual(value, e_value)
# Reverse sort aka descending
sort = bf.sort("Weight", ascending=False)
rows = sort.rows
for row, e_row in zip(rows, reversed(expected_rows)):
self.assertEqual(row, e_row)
values = sort["Weight"].values
for value, e_value in zip(values, reversed(expected_values)):
self.assertEqual(value, e_value)
# Sort on those column
# ⇓ ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
bf = BatFrame(DatasetTest.dataset_url)
sort = bf.sort(["Height", "Weight"]) # ascending=True is default
rows = sort.rows
expected_rows = [
"Catwoman", "Wonder Woman", "Joker", "Flash", "Batman", "Superman"
]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [170, 183, 183, 183, 188, 190.5]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [133, 130, 183, 190, 210, 235]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
# Reverse sort aka descending. Both are descending
sort = bf.sort(["Height", "Weight"], ascending=False)
rows = sort.rows
for row, e_row in zip(rows, reversed(expected_rows)):
self.assertEqual(row, e_row)
heights = sort["Height"].values
for height, e_height in zip(heights, reversed(expected_height)):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
for weight, e_weight in zip(weights, reversed(expected_weight)):
self.assertEqual(weight, e_weight)
# Different sorting order
sort = bf.sort(["Height", "Weight"], [True, False])
rows = sort.rows
expected_rows = [
"Catwoman", "Flash", "Joker", "Wonder Woman", "Batman", "Superman"
]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [170, 183, 183, 183, 188, 190.5]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [133, 190, 183, 130, 210, 235]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
# Sort on this column
# ⇓
# ---------------------------------------------------------------------------------
# | | Gender | Height | Weight | Eyes | Hair | Skin | Good | Bad |
# ---------------------------------------------------------------------------------
# | Batman | Male | 188 | 210 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Wonder Woman | Female | 183 | 130 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Flash | Male | 183 | 190 | Green | Red | | True | False |
# ---------------------------------------------------------------------------------
# | Catwoman | Female | 170 | 133 | Green | Black | | True | True |
# ---------------------------------------------------------------------------------
# | Superman | Male | 190.5 | 235 | Blue | Black | | True | False |
# ---------------------------------------------------------------------------------
# | Joker | Male | 183 | 183 | Green | Green | White | False | True |
# ---------------------------------------------------------------------------------
sort = bf.sort("Skin")
rows = sort.rows
expected_rows = [
"Superman", "Wonder Woman", "Catwoman", "Batman", "Flash", "Joker"
]
for row, e_row in zip(rows, expected_rows):
self.assertEqual(row, e_row)
heights = sort["Height"].values
expected_height = [190.5, 183, 170, 188, 183, 183]
for height, e_height in zip(heights, expected_height):
self.assertEqual(height, e_height)
weights = sort["Weight"].values
expected_weight = [235, 130, 133, 210, 190, 183]
for weight, e_weight in zip(weights, expected_weight):
self.assertEqual(weight, e_weight)
