column_name, topic_id, subscription_id,

timeout=300):

"""Uses the Data Loss Prevention API to compute risk metrics of a column

# Import the client library.

import google.cloud.dlp

# This sample additionally uses Cloud Pub/Sub to receive results from

# potentially long-running operations.

import google.cloud.pubsub

# This sample also uses threading.Event() to wait for the job to finish.

import threading

# Instantiate a client.

dlp = google.cloud.dlp.DlpServiceClient()

# Convert the project id into a full resource id.

parent = dlp.project_path(project)

# Location info of the BigQuery table.

source_table = {

'project_id': table_project_id,

'dataset_id': dataset_id,

'table_id': table_id

}

# Tell the API where to send a notification when the job is complete.

actions = [{

'pub_sub': {'topic': '{}/topics/{}'.format(parent, topic_id)}

}]

# Configure risk analysis job

# Give the name of the numeric column to compute risk metrics for

risk_job = {

'privacy_metric': {

'numerical_stats_config': {

'field': {

'name': column_name

}

}

},

'source_table': source_table,

'actions': actions

}

# Call API to start risk analysis job

operation = dlp.create_dlp_job(parent, risk_job=risk_job)

# Create a Pub/Sub client and find the subscription. The subscription is

# expected to already be listening to the topic.

subscriber = google.cloud.pubsub.SubscriberClient()

subscription_path = subscriber.subscription_path(

project, subscription_id)

subscription = subscriber.subscribe(subscription_path)

# Set up a callback to acknowledge a message. This closes around an event

# so that it can signal that it is done and the main thread can continue.

job_done = threading.Event()

def callback(message):

try:

if (message.attributes['DlpJobName'] == operation.name):

# This is the message we're looking for, so acknowledge it.

message.ack()

# Now that the job is done, fetch the results and print them.

job = dlp.get_dlp_job(operation.name)

results = job.risk_details.numerical_stats_result

print('Value Range: [{}, {}]'.format(

results.min_value.integer_value,

results.max_value.integer_value))

prev_value = None

for percent, result in enumerate(results.quantile_values):

value = result.integer_value

if prev_value != value:

print('Value at {}% quantile: {}'.format(

percent, value))

prev_value = value

# Signal to the main thread that we can exit.

job_done.set()

else:

# This is not the message we're looking for.

message.drop()

except Exception as e:

# Because this is executing in a thread, an exception won't be

# noted unless we print it manually.

print(e)

raise

# Register the callback and wait on the event.

subscription.open(callback)

finished = job_done.wait(timeout=timeout)

if not finished:

print('No event received before the timeout. Please verify that the '

column_name, topic_id, subscription_id,

timeout=300):

"""Uses the Data Loss Prevention API to compute risk metrics of a column

# Import the client library.

import google.cloud.dlp

# This sample additionally uses Cloud Pub/Sub to receive results from

# potentially long-running operations.

import google.cloud.pubsub

# This sample also uses threading.Event() to wait for the job to finish.

import threading

# Instantiate a client.

dlp = google.cloud.dlp.DlpServiceClient()

# Convert the project id into a full resource id.

parent = dlp.project_path(project)

# Location info of the BigQuery table.

source_table = {

'project_id': table_project_id,

'dataset_id': dataset_id,

'table_id': table_id

}

# Tell the API where to send a notification when the job is complete.

actions = [{

'pub_sub': {'topic': '{}/topics/{}'.format(parent, topic_id)}

}]

# Configure risk analysis job

# Give the name of the numeric column to compute risk metrics for

risk_job = {

'privacy_metric': {

'categorical_stats_config': {

'field': {

'name': column_name

}

}

},

'source_table': source_table,

'actions': actions

}

# Call API to start risk analysis job

operation = dlp.create_dlp_job(parent, risk_job=risk_job)

# Create a Pub/Sub client and find the subscription. The subscription is

# expected to already be listening to the topic.

subscriber = google.cloud.pubsub.SubscriberClient()

subscription_path = subscriber.subscription_path(

project, subscription_id)

subscription = subscriber.subscribe(subscription_path)

# Set up a callback to acknowledge a message. This closes around an event

# so that it can signal that it is done and the main thread can continue.

job_done = threading.Event()

def callback(message):

try:

if (message.attributes['DlpJobName'] == operation.name):

# This is the message we're looking for, so acknowledge it.

message.ack()

# Now that the job is done, fetch the results and print them.

job = dlp.get_dlp_job(operation.name)

histogram_buckets = (job.risk_details

.categorical_stats_result

.value_frequency_histogram_buckets)

# Print bucket stats

for i, bucket in enumerate(histogram_buckets):

print('Bucket {}:'.format(i))

print(' Most common value occurs {} time(s)'.format(

bucket.value_frequency_upper_bound))

print(' Least common value occurs {} time(s)'.format(

bucket.value_frequency_lower_bound))

print(' {} unique values total.'.format(

bucket.bucket_size))

for value in bucket.bucket_values:

print(' Value {} occurs {} time(s)'.format(

value.value.integer_value, value.count))

# Signal to the main thread that we can exit.

job_done.set()

else:

