def test_wait_for_target_processed(
self,
mock_database: VuforiaDatabase,
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to use a command to wait for a target to be processed.
"""
runner = CliRunner()
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 0
assert result.stdout == ''
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status != TargetStatuses.PROCESSING
def test_custom_timeout(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to set a maximum timeout.
"""
runner = CliRunner(mix_stderr=False)
with MockVWS(processing_time_seconds=0.5) as mock:
mock_database = VuforiaDatabase()
mock.add_database(database=mock_database)
vws_client = VWS(
server_access_key=mock_database.server_access_key,
server_secret_key=mock_database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--timeout-seconds',
'0.1',
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code != 0
assert result.stderr == 'Timeout of 0.1 seconds reached.\n'
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--timeout-seconds',
'0.5',
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 0
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status != TargetStatuses.PROCESSING
def test_inactive_project(
self,
inactive_vws_client: VWS,
) -> None:
"""
The project's active state does not affect getting a target.
"""
with pytest.raises(UnknownTarget):
inactive_vws_client.get_target_summary_report(
target_id=uuid.uuid4().hex, )
def test_recognition(
self,
vws_client: VWS,
cloud_reco_client: CloudRecoService,
high_quality_image: io.BytesIO,
) -> None:
"""
The recognition counts stay at 0 even after recognitions.
"""
target_id = vws_client.add_target(
name='example',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
results = cloud_reco_client.query(image=high_quality_image)
[result] = results
assert result.target_id == target_id
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.SUCCESS
assert report.total_recos == 0
assert report.current_month_recos == 0
assert report.previous_month_recos == 0
def test_get_target_summary_report(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
Details of a target are returned by ``get_target_summary_report``.
"""
date = '2018-04-25'
target_name = uuid.uuid4().hex
with freeze_time(date):
target_id = vws_client.add_target(
name=target_name,
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
result = vws_client.get_target_summary_report(target_id=target_id)
expected_report = TargetSummaryReport(
status=TargetStatuses.SUCCESS,
database_name=result.database_name,
target_name=target_name,
upload_date=datetime.date(2018, 4, 25),
active_flag=True,
tracking_rating=result.tracking_rating,
total_recos=0,
current_month_recos=0,
previous_month_recos=0,
)
assert result == expected_report
def test_wait_for_target_processed(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to wait until a target is processed.
"""
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
vws_client.wait_for_target_processed(target_id=target_id)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status != TargetStatuses.PROCESSING
def test_custom_timeout(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to set a maximum timeout.
"""
with MockVWS(processing_time_seconds=0.5) as mock:
database = VuforiaDatabase()
mock.add_database(database=database)
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
with pytest.raises(TargetProcessingTimeout):
vws_client.wait_for_target_processed(
target_id=target_id,
timeout_seconds=0.1,
)
vws_client.wait_for_target_processed(
target_id=target_id,
timeout_seconds=0.5,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status != TargetStatuses.PROCESSING
def test_after_processing(
self,
vws_client: VWS,
request: SubRequest,
image_fixture_name: str,
expected_status: TargetStatuses,
) -> None:
"""
After processing is completed, the tracking rating is in the range of
0 to 5.
The documentation says:
> Note: tracking_rating and reco_rating are provided only when
> status = success.
However, this shows that ``tracking_rating`` is given when the status
is not success.
It also shows that ``reco_rating`` is not provided even when the status
is success.
"""
image_file = request.getfixturevalue(image_fixture_name)
target_id = vws_client.add_target(
name='example',
width=1,
image=image_file,
active_flag=True,
application_metadata=None,
)
# The tracking rating may change during processing.
# Therefore we wait until processing ends.
vws_client.wait_for_target_processed(target_id=target_id)
report = vws_client.get_target_summary_report(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
tracking_rating = target_details.target_record.tracking_rating
assert report.tracking_rating == tracking_rating
assert report.tracking_rating in range(6)
assert report.status == expected_status
assert report.total_recos == 0
assert report.current_month_recos == 0
assert report.previous_month_recos == 0
def test_target_summary(
self,
vws_client: VWS,
vuforia_database: VuforiaDatabase,
image_file_failed_state: io.BytesIO,
active_flag: bool,
) -> None:
"""
A target summary is returned.
"""
name = uuid.uuid4().hex
gmt = ZoneInfo('GMT')
date_before_add_target = datetime.datetime.now(tz=gmt).date()
target_id = vws_client.add_target(
name=name,
width=1,
image=image_file_failed_state,
active_flag=active_flag,
application_metadata=None,
)
date_after_add_target = datetime.datetime.now(tz=gmt).date()
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
assert report.database_name == vuforia_database.database_name
assert report.target_name == name
assert report.active_flag == active_flag
# In case the date changes while adding a target
# we allow the date before and after adding the target.
assert report.upload_date in (
date_before_add_target,
date_after_add_target,
)
# While processing the tracking rating is -1.
assert report.tracking_rating == -1
assert report.total_recos == 0
assert report.current_month_recos == 0
assert report.previous_month_recos == 0
def get_target_summary_report(
server_access_key: str,
server_secret_key: str,
target_id: str,
base_vws_url: str,
) -> None:
"""
Get a target summary report.
\b
See
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Summary-Report.
"""
vws_client = VWS(
server_access_key=server_access_key,
server_secret_key=server_secret_key,
base_vws_url=base_vws_url,
)
report = vws_client.get_target_summary_report(target_id=target_id)
report_dict = dataclasses.asdict(report)
report_dict['status'] = report_dict['status'].value
report_dict['upload_date'] = str(report_dict['upload_date'])
yaml_summary_report = yaml.dump(report_dict)
click.echo(yaml_summary_report)
