def get(self, request):
cache = redis_conn.get(
f"user:{request.user.id}:analysis_and_training:filters"
)
filters = loads(cache) if cache else None
user = request.user
issues = get_issues_dataframe(
fields=[
get_source_field(user),
"Priority",
"Resolution",
"Description_tr",
"Assignee",
"Reporter",
],
filters=filters,
)
if issues.empty:
return Response({})
settings = {
"source_field": get_source_field(user),
"bug_resolution": get_bug_resolutions(user),
"mark_up_entities": get_mark_up_entities(user),
}
significant_terms = get_significant_terms(issues, settings)
context = {"significant_terms": significant_terms}
return Response(context)
def post(self, request):
user = request.user
cache = redis_conn.get(
f"user:{request.user.id}:analysis_and_training:filters"
)
filters = loads(cache) if cache else None
fields = get_issues_fields(request.user)
issues = get_issues_dataframe(filters=filters, fields=fields)
if issues.empty:
raise BugsNotFoundWarning
source_field = get_source_field(user)
if source_field not in issues.columns:
raise InvalidSourceField
resolutions = (
[resolution["value"] for resolution in get_bug_resolutions(user)]
if len(get_bug_resolutions(user)) != 0
else []
)
areas_of_testing = []
mark_up_entities = get_mark_up_entities(user)
if source_field:
areas_of_testing = [
area["area_of_testing"] for area in mark_up_entities
] + ["Other"]
for area in mark_up_entities:
issues = mark_up_series(
issues,
get_source_field(user),
area["area_of_testing"],
area["entities"],
)
issues = mark_up_other_data(issues, areas_of_testing)
train(
user,
issues,
areas_of_testing,
resolutions,
)
clear_cache(
["qa_metrics:predictions_page", "qa_metrics:predictions_table"],
request.user.id,
)
context = {
"result": "success",
}
return Response(context, status=200)
def post(self, request):
check_issues_exist()
request_data = request.data.copy()
user = request.user
request_data["predictions_table"] = get_predictions_table_settings(
user)
request_data["source_field"] = get_source_field(user)
update_resolutions(request_data, user)
remove_cache_record("settings:predictions_table", user.id)
training_serializer = UserTrainingSerializer(data=request_data)
training_serializer.is_valid(raise_exception=True)
update_bug_resolutions(user,
training_serializer.data["bug_resolution"])
update_mark_up_entities(user,
training_serializer.data["mark_up_entities"])
remove_training_parameters(user)
return Response({"result": "success"})
def test_update_source_field(self):
from apps.settings.serializers import (
SourceFieldSerializer, )
user = User.objects.get(name=TEST_USER["name"])
source_field = {
"source_field": "Priority",
}
source_field_serializer = SourceFieldSerializer(source_field)
update_source_field(user, source_field_serializer.data)
assert get_source_field(user) == "Priority"
def get(self, request):
check_issues_exist()
source_field = get_source_field(request.user)
source_field_names = sorted(get_fields())
result = {
"source_field": source_field,
"source_field_names": source_field_names,
}
return Response(result)
def get(self, request):
check_issues_exist()
mark_up_entities = get_mark_up_entities(request.user)
source_field = get_source_field(request.user)
if not source_field:
return Response({})
unique_values = get_unique_values(source_field)
unique_values = split_values(unique_values)
result = {
"mark_up_entities": mark_up_entities,
"entity_names": sorted(unique_values),
}
return Response(result)
def post(self, request):
metric = request.GET["metric"]
cache = redis_conn.get(
f"user:{request.user.id}:analysis_and_training:filters"
)
filters = loads(cache) if cache else None
source_field = get_source_field(request.user)
issues = get_issues_dataframe(
fields=[
metric.split()[0],
source_field,
"Description_tr",
"Assignee",
"Reporter",
],
filters=filters,
)
if issues.empty:
return Response({})
mark_up_entities = get_mark_up_entities(request.user)
if metric.split()[0] not in ("Resolution", "Priority"):
if source_field and mark_up_entities:
for area in mark_up_entities:
if area["area_of_testing"] == metric.split()[0]:
issues = mark_up_series(
issues,
source_field,
metric.split()[0],
area["entities"],
)
significant_terms = calculate_significance_weights(issues, metric)
context = {"significant_terms": significant_terms}
return Response(context)