def delete_experiment(uuid, project_id): """Delete an experiment in our database and in the object storage. Args: uuid (str): the experiment uuid to look for in our database. project_id (str): the project uuid. Returns: The deletion result. """ raise_if_project_does_not_exist(project_id) experiment = Experiment.query.get(uuid) if experiment is None: raise NOTFOUND # remove compare results CompareResult.query.filter(CompareResult.experiment_id == uuid).delete() # remove operators Operator.query.filter(Operator.experiment_id == uuid).delete() db_session.delete(experiment) db_session.commit() fix_positions(project_id=experiment.project_id) prefix = join("experiments", uuid) remove_objects(prefix=prefix) return {"message": "Experiment deleted"}
def delete_operator(uuid, project_id, experiment_id): """Delete an operator in our database. Args: uuid (str): the operator uuid to look for in our database. project_id (str): the project uuid. experiment_id (str): the experiment uuid. Returns: The deletion result. """ raise_if_project_does_not_exist(project_id) raise_if_experiment_does_not_exist(experiment_id) operator = Operator.query.get(uuid) if operator is None: raise NotFound("The specified operator does not exist") # check if other operators contains the operator being deleted # in dependencies and remove this operator from dependencies operators = db_session.query(Operator) \ .filter_by(experiment_id=experiment_id) \ .filter(Operator.uuid != uuid)\ .all() for op in operators: if uuid in op.dependencies: dependencies = op.dependencies.remove(uuid) if dependencies is None: dependencies = [] update_operator(op.uuid, project_id, experiment_id, dependencies=dependencies) db_session.delete(operator) db_session.commit() return {"message": "Operator deleted"}
def update_compare_result(uuid, project_id, **kwargs): """Updates a compare result in our database. Args: uuid (str): the a compare result uuid to look for in our database. project_id (str): the project uuid. **kwargs: arbitrary keyword arguments. Returns: The compare result info. """ raise_if_project_does_not_exist(project_id) compare_result = CompareResult.query.get(uuid) if compare_result is None: raise NOT_FOUND experiment_id = kwargs.get("experiment_id", None) if experiment_id: raise_if_experiment_does_not_exist(experiment_id) data = {"updated_at": datetime.utcnow()} data.update(kwargs) try: db_session.query(CompareResult).filter_by(uuid=uuid).update(data) db_session.commit() except (InvalidRequestError, ProgrammingError) as e: raise BadRequest(str(e)) return compare_result.as_dict()
def create_operator(project_id, experiment_id, task_id=None, parameters=None, dependencies=None, position_x=None, position_y=None, **kwargs): """ Creates a new operator in our database. The new operator is added to the end of the operator list. Args: project_id (str): the project uuid. experiment_id (str): the experiment uuid. task_id (str): the task uuid. parameters (dict): the parameters dict. dependencies (list): the dependencies array. position_x (float): position x. position_y (float): position y. Returns: The operator info. """ raise_if_project_does_not_exist(project_id) raise_if_experiment_does_not_exist(experiment_id) if not isinstance(task_id, str): raise BadRequest("taskId is required") try: raise_if_task_does_not_exist(task_id) except NotFound as e: raise BadRequest(e.description) if parameters is None: parameters = {} raise_if_parameters_are_invalid(parameters) if dependencies is None: dependencies = [] raise_if_dependencies_are_invalid(project_id, experiment_id, dependencies) operator = Operator(uuid=uuid_alpha(), experiment_id=experiment_id, task_id=task_id, dependencies=dependencies, parameters=parameters, position_x=position_x, position_y=position_y) db_session.add(operator) db_session.commit() check_status(operator) return operator.as_dict()
def create_compare_result(project_id=None): """Creates a new compare result in our database. Args: project_id (str): the project uuid. Returns: The compare result info. """ raise_if_project_does_not_exist(project_id) compare_result = CompareResult(uuid=uuid_alpha(), project_id=project_id) db_session.add(compare_result) db_session.commit() return compare_result.as_dict()
def list_compare_results(project_id): """Lists all compare results under a project. Args: project_id (str): the project uuid. Returns: A list of all compare results. """ raise_if_project_does_not_exist(project_id) compare_results = db_session.query(CompareResult) \ .filter_by(project_id=project_id) \ .order_by(CompareResult.created_at.asc()) \ .all() return [compare_result.as_dict() for compare_result in compare_results]
def list_experiments(project_id): """Lists all experiments under a project. Args: project_id (str): the project uuid. Returns: A list of all experiments. """ raise_if_project_does_not_exist(project_id) experiments = db_session.query(Experiment) \ .filter_by(project_id=project_id) \ .order_by(Experiment.position.asc()) \ .all() return [experiment.as_dict() for experiment in experiments]
def get_experiment(uuid, project_id): """Details an experiment from our database. Args: uuid (str): the experiment uuid to look for in our database. project_id (str): the project uuid. Returns: The experiment info. """ raise_if_project_does_not_exist(project_id) experiment = Experiment.query.get(uuid) if experiment is None: raise NOTFOUND return experiment.as_dict()
def delete_compare_result(uuid, project_id): """Delete a compare result in our database. Args: uuid (str): the compare result uuid to look for in our database. project_id (str): the project uuid. Returns: The deletion result. """ raise_if_project_does_not_exist(project_id) compare_result = CompareResult.query.get(uuid) if compare_result is None: raise NOT_FOUND db_session.delete(compare_result) db_session.commit() return {"message": "Compare result deleted"}
def list_operators(project_id, experiment_id): """Lists all operators under an experiment. Args: project_id (str): the project uuid. experiment_id (str): the experiment uuid. Returns: A list of all operator. """ raise_if_project_does_not_exist(project_id) raise_if_experiment_does_not_exist(experiment_id) operators = db_session.query(Operator) \ .filter_by(experiment_id=experiment_id) \ .all() response = [] for operator in operators: check_status(operator) response.append(operator.as_dict()) return response
def update_operator(uuid, project_id, experiment_id, **kwargs): """Updates an operator in our database and adjusts the position of others. Args: uuid (str): the operator uuid to look for in our database. project_id (str): the project uuid. experiment_id (str): the experiment uuid. **kwargs: arbitrary keyword arguments. Returns: The operator info. """ raise_if_project_does_not_exist(project_id) raise_if_experiment_does_not_exist(experiment_id) operator = Operator.query.get(uuid) if operator is None: raise NotFound("The specified operator does not exist") raise_if_parameters_are_invalid(kwargs.get("parameters", {})) dependencies = kwargs.get("dependencies") if dependencies is not None: raise_if_dependencies_are_invalid(project_id, experiment_id, dependencies, operator_id=uuid) data = {"updated_at": datetime.utcnow()} data.update(kwargs) try: db_session.query(Operator).filter_by(uuid=uuid).update(data) db_session.commit() except (InvalidRequestError, ProgrammingError) as e: raise BadRequest(str(e)) check_status(operator) return operator.as_dict()
def create_experiment(name=None, project_id=None, copy_from=None): """Creates a new experiment in our database and adjusts the position of others. The new experiment is added to the end of the experiment list. Args: name (str): the experiment name. project_id (str): the project uuid. copy_from (str): the copy_from uuid. Returns: The experiment info. """ raise_if_project_does_not_exist(project_id) if not isinstance(name, str): raise BadRequest("name is required") check_experiment_name = db_session.query(Experiment)\ .filter(Experiment.project_id == project_id)\ .filter(Experiment.name == name)\ .first() if check_experiment_name: raise BadRequest("an experiment with that name already exists") experiment = Experiment(uuid=uuid_alpha(), name=name, project_id=project_id) db_session.add(experiment) db_session.commit() if copy_from: try: experiment_find = find_by_experiment_id(experiment_id=copy_from) source_operators = {} for source_operator in experiment_find['operators']: source_dependencies = source_operator.dependencies kwargs = { "task_id": source_operator.task_id, "parameters": source_operator.parameters, "dependencies": [], "position_x": source_operator.position_x, "position_y": source_operator.position_y } operator = create_operator(project_id, experiment.uuid, **kwargs) source_operators[source_operator.uuid] = { "copy_uuid": operator["uuid"], "dependencies": source_dependencies } # update dependencies on new operators for _, value in source_operators.items(): dependencies = [source_operators[d]['copy_uuid'] for d in value['dependencies']] update_operator(value['copy_uuid'], project_id, experiment.uuid, dependencies=dependencies) except NotFound: delete_experiment(experiment.uuid, project_id) raise BadRequest('Source experiment does not exist') fix_positions(project_id=project_id, experiment_id=experiment.uuid, new_position=sys.maxsize) # will add to end of list return experiment.as_dict()
def update_experiment(uuid, project_id, **kwargs): """Updates an experiment in our database and adjusts the position of others. Args: uuid (str): the experiment uuid to look for in our database. project_id (str): the project uuid. **kwargs: arbitrary keyword arguments. Returns: The experiment info. """ raise_if_project_does_not_exist(project_id) experiment = Experiment.query.get(uuid) if experiment is None: raise NOTFOUND if "name" in kwargs: name = kwargs["name"] if name != experiment.name: check_experiment_name = db_session.query(Experiment)\ .filter(Experiment.project_id == project_id)\ .filter(Experiment.name == name)\ .first() if check_experiment_name: raise BadRequest("an experiment with that name already exists") # updates operators if "template_id" in kwargs: template_id = kwargs["template_id"] del kwargs["template_id"] template = Template.query.get(template_id) if template is None: raise BadRequest("The specified template does not exist") # remove operators Operator.query.filter(Operator.experiment_id == uuid).delete() # save the last operator id created to create dependency on next operator last_operator_id = None for task_id in template.tasks: operator_id = uuid_alpha() dependencies = [] if last_operator_id is not None: dependencies = [last_operator_id] objects = [ Operator(uuid=operator_id, experiment_id=uuid, task_id=task_id, dependencies=dependencies) ] db_session.bulk_save_objects(objects) last_operator_id = operator_id data = {"updated_at": datetime.utcnow()} data.update(kwargs) try: db_session.query(Experiment).filter_by(uuid=uuid).update(data) db_session.commit() except (InvalidRequestError, ProgrammingError) as e: raise BadRequest(str(e)) fix_positions(project_id=experiment.project_id, experiment_id=experiment.uuid, new_position=experiment.position) return experiment.as_dict()