# This is not the message we're looking for.

message.drop()

except Exception as e:

# Because this is executing in a thread, an exception won't be

# noted unless we print it manually.

print(e)

raise

# Register the callback and wait on the event.

subscription.open(callback)

finished = job_done.wait(timeout=timeout)

if not finished:

print('No event received before the timeout. Please verify that the '

topic_id, subscription_id, quasi_ids, timeout=300):

"""Uses the Data Loss Prevention API to compute the k-anonymity of a

# Import the client library.

import google.cloud.dlp

# This sample additionally uses Cloud Pub/Sub to receive results from

# potentially long-running operations.

import google.cloud.pubsub

# This sample also uses threading.Event() to wait for the job to finish.

import threading

# Instantiate a client.

dlp = google.cloud.dlp.DlpServiceClient()

# Convert the project id into a full resource id.

parent = dlp.project_path(project)

# Location info of the BigQuery table.

source_table = {

'project_id': table_project_id,

'dataset_id': dataset_id,

'table_id': table_id

}

# Convert quasi id list to Protobuf type

def map_fields(field):

return {'name': field}

quasi_ids = map(map_fields, quasi_ids)

# Tell the API where to send a notification when the job is complete.

actions = [{

'pub_sub': {'topic': '{}/topics/{}'.format(parent, topic_id)}

}]

# Configure risk analysis job

# Give the name of the numeric column to compute risk metrics for

risk_job = {

'privacy_metric': {

'k_anonymity_config': {

'quasi_ids': quasi_ids

}

},

'source_table': source_table,

'actions': actions

}

# Call API to start risk analysis job

operation = dlp.create_dlp_job(parent, risk_job=risk_job)

# Create a Pub/Sub client and find the subscription. The subscription is

# expected to already be listening to the topic.

subscriber = google.cloud.pubsub.SubscriberClient()

subscription_path = subscriber.subscription_path(

project, subscription_id)

subscription = subscriber.subscribe(subscription_path)

# Set up a callback to acknowledge a message. This closes around an event

# so that it can signal that it is done and the main thread can continue.

job_done = threading.Event()

# Create helper function for unpacking values

def get_values(obj):

return int(obj.integer_value)

def callback(message):

try:

if (message.attributes['DlpJobName'] == operation.name):

# This is the message we're looking for, so acknowledge it.

message.ack()

# Now that the job is done, fetch the results and print them.

job = dlp.get_dlp_job(operation.name)

histogram_buckets = (job.risk_details

.k_anonymity_result

.equivalence_class_histogram_buckets)

# Print bucket stats

for i, bucket in enumerate(histogram_buckets):

print('Bucket {}:'.format(i))

if bucket.equivalence_class_size_lower_bound:

print(' Bucket size range: [{}, {}]'.format(

bucket.equivalence_class_size_lower_bound,

bucket.equivalence_class_size_upper_bound))

for value_bucket in bucket.bucket_values:

print(' Quasi-ID values: {}'.format(

map(get_values, value_bucket.quasi_ids_values)

))

print(' Class size: {}'.format(

value_bucket.equivalence_class_size))

# Signal to the main thread that we can exit.

job_done.set()

else:

# This is not the message we're looking for.

message.drop()

except Exception as e:

# Because this is executing in a thread, an exception won't be

# noted unless we print it manually.

print(e)

raise

# Register the callback and wait on the event.

subscription.open(callback)

finished = job_done.wait(timeout=timeout)

if not finished:

print('No event received before the timeout. Please verify that the '

topic_id, subscription_id, sensitive_attribute,

quasi_ids, timeout=300):

"""Uses the Data Loss Prevention API to compute the l-diversity of a

# Import the client library.

import google.cloud.dlp

# This sample additionally uses Cloud Pub/Sub to receive results from

# potentially long-running operations.

import google.cloud.pubsub

# This sample also uses threading.Event() to wait for the job to finish.

import threading

# Instantiate a client.

dlp = google.cloud.dlp.DlpServiceClient()

# Convert the project id into a full resource id.

parent = dlp.project_path(project)

# Location info of the BigQuery table.

source_table = {

'project_id': table_project_id,

'dataset_id': dataset_id,

'table_id': table_id

}

# Convert quasi id list to Protobuf type

def map_fields(field):

return {'name': field}

quasi_ids = map(map_fields, quasi_ids)

# Tell the API where to send a notification when the job is complete.

actions = [{

'pub_sub': {'topic': '{}/topics/{}'.format(parent, topic_id)}

}]

# Configure risk analysis job

# Give the name of the numeric column to compute risk metrics for

risk_job = {

'privacy_metric': {

'l_diversity_config': {

'quasi_ids': quasi_ids,

'sensitive_attribute': {

'name': sensitive_attribute

}

}

},

'source_table': source_table,

'actions': actions

}

# Call API to start risk analysis job

operation = dlp.create_dlp_job(parent, risk_job=risk_job)

# Create a Pub/Sub client and find the subscription. The subscription is

# expected to already be listening to the topic.

subscriber = google.cloud.pubsub.SubscriberClient()

subscription_path = subscriber.subscription_path(

project, subscription_id)

