def delete_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Delete a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Delete-a-Target
"""
body: Dict[str, str] = {}
target = _get_target_from_request(
request_path=request.path,
databases=self.databases,
)
if target.status == TargetStatuses.PROCESSING.value:
context.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_STATUS_PROCESSING.value,
}
return json_dump(body)
target.delete()
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
}
return json_dump(body)
def add_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Add a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Add-a-Target
"""
name = request.json()['name']
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self.databases,
)
assert isinstance(database, VuforiaDatabase)
targets = (
target for target in database.targets if not target.delete_date
)
if any(target.name == name for target in targets):
context.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_NAME_EXIST.value,
}
return json_dump(body)
active_flag = request.json().get('active_flag')
if active_flag is None:
active_flag = True
image = request.json()['image']
decoded = base64.b64decode(image)
image_file = io.BytesIO(decoded)
new_target = Target(
name=request.json()['name'],
width=request.json()['width'],
image=image_file,
active_flag=active_flag,
processing_time_seconds=self._processing_time_seconds,
application_metadata=request.json().get('application_metadata'),
)
database.targets.add(new_target)
context.status_code = HTTPStatus.CREATED
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_CREATED.value,
'target_id': new_target.target_id,
}
return json_dump(body)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.UNAUTHORIZED
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.AUTHENTICATION_FAILURE.value,
}
self.response_text = json_dump(body)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
self.headers = {
'Content-Type': 'application/json',
'Connection': 'keep-alive',
'Server': 'nginx',
'Date': date,
'WWW-Authenticate': 'VWS',
'Content-Length': str(len(self.response_text)),
}
def target_summary(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Get a summary report for a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Summary-Report
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
target_id = request.path.split('/')[-1]
target = database.get_target(target_id=target_id)
assert isinstance(database, VuforiaDatabase)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
body = {
'status': target.status,
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'database_name': database.database_name,
'target_name': target.name,
'upload_date': target.upload_date.strftime('%Y-%m-%d'),
'active_flag': target.active_flag,
'tracking_rating': target.tracking_rating,
'total_recos': target.total_recos,
'current_month_recos': target.current_month_recos,
'previous_month_recos': target.previous_month_recos,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Content-Length': str(len(body_json)),
'Server': 'nginx',
'Date': date,
}
return body_json
def get_target(
self,
request: _RequestObjectProxy,
context: _Context, # pylint: disable=unused-argument
) -> str:
"""
Get details of a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Record
"""
target = _get_target_from_request(
request_path=request.path,
databases=self.databases,
)
target_record = {
'target_id': target.target_id,
'active_flag': target.active_flag,
'name': target.name,
'width': target.width,
'tracking_rating': target.tracking_rating,
'reco_rating': target.reco_rating,
}
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
'target_record': target_record,
'status': target.status,
}
return json_dump(body)
def target_list(
self,
request: _RequestObjectProxy,
context: _Context, # pylint: disable=unused-argument
) -> str:
"""
Get a list of all targets.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Get-a-Target-List-for-a-Cloud-Database
"""
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self.databases,
)
assert isinstance(database, VuforiaDatabase)
results = [
target.target_id
for target in database.targets
if not target.delete_date
]
body: Dict[str, Union[str, List[str]]] = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'results': results,
}
return json_dump(body)
def target_list() -> Response:
"""
Get a list of all targets.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Get-a-Target-List-for-a-Cloud-Database
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
results = [target.target_id for target in database.not_deleted_targets]
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'results': results,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def target_list(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Get a list of all targets.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Get-a-Target-List-for-a-Cloud-Database
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
results = [target.target_id for target in database.not_deleted_targets]
body: Dict[str, str | list[str]] = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'results': results,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
def get_duplicates(target_id: str) -> Response:
"""
Get targets which may be considered duplicates of a given target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Check-for-Duplicate-Targets
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
[target] = [
target for target in database.targets if target.target_id == target_id
]
other_targets = set(database.targets) - {target}
similar_targets: list[str] = [
other.target_id
for other in other_targets
if other.image_value == target.image_value
and TargetStatuses.FAILED.value not in (target.status, other.status)
and TargetStatuses.PROCESSING.value != other.status
and other.active_flag
]
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'similar_targets': similar_targets,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.REQUEST_TIME_TOO_SKEWED.value,
}
self.response_text = json_dump(body)
def __init__(self, status_code: int) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = status_code
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.FAIL.value,
}
self.response_text = json_dump(body)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.UNAUTHORIZED
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.AUTHENTICATION_FAILURE.value,
}
self.response_text = json_dump(body)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.UNPROCESSABLE_ENTITY
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.IMAGE_TOO_LARGE.value,
}
self.response_text = json_dump(body)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.NOT_FOUND
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.UNKNOWN_TARGET.value,
}
self.response_text = json_dump(body)
def get_target(target_id: str) -> Response:
"""
Get details of a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Record
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
[target] = [
target for target in database.targets if target.target_id == target_id
]
target_record = {
'target_id': target.target_id,
'active_flag': target.active_flag,
'name': target.name,
'width': target.width,
'tracking_rating': target.tracking_rating,
'reco_rating': target.reco_rating,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
'target_record': target_record,
'status': target.status,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def database_summary() -> Response:
"""
Get a database summary report.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Get-a-Database-Summary-Report
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
'name': database.database_name,
'active_images': len(database.active_targets),
'inactive_images': len(database.inactive_targets),
'failed_images': len(database.failed_targets),
'target_quota': database.target_quota,
'total_recos': database.total_recos,
'current_month_recos': database.current_month_recos,
'previous_month_recos': database.previous_month_recos,
'processing_images': len(database.processing_targets),
'reco_threshold': database.reco_threshold,
'request_quota': database.request_quota,
# We have ``self.request_count`` but Vuforia always shows 0.
# This was not always the case.
'request_usage': 0,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def delete_target(target_id: str) -> Response:
"""
Delete a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Delete-a-Target
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
[target] = [
target for target in database.targets if target.target_id == target_id
]
if target.status == TargetStatuses.PROCESSING.value:
raise TargetStatusProcessing
target_manager_base_url = os.environ['TARGET_MANAGER_BASE_URL']
databases_url = f'{target_manager_base_url}/databases'
requests.delete(
url=f'{databases_url}/{database.database_name}/targets/{target_id}',
)
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def target_summary(target_id: str) -> Response:
"""
Get a summary report for a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Summary-Report
"""
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
[target] = [
target for target in database.targets if target.target_id == target_id
]
body = {
'status': target.status,
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'database_name': database.database_name,
'target_name': target.name,
'upload_date': target.upload_date.strftime('%Y-%m-%d'),
'active_flag': target.active_flag,
'tracking_rating': target.tracking_rating,
'total_recos': target.total_recos,
'current_month_recos': target.current_month_recos,
'previous_month_recos': target.previous_month_recos,
}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def get_duplicates(
self,
request: _RequestObjectProxy,
context: _Context, # pylint: disable=unused-argument
) -> str:
"""
Get targets which may be considered duplicates of a given target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Check-for-Duplicate-Targets
"""
target = _get_target_from_request(
request_path=request.path,
databases=self.databases,
)
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self.databases,
)
assert isinstance(database, VuforiaDatabase)
other_targets = set(database.targets) - set([target])
similar_targets: List[str] = [
other.target_id
for other in other_targets
if Image.open(other.image) == Image.open(target.image)
and TargetStatuses.FAILED.value
not in (target.status, other.status)
and TargetStatuses.PROCESSING.value != other.status
and other.active_flag
]
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'similar_targets': similar_targets,
}
return json_dump(body)
def target_summary(
self,
request: _RequestObjectProxy,
context: _Context, # pylint: disable=unused-argument
) -> str:
"""
Get a summary report for a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Summary-Report
"""
target = _get_target_from_request(
request_path=request.path,
databases=self.databases,
)
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self.databases,
)
assert isinstance(database, VuforiaDatabase)
body = {
'status': target.status,
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'database_name': database.database_name,
'target_name': target.name,
'upload_date': target.upload_date.strftime('%Y-%m-%d'),
'active_flag': target.active_flag,
'tracking_rating': target.tracking_rating,
'total_recos': 0,
'current_month_recos': 0,
'previous_month_recos': 0,
}
return json_dump(body)
def __init__(self) -> None:
"""
Attributes:
status_code: The status code to use in a response if this is
raised.
response_text: The response text to use in a response if this is
raised.
"""
super().__init__()
self.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_STATUS_PROCESSING.value,
}
self.response_text = json_dump(body)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
self.headers = {
'Content-Type': 'application/json',
'Connection': 'keep-alive',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(self.response_text)),
}
def update_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Update a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Update-a-Target
"""
target = _get_target_from_request(
request_path=request.path,
databases=self.databases,
)
body: Dict[str, str] = {}
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self.databases,
)
assert isinstance(database, VuforiaDatabase)
if target.status != TargetStatuses.SUCCESS.value:
context.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_STATUS_NOT_SUCCESS.value,
}
return json_dump(body)
if 'width' in request.json():
target.width = request.json()['width']
if 'active_flag' in request.json():
active_flag = request.json()['active_flag']
if active_flag is None:
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.FAIL.value,
}
context.status_code = HTTPStatus.BAD_REQUEST
return json_dump(body)
target.active_flag = active_flag
if 'application_metadata' in request.json():
if request.json()['application_metadata'] is None:
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.FAIL.value,
}
context.status_code = HTTPStatus.BAD_REQUEST
return json_dump(body)
application_metadata = request.json()['application_metadata']
target.application_metadata = application_metadata
if 'name' in request.json():
name = request.json()['name']
other_targets = set(database.targets) - set([target])
if any(
other.name == name
for other in other_targets
if not other.delete_date
):
context.status_code = HTTPStatus.FORBIDDEN
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_NAME_EXIST.value,
}
return json_dump(body)
target.name = name
if 'image' in request.json():
image = request.json()['image']
decoded = base64.b64decode(image)
image_file = io.BytesIO(decoded)
target.image = image_file
# In the real implementation, the tracking rating can stay the same.
# However, for demonstration purposes, the tracking rating changes but
# when the target is updated.
available_values = list(set(range(6)) - set([target.tracking_rating]))
target.processed_tracking_rating = random.choice(available_values)
gmt = ZoneInfo('GMT')
now = datetime.datetime.now(tz=gmt)
target.last_modified_date = now
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
}
return json_dump(body)
def add_target() -> Response:
"""
Add a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Add-a-Target
"""
processing_time_seconds = float(
os.environ.get('PROCESSING_TIME_SECONDS', '0.5'),
)
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
# We do not use ``request.get_json(force=True)`` because this only works
# when the content type is given as ``application/json``.
request_json = json.loads(request.data)
name = request_json['name']
active_flag = request_json.get('active_flag')
if active_flag is None:
active_flag = True
new_target = Target(
name=name,
width=request_json['width'],
image_value=base64.b64decode(request_json['image']),
active_flag=active_flag,
processing_time_seconds=processing_time_seconds,
application_metadata=request_json.get('application_metadata'),
)
target_manager_base_url = os.environ['TARGET_MANAGER_BASE_URL']
databases_url = f'{target_manager_base_url}/databases'
requests.post(
url=f'{databases_url}/{database.database_name}/targets',
json=new_target.to_dict(),
)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_CREATED.value,
'target_id': new_target.target_id,
}
return Response(
status=HTTPStatus.CREATED,
response=json_dump(body),
headers=headers,
)
def get_query_match_response_text(
request_headers: Dict[str, str],
request_body: bytes,
request_method: str,
request_path: str,
databases: Set[VuforiaDatabase],
query_processes_deletion_seconds: Union[int, float],
query_recognizes_deletion_seconds: Union[int, float],
) -> str:
"""
Args:
request_path: The path of the request.
request_headers: The headers sent with the request.
request_body: The body of the request.
request_method: The HTTP method of the request.
databases: All Vuforia databases.
query_recognizes_deletion_seconds: The number of seconds after a target
has been deleted that the query endpoint will still recognize the
target for.
query_processes_deletion_seconds: The number of seconds after a target
deletion is recognized that the query endpoint will return a 500
response on a match.
Returns:
The response text for a query endpoint request.
Raises:
MatchingTargetsWithProcessingStatus: There is at least one matching
target which has the status 'processing'.
ActiveMatchingTargetsDeleteProcessing: There is at least one active
target which matches and was recently deleted.
"""
body_file = io.BytesIO(request_body)
_, pdict = cgi.parse_header(request_headers['Content-Type'])
parsed = cgi.parse_multipart(
fp=body_file,
pdict={
'boundary': pdict['boundary'].encode(),
},
)
[max_num_results] = parsed.get('max_num_results', ['1'])
[include_target_data] = parsed.get('include_target_data', ['top'])
include_target_data = include_target_data.lower()
[image_bytes] = parsed['image']
assert isinstance(image_bytes, bytes)
image = io.BytesIO(image_bytes)
gmt = ZoneInfo('GMT')
now = datetime.datetime.now(tz=gmt)
processing_timedelta = datetime.timedelta(
seconds=query_processes_deletion_seconds,
)
recognition_timedelta = datetime.timedelta(
seconds=query_recognizes_deletion_seconds,
)
database = get_database_matching_client_keys(
request_headers=request_headers,
request_body=request_body,
request_method=request_method,
request_path=request_path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
matching_targets = [
target
for target in database.targets
if _images_match(image=target.image, another_image=image)
]
not_deleted_matches = [
target
for target in matching_targets
if target.active_flag
and not target.delete_date
and target.status == TargetStatuses.SUCCESS.value
]
deletion_not_recognized_matches = [
target
for target in matching_targets
if target.active_flag
and target.delete_date
and (now - target.delete_date) < recognition_timedelta
]
matching_targets_with_processing_status = [
target
for target in matching_targets
if target.status == TargetStatuses.PROCESSING.value
]
active_matching_targets_delete_processing = [
target
for target in matching_targets
if target.active_flag
and target.delete_date
and (now - target.delete_date)
< (recognition_timedelta + processing_timedelta)
and target not in deletion_not_recognized_matches
]
if matching_targets_with_processing_status:
raise MatchingTargetsWithProcessingStatus
if active_matching_targets_delete_processing:
raise ActiveMatchingTargetsDeleteProcessing
matches = not_deleted_matches + deletion_not_recognized_matches
results: List[Dict[str, Any]] = []
for target in matches:
target_timestamp = target.last_modified_date.timestamp()
if target.application_metadata is None:
application_metadata = None
else:
application_metadata = base64.b64encode(
decode_base64(encoded_data=target.application_metadata),
).decode('ascii')
target_data = {
'target_timestamp': int(target_timestamp),
'name': target.name,
'application_metadata': application_metadata,
}
if include_target_data == 'all':
result = {
'target_id': target.target_id,
'target_data': target_data,
}
elif include_target_data == 'top' and not results:
result = {
'target_id': target.target_id,
'target_data': target_data,
}
else:
result = {
'target_id': target.target_id,
}
results.append(result)
results = results[: int(max_num_results)]
body = {
'result_code': ResultCodes.SUCCESS.value,
'results': results,
'query_id': uuid.uuid4().hex,
}
value = json_dump(body)
return value
def update_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Update a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Update-a-Target
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
target_id = request.path.split('/')[-1]
target = database.get_target(target_id=target_id)
body: Dict[str, str] = {}
date = email.utils.formatdate(None, localtime=False, usegmt=True)
if target.status != TargetStatuses.SUCCESS.value:
exception = TargetStatusNotSuccess()
context.headers = exception.headers
context.status_code = exception.status_code
return exception.response_text
width = request.json().get('width', target.width)
name = request.json().get('name', target.name)
active_flag = request.json().get('active_flag', target.active_flag)
application_metadata = request.json().get(
'application_metadata',
target.application_metadata,
)
image_value = target.image_value
if 'image' in request.json():
image_value = base64.b64decode(request.json()['image'])
if 'active_flag' in request.json() and active_flag is None:
fail_exception = Fail(status_code=HTTPStatus.BAD_REQUEST)
context.headers = fail_exception.headers
context.status_code = fail_exception.status_code
return fail_exception.response_text
if (
'application_metadata' in request.json()
and application_metadata is None
):
fail_exception = Fail(status_code=HTTPStatus.BAD_REQUEST)
context.headers = fail_exception.headers
context.status_code = fail_exception.status_code
return fail_exception.response_text
# In the real implementation, the tracking rating can stay the same.
# However, for demonstration purposes, the tracking rating changes but
# when the target is updated.
available_values = list(set(range(6)) - {target.tracking_rating})
processed_tracking_rating = random.choice(available_values)
gmt = ZoneInfo('GMT')
last_modified_date = datetime.datetime.now(tz=gmt)
new_target = dataclasses.replace(
target,
name=name,
width=width,
active_flag=active_flag,
application_metadata=application_metadata,
image_value=image_value,
processed_tracking_rating=processed_tracking_rating,
last_modified_date=last_modified_date,
)
database.targets.remove(target)
database.targets.add(new_target)
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
def database_summary(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Get a database summary report.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Get-a-Database-Summary-Report
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
body: Dict[str, str | int] = {}
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
'name': database.database_name,
'active_images': len(database.active_targets),
'inactive_images': len(database.inactive_targets),
'failed_images': len(database.failed_targets),
'target_quota': database.target_quota,
'total_recos': database.total_recos,
'current_month_recos': database.current_month_recos,
'previous_month_recos': database.previous_month_recos,
'processing_images': len(database.processing_targets),
'reco_threshold': database.reco_threshold,
'request_quota': database.request_quota,
'request_usage': 0,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
def add_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Add a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Add-a-Target
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
given_active_flag = request.json().get('active_flag')
active_flag = {
None: True,
True: True,
False: False,
}[given_active_flag]
application_metadata = request.json().get('application_metadata')
new_target = Target(
name=request.json()['name'],
width=request.json()['width'],
image_value=base64.b64decode(request.json()['image']),
active_flag=active_flag,
processing_time_seconds=self._processing_time_seconds,
application_metadata=application_metadata,
)
database.targets.add(new_target)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
context.status_code = HTTPStatus.CREATED
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.TARGET_CREATED.value,
'target_id': new_target.target_id,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
def get_duplicates(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Get targets which may be considered duplicates of a given target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Check-for-Duplicate-Targets
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
target_id = request.path.split('/')[-1]
target = database.get_target(target_id=target_id)
other_targets = set(database.targets) - {target}
similar_targets: list[str] = [
other.target_id
for other in other_targets
if other.image_value == target.image_value
and TargetStatuses.FAILED.value
not in (target.status, other.status)
and TargetStatuses.PROCESSING.value != other.status
and other.active_flag
]
date = email.utils.formatdate(None, localtime=False, usegmt=True)
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
'similar_targets': similar_targets,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
def update_target(target_id: str) -> Response:
"""
Update a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Update-a-Target
"""
# We do not use ``request.get_json(force=True)`` because this only works
# when the content type is given as ``application/json``.
request_json = json.loads(request.data)
databases = get_all_databases()
database = get_database_matching_server_keys(
request_headers=dict(request.headers),
request_body=request.data,
request_method=request.method,
request_path=request.path,
databases=databases,
)
assert isinstance(database, VuforiaDatabase)
[target] = [
target for target in database.targets if target.target_id == target_id
]
if target.status != TargetStatuses.SUCCESS.value:
raise TargetStatusNotSuccess
update_values = {}
if 'width' in request_json:
update_values['width'] = request_json['width']
if 'active_flag' in request_json:
active_flag = request_json['active_flag']
if active_flag is None:
raise Fail(status_code=HTTPStatus.BAD_REQUEST)
update_values['active_flag'] = active_flag
if 'application_metadata' in request_json:
application_metadata = request_json['application_metadata']
if application_metadata is None:
raise Fail(status_code=HTTPStatus.BAD_REQUEST)
update_values['application_metadata'] = application_metadata
if 'name' in request_json:
name = request_json['name']
update_values['name'] = name
if 'image' in request_json:
image = request_json['image']
update_values['image'] = image
target_manager_base_url = os.environ['TARGET_MANAGER_BASE_URL']
put_url = (
f'{target_manager_base_url}/databases/{database.database_name}/'
f'targets/{target_id}'
)
requests.put(url=put_url, json=update_values)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
}
body = {
'result_code': ResultCodes.SUCCESS.value,
'transaction_id': uuid.uuid4().hex,
}
return Response(
status=HTTPStatus.OK,
response=json_dump(body),
headers=headers,
)
def delete_target(
self,
request: _RequestObjectProxy,
context: _Context,
) -> str:
"""
Delete a target.
Fake implementation of
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Delete-a-Target
"""
try:
run_services_validators(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
except ValidatorException as exc:
context.headers = exc.headers
context.status_code = exc.status_code
return exc.response_text
body: Dict[str, str] = {}
database = get_database_matching_server_keys(
request_headers=request.headers,
request_body=request.body,
request_method=request.method,
request_path=request.path,
databases=self._target_manager.databases,
)
assert isinstance(database, VuforiaDatabase)
target_id = request.path.split('/')[-1]
target = database.get_target(target_id=target_id)
if target.status == TargetStatuses.PROCESSING.value:
target_processing_exception = TargetStatusProcessing()
context.headers = target_processing_exception.headers
context.status_code = target_processing_exception.status_code
return target_processing_exception.response_text
now = datetime.datetime.now(tz=target.upload_date.tzinfo)
new_target = dataclasses.replace(target, delete_date=now)
database.targets.remove(target)
database.targets.add(new_target)
date = email.utils.formatdate(None, localtime=False, usegmt=True)
body = {
'transaction_id': uuid.uuid4().hex,
'result_code': ResultCodes.SUCCESS.value,
}
body_json = json_dump(body)
context.headers = {
'Connection': 'keep-alive',
'Content-Type': 'application/json',
'Server': 'nginx',
'Date': date,
'Content-Length': str(len(body_json)),
}
return body_json
