def update(self, request, pk=None):
"""
PUT request for updating a project.
:param request: PUT request
:return: The updated/200
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs,
context={'request': request})
if serializer.is_valid() and pk is not None:
try:
project = Project.objects.get(id=int(pk))
except Project.DoesNotExist:
return Response("No project found for id: {}".format(pk),
status=status.HTTP_400_BAD_REQUEST)
if IsOwner().has_object_permission(request, self, project):
project = serializer.update(project, serializer.validated_data)
if "metadata" not in dataset_inputs.keys():
dataset_inputs["metadata"] = None
m = Metadata(project, dataset_inputs["metadata"])
meta = m.set_metadata("ProjectMetadata")
response_data = serializer.data
if meta:
response_data["metadata"] = meta
request_status = status.HTTP_200_OK
return Response(response_data, status=request_status)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk=None):
"""
PUT request to update an existing location.
:param request: PUT request
:param pk: Location ID
:return:
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs,
context={'request': request})
if serializer.is_valid() and pk is not None:
try:
original_location = Location.objects.get(id=int(pk))
except Location.DoesNotExist:
return Response("No location found for id: {}".format(pk),
status=status.HTTP_400_BAD_REQUEST)
if original_location.owner == request.user:
location = serializer.update(original_location,
serializer.validated_data)
if location:
l = serializer.data
m = Metadata(location, dataset_inputs["metadata"])
meta = m.set_metadata("LocationMetadata")
if meta:
l["metadata"] = meta
request_status = status.HTTP_201_CREATED
if int(pk) == location.id:
request_status = status.HTTP_200_OK
return Response(l, status=request_status)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
"""
POST request that creates a new Pipeline.
:param request: POST request
:return: New pipeline object
"""
pipeline_inputs = load_request(request)
serializer = self.serializer_class(data=pipeline_inputs,
context={'request': request})
try:
project = Project.objects.get(id=int(pipeline_inputs["project"]))
except Project.DoesNotExist:
return Response("No project found for id: {}".format(
int(pipeline_inputs["project"])),
status=status.HTTP_400_BAD_REQUEST)
if project.owner != request.user:
return Response(status=status.HTTP_401_UNAUTHORIZED)
if serializer.is_valid():
serializer.save()
pipeline = serializer.data
if "metadata" not in pipeline_inputs.keys():
pipeline_inputs["metadata"] = None
a = Pipeline.objects.get(pk=int(pipeline["id"]))
m = Metadata(a, pipeline_inputs["metadata"])
meta = m.set_metadata("PipelineMetadata")
pipeline["metadata"] = meta
if pipeline:
return Response(pipeline, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk=None):
"""
PUT request to update a dataset
:param request: PUT request
:param pk: dataset ID to be updated
:return: 200/details of updated dataset, 400/bad request, or 401/unauthorized
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs, context={'request': request})
if serializer.is_valid() and pk is not None:
try:
original_dataset = Dataset.objects.get(id=int(pk))
except Dataset.DoesNotExist:
return Response(
"No dataset found for id: {}".format(pk),
status=status.HTTP_400_BAD_REQUEST
)
if IsOwner().has_object_permission(request, self, original_dataset):
amodel = serializer.update(original_dataset, serializer.validated_data)
m = Metadata(amodel, dataset_inputs["metadata"])
meta = m.set_metadata("DatasetMetadata")
if amodel:
response_status = status.HTTP_201_CREATED
response_data = serializer.data
response_data["id"] = amodel.id
del response_data["data"]
if meta:
response_data["metadata"] = meta
if int(pk) == amodel.id:
response_status = status.HTTP_200_OK
return Response(response_data, status=response_status)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
"""
POST request that creates a new Dataset.
:param request: POST request.
:return: New dataset
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs, context={'request': request})
if serializer.is_valid():
serializer.save()
dataset = serializer.data
if dataset:
d = Dataset.objects.get(id=dataset["id"])
if "metadata" not in dataset_inputs.keys():
dataset_inputs["metadata"] = None
m = Metadata(d, dataset_inputs["metadata"])
meta = m.set_metadata("DatasetMetadata")
response = "Response"
if meta:
dataset["metadata"] = meta
response = meta["target"]
data = load_dataset(d.id)
if response not in data:
response = data.columns.tolist()[0]
dataset["statistics"] = DatasetStatistics(data).calculate_statistics(response)
del dataset["data"]
return Response(dataset, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def execute(self, request):
input_data = load_request(request)
required_parameters = ["project_id", "dataset_id", "pipeline_id"]
if set(required_parameters).issubset(input_data.keys()):
permissions = []
try:
project = Project.objects.get(id=int(input_data["project_id"]))
if not IsOwnerOfProject().has_object_permission(
request, self, project):
permissions.append("Unauthorized to access project.")
except Project.DoesNotExist:
project = None
try:
pipeline = Pipeline.objects.get(
id=int(input_data["pipeline_id"]))
if not IsOwnerOfPipeline().has_object_permission(
request, self, pipeline):
permissions.append("Unauthorized to access pipeline")
except Pipeline.DoesNotExist:
pipeline = None
try:
dataset = Dataset.objects.get(id=int(input_data["dataset_id"]))
if not IsOwnerOfDataset().has_object_permission(
request, self, dataset):
permissions.append("Unauthorized to access dataset")
except Dataset.DoesNotExist:
dataset = None
if len(permissions) > 0:
return Response(permissions,
status=status.HTTP_401_UNAUTHORIZED)
if project is None or dataset is None or pipeline is None:
message = []
if project is None:
message.append("No project found for id: {}".format(
input_data["project_id"]))
if dataset is None:
message.append("No dataset found for id: {}".format(
input_data["dataset_id"]))
if pipeline is None:
message.append("No pipeline found for id: {}".format(
input_data["pipeline_id"]))
return Response(", ".join(message),
status=status.HTTP_400_BAD_REQUEST)
try:
DaskTasks.setup_task(project_id=project.id,
dataset_id=dataset.id,
pipeline_id=pipeline.id)
response = "Successfully executed pipeline"
except Exception as ex:
response = "Error occured attempting to execute pipeline. Message: {}".format(
ex)
return Response(response, status=status.HTTP_200_OK)
else:
return Response(
"Missing required parameters in POST request. Required parameters: {}"
.format(", ".join(required_parameters)),
status.HTTP_400_BAD_REQUEST)
def refit_model(self, request):
input_data = load_request(request)
required_parameters = ["project_id", "model_id", "predictive_models"]
if set(required_parameters).issubset(input_data.keys()):
permissions = []
try:
project = Project.objects.get(id=int(input_data["project_id"]))
if not IsOwnerOfProject().has_object_permission(
request, self, project):
permissions.append("Unauthorized to access project.")
except Project.DoesNotExist:
project = None
try:
model = Model.objects.get(id=int(input_data["model_id"]))
if not IsOwnerOfModel().has_object_permission(
request, self, model):
permissions.append("Unauthorized to access pipeline")
except Model.DoesNotExist:
model = None
if len(permissions) > 0:
return Response(permissions,
status=status.HTTP_401_UNAUTHORIZED)
if model is None or project is None:
message = []
if project is None:
message.append("No project found for id: {}".format(
input_data["project_id"]))
if model is None:
message.append("No model found for id: {}".format(
input_data["model_id"]))
return Response(", ".join(message),
status=status.HTTP_400_BAD_REQUEST)
p_models = {}
for p in json.loads(input_data["predictive_models"]):
p_models[p[0]] = int(p[1])
m = Metadata(model, json.dumps({"predictive_models": p_models}))
meta = m.set_metadata("ModelMetadata")
response = {}
DaskTasks.refit_task(project.id, model.id, p_models)
response["project_id"] = project.id
response["pipeline_id"] = model.pipeline.id
response["model_id"] = model.id
response["dataset_id"] = project.dataset
response["model_metadata"] = meta
response[
"status"] = "Initiated refit for specified models for prediction"
return Response(response, status=status.HTTP_200_OK)
data = "Missing required parameters: {}".format(
", ".join(required_parameters))
response_status = status.HTTP_200_OK
return Response(data, status=response_status)
def evaluate(self, request):
"""
:param request:
:return:
"""
input_data = load_request(request)
required_parameters = ["project_id", "model_id"]
if set(required_parameters).issubset(input_data.keys()):
permissions = []
try:
project = Project.objects.get(id=int(input_data["project_id"]))
if not IsOwnerOfProject().has_object_permission(
request, self, project):
permissions.append("Unauthorized to access project.")
except Project.DoesNotExist:
project = None
try:
model = Model.objects.get(id=int(input_data["model_id"]))
if not IsOwnerOfModel().has_object_permission(
request, self, model):
permissions.append("Unauthorized to access pipeline")
except Model.DoesNotExist:
model = None
if len(permissions) > 0:
return Response(permissions,
status=status.HTTP_401_UNAUTHORIZED)
if model is None or project is None:
message = []
if project is None:
message.append("No project found for id: {}".format(
input_data["project_id"]))
if model is None:
message.append("No model found for id: {}".format(
input_data["model_id"]))
return Response(", ".join(message),
status=status.HTTP_400_BAD_REQUEST)
flag = input_data["flag"] if "flag" in input_data.keys() else None
response = {}
results = DaskTasks.evaluate(project.id, model.id, flag)
response["project_id"] = project.id
response["pipeline_id"] = model.pipeline.id
response["model_id"] = model.id
response["dataset_id"] = project.dataset
response["results"] = results
return Response(response, status=status.HTTP_200_OK)
data = "Missing required parameters: {}".format(
", ".join(required_parameters))
response_status = status.HTTP_200_OK
return Response(data, status=response_status)
def update(self, request, pk=None):
"""
:param request:
:param pk:
:return:
"""
pipeline_inputs = load_request(request)
serializer = self.serializer_class(data=pipeline_inputs,
context={'request': request})
try:
project = Project.objects.get(id=int(pipeline_inputs["project"]))
except Project.DoesNotExist:
return Response("No project found for id: {}".format(
int(pipeline_inputs["project"])),
status=status.HTTP_400_BAD_REQUEST)
if project.owner != request.user:
return Response(status=status.HTTP_401_UNAUTHORIZED)
if serializer.is_valid() and pk is not None:
try:
original_pipeline = Pipeline.objects.get(id=int(pk))
except Pipeline.DoesNotExist:
return Response("No pipeline found for id: {}".format(pk),
status=status.HTTP_400_BAD_REQUEST)
if IsOwnerOfPipeline().has_object_permission(
request, self, original_pipeline):
experiment = serializer.update(original_pipeline,
serializer.validated_data)
if experiment:
response_status = status.HTTP_201_CREATED
response_data = serializer.data
response_data["id"] = experiment.id
if int(pk) == experiment.id:
response_status = status.HTTP_200_OK
if "metadata" not in pipeline_inputs.keys():
pipeline_inputs["metadata"] = None
a = Pipeline.objects.get(pk=experiment.id)
m = Metadata(a, pipeline_inputs["metadata"])
response_data["metadata"] = m.set_metadata(
"PipelineMetadata")
return Response(response_data, status=response_status)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def predict_and_save(self, request):
"""
:param request:
:return:
"""
input_data = load_request(request)
required_parameters = ["project_id", "model_id"]
if set(required_parameters).issubset(input_data.keys()):
permissions = []
try:
project = Project.objects.get(id=int(input_data["project_id"]))
if not IsOwnerOfProject().has_object_permission(
request, self, project):
permissions.append("Unauthorized to access project.")
except Project.DoesNotExist:
project = None
try:
model = Model.objects.get(id=int(input_data["model_id"]))
if not IsOwnerOfModel().has_object_permission(
request, self, model):
permissions.append("Unauthorized to access pipeline")
except Model.DoesNotExist:
model = None
if len(permissions) > 0:
return Response(permissions,
status=status.HTTP_401_UNAUTHORIZED)
if model is None or project is None:
message = []
if project is None:
message.append("No project found for id: {}".format(
input_data["project_id"]))
if model is None:
message.append("No model found for id: {}".format(
input_data["model_id"]))
return Response(", ".join(message),
status=status.HTTP_400_BAD_REQUEST)
pd = PredictionData(project_id=project.id, model_id=model.id)
data = pd.get_cv_predictions()
return Response(data, status=status.HTTP_200_OK)
data = "Missing required parameters: {}".format(
", ".join(required_parameters))
response_status = status.HTTP_200_OK
return Response(data, status=response_status)
def create(self, request):
"""
POST request that creates a new project.
:param request: POST request
:return: New project object
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs, context={'request': request})
if serializer.is_valid():
serializer.save()
project = serializer.data
p = Project.objects.get(id=project["id"])
if "metadata" not in dataset_inputs.keys():
dataset_inputs["metadata"] = None
m = Metadata(p, dataset_inputs["metadata"])
meta = m.set_metadata("ProjectMetadata")
project["metadata"] = meta
return Response(project, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
"""
POST request that creates a new location.
:param request: POST request
:return: New location object
"""
dataset_inputs = load_request(request)
serializer = self.serializer_class(data=dataset_inputs,
context={'request': request})
# TODO: Add project existence and ownership check
if serializer.is_valid():
location = serializer.save()
location_data = serializer.data
if "metadata" not in dataset_inputs.keys():
dataset_inputs["metadata"] = None
m = Metadata(location, dataset_inputs["metadata"])
meta = m.set_metadata("LocationMetadata")
if meta:
location_data["metadata"] = meta
if location:
return Response(location_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)