subscription = subscriber.subscribe(subscription_path)

# Set up a callback to acknowledge a message. This closes around an event

# so that it can signal that it is done and the main thread can continue.

job_done = threading.Event()

# Create helper function for unpacking values

def get_values(obj):

return int(obj.integer_value)

def callback(message):

try:

if (message.attributes['DlpJobName'] == operation.name):

# This is the message we're looking for, so acknowledge it.

message.ack()

# Now that the job is done, fetch the results and print them.

job = dlp.get_dlp_job(operation.name)

histogram_buckets = (

job.risk_details

.l_diversity_result

.sensitive_value_frequency_histogram_buckets)

# Print bucket stats

for i, bucket in enumerate(histogram_buckets):

print('Bucket {}:'.format(i))

print(' Bucket size range: [{}, {}]'.format(

bucket.sensitive_value_frequency_lower_bound,

bucket.sensitive_value_frequency_upper_bound))

for value_bucket in bucket.bucket_values:

print(' Quasi-ID values: {}'.format(

map(get_values, value_bucket.quasi_ids_values)))

print(' Class size: {}'.format(

value_bucket.equivalence_class_size))

for value in value_bucket.top_sensitive_values:

print((' Sensitive value {} occurs {} time(s)'

.format(value.value, value.count)))

# Signal to the main thread that we can exit.

job_done.set()

else:

# This is not the message we're looking for.

message.drop()

except Exception as e:

# Because this is executing in a thread, an exception won't be

# noted unless we print it manually.

print(e)

raise

# Register the callback and wait on the event.

subscription.open(callback)

finished = job_done.wait(timeout=timeout)

if not finished:

print('No event received before the timeout. Please verify that the '

topic_id, subscription_id, quasi_ids, info_types,

region_code='US', timeout=300):

"""Uses the Data Loss Prevention API to compute the k-map risk estimation

# Import the client library.

import google.cloud.dlp

# This sample additionally uses Cloud Pub/Sub to receive results from

# potentially long-running operations.

import google.cloud.pubsub

# This sample also uses threading.Event() to wait for the job to finish.

import threading

# Instantiate a client.

dlp = google.cloud.dlp.DlpServiceClient()

# Convert the project id into a full resource id.

parent = dlp.project_path(project)

# Location info of the BigQuery table.

source_table = {

'project_id': table_project_id,

'dataset_id': dataset_id,

'table_id': table_id

}

# Check that numbers of quasi-ids and info types are equal

if len(quasi_ids) != len(info_types):

raise ValueError("""Number of infoTypes and number of quasi-identifiers

must be equal!""")

# Convert quasi id list to Protobuf type

def map_fields(quasi_id, info_type):

return {'field': {'name': quasi_id}, 'info_type': {'name': info_type}}

quasi_ids = map(map_fields, quasi_ids, info_types)

# Tell the API where to send a notification when the job is complete.

actions = [{

'pub_sub': {'topic': '{}/topics/{}'.format(parent, topic_id)}

}]

# Configure risk analysis job

# Give the name of the numeric column to compute risk metrics for

risk_job = {

'privacy_metric': {

'k_map_estimation_config': {

'quasi_ids': quasi_ids,

'region_code': region_code

}

},

'source_table': source_table,

'actions': actions

}

# Call API to start risk analysis job

operation = dlp.create_dlp_job(parent, risk_job=risk_job)

# Create a Pub/Sub client and find the subscription. The subscription is

# expected to already be listening to the topic.

subscriber = google.cloud.pubsub.SubscriberClient()

subscription_path = subscriber.subscription_path(

project, subscription_id)

subscription = subscriber.subscribe(subscription_path)

# Set up a callback to acknowledge a message. This closes around an event

# so that it can signal that it is done and the main thread can continue.

job_done = threading.Event()

# Create helper function for unpacking values

def get_values(obj):

return int(obj.integer_value)

def callback(message):

try:

if (message.attributes['DlpJobName'] == operation.name):

# This is the message we're looking for, so acknowledge it.

message.ack()

# Now that the job is done, fetch the results and print them.

job = dlp.get_dlp_job(operation.name)

histogram_buckets = (job.risk_details

.k_map_estimation_result

.k_map_estimation_histogram)

# Print bucket stats

for i, bucket in enumerate(histogram_buckets):

print('Bucket {}:'.format(i))

print(' Anonymity range: [{}, {}]'.format(

bucket.min_anonymity, bucket.max_anonymity))

print(' Size: {}'.format(bucket.bucket_size))

for value_bucket in bucket.bucket_values:

print(' Values: {}'.format(

map(get_values, value_bucket.quasi_ids_values)))

print(' Estimated k-map anonymity: {}'.format(

value_bucket.estimated_anonymity))

# Signal to the main thread that we can exit.

job_done.set()

else:

# This is not the message we're looking for.

message.drop()

except Exception as e:

# Because this is executing in a thread, an exception won't be

# noted unless we print it manually.

print(e)

raise

# Register the callback and wait on the event.

subscription.open(callback)

finished = job_done.wait(timeout=timeout)

if not finished:

print('No event received before the timeout. Please verify that the '