def test_split_cols(self):
order = "split the dataset random0 by 2 columns"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'SplitByCols')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'random0')
self.assertEqual(data['queryResult']['parameters']['split'], 2)
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
al.split_by_cols(data['queryResult']['parameters'])
datasets = re.findall('random0c[0-9]*',
str(al.Workspace().get_all_dataset()))
num_datasets = len(datasets)
self.assertEqual(num_datasets, 5)
workspace = al.Workspace()
for num in range(num_datasets):
dataset = workspace.get_dataset(datasets[num])
ncol = dataset.columns.size
nrow = dataset.index.size
self.assertEqual(ncol, 2)
self.assertEqual(nrow, 200)
def test_join_rows(self):
order = "join by rows the datasets random0 and random1"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'JoinByRows')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'random0')
self.assertEqual(data['queryResult']['parameters']['Dataset2'],
'random1')
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
al.join_by_rows(data['queryResult']['parameters'])
dataset = al.Workspace().get_dataset('join0')
ncol = dataset.columns.size
nrow = dataset.index.size
self.assertEqual(ncol, 10)
self.assertEqual(nrow, 400)
def test_subdataset_cols(self):
order = "obtain a subset from random0 by columns at col0, col2, and col7"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'SubDatasetCols')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'random0')
self.assertEqual(data['queryResult']['parameters']['cols'],
['col0', 'col2', 'col7'])
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
al.get_subdataset_columns(data['queryResult']['parameters'])
dataset = al.Workspace().get_dataset('subcol0random0')
ncol = dataset.columns.size
cols = dataset.columns.to_list()
expected = ['col0', 'col2', 'col7']
self.assertEqual(ncol, 3)
for n in range(3):
self.assertEqual(cols[n], expected[n])
def test_find_best_n_motifs(self):
order = "Execute stomp on energy and consumption with a subsequence length of 3"
data = response(self, order)
tt1 = pd.DataFrame([10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9])
tt2 = pd.DataFrame([10, 11, 10, 9])
self.workspace.save_dataset('energy', tt1)
self.workspace.save_dataset('consumption', tt2)
al.do_matrix(data['queryResult']['parameters'])
order = "Find best 1 motif from stomp0"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'], 'DoMatrix_Best')
self.assertGreater(data['queryResult']['intentDetectionConfidence'], 0.8)
self.assertEqual(data['queryResult']['parameters']['operation'], 'find_best_n_motifs')
self.assertEqual(data['queryResult']['parameters']['n'], 1)
al.do_matrix(data['queryResult']['parameters'])
find_best_n_motifs_result = al.Workspace().get_dataset('motifs0')
for i in range(3):
self.assertEqual(find_best_n_motifs_result['col0'][i], 10)
def create_dataset(parameters):
"""
Creates a random dataset and saves it.
:param parameters: The parameters for the creation (number of rows, numbers of columns,...).
"""
workspace = al.Workspace()
num_rows, num_col, values = rand_param(parameters)
print('Creating the random dataset')
tt = pd.DataFrame(index=range(num_rows))
for n in range(num_col):
tt['col' + str(n)] = pd.DataFrame(np.random.uniform(values[0],
values[1],
size=num_rows),
dtype='float32')
rand = workspace.get_counter('rand')
workspace.save_dataset('random' + str(rand), tt)
workspace.save_dataset('current', tt)
print(
'Created and saved as random{} which has {} columns, {} rows and values '
'between {} and {}'.format(str(rand), num_col, num_rows, values[0],
values[1]))
def test_find_best_n_discords(self):
order = "Execute stomp on energy and consumption with a subsequence length of 3"
data = response(self, order)
tt1 = pd.DataFrame([11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11])
tt2 = pd.DataFrame([9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9])
self.workspace.save_dataset('energy', tt1)
self.workspace.save_dataset('consumption', tt2)
al.do_matrix(data['queryResult']['parameters'])
order = "Find best 2 discords from stomp0"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'], 'DoMatrix_Best')
self.assertGreater(data['queryResult']['intentDetectionConfidence'], 0.8)
self.assertEqual(data['queryResult']['parameters']['operation'], 'find_best_n_discords')
self.assertEqual(data['queryResult']['parameters']['n'], 2)
al.do_matrix(data['queryResult']['parameters'])
find_best_n_discord_result = al.Workspace().get_dataset('discords0')
expected_result = [11, 10, 11]
for i in range(1):
col = find_best_n_discord_result['col' + str(i)].tolist()
for j in range(2):
self.assertEqual(col[j], expected_result[j])
def test_decimal_scaling_norm(self):
order = 'Execute the decimal scaling normalization on timeserie'
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoNormalization')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.9)
self.assertEqual(data['queryResult']['parameters']['operation'],
'decimal_scaling_norm')
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'timeserie')
tt = pd.DataFrame([[0, 1, -2, 3], [40, 50, 60, -70]])
self.workspace.save_dataset('timeserie', tt)
al.do_normalization(data['queryResult']['parameters'])
max_min_norm_result = al.Workspace().get_dataset(
"dec_sca_norm0").to_numpy().flatten()
expected = [[0.0, 0.1, -0.2, 0.3], [0.4, 0.5, 0.6, -0.7]]
for i in range(len(expected)):
self.assertAlmostEqual(max_min_norm_result[i],
expected[0][i],
delta=self.DELTA)
self.assertAlmostEqual(max_min_norm_result[i + 4],
expected[1][i],
delta=self.DELTA)
def do_dimensionality(parameters):
"""
Do an operation of dimensionality.
:param parameters: The parameters of the function (name of the operation, ...).
"""
op = parameters.pop("operation")
workspace = al.Workspace()
data_name = parameters["Dataset"]
dataset = workspace.get_dataset(data_name)
if op == "paa":
# Calling khiva
data = al.paa(dataset, parameters)
num = workspace.get_counter('redux')
workspace.save_dataset("paa" + str(num), data)
print('The reduction of points is stored as paa' + str(num))
elif op == 'pip':
data = al.pip(dataset, parameters)
num = workspace.get_counter('redux')
workspace.save_dataset("pip" + str(num), data)
print('The reduction of points is stored as pip' + str(num))
elif op == 'ramer_douglas_peucker':
data = al.ramer_douglas_peucker(dataset, parameters)
num = workspace.get_counter('redux')
workspace.save_dataset("RDP" + str(num), data)
print('The reduction of points is stored as RDP' + str(num))
elif op == 'visvalingam':
data = al.visvalingam(dataset, parameters)
num = workspace.get_counter('redux')
workspace.save_dataset("visvalingam" + str(num), data)
print('The reduction of points is stored as visvalingam' + str(num))
def do_clustering(parameters):
"""
Do an operation of clustering.
:param parameters: The parameters of the function (name of the operation, number of clusters, ...).
"""
op = parameters.pop("operation")
workspace = al.Workspace()
data_name = parameters["Dataset"]
dataset = workspace.get_dataset(data_name)
if op == "kmeans":
(centroids, labels) = al.kmean(dataset, parameters)
number = workspace.get_counter('clustering')
workspace.save_dataset('centroids' + str(number), centroids)
workspace.save_dataset('labels' + str(number), labels)
elif op == "kshape":
(centroids, labels) = al.kshape(dataset, parameters)
number = workspace.get_counter('clustering')
workspace.save_dataset('centroids' + str(number), centroids)
workspace.save_dataset('labels' + str(number), labels)
else:
return
print("The centroids are stored in centroids" + str(number))
print("The labels are stored in labels" + str(number))
def test_mean_norm(self):
order = 'Execute the mean norm on timeserie'
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoNormalization')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.9)
self.assertEqual(data['queryResult']['parameters']['operation'],
'mean_norm')
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'timeserie')
tt = pd.DataFrame([[0, 1, 2, 3], [4, 5, 6, 7]])
self.workspace.save_dataset('timeserie', tt)
al.do_normalization(data['queryResult']['parameters'])
max_min_norm_result = al.Workspace().get_dataset(
"mean_norm0").to_numpy().flatten()
expected = [-0.5, -0.166666667, 0.166666667, 0.5]
for i in range(len(expected)):
self.assertAlmostEqual(max_min_norm_result[i],
expected[i],
delta=self.DELTA)
self.assertAlmostEqual(max_min_norm_result[i + 4],
expected[i],
delta=self.DELTA)
def get_subdataset_columns(parameters):
"""
Obtains a subset of the dataset by its columns.
:param parameters: The parameter of the function(dataset name,...).
"""
workspace = al.Workspace()
data_name = parameters['Dataset']
dataset = workspace.get_dataset(data_name)
cols = []
if parameters["cols"]:
cols = parameters['cols']
else:
stop = False
while not stop:
cols.append(al.obtain_column(dataset))
print('Do you want to continue? yes or no?')
response = al.query_input()
if response == 'no':
stop = True
dataset = dataset[cols]
num = workspace.get_counter('sub')
name = 'subcol' + str(num) + data_name
workspace.save_dataset(name, dataset)
txt = 'The sub-dataset by the rows is saved as ' + name
print(txt)
def join_by_rows(parameters):
"""
Join two dataset with the same number of columns.
:param parameters: The parameters of the function (dataset names).
"""
workspace = al.Workspace()
name_data1 = parameters['Dataset']
name_data2 = parameters['Dataset2']
dataset1 = workspace.get_dataset(name_data1)
dataset2 = workspace.get_dataset(name_data2)
if dataset2 is None:
if not name_data2 == "":
print("The object " + name_data2 + " does not exist.")
print("Please, provide the two datasets that should be joined.")
return
if dataset1.columns.size != dataset2.columns.size:
print(
'Not able to execute.\nThe datasets have different number of columns'
)
return
dataset = pd.concat([dataset1, dataset2], ignore_index=True)
num = workspace.get_counter('join')
name = 'join' + str(num)
workspace.save_dataset(name, dataset)
print('The resulting dataset between ' + name_data1 + ' and ' +
name_data2 + ' is saved as ' + name)
def test_znorm(self):
order = 'Execute znorm on timeserie'
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoNormalization')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.9)
self.assertEqual(data['queryResult']['parameters']['operation'],
'znorm')
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'timeserie')
tt = pd.DataFrame([[0, 1, 2, 3], [4, 5, 6, 7]])
self.workspace.save_dataset('timeserie', tt)
al.do_normalization(data['queryResult']['parameters'])
znorm_result = al.Workspace().get_dataset(
"znorm0").to_numpy().flatten()
expected = [
-1.341640786499870, -0.447213595499958, 0.447213595499958,
1.341640786499870
]
for i in range(len(expected)):
self.assertAlmostEqual(znorm_result[i],
expected[i],
delta=self.DELTA)
self.assertAlmostEqual(znorm_result[i + 4],
expected[i],
delta=self.DELTA)
def test_subdataset_rows(self):
order = "obtain a subset by rows from random0 from 10 to 60"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'SubDatasetRow')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'random0')
self.assertEqual(data['queryResult']['parameters']['from'], 10)
self.assertEqual(data['queryResult']['parameters']['to'], 60)
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
al.get_subdataset_rows(data['queryResult']['parameters'])
dataset = al.Workspace().get_dataset('subrow0random0')
index = dataset.index
nrow = dataset.index.size
self.assertEqual(index.min(),
data['queryResult']['parameters']['from'])
self.assertEqual(index.max(),
data['queryResult']['parameters']['to'] - 1)
self.assertEqual(nrow, 50)
def split_by_rows(parameters):
"""
Split a dataset into n datasets of m rows.
:param parameters: The parameters of the function (dataset name, size of the split dataset for the rows).
"""
workspace = al.Workspace()
name_data = parameters['Dataset']
dataset = workspace.get_dataset(name_data)
if parameters['split']:
div = int(parameters['split'])
else:
print('How many rows will each dataset have?')
query = al.query_input()
while not al.isnumber(query):
print(
'Incorrect input.\nIt is not a number.\nPlease introduce one:')
query = al.query_input()
div = int(query)
it = 0
names = []
while it < dataset.index.size:
div_dataset = dataset.iloc[it:it + div]
num = workspace.get_counter('split')
name = name_data + 'r' + str(num)
names.append(name)
workspace.save_dataset(name, div_dataset)
it = it + div
print('The splits of ' + name_data + ' are saved as: ' + str(names)[1:-1])
def test_max_min_norm_with_param(self):
order = 'Execute maximal minimal normalization on timeserie with max value of 2 and min value of 1'
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoNormalization')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.9)
self.assertEqual(data['queryResult']['parameters']['operation'],
'max_min_norm')
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'timeserie')
self.assertEqual(data['queryResult']['parameters']['max'], 2)
self.assertEqual(data['queryResult']['parameters']['min'], 1)
tt = pd.DataFrame([[0, 1, 2, 3], [4, 5, 6, 7]])
self.workspace.save_dataset('timeserie', tt)
al.do_normalization(data['queryResult']['parameters'])
max_min_norm_result = al.Workspace().get_dataset(
"max_min_norm0").to_numpy().flatten()
expected = [1.0, 1.3333333333333, 1.66666667, 2.0]
for i in range(len(expected)):
self.assertAlmostEqual(max_min_norm_result[i],
expected[i],
delta=self.DELTA)
self.assertAlmostEqual(max_min_norm_result[i + 4],
expected[i],
delta=self.DELTA)
def execute_print(parameters):
"""
Execute the print function.
:param parameters: The parameter for the print (Dataset name, ...).
"""
workspace = al.Workspace()
data_name = parameters["Dataset"]
dataset = workspace.get_dataset(data_name)
print(dataset)
def execute_plot(parameters):
"""
Execute the function plot.
:param parameters: The parameters for the graphic (dataset name, intervals,...).
"""
workspace = al.Workspace()
data_name = parameters["Dataset"]
dataset = workspace.get_dataset(data_name)
plot_dataset(dataset, parameters)
def setUp(self):
set_backend(KHIVABackend.KHIVA_BACKEND_CPU)
self.project_id = "aljuaritmo"
self.language_code = "en"
self.session_client = dialogflow.SessionsClient()
self.session = self.session_client.session_path(self.project_id, self.session_id)
self.workspace = al.Workspace()
self.workspace.init_current()
def test_shape_dataset(self):
order = "Do the kshape of 3 clusters for energy"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoClustering')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['operation'],
'kshape')
self.assertEqual(data['queryResult']['parameters']['number'], 3)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'energy')
tts = pd.DataFrame([[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
[0.0, 10.0, 4.0, 5.0, 7.0, -3.0, 0.0],
[-1.0, 15.0, -12.0, 8.0, 9.0, 4.0, 5.0],
[2.0, 8.0, 7.0, -6.0, -1.0, 2.0, 9.0],
[-5.0, -5.0, -6.0, 7.0, 9.0, 9.0, 0.0]])
self.workspace.save_dataset('energy', tts)
expected_c = pd.DataFrame(
[[-0.5234, 0.1560, -0.3627, -1.2764, -0.7781, 0.9135, 1.8711],
[-0.7825, 1.5990, 0.1701, 0.4082, 0.8845, -1.4969, -0.7825],
[-0.6278, 1.3812, -2.0090, 0.5022, 0.6278, 0.0000, 0.1256]])
al.do_clustering(data['queryResult']['parameters'])
(centroid, labels) = (al.Workspace().get_dataset('centroids0'),
al.Workspace().get_dataset('labels0'))
for i in range(len(expected_c)):
self.assertAlmostEqual(centroid[0][i],
expected_c[0][i],
delta=self.DELTA)
self.assertAlmostEqual(centroid[1][i],
expected_c[1][i],
delta=self.DELTA)
self.assertAlmostEqual(centroid[2][i],
expected_c[2][i],
delta=self.DELTA)
def main(*args, **kwargs):
try:
al.Workspace().init_current()
print("Welcome, I'm Aljuarismo, what can I do for you?")
while True:
query = click.prompt('')
click.echo('DEBUG: %s' % query)
detect_intent_text(project_id, session_id, query, language_code)
except click.exceptions.Abort:
print('Closing the program')
sys.exit()
def setUp(self):
self.project_id = "aljuaritmo"
self.language_code = "en"
self.session_client = dialogflow.SessionsClient()
self.session = self.session_client.session_path(
self.project_id, self.session_id)
self.workspace = al.Workspace()
self.workspace.save_dataset_path('titanic', 'datasets')
self.workspace.init_current()
def setUp(self):
set_backend(KHIVABackend.KHIVA_BACKEND_CPU)
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/home/franco.gonzalez/Desktop/Credentials/" \
"Aljuaritmo-3ac32e58ff41.json"
self.project_id = "aljuaritmo"
self.language_code = "en"
self.session_client = dialogflow.SessionsClient()
self.session = self.session_client.session_path(
self.project_id, self.session_id)
self.workspace = al.Workspace()
self.workspace.init_current()
def test_change_name(self):
order = "rename random0 to r_a_n_d_o_m_0"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'ChangeName')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.95)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'random0')
self.assertEqual(data['queryResult']['parameters']['NameInto'],
'r_a_n_d_o_m_0')
al.create_dataset({'columns': 10, 'rows': 200, 'values': [0, 1]})
self.assertTrue(al.Workspace().get_dataset('random0') is not None)
self.assertTrue(al.Workspace().get_dataset('r_a_n_d_o_m_0') is None)
data1 = al.Workspace().get_dataset('random0')
al.change_name(data['queryResult']['parameters'])
self.assertTrue(al.Workspace().get_dataset('random0') is None)
self.assertTrue(
al.Workspace().get_dataset('r_a_n_d_o_m_0') is not None)
data2 = al.Workspace().get_dataset('r_a_n_d_o_m_0')
self.assertTrue(pd.DataFrame.equals(data1, data2))
def test_kmeans_dataset(self):
order = "Do the kmeans of 3 clusters for energy"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'DoClustering')
self.assertGreater(data['queryResult']['intentDetectionConfidence'],
0.8)
self.assertEqual(data['queryResult']['parameters']['operation'],
'kmeans')
self.assertEqual(data['queryResult']['parameters']['number'], 3)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'energy')
tts = pd.DataFrame([[0.0, 1.0, 2.0, 3.0], [6.0, 7.0, 8.0, 9.0],
[2.0, -2.0, 4.0, -4.0], [8.0, 5.0, 3.0, 1.0],
[15.0, 10.0, 5.0, 0.0], [7.0, -7.0, 1.0, -1.0]])
self.workspace.save_dataset('energy', tts)
expected_c = pd.DataFrame([[0.0, 0.1667, 0.3333, 0.5],
[1.5, -1.5, 0.8333, -0.8333],
[4.8333, 3.6667, 2.6667, 1.6667]])
al.do_clustering(data['queryResult']['parameters'])
(centroid, labels) = (al.Workspace().get_dataset('centroids0'),
al.Workspace().get_dataset('labels0'))
for i in range(len(expected_c)):
self.assertAlmostEqual(centroid[0][i],
expected_c[0][i],
delta=self.DELTA)
self.assertAlmostEqual(centroid[1][i],
expected_c[1][i],
delta=self.DELTA)
self.assertAlmostEqual(centroid[2][i],
expected_c[2][i],
delta=self.DELTA)
def do_features(parameters):
"""
Execute the feature operations.
:param parameters: The parameters for this function (name_dataset).
"""
workspace = al.Workspace()
data_name = parameters['Dataset']
dataset = workspace.get_dataset(data_name)
features = al.features(dataset)
num_norm = str(workspace.get_counter('feat'))
name = data_name + 'Features' + num_norm
workspace.save_dataset(name, features)
print('The features are stored as ' + name)
def do_normalization(parameters):
"""
Do an operation of normalization.
:param parameters: The parameters of the function (name of the operation, dataset, ...).
"""
op = parameters.pop("operation")
workspace = al.Workspace()
data_name = parameters["Dataset"]
dataset = workspace.get_dataset(data_name)
name = ''
if not re.search("_in_place$", op):
if op == 'decimal_scaling_norm':
norm = al.decimal_scaling_norm(dataset)
num_norm = str(workspace.get_counter('norm'))
name = 'dec_sca_norm' + num_norm
workspace.save_dataset(name, norm)
elif op == 'max_min_norm':
norm = al.max_min_norm(dataset, parameters)
num_norm = str(workspace.get_counter('norm'))
name = 'max_min_norm' + num_norm
workspace.save_dataset(name, norm)
elif op == 'mean_norm':
norm = al.mean_norm(dataset)
num_norm = str(workspace.get_counter('norm'))
name = 'mean_norm' + num_norm
workspace.save_dataset(name, norm)
elif op == 'znorm':
norm = al.znorm(dataset, parameters)
num_norm = str(workspace.get_counter('norm'))
name = 'znorm' + num_norm
workspace.save_dataset(name, norm)
print('The normalization is stored as ' + name)
al.voice('The normalization is stored as ' + name)
else:
if op == 'decimal_scaling_norm_in_place':
pass
elif op == 'max_min_norm_in_place':
pass
elif op == 'mean_norm_in_place':
pass
elif op == 'znorm_in_place':
pass
def exiting_no(response):
"""
Exit the program deleting the workspace.
:param response: The response from Dialogflow.
"""
print('Deleting workspace')
al.Workspace().clean_workspace()
print('Deleted workspace')
print('DEBUG: Fulfillment text: {}'.format(response))
print('Closing program')
exit()
def get_subdataset_rows(parameters):
"""
Obtains a subset of the dataset by its rows.
:param parameters: The parameter of the function(dataset name,...).
"""
workspace = al.Workspace()
data_name = parameters['Dataset']
dataset = workspace.get_dataset(data_name)
if parameters["from"]:
index_a = int(parameters["from"])
else:
print('From what row number?')
al.voice('From what row number?')
query = al.query_input()
while not al.isnumber(query):
print(
'Incorrect input.\nIt is not a number.\nPlease introduce one:')
al.voice(
'Incorrect input.\nIt is not a number.\nPlease introduce one.')
query = al.query_input()
index_a = int(query)
if parameters["to"]:
index_b = int(parameters['to'])
else:
print('To what row number?')
al.voice('To what row number?')
query = al.query_input()
while not al.isnumber(query):
print(
'Incorrect input.\nIt is not a number.\nPlease introduce one:')
al.voice(
'Incorrect input.\nIt is not a number.\nPlease introduce one.')
query = al.query_input()
index_b = int(query)
if index_b < index_a:
print(
'This operation cannot be done.\nThe starting row number is greater than the last row number.'
)
raise Exception()
dataset = dataset.iloc[index_a:index_b]
num = workspace.get_counter('sub')
name = 'subrow' + str(num) + data_name
workspace.save_dataset(name, dataset)
txt = 'The sub-dataset by the rows is saved as ' + name
print(txt)
def test_load_dataset(self):
order = "load dataset titanic.csv"
data = response(self, order)
self.assertEqual(data['queryResult']['intent']['displayName'],
'LoadDataset')
self.assertEqual(data['queryResult']['intentDetectionConfidence'], 1.0)
self.assertEqual(data['queryResult']['parameters']['Dataset'],
'titanic')
al.load_dataset(data['queryResult']['parameters'])
self.workspace = al.Workspace()
dataset = self.workspace.get_dataset('current')
titanic = pd.read_csv("datasets/titanic.csv")
self.assertEqual(dataset.to_json(), titanic.to_json())
