Illustrates applying both exclusion and hotword rules. This snippet's rule set includes both hotword rules and dictionary and regex exclusion rules. Notice that the four rules are specified in an array within the rules element.
Explore further
For detailed documentation that includes this code sample, see the following:
Code sample
C#
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
using
System
;
using
System.Text.RegularExpressions
;
using
Google.Api.Gax.ResourceNames
;
using
Google.Cloud.Dlp.V2
;
using
static
Google
.
Cloud
.
Dlp
.
V2
.
CustomInfoType
.
Types
;
public
class
InspectStringMultipleRules
{
public
static
InspectContentResponse
Inspect
(
string
projectId
,
string
textToInspect
)
{
var
dlp
=
DlpServiceClient
.
Create
();
var
byteContentItem
=
new
ByteContentItem
{
Type
=
ByteContentItem
.
Types
.
BytesType
.
TextUtf8
,
Data
=
Google
.
Protobuf
.
ByteString
.
CopyFromUtf8
(
textToInspect
)
};
var
contentItem
=
new
ContentItem
{
ByteItem
=
byteContentItem
};
var
patientRule
=
new
DetectionRule
.
Types
.
HotwordRule
{
HotwordRegex
=
new
CustomInfoType
.
Types
.
Regex
{
Pattern
=
"patient"
},
Proximity
=
new
DetectionRule
.
Types
.
Proximity
{
WindowBefore
=
10
},
LikelihoodAdjustment
=
new
DetectionRule
.
Types
.
LikelihoodAdjustment
{
FixedLikelihood
=
Likelihood
.
VeryLikely
}
};
var
doctorRule
=
new
DetectionRule
.
Types
.
HotwordRule
{
HotwordRegex
=
new
CustomInfoType
.
Types
.
Regex
{
Pattern
=
"doctor"
},
Proximity
=
new
DetectionRule
.
Types
.
Proximity
{
WindowBefore
=
10
},
LikelihoodAdjustment
=
new
DetectionRule
.
Types
.
LikelihoodAdjustment
{
FixedLikelihood
=
Likelihood
.
Unlikely
}
};
// Construct exclusion rules
var
quasimodoRule
=
new
ExclusionRule
{
Dictionary
=
new
Dictionary
{
WordList
=
new
Dictionary
.
Types
.
WordList
{
Words
=
{
"Quasimodo"
}
}
},
MatchingType
=
MatchingType
.
PartialMatch
};
var
redactedRule
=
new
ExclusionRule
{
Regex
=
new
CustomInfoType
.
Types
.
Regex
{
Pattern
=
"REDACTED"
},
MatchingType
=
MatchingType
.
PartialMatch
};
var
infoType
=
new
InfoType
{
Name
=
"PERSON_NAME"
};
var
inspectionRuleSet
=
new
InspectionRuleSet
{
InfoTypes
=
{
infoType
},
Rules
=
{
new
InspectionRule
{
HotwordRule
=
patientRule
},
new
InspectionRule
{
HotwordRule
=
doctorRule
},
new
InspectionRule
{
ExclusionRule
=
quasimodoRule
},
new
InspectionRule
{
ExclusionRule
=
redactedRule
}
}
};
var
inspectConfig
=
new
InspectConfig
{
InfoTypes
=
{
infoType
},
IncludeQuote
=
true
,
RuleSet
=
{
inspectionRuleSet
}
};
var
request
=
new
InspectContentRequest
{
Parent
=
new
LocationName
(
projectId
,
"global"
).
ToString
(),
Item
=
contentItem
,
InspectConfig
=
inspectConfig
};
var
response
=
dlp
.
InspectContent
(
request
);
Console
.
WriteLine
(
$"Findings: {response.Result.Findings.Count}"
);
foreach
(
var
f
in
response
.
Result
.
Findings
)
{
Console
.
WriteLine
(
"\tQuote: "
+
f
.
Quote
);
Console
.
WriteLine
(
"\tInfo type: "
+
f
.
InfoType
.
Name
);
Console
.
WriteLine
(
"\tLikelihood: "
+
f
.
Likelihood
);
}
return
response
;
}
}
Go
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
import
(
"context"
"fmt"
"io"
dlp
"cloud.google.com/go/dlp/apiv2"
"cloud.google.com/go/dlp/apiv2/dlppb"
)
// inspectStringMultipleRules inspects the provided text,
// avoiding matches specified in the exclusion list.
// this function implements the both exclusion and hot word rules.
func
inspectStringMultipleRules
(
w
io
.
Writer
,
projectID
,
textToInspect
string
)
error
{
// projectID := "my-project-id"
// textToInspect := "patient: Jane Doe"
ctx
:=
context
.
Background
()
// Initialize a client once and reuse it to send multiple requests. Clients
// are safe to use across goroutines. When the client is no longer needed,
// call the Close method to cleanup its resources.
client
,
err
:=
dlp
.
NewClient
(
ctx
)
if
err
!=
nil
{
return
err
}
// Closing the client safely cleans up background resources.
defer
client
.
Close
()
// Specify the type and content to be inspected.
ContentItem
:=
& dlppb
.
ContentItem
{
DataItem
:
& dlppb
.
ContentItem_ByteItem
{
ByteItem
:
& dlppb
.
ByteContentItem
{
Type
:
dlppb
.
ByteContentItem_TEXT_UTF8
,
Data
:
[]
byte
(
textToInspect
),
},
},
}
// Construct the rule that adjust the likelihood of findings
// within a certain proximity of hot-word("patient").
patientRule
:=
& dlppb
.
InspectionRule_HotwordRule
{
HotwordRule
:
& dlppb
.
CustomInfoType_DetectionRule_HotwordRule
{
HotwordRegex
:
& dlppb
.
CustomInfoType_Regex
{
Pattern
:
"patient"
,
},
Proximity
:
& dlppb
.
CustomInfoType_DetectionRule_Proximity
{
WindowBefore
:
10
,
},
LikelihoodAdjustment
:
& dlppb
.
CustomInfoType_DetectionRule_LikelihoodAdjustment
{
Adjustment
:
& dlppb
.
CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood
{
FixedLikelihood
:
dlppb
.
Likelihood_VERY_LIKELY
,
},
},
},
}
// Construct the rule that adjust the likelihood of findings
// within a certain proximity of hot-word("doctor").
doctorRule
:=
& dlppb
.
InspectionRule_HotwordRule
{
HotwordRule
:
& dlppb
.
CustomInfoType_DetectionRule_HotwordRule
{
HotwordRegex
:
& dlppb
.
CustomInfoType_Regex
{
Pattern
:
"doctor"
,
},
Proximity
:
& dlppb
.
CustomInfoType_DetectionRule_Proximity
{
WindowBefore
:
10
,
},
LikelihoodAdjustment
:
& dlppb
.
CustomInfoType_DetectionRule_LikelihoodAdjustment
{
Adjustment
:
& dlppb
.
CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood
{
FixedLikelihood
:
dlppb
.
Likelihood_UNLIKELY
,
},
},
},
}
// Construct the exclusion rule that avoids the matches for the specified word list.
quasimodoRule
:=
& dlppb
.
ExclusionRule
{
Type
:
& dlppb
.
ExclusionRule_Dictionary
{
Dictionary
:
& dlppb
.
CustomInfoType_Dictionary
{
Source
:
& dlppb
.
CustomInfoType_Dictionary_WordList_
{
WordList
:
& dlppb
.
CustomInfoType_Dictionary_WordList
{
Words
:
[]
string
{
"Quasimodo"
},
},
},
},
},
MatchingType
:
dlppb
.
MatchingType_MATCHING_TYPE_PARTIAL_MATCH
,
}
// Construct the exclusion rule that avoids the matches for the specified regex pattern.
redactedRule
:=
& dlppb
.
ExclusionRule
{
Type
:
& dlppb
.
ExclusionRule_Regex
{
Regex
:
& dlppb
.
CustomInfoType_Regex
{
Pattern
:
"REDACTED"
,
},
},
MatchingType
:
dlppb
.
MatchingType_MATCHING_TYPE_PARTIAL_MATCH
,
}
// Construct a ruleSet that applies the rules to the PERSON_NAME infoType.
ruleSet
:=
& dlppb
.
InspectionRuleSet
{
InfoTypes
:
[]
*
dlppb
.
InfoType
{
{
Name
:
"PERSON_NAME"
},
},
Rules
:
[]
*
dlppb
.
InspectionRule
{
{
Type
:
& dlppb
.
InspectionRule_HotwordRule
{
HotwordRule
:
doctorRule
.
HotwordRule
}},
{
Type
:
& dlppb
.
InspectionRule_HotwordRule
{
HotwordRule
:
patientRule
.
HotwordRule
}},
{
Type
:
& dlppb
.
InspectionRule_ExclusionRule
{
ExclusionRule
:
quasimodoRule
}},
{
Type
:
& dlppb
.
InspectionRule_ExclusionRule
{
ExclusionRule
:
redactedRule
}},
},
}
// Construct the configuration for the Inspect request, including the ruleSet.
inspectConfig
:=
& dlppb
.
InspectConfig
{
InfoTypes
:
[]
*
dlppb
.
InfoType
{
{
Name
:
"PERSON_NAME"
},
},
IncludeQuote
:
true
,
RuleSet
:
[]
*
dlppb
.
InspectionRuleSet
{
ruleSet
,
},
}
// Create and send the request.
req
:=
& dlppb
.
InspectContentRequest
{
Parent
:
fmt
.
Sprintf
(
"projects/%s/locations/global"
,
projectID
),
Item
:
ContentItem
,
InspectConfig
:
inspectConfig
,
}
// Send the request.
resp
,
err
:=
client
.
InspectContent
(
ctx
,
req
)
if
err
!=
nil
{
return
err
}
// Process the results.
fmt
.
Fprintf
(
w
,
"Findings: %v\n"
,
len
(
resp
.
Result
.
Findings
))
for
_
,
v
:=
range
resp
.
GetResult
().
Findings
{
fmt
.
Fprintf
(
w
,
"Quote: %v\n"
,
v
.
GetQuote
())
fmt
.
Fprintf
(
w
,
"Infotype Name: %v\n"
,
v
.
GetInfoType
().
GetName
())
fmt
.
Fprintf
(
w
,
"Likelihood: %v\n"
,
v
.
GetLikelihood
())
}
return
nil
}
Java
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
import
com.google.cloud.dlp.v2. DlpServiceClient
;
import
com.google.privacy.dlp.v2. ByteContentItem
;
import
com.google.privacy.dlp.v2. ByteContentItem
. BytesType
;
import
com.google.privacy.dlp.v2. ContentItem
;
import
com.google.privacy.dlp.v2. CustomInfoType
. DetectionRule
. HotwordRule
;
import
com.google.privacy.dlp.v2. CustomInfoType
. DetectionRule
. LikelihoodAdjustment
;
import
com.google.privacy.dlp.v2. CustomInfoType
. DetectionRule
. Proximity
;
import
com.google.privacy.dlp.v2. CustomInfoType
. Dictionary
;
import
com.google.privacy.dlp.v2. CustomInfoType
. Dictionary
. WordList
;
import
com.google.privacy.dlp.v2. CustomInfoType
. Regex
;
import
com.google.privacy.dlp.v2. ExclusionRule
;
import
com.google.privacy.dlp.v2. Finding
;
import
com.google.privacy.dlp.v2. InfoType
;
import
com.google.privacy.dlp.v2. InspectConfig
;
import
com.google.privacy.dlp.v2. InspectContentRequest
;
import
com.google.privacy.dlp.v2. InspectContentResponse
;
import
com.google.privacy.dlp.v2. InspectionRule
;
import
com.google.privacy.dlp.v2. InspectionRuleSet
;
import
com.google.privacy.dlp.v2. Likelihood
;
import
com.google.privacy.dlp.v2. LocationName
;
import
com.google.privacy.dlp.v2. MatchingType
;
import
com.google.protobuf. ByteString
;
import
java.io.IOException
;
public
class
InspectStringMultipleRules
{
public
static
void
main
(
String
[]
args
)
throws
Exception
{
// TODO(developer): Replace these variables before running the sample.
String
projectId
=
"your-project-id"
;
String
textToInspect
=
"patient: Jane Doe"
;
inspectStringMultipleRules
(
projectId
,
textToInspect
);
}
// Inspects the provided text, avoiding matches specified in the exclusion list.
public
static
void
inspectStringMultipleRules
(
String
projectId
,
String
textToInspect
)
throws
IOException
{
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try
(
DlpServiceClient
dlp
=
DlpServiceClient
.
create
())
{
// Specify the type and content to be inspected.
ByteContentItem
byteItem
=
ByteContentItem
.
newBuilder
()
.
setType
(
BytesType
.
TEXT_UTF8
)
.
setData
(
ByteString
.
copyFromUtf8
(
textToInspect
))
.
build
();
ContentItem
item
=
ContentItem
.
newBuilder
().
setByteItem
(
byteItem
).
build
();
// Construct hotword rules
HotwordRule
patientRule
=
HotwordRule
.
newBuilder
()
.
setHotwordRegex
(
Regex
.
newBuilder
().
setPattern
(
"patient"
))
.
setProximity
(
Proximity
.
newBuilder
().
setWindowBefore
(
10
))
.
setLikelihoodAdjustment
(
LikelihoodAdjustment
.
newBuilder
().
setFixedLikelihood
(
Likelihood
.
VERY_LIKELY
))
.
build
();
HotwordRule
doctorRule
=
HotwordRule
.
newBuilder
()
.
setHotwordRegex
(
Regex
.
newBuilder
().
setPattern
(
"doctor"
))
.
setProximity
(
Proximity
.
newBuilder
().
setWindowBefore
(
10
))
.
setLikelihoodAdjustment
(
LikelihoodAdjustment
.
newBuilder
().
setFixedLikelihood
(
Likelihood
.
UNLIKELY
))
.
build
();
// Construct exclusion rules
ExclusionRule
quasimodoRule
=
ExclusionRule
.
newBuilder
()
.
setDictionary
(
Dictionary
.
newBuilder
().
setWordList
(
WordList
.
newBuilder
().
addWords
(
"Quasimodo"
)))
.
setMatchingType
(
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
)
.
build
();
ExclusionRule
redactedRule
=
ExclusionRule
.
newBuilder
()
.
setRegex
(
Regex
.
newBuilder
().
setPattern
(
"REDACTED"
))
.
setMatchingType
(
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
)
.
build
();
// Construct a ruleset that applies the rules to the PERSON_NAME infotype.
InspectionRuleSet
ruleSet
=
InspectionRuleSet
.
newBuilder
()
.
addInfoTypes
(
InfoType
.
newBuilder
().
setName
(
"PERSON_NAME"
))
.
addRules
(
InspectionRule
.
newBuilder
().
setHotwordRule
(
patientRule
))
.
addRules
(
InspectionRule
.
newBuilder
().
setHotwordRule
(
doctorRule
))
.
addRules
(
InspectionRule
.
newBuilder
().
setExclusionRule
(
quasimodoRule
))
.
addRules
(
InspectionRule
.
newBuilder
().
setExclusionRule
(
redactedRule
))
.
build
();
// Construct the configuration for the Inspect request, including the ruleset.
InspectConfig
config
=
InspectConfig
.
newBuilder
()
.
addInfoTypes
(
InfoType
.
newBuilder
().
setName
(
"PERSON_NAME"
))
.
setIncludeQuote
(
true
)
.
addRuleSet
(
ruleSet
)
.
build
();
// Construct the Inspect request to be sent by the client.
InspectContentRequest
request
=
InspectContentRequest
.
newBuilder
()
.
setParent
(
LocationName
.
of
(
projectId
,
"global"
).
toString
())
.
setItem
(
item
)
.
setInspectConfig
(
config
)
.
build
();
// Use the client to send the API request.
InspectContentResponse
response
=
dlp
.
inspectContent
(
request
);
// Parse the response and process results
System
.
out
.
println
(
"Findings: "
+
response
.
getResult
().
getFindingsCount
());
for
(
Finding
f
:
response
.
getResult
().
getFindingsList
())
{
System
.
out
.
println
(
"\tQuote: "
+
f
.
getQuote
());
System
.
out
.
println
(
"\tInfo type: "
+
f
.
getInfoType
().
getName
());
System
.
out
.
println
(
"\tLikelihood: "
+
f
.
getLikelihood
());
}
}
}
}
Node.js
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
// Imports the Google Cloud Data Loss Prevention library
const
DLP
=
require
(
' @google-cloud/dlp
'
);
// Instantiates a client
const
dlp
=
new
DLP
.
DlpServiceClient
();
// The project ID to run the API call under
// const projectId = 'my-project';
// The string to inspect
// const string = 'patient: Jane Doe';
async
function
inspectStringMultipleRules
()
{
// Construct item to inspect
const
item
=
{
value
:
string
};
// Construct hotword rules
const
patientRule
=
{
hotwordRegex
:
{
pattern
:
'patient'
},
proximity
:
{
windowBefore
:
10
},
likelihoodAdjustment
:
{
fixedLikelihood
:
DLP
.
protos
.
google
.
privacy
.
dlp
.
v2
.
Likelihood
.
VERY_LIKELY
,
},
};
const
doctorRule
=
{
hotwordRegex
:
{
pattern
:
'doctor'
},
proximity
:
{
windowBefore
:
10
},
likelihoodAdjustment
:
{
fixedLikelihood
:
DLP
.
protos
.
google
.
privacy
.
dlp
.
v2
.
Likelihood
.
UNLIKELY
,
},
};
// Construct exclusion rules
const
quasimodoRule
=
{
dictionary
:
{
wordList
:
{
words
:
[
'quasimodo'
]}},
matchingType
:
DLP
.
protos
.
google
.
privacy
.
dlp
.
v2
.
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
,
};
const
redactedRule
=
{
regex
:
{
pattern
:
'REDACTED'
},
matchingType
:
DLP
.
protos
.
google
.
privacy
.
dlp
.
v2
.
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
,
};
// The infoTypes of information to match
const
infoTypes
=
[{
name
:
'PERSON_NAME'
}];
// Construct a ruleset that applies the rules to the PERSON_NAME infotype.
const
ruleSet
=
[
{
infoTypes
:
infoTypes
,
rules
:
[
{
hotwordRule
:
patientRule
},
{
hotwordRule
:
doctorRule
},
{
exclusionRule
:
quasimodoRule
},
{
exclusionRule
:
redactedRule
},
],
},
];
// Construct the configuration for the Inspect request, including the ruleset.
const
inspectConfig
=
{
infoTypes
:
infoTypes
,
ruleSet
:
ruleSet
,
includeQuote
:
true
,
};
// Construct the Inspect request to be sent by the client.
const
request
=
{
parent
:
`projects/
${
projectId
}
/locations/global`
,
inspectConfig
:
inspectConfig
,
item
:
item
,
};
// Use the client to send the API request.
const
[
response
]
=
await
dlp
.
inspectContent
(
request
);
// Print findings.
const
findings
=
response
.
result
.
findings
;
if
(
findings
.
length
>
0
)
{
console
.
log
(
`Findings:
${
findings
.
length
}
\n`
);
findings
.
forEach
(
finding
=
>
{
console
.
log
(
`InfoType:
${
finding
.
infoType
.
name
}
`
);
console
.
log
(
`\tQuote:
${
finding
.
quote
}
`
);
console
.
log
(
`\tLikelihood:
${
finding
.
likelihood
}
\n`
);
});
}
else
{
console
.
log
(
'No findings.'
);
}
}
inspectStringMultipleRules
();
PHP
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\CustomInfoType\DetectionRule\HotwordRule;
use Google\Cloud\Dlp\V2\CustomInfoType\DetectionRule\LikelihoodAdjustment;
use Google\Cloud\Dlp\V2\CustomInfoType\DetectionRule\Proximity;
use Google\Cloud\Dlp\V2\CustomInfoType\Dictionary;
use Google\Cloud\Dlp\V2\CustomInfoType\Dictionary\WordList;
use Google\Cloud\Dlp\V2\CustomInfoType\Regex;
use Google\Cloud\Dlp\V2\ExclusionRule;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\InspectionRule;
use Google\Cloud\Dlp\V2\InspectionRuleSet;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\MatchingType;
/**
* Inspect a string for sensitive data by using multiple rules
* Illustrates applying both exclusion and hotword rules. This snippet's rule set includes both hotword rules and dictionary and regex exclusion rules. Notice that the four rules are specified in an array within the rules element.
*
* @param string $projectId The Google Cloud project id to use as a parent resource.
* @param string $textToInspect The string to inspect.
*/
function inspect_string_multiple_rules(
// TODO(developer): Replace sample parameters before running the code.
string $projectId,
string $textToInspect = 'patient: Jane Doe'
): void {
// Instantiate a client.
$dlp = new DlpServiceClient();
$parent = "projects/$projectId/locations/global";
// Specify what content you want the service to Inspect.
$item = (new ContentItem())
->setValue($textToInspect);
// Construct hotword rules
$patientRule = (new HotwordRule())
->setHotwordRegex((new Regex())
->setPattern('patient'))
->setProximity((new Proximity())
->setWindowBefore(10))
->setLikelihoodAdjustment((new LikelihoodAdjustment())
->setFixedLikelihood(Likelihood::VERY_LIKELY));
$doctorRule = (new HotwordRule())
->setHotwordRegex((new Regex())
->setPattern('doctor'))
->setProximity((new Proximity())
->setWindowBefore(10))
->setLikelihoodAdjustment((new LikelihoodAdjustment())
->setFixedLikelihood(Likelihood::VERY_UNLIKELY));
// Construct exclusion rules
$wordList = (new Dictionary())
->setWordList((new WordList())
->setWords(['Quasimodo']));
$quasimodoRule = (new ExclusionRule())
->setMatchingType(MatchingType::MATCHING_TYPE_PARTIAL_MATCH)
->setDictionary($wordList);
$redactedRule = (new ExclusionRule())
->setMatchingType(MatchingType::MATCHING_TYPE_PARTIAL_MATCH)
->setRegex((new Regex())
->setPattern('REDACTED'));
// Specify the exclusion rule and build-in info type the inspection will look for.
$personName = (new InfoType())
->setName('PERSON_NAME');
$inspectionRuleSet = (new InspectionRuleSet())
->setInfoTypes([$personName])
->setRules([
(new InspectionRule())
->setHotwordRule($patientRule),
(new InspectionRule())
->setHotwordRule($doctorRule),
(new InspectionRule())
->setExclusionRule($quasimodoRule),
(new InspectionRule())
->setExclusionRule($redactedRule),
]);
// Construct the configuration for the Inspect request, including the ruleset.
$inspectConfig = (new InspectConfig())
->setInfoTypes([$personName])
->setIncludeQuote(true)
->setRuleSet([$inspectionRuleSet]);
// Run request
$inspectContentRequest = (new InspectContentRequest())
->setParent($parent)
->setInspectConfig($inspectConfig)
->setItem($item);
$response = $dlp->inspectContent($inspectContentRequest);
// Print the results
$findings = $response->getResult()->getFindings();
if (count($findings) == 0) {
printf('No findings.' . PHP_EOL);
} else {
printf('Findings:' . PHP_EOL);
foreach ($findings as $finding) {
printf(' Quote: %s' . PHP_EOL, $finding->getQuote());
printf(' Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
printf(' Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
}
}
}
Python
To learn how to install and use the client library for Sensitive Data Protection, see Sensitive Data Protection client libraries .
To authenticate to Sensitive Data Protection, set up Application Default Credentials. For more information, see Set up authentication for a local development environment .
import
google.cloud.dlp
def
inspect_string_multiple_rules
(
project
:
str
,
content_string
:
str
)
-
> None
:
"""Uses the Data Loss Prevention API to modify likelihood for matches on
PERSON_NAME combining multiple hotword and exclusion rules.
Args:
project: The Google Cloud project id to use as a parent resource.
content_string: The string to inspect.
Returns:
None; the response from the API is printed to the terminal.
"""
# Instantiate a client.
dlp
=
google
.
cloud
.
dlp_v2
.
DlpServiceClient
()
# Construct hotword rules
patient_rule
=
{
"hotword_regex"
:
{
"pattern"
:
"patient"
},
"proximity"
:
{
"window_before"
:
10
},
"likelihood_adjustment"
:
{
"fixed_likelihood"
:
google
.
cloud
.
dlp_v2
.
Likelihood
.
VERY_LIKELY
},
}
doctor_rule
=
{
"hotword_regex"
:
{
"pattern"
:
"doctor"
},
"proximity"
:
{
"window_before"
:
10
},
"likelihood_adjustment"
:
{
"fixed_likelihood"
:
google
.
cloud
.
dlp_v2
.
Likelihood
.
UNLIKELY
},
}
# Construct exclusion rules
quasimodo_rule
=
{
"dictionary"
:
{
"word_list"
:
{
"words"
:
[
"quasimodo"
]}},
"matching_type"
:
google
.
cloud
.
dlp_v2
.
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
,
}
redacted_rule
=
{
"regex"
:
{
"pattern"
:
"REDACTED"
},
"matching_type"
:
google
.
cloud
.
dlp_v2
.
MatchingType
.
MATCHING_TYPE_PARTIAL_MATCH
,
}
# Construct the rule set, combining the above rules
rule_set
=
[
{
"info_types"
:
[{
"name"
:
"PERSON_NAME"
}],
"rules"
:
[
{
"hotword_rule"
:
patient_rule
},
{
"hotword_rule"
:
doctor_rule
},
{
"exclusion_rule"
:
quasimodo_rule
},
{
"exclusion_rule"
:
redacted_rule
},
],
}
]
# Construct the configuration dictionary
inspect_config
=
{
"info_types"
:
[{
"name"
:
"PERSON_NAME"
}],
"rule_set"
:
rule_set
,
"include_quote"
:
True
,
}
# Construct the `item`.
item
=
{
"value"
:
content_string
}
# Convert the project id into a full resource id.
parent
=
f
"projects/
{
project
}
"
# Call the API.
response
=
dlp
.
inspect_content
(
request
=
{
"parent"
:
parent
,
"inspect_config"
:
inspect_config
,
"item"
:
item
}
)
# Print out the results.
if
response
.
result
.
findings
:
for
finding
in
response
.
result
.
findings
:
print
(
f
"Quote:
{
finding
.
quote
}
"
)
print
(
f
"Info type:
{
finding
.
info_type
.
name
}
"
)
print
(
f
"Likelihood:
{
finding
.
likelihood
}
"
)
else
:
print
(
"No findings."
)
What's next
To search and filter code samples for other Google Cloud products, see the Google Cloud sample browser .
