diff --git a/dlp/LICENSE b/dlp/LICENSE new file mode 100644 index 000000000000..724a8807144b --- /dev/null +++ b/dlp/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/dlp/MANIFEST.in b/dlp/MANIFEST.in new file mode 100644 index 000000000000..30ee3dbb80ea --- /dev/null +++ b/dlp/MANIFEST.in @@ -0,0 +1,4 @@ +include README.rst LICENSE +recursive-include google *.json *.proto +global-exclude *.py[co] +global-exclude __pycache__ diff --git a/dlp/README.rst b/dlp/README.rst new file mode 100644 index 000000000000..b4ffbaee1d5e --- /dev/null +++ b/dlp/README.rst @@ -0,0 +1,98 @@ +Python Client for DLP API (`Alpha`_) +==================================== + +`DLP API`_: The Google Data Loss Prevention API provides methods for detection of +privacy-sensitive fragments in text, images, and Google Cloud Platform +storage repositories. + +- `Client Library Documentation`_ +- `Product Documentation`_ + +.. _Alpha: https://github.com/GoogleCloudPlatform/google-cloud-python/blob/master/README.rst +.. _DLP API: https://cloud.google.com/dlp +.. _Client Library Documentation: https://googlecloudplatform.github.io/google-cloud-python/stable/dlp-usage +.. _Product Documentation: https://cloud.google.com/dlp + +Quick Start +----------- + +In order to use this library, you first need to go through the following steps: + +1. `Select or create a Cloud Platform project.`_ +2. `Enable the DLP API.`_ +3. `Setup Authentication.`_ + +.. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project +.. _Enable the DLP API.: https://cloud.google.com/dlp +.. _Setup Authentication.: https://googlecloudplatform.github.io/google-cloud-python/stable/google-cloud-auth + +Installation +~~~~~~~~~~~~ + +Install this library in a `virtualenv`_ using pip. `virtualenv`_ is a tool to +create isolated Python environments. The basic problem it addresses is one of +dependencies and versions, and indirectly permissions. + +With `virtualenv`_, it's possible to install this library without needing system +install permissions, and without clashing with the installed system +dependencies. + +.. _`virtualenv`: https://virtualenv.pypa.io/en/latest/ + + +Mac/Linux +^^^^^^^^^ + +.. code-block:: console + + pip install virtualenv + virtualenv + source /bin/activate + /bin/pip install google-cloud-dlp + + +Windows +^^^^^^^ + +.. code-block:: console + + pip install virtualenv + virtualenv + \Scripts\activate + \Scripts\pip.exe install google-cloud-dlp + +Preview +~~~~~~~ + +DlpServiceClient +^^^^^^^^^^^^^^^^ + +.. code:: py + + from google.cloud import dlp_v2beta1 + + client = dlp_v2beta1.DlpServiceClient() + + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + response = client.inspect_content(inspect_config, items) + +Next Steps +~~~~~~~~~~ + +- Read the `Client Library Documentation`_ for DLP API + API to see other available methods on the client. +- Read the `DLP API Product documentation`_ to learn + more about the product and see How-to Guides. +- View this `repository’s main README`_ to see the full list of Cloud + APIs that we cover. + +.. _DLP API Product documentation: https://cloud.google.com/dlp +.. _repository’s main README: https://github.com/GoogleCloudPlatform/google-cloud-python/blob/master/README.rst \ No newline at end of file diff --git a/dlp/docs/conf.py b/dlp/docs/conf.py new file mode 100644 index 000000000000..8d4ba57c1269 --- /dev/null +++ b/dlp/docs/conf.py @@ -0,0 +1,310 @@ +# -*- coding: utf-8 -*- +# +# google-cloud-dlp documentation build configuration file +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +import sys +import os +import shlex + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +sys.path.insert(0, os.path.abspath('..')) + +__version__ = '0.15.4' + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +#needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.autosummary', + 'sphinx.ext.intersphinx', + 'sphinx.ext.coverage', + 'sphinx.ext.napoleon', + 'sphinx.ext.viewcode', +] + +# autodoc/autosummary flags +autoclass_content = 'both' +autodoc_default_flags = ['members'] +autosummary_generate = True + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# source_suffix = ['.rst', '.md'] +source_suffix = '.rst' + +# The encoding of source files. +#source_encoding = 'utf-8-sig' + +# The master toctree document. +master_doc = 'index' + +# General information about the project. +project = u'google-cloud-dlp' +copyright = u'2017, Google' +author = u'Google APIs' + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The full version, including alpha/beta/rc tags. +release = __version__ +# The short X.Y version. +version = '.'.join(release.split('.')[0:2]) + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = None + +# There are two options for replacing |today|: either, you set today to some +# non-false value, then it is used: +#today = '' +# Else, today_fmt is used as the format for a strftime call. +#today_fmt = '%B %d, %Y' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = ['_build'] + +# The reST default role (used for this markup: `text`) to use for all +# documents. +#default_role = None + +# If true, '()' will be appended to :func: etc. cross-reference text. +#add_function_parentheses = True + +# If true, the current module name will be prepended to all description +# unit titles (such as .. function::). +#add_module_names = True + +# If true, sectionauthor and moduleauthor directives will be shown in the +# output. They are ignored by default. +#show_authors = False + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = 'sphinx' + +# A list of ignored prefixes for module index sorting. +#modindex_common_prefix = [] + +# If true, keep warnings as "system message" paragraphs in the built documents. +#keep_warnings = False + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = True + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +html_theme = 'sphinx_rtd_theme' + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +#html_theme_options = {} + +# Add any paths that contain custom themes here, relative to this directory. +#html_theme_path = [] + +# The name for this set of Sphinx documents. If None, it defaults to +# " v documentation". +#html_title = None + +# A shorter title for the navigation bar. Default is the same as html_title. +#html_short_title = None + +# The name of an image file (relative to this directory) to place at the top +# of the sidebar. +#html_logo = None + +# The name of an image file (within the static path) to use as favicon of the +# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 +# pixels large. +#html_favicon = None + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +# html_static_path = [] + +# Add any extra paths that contain custom files (such as robots.txt or +# .htaccess) here, relative to this directory. These files are copied +# directly to the root of the documentation. +#html_extra_path = [] + +# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, +# using the given strftime format. +#html_last_updated_fmt = '%b %d, %Y' + +# If true, SmartyPants will be used to convert quotes and dashes to +# typographically correct entities. +#html_use_smartypants = True + +# Custom sidebar templates, maps document names to template names. +#html_sidebars = {} + +# Additional templates that should be rendered to pages, maps page names to +# template names. +#html_additional_pages = {} + +# If false, no module index is generated. +#html_domain_indices = True + +# If false, no index is generated. +#html_use_index = True + +# If true, the index is split into individual pages for each letter. +#html_split_index = False + +# If true, links to the reST sources are added to the pages. +#html_show_sourcelink = True + +# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. +#html_show_sphinx = True + +# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. +#html_show_copyright = True + +# If true, an OpenSearch description file will be output, and all pages will +# contain a tag referring to it. The value of this option must be the +# base URL from which the finished HTML is served. +#html_use_opensearch = '' + +# This is the file name suffix for HTML files (e.g. ".xhtml"). +#html_file_suffix = None + +# Language to be used for generating the HTML full-text search index. +# Sphinx supports the following languages: +# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja' +# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr' +#html_search_language = 'en' + +# A dictionary with options for the search language support, empty by default. +# Now only 'ja' uses this config value +#html_search_options = {'type': 'default'} + +# The name of a javascript file (relative to the configuration directory) that +# implements a search results scorer. If empty, the default will be used. +#html_search_scorer = 'scorer.js' + +# Output file base name for HTML help builder. +htmlhelp_basename = 'google-cloud-dlp-doc' + +# -- Options for LaTeX output --------------------------------------------- + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + #'papersize': 'letterpaper', + + # The font size ('10pt', '11pt' or '12pt'). + #'pointsize': '10pt', + + # Additional stuff for the LaTeX preamble. + #'preamble': '', + + # Latex figure (float) alignment + #'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + (master_doc, 'google-cloud-dlp.tex', u'google-cloud-dlp Documentation', + author, 'manual'), +] + +# The name of an image file (relative to this directory) to place at the top of +# the title page. +#latex_logo = None + +# For "manual" documents, if this is true, then toplevel headings are parts, +# not chapters. +#latex_use_parts = False + +# If true, show page references after internal links. +#latex_show_pagerefs = False + +# If true, show URL addresses after external links. +#latex_show_urls = False + +# Documents to append as an appendix to all manuals. +#latex_appendices = [] + +# If false, no module index is generated. +#latex_domain_indices = True + +# -- Options for manual page output --------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [(master_doc, 'google-cloud-dlp', + u'google-cloud-dlp Documentation', [author], 1)] + +# If true, show URL addresses after external links. +#man_show_urls = False + +# -- Options for Texinfo output ------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + (master_doc, 'google-cloud-dlp', u'google-cloud-dlp Documentation', author, + 'google-cloud-dlp', + 'GAPIC library for the {metadata.shortName} v2beta1 service', 'APIs'), +] + +# Documents to append as an appendix to all manuals. +#texinfo_appendices = [] + +# If false, no module index is generated. +#texinfo_domain_indices = True + +# How to display URL addresses: 'footnote', 'no', or 'inline'. +#texinfo_show_urls = 'footnote' + +# If true, do not generate a @detailmenu in the "Top" node's menu. +#texinfo_no_detailmenu = False + +# Example configuration for intersphinx: refer to the Python standard library. +intersphinx_mapping = { + 'python': ('http://python.readthedocs.org/en/latest/', None), + 'gax': ('https://gax-python.readthedocs.org/en/latest/', None), +} + +# Napoleon settings +napoleon_google_docstring = True +napoleon_numpy_docstring = True +napoleon_include_private_with_doc = False +napoleon_include_special_with_doc = True +napoleon_use_admonition_for_examples = False +napoleon_use_admonition_for_notes = False +napoleon_use_admonition_for_references = False +napoleon_use_ivar = False +napoleon_use_param = True +napoleon_use_rtype = True diff --git a/dlp/docs/gapic/v2beta1/api.rst b/dlp/docs/gapic/v2beta1/api.rst new file mode 100644 index 000000000000..e1cd9b639cd3 --- /dev/null +++ b/dlp/docs/gapic/v2beta1/api.rst @@ -0,0 +1,6 @@ +Client for DLP API +================== + +.. automodule:: google.cloud.dlp_v2beta1 + :members: + :inherited-members: \ No newline at end of file diff --git a/dlp/docs/gapic/v2beta1/types.rst b/dlp/docs/gapic/v2beta1/types.rst new file mode 100644 index 000000000000..cc8d01d83c99 --- /dev/null +++ b/dlp/docs/gapic/v2beta1/types.rst @@ -0,0 +1,5 @@ +Types for DLP API Client +======================== + +.. automodule:: google.cloud.dlp_v2beta1.types + :members: \ No newline at end of file diff --git a/dlp/docs/index.rst b/dlp/docs/index.rst new file mode 100644 index 000000000000..2bd5c283fea8 --- /dev/null +++ b/dlp/docs/index.rst @@ -0,0 +1,106 @@ +Python Client for DLP API (`Alpha`_) +==================================== + +`DLP API`_: The Google Data Loss Prevention API provides methods for detection of +privacy-sensitive fragments in text, images, and Google Cloud Platform +storage repositories. + +- `Client Library Documentation`_ +- `Product Documentation`_ + +.. _Alpha: https://github.com/GoogleCloudPlatform/google-cloud-python/blob/master/README.rst +.. _DLP API: https://cloud.google.com/dlp +.. _Client Library Documentation: https://googlecloudplatform.github.io/google-cloud-python/stable/dlp-usage +.. _Product Documentation: https://cloud.google.com/dlp + +Quick Start +----------- + +In order to use this library, you first need to go through the following steps: + +1. `Select or create a Cloud Platform project.`_ +2. `Enable the DLP API.`_ +3. `Setup Authentication.`_ + +.. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project +.. _Enable the DLP API.: https://cloud.google.com/dlp +.. _Setup Authentication.: https://googlecloudplatform.github.io/google-cloud-python/stable/google-cloud-auth + +Installation +~~~~~~~~~~~~ + +Install this library in a `virtualenv`_ using pip. `virtualenv`_ is a tool to +create isolated Python environments. The basic problem it addresses is one of +dependencies and versions, and indirectly permissions. + +With `virtualenv`_, it's possible to install this library without needing system +install permissions, and without clashing with the installed system +dependencies. + +.. _`virtualenv`: https://virtualenv.pypa.io/en/latest/ + + +Mac/Linux +^^^^^^^^^ + +.. code-block:: console + + pip install virtualenv + virtualenv + source /bin/activate + /bin/pip install google-cloud-dlp + + +Windows +^^^^^^^ + +.. code-block:: console + + pip install virtualenv + virtualenv + \Scripts\activate + \Scripts\pip.exe install google-cloud-dlp + +Preview +~~~~~~~ + +DlpServiceClient +^^^^^^^^^^^^^^^^ + +.. code:: py + + from google.cloud import dlp_v2beta1 + + client = dlp_v2beta1.DlpServiceClient() + + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + response = client.inspect_content(inspect_config, items) + +Next Steps +~~~~~~~~~~ + +- Read the `Client Library Documentation`_ for DLP API + API to see other available methods on the client. +- Read the `DLP API Product documentation`_ to learn + more about the product and see How-to Guides. +- View this `repository’s main README`_ to see the full list of Cloud + APIs that we cover. + +.. _DLP API Product documentation: https://cloud.google.com/dlp +.. _repository’s main README: https://github.com/GoogleCloudPlatform/google-cloud-python/blob/master/README.rst + +Api Reference +------------- +.. toctree:: + :maxdepth: 2 + + gapic/v2beta1/api + gapic/v2beta1/types \ No newline at end of file diff --git a/dlp/google/__init__.py b/dlp/google/__init__.py new file mode 100644 index 000000000000..d2547b8d952f --- /dev/null +++ b/dlp/google/__init__.py @@ -0,0 +1,6 @@ +try: + import pkg_resources + pkg_resources.declare_namespace(__name__) +except ImportError: + import pkgutil + __path__ = pkgutil.extend_path(__path__, __name__) \ No newline at end of file diff --git a/dlp/google/cloud/__init__.py b/dlp/google/cloud/__init__.py new file mode 100644 index 000000000000..3bfbec109db0 --- /dev/null +++ b/dlp/google/cloud/__init__.py @@ -0,0 +1,6 @@ +try: + import pkg_resources + pkg_resources.declare_namespace(__name__) +except ImportError: + import pkgutil + __path__ = pkgutil.extend_path(__path__, __name__) diff --git a/dlp/google/cloud/dlp.py b/dlp/google/cloud/dlp.py new file mode 100644 index 000000000000..8bd8d4f1efc1 --- /dev/null +++ b/dlp/google/cloud/dlp.py @@ -0,0 +1,25 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import + +from google.cloud.dlp_v2beta1 import DlpServiceClient +from google.cloud.dlp_v2beta1 import enums +from google.cloud.dlp_v2beta1 import types + +__all__ = ( + 'enums', + 'types', + 'DlpServiceClient', +) diff --git a/dlp/google/cloud/dlp_v2beta1/__init__.py b/dlp/google/cloud/dlp_v2beta1/__init__.py new file mode 100644 index 000000000000..61250599e5da --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/__init__.py @@ -0,0 +1,31 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import + +from google.cloud.dlp_v2beta1 import types +from google.cloud.dlp_v2beta1.gapic import dlp_service_client +from google.cloud.dlp_v2beta1.gapic import enums + + +class DlpServiceClient(dlp_service_client.DlpServiceClient): + __doc__ = dlp_service_client.DlpServiceClient.__doc__ + enums = enums + + +__all__ = ( + 'enums', + 'types', + 'DlpServiceClient', +) diff --git a/dlp/google/cloud/dlp_v2beta1/gapic/__init__.py b/dlp/google/cloud/dlp_v2beta1/gapic/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client.py b/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client.py new file mode 100644 index 000000000000..738964f5ec29 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client.py @@ -0,0 +1,634 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# EDITING INSTRUCTIONS +# This file was generated from the file +# https://github.com/google/googleapis/blob/master/google/privacy/dlp/v2beta1/dlp.proto, +# and updates to that file get reflected here through a refresh process. +# For the short term, the refresh process will only be runnable by Google engineers. +# +# The only allowed edits are to method and file documentation. A 3-way +# merge preserves those additions if the generated source changes. +"""Accesses the google.privacy.dlp.v2beta1 DlpService API.""" + +import pkg_resources + +import google.api_core.gapic_v1.client_info +import google.api_core.gapic_v1.config +import google.api_core.gapic_v1.method +import google.api_core.grpc_helpers +import google.api_core.operation +import google.api_core.operations_v1 +import google.api_core.path_template + +from google.cloud.dlp_v2beta1.gapic import dlp_service_client_config +from google.cloud.dlp_v2beta1.gapic import enums +from google.cloud.dlp_v2beta1.proto import dlp_pb2 +from google.cloud.dlp_v2beta1.proto import storage_pb2 + +_GAPIC_LIBRARY_VERSION = pkg_resources.get_distribution('google-cloud-dlp', + ).version + + +class DlpServiceClient(object): + """ + The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + + SERVICE_ADDRESS = 'dlp.googleapis.com:443' + """The default address of the service.""" + + # The scopes needed to make gRPC calls to all of the methods defined in + # this service + _DEFAULT_SCOPES = ('https://www.googleapis.com/auth/cloud-platform', ) + + # The name of the interface for this client. This is the key used to find + # method configuration in the client_config dictionary + _INTERFACE_NAME = ('google.privacy.dlp.v2beta1.DlpService') + + @classmethod + def result_path(cls, result): + """Returns a fully-qualified result resource name string.""" + return google.api_core.path_template.expand( + 'inspect/results/{result}', + result=result, + ) + + def __init__(self, + channel=None, + credentials=None, + client_config=dlp_service_client_config.config, + client_info=None): + """Constructor. + + Args: + channel (grpc.Channel): A ``Channel`` instance through + which to make calls. If specified, then the ``credentials`` + argument is ignored. + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If none + are specified, the client will attempt to ascertain the + credentials from the environment. + client_config (dict): + A dictionary of call options for each method. If not specified + the default configuration is used. Generally, you only need + to set this if you're developing your own client library. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + """ + if channel is not None and credentials is not None: + raise ValueError( + 'channel and credentials arguments to {} are mutually ' + 'exclusive.'.format(self.__class__.__name__)) + + if channel is None: + channel = google.api_core.grpc_helpers.create_channel( + self.SERVICE_ADDRESS, + credentials=credentials, + scopes=self._DEFAULT_SCOPES) + + self.dlp_service_stub = (dlp_pb2.DlpServiceStub(channel)) + + # Operations client for methods that return long-running operations + # futures. + self.operations_client = ( + google.api_core.operations_v1.OperationsClient(channel)) + + if client_info is None: + client_info = ( + google.api_core.gapic_v1.client_info.DEFAULT_CLIENT_INFO) + + client_info.gapic_version = _GAPIC_LIBRARY_VERSION + + interface_config = client_config['interfaces'][self._INTERFACE_NAME] + method_configs = google.api_core.gapic_v1.config.parse_method_configs( + interface_config) + + self._inspect_content = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.InspectContent, + default_retry=method_configs['InspectContent'].retry, + default_timeout=method_configs['InspectContent'].timeout, + client_info=client_info) + self._redact_content = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.RedactContent, + default_retry=method_configs['RedactContent'].retry, + default_timeout=method_configs['RedactContent'].timeout, + client_info=client_info) + self._deidentify_content = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.DeidentifyContent, + default_retry=method_configs['DeidentifyContent'].retry, + default_timeout=method_configs['DeidentifyContent'].timeout, + client_info=client_info) + self._analyze_data_source_risk = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.AnalyzeDataSourceRisk, + default_retry=method_configs['AnalyzeDataSourceRisk'].retry, + default_timeout=method_configs['AnalyzeDataSourceRisk'].timeout, + client_info=client_info) + self._create_inspect_operation = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.CreateInspectOperation, + default_retry=method_configs['CreateInspectOperation'].retry, + default_timeout=method_configs['CreateInspectOperation'].timeout, + client_info=client_info) + self._list_inspect_findings = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.ListInspectFindings, + default_retry=method_configs['ListInspectFindings'].retry, + default_timeout=method_configs['ListInspectFindings'].timeout, + client_info=client_info) + self._list_info_types = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.ListInfoTypes, + default_retry=method_configs['ListInfoTypes'].retry, + default_timeout=method_configs['ListInfoTypes'].timeout, + client_info=client_info) + self._list_root_categories = google.api_core.gapic_v1.method.wrap_method( + self.dlp_service_stub.ListRootCategories, + default_retry=method_configs['ListRootCategories'].retry, + default_timeout=method_configs['ListRootCategories'].timeout, + client_info=client_info) + + # Service calls + def inspect_content(self, + inspect_config, + items, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Finds potentially sensitive info in a list of strings. + This method has limits on input size, processing time, and output size. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> name = 'EMAIL_ADDRESS' + >>> info_types_element = {'name': name} + >>> info_types = [info_types_element] + >>> inspect_config = {'info_types': info_types} + >>> type_ = 'text/plain' + >>> value = 'My email is example@example.com.' + >>> items_element = {'type': type_, 'value': value} + >>> items = [items_element] + >>> + >>> response = client.inspect_content(inspect_config, items) + + Args: + inspect_config (Union[dict, ~google.cloud.dlp_v2beta1.types.InspectConfig]): Configuration for the inspector. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.InspectConfig` + items (list[Union[dict, ~google.cloud.dlp_v2beta1.types.ContentItem]]): The list of items to inspect. Items in a single request are + considered \"related\" unless inspect_config.independent_inputs is true. + Up to 100 are allowed per request. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.ContentItem` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.InspectContentResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.InspectContentRequest( + inspect_config=inspect_config, items=items) + return self._inspect_content(request, retry=retry, timeout=timeout) + + def redact_content(self, + inspect_config, + items, + replace_configs=None, + image_redaction_configs=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Redacts potentially sensitive info from a list of strings. + This method has limits on input size, processing time, and output size. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> name = 'EMAIL_ADDRESS' + >>> info_types_element = {'name': name} + >>> info_types = [info_types_element] + >>> inspect_config = {'info_types': info_types} + >>> type_ = 'text/plain' + >>> value = 'My email is example@example.com.' + >>> items_element = {'type': type_, 'value': value} + >>> items = [items_element] + >>> + >>> response = client.redact_content(inspect_config, items) + + Args: + inspect_config (Union[dict, ~google.cloud.dlp_v2beta1.types.InspectConfig]): Configuration for the inspector. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.InspectConfig` + items (list[Union[dict, ~google.cloud.dlp_v2beta1.types.ContentItem]]): The list of items to inspect. Up to 100 are allowed per request. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.ContentItem` + replace_configs (list[Union[dict, ~google.cloud.dlp_v2beta1.types.ReplaceConfig]]): The strings to replace findings text findings with. Must specify at least + one of these or one ImageRedactionConfig if redacting images. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.ReplaceConfig` + image_redaction_configs (list[Union[dict, ~google.cloud.dlp_v2beta1.types.ImageRedactionConfig]]): The configuration for specifying what content to redact from images. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.ImageRedactionConfig` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.RedactContentResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.RedactContentRequest( + inspect_config=inspect_config, + items=items, + replace_configs=replace_configs, + image_redaction_configs=image_redaction_configs) + return self._redact_content(request, retry=retry, timeout=timeout) + + def deidentify_content(self, + deidentify_config, + inspect_config, + items, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + De-identifies potentially sensitive info from a list of strings. + This method has limits on input size and output size. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> deidentify_config = {} + >>> inspect_config = {} + >>> items = [] + >>> + >>> response = client.deidentify_content(deidentify_config, inspect_config, items) + + Args: + deidentify_config (Union[dict, ~google.cloud.dlp_v2beta1.types.DeidentifyConfig]): Configuration for the de-identification of the list of content items. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.DeidentifyConfig` + inspect_config (Union[dict, ~google.cloud.dlp_v2beta1.types.InspectConfig]): Configuration for the inspector. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.InspectConfig` + items (list[Union[dict, ~google.cloud.dlp_v2beta1.types.ContentItem]]): The list of items to inspect. Up to 100 are allowed per request. + All items will be treated as text/*. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.ContentItem` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.DeidentifyContentResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.DeidentifyContentRequest( + deidentify_config=deidentify_config, + inspect_config=inspect_config, + items=items) + return self._deidentify_content(request, retry=retry, timeout=timeout) + + def analyze_data_source_risk( + self, + privacy_metric, + source_table, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Schedules a job to compute risk analysis metrics over content in a Google + Cloud Platform repository. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> privacy_metric = {} + >>> source_table = {} + >>> + >>> response = client.analyze_data_source_risk(privacy_metric, source_table) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + privacy_metric (Union[dict, ~google.cloud.dlp_v2beta1.types.PrivacyMetric]): Privacy metric to compute. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.PrivacyMetric` + source_table (Union[dict, ~google.cloud.dlp_v2beta1.types.BigQueryTable]): Input dataset to compute metrics over. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.BigQueryTable` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types._OperationFuture` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.AnalyzeDataSourceRiskRequest( + privacy_metric=privacy_metric, source_table=source_table) + operation = self._analyze_data_source_risk( + request, retry=retry, timeout=timeout) + return google.api_core.operation.from_gapic( + operation, + self.operations_client, + dlp_pb2.RiskAnalysisOperationResult, + metadata_type=dlp_pb2.RiskAnalysisOperationMetadata) + + def create_inspect_operation( + self, + inspect_config, + storage_config, + output_config, + operation_config=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Schedules a job scanning content in a Google Cloud Platform data + repository. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> name = 'EMAIL_ADDRESS' + >>> info_types_element = {'name': name} + >>> info_types = [info_types_element] + >>> inspect_config = {'info_types': info_types} + >>> url = 'gs://example_bucket/example_file.png' + >>> file_set = {'url': url} + >>> cloud_storage_options = {'file_set': file_set} + >>> storage_config = {'cloud_storage_options': cloud_storage_options} + >>> output_config = {} + >>> + >>> response = client.create_inspect_operation(inspect_config, storage_config, output_config) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + inspect_config (Union[dict, ~google.cloud.dlp_v2beta1.types.InspectConfig]): Configuration for the inspector. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.InspectConfig` + storage_config (Union[dict, ~google.cloud.dlp_v2beta1.types.StorageConfig]): Specification of the data set to process. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.StorageConfig` + output_config (Union[dict, ~google.cloud.dlp_v2beta1.types.OutputStorageConfig]): Optional location to store findings. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.OutputStorageConfig` + operation_config (Union[dict, ~google.cloud.dlp_v2beta1.types.OperationConfig]): Additional configuration settings for long running operations. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.dlp_v2beta1.types.OperationConfig` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types._OperationFuture` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.CreateInspectOperationRequest( + inspect_config=inspect_config, + storage_config=storage_config, + output_config=output_config, + operation_config=operation_config) + operation = self._create_inspect_operation( + request, retry=retry, timeout=timeout) + return google.api_core.operation.from_gapic( + operation, + self.operations_client, + dlp_pb2.InspectOperationResult, + metadata_type=dlp_pb2.InspectOperationMetadata) + + def list_inspect_findings(self, + name, + page_size=None, + page_token=None, + filter_=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Returns list of results for given inspect operation result set id. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> name = client.result_path('[RESULT]') + >>> + >>> response = client.list_inspect_findings(name) + + Args: + name (str): Identifier of the results set returned as metadata of + the longrunning operation created by a call to InspectDataSource. + Should be in the format of ``inspect/results/{id}``. + page_size (int): Maximum number of results to return. + If 0, the implementation selects a reasonable value. + page_token (str): The value returned by the last ``ListInspectFindingsResponse``; indicates + that this is a continuation of a prior ``ListInspectFindings`` call, and that + the system should return the next page of data. + filter_ (str): Restricts findings to items that match. Supports info_type and likelihood. + + Examples: + + - info_type=EMAIL_ADDRESS + - info_type=PHONE_NUMBER,EMAIL_ADDRESS + - likelihood=VERY_LIKELY + - likelihood=VERY_LIKELY,LIKELY + - info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.ListInspectFindingsResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.ListInspectFindingsRequest( + name=name, + page_size=page_size, + page_token=page_token, + filter=filter_) + return self._list_inspect_findings( + request, retry=retry, timeout=timeout) + + def list_info_types(self, + category, + language_code, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Returns sensitive information types for given category. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> category = 'PII' + >>> language_code = 'en' + >>> + >>> response = client.list_info_types(category, language_code) + + Args: + category (str): Category name as returned by ListRootCategories. + language_code (str): Optional BCP-47 language code for localized info type friendly + names. If omitted, or if localized strings are not available, + en-US strings will be returned. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.ListInfoTypesResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.ListInfoTypesRequest( + category=category, language_code=language_code) + return self._list_info_types(request, retry=retry, timeout=timeout) + + def list_root_categories(self, + language_code, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT): + """ + Returns the list of root categories of sensitive information. + + Example: + >>> from google.cloud import dlp_v2beta1 + >>> + >>> client = dlp_v2beta1.DlpServiceClient() + >>> + >>> language_code = 'en' + >>> + >>> response = client.list_root_categories(language_code) + + Args: + language_code (str): Optional language code for localized friendly category names. + If omitted or if localized strings are not available, + en-US strings will be returned. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + + Returns: + A :class:`~google.cloud.dlp_v2beta1.types.ListRootCategoriesResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + request = dlp_pb2.ListRootCategoriesRequest( + language_code=language_code) + return self._list_root_categories( + request, retry=retry, timeout=timeout) diff --git a/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client_config.py b/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client_config.py new file mode 100644 index 000000000000..c1fdc10c372e --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/gapic/dlp_service_client_config.py @@ -0,0 +1,63 @@ +config = { + "interfaces": { + "google.privacy.dlp.v2beta1.DlpService": { + "retry_codes": { + "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "non_idempotent": [] + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 100, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 60000, + "initial_rpc_timeout_millis": 20000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 20000, + "total_timeout_millis": 600000 + } + }, + "methods": { + "InspectContent": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "RedactContent": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "DeidentifyContent": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "AnalyzeDataSourceRisk": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "CreateInspectOperation": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "ListInspectFindings": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "ListInfoTypes": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "ListRootCategories": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + } + } + } + } +} diff --git a/dlp/google/cloud/dlp_v2beta1/gapic/enums.py b/dlp/google/cloud/dlp_v2beta1/gapic/enums.py new file mode 100644 index 000000000000..c1640162e733 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/gapic/enums.py @@ -0,0 +1,147 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Wrappers for protocol buffer enum types.""" + + +class Likelihood(object): + """ + Categorization of results based on how likely they are to represent a match, + based on the number of elements they contain which imply a match. + + Attributes: + LIKELIHOOD_UNSPECIFIED (int): Default value; information with all likelihoods is included. + VERY_UNLIKELY (int): Few matching elements. + UNLIKELY (int) + POSSIBLE (int): Some matching elements. + LIKELY (int) + VERY_LIKELY (int): Many matching elements. + """ + LIKELIHOOD_UNSPECIFIED = 0 + VERY_UNLIKELY = 1 + UNLIKELY = 2 + POSSIBLE = 3 + LIKELY = 4 + VERY_LIKELY = 5 + + +class RelationalOperator(object): + """ + Operators available for comparing the value of fields. + + Attributes: + RELATIONAL_OPERATOR_UNSPECIFIED (int) + EQUAL_TO (int): Equal. + NOT_EQUAL_TO (int): Not equal to. + GREATER_THAN (int): Greater than. + LESS_THAN (int): Less than. + GREATER_THAN_OR_EQUALS (int): Greater than or equals. + LESS_THAN_OR_EQUALS (int): Less than or equals. + EXISTS (int): Exists + """ + RELATIONAL_OPERATOR_UNSPECIFIED = 0 + EQUAL_TO = 1 + NOT_EQUAL_TO = 2 + GREATER_THAN = 3 + LESS_THAN = 4 + GREATER_THAN_OR_EQUALS = 5 + LESS_THAN_OR_EQUALS = 6 + EXISTS = 7 + + +class TimePartConfig(object): + class TimePart(object): + """ + Attributes: + TIME_PART_UNSPECIFIED (int) + YEAR (int): [000-9999] + MONTH (int): [1-12] + DAY_OF_MONTH (int): [1-31] + DAY_OF_WEEK (int): [1-7] + WEEK_OF_YEAR (int): [1-52] + HOUR_OF_DAY (int): [0-24] + """ + TIME_PART_UNSPECIFIED = 0 + YEAR = 1 + MONTH = 2 + DAY_OF_MONTH = 3 + DAY_OF_WEEK = 4 + WEEK_OF_YEAR = 5 + HOUR_OF_DAY = 6 + + +class CharsToIgnore(object): + class CharacterGroup(object): + """ + Attributes: + CHARACTER_GROUP_UNSPECIFIED (int) + NUMERIC (int): 0-9 + ALPHA_UPPER_CASE (int): A-Z + ALPHA_LOWER_CASE (int): a-z + PUNCTUATION (int): US Punctuation, one of !\"#$%&'()*+,-./:;<=>?@[\]^_``{|}~ + WHITESPACE (int): Whitespace character, one of [ \t\n\x0B\f\r] + """ + CHARACTER_GROUP_UNSPECIFIED = 0 + NUMERIC = 1 + ALPHA_UPPER_CASE = 2 + ALPHA_LOWER_CASE = 3 + PUNCTUATION = 4 + WHITESPACE = 5 + + +class CryptoReplaceFfxFpeConfig(object): + class FfxCommonNativeAlphabet(object): + """ + These are commonly used subsets of the alphabet that the FFX mode + natively supports. In the algorithm, the alphabet is selected using + the \"radix\". Therefore each corresponds to particular radix. + + Attributes: + FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED (int) + NUMERIC (int): [0-9] (radix of 10) + HEXADECIMAL (int): [0-9A-F] (radix of 16) + UPPER_CASE_ALPHA_NUMERIC (int): [0-9A-Z] (radix of 36) + ALPHA_NUMERIC (int): [0-9A-Za-z] (radix of 62) + """ + FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED = 0 + NUMERIC = 1 + HEXADECIMAL = 2 + UPPER_CASE_ALPHA_NUMERIC = 3 + ALPHA_NUMERIC = 4 + + +class RecordCondition(object): + class Expressions(object): + class LogicalOperator(object): + """ + Attributes: + LOGICAL_OPERATOR_UNSPECIFIED (int) + AND (int) + """ + LOGICAL_OPERATOR_UNSPECIFIED = 0 + AND = 1 + + +class TransformationSummary(object): + class TransformationResultCode(object): + """ + Possible outcomes of transformations. + + Attributes: + TRANSFORMATION_RESULT_CODE_UNSPECIFIED (int) + SUCCESS (int) + ERROR (int) + """ + TRANSFORMATION_RESULT_CODE_UNSPECIFIED = 0 + SUCCESS = 1 + ERROR = 2 diff --git a/dlp/google/cloud/dlp_v2beta1/proto/__init__.py b/dlp/google/cloud/dlp_v2beta1/proto/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2.py b/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2.py new file mode 100644 index 000000000000..b87439351522 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2.py @@ -0,0 +1,6128 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/privacy/dlp_v2beta1/proto/dlp.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.longrunning import operations_pb2 as google_dot_longrunning_dot_operations__pb2 +from google.cloud.privacy.dlp_v2beta1.proto import storage_pb2 as google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2 +from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from google.type import date_pb2 as google_dot_type_dot_date__pb2 +from google.type import timeofday_pb2 as google_dot_type_dot_timeofday__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/cloud/privacy/dlp_v2beta1/proto/dlp.proto', + package='google.privacy.dlp.v2beta1', + syntax='proto3', + serialized_pb=_b('\n0google/cloud/privacy/dlp_v2beta1/proto/dlp.proto\x12\x1agoogle.privacy.dlp.v2beta1\x1a\x1cgoogle/api/annotations.proto\x1a#google/longrunning/operations.proto\x1a\x34google/cloud/privacy/dlp_v2beta1/proto/storage.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x16google/type/date.proto\x1a\x1bgoogle/type/timeofday.proto\"\xc7\x03\n\rInspectConfig\x12\x38\n\ninfo_types\x18\x01 \x03(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12>\n\x0emin_likelihood\x18\x02 \x01(\x0e\x32&.google.privacy.dlp.v2beta1.Likelihood\x12\x14\n\x0cmax_findings\x18\x03 \x01(\x05\x12\x15\n\rinclude_quote\x18\x04 \x01(\x08\x12\x15\n\rexclude_types\x18\x06 \x01(\x08\x12Q\n\x10info_type_limits\x18\x07 \x03(\x0b\x32\x37.google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit\x12\x45\n\x11\x63ustom_info_types\x18\x08 \x03(\x0b\x32*.google.privacy.dlp.v2beta1.CustomInfoType\x1a^\n\rInfoTypeLimit\x12\x37\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12\x14\n\x0cmax_findings\x18\x02 \x01(\x05\",\n\x0fOperationConfig\x12\x19\n\x11max_item_findings\x18\x01 \x01(\x03\"}\n\x0b\x43ontentItem\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0e\n\x04\x64\x61ta\x18\x02 \x01(\x0cH\x00\x12\x0f\n\x05value\x18\x03 \x01(\tH\x00\x12\x32\n\x05table\x18\x04 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.TableH\x00\x42\x0b\n\tdata_item\"\xac\x01\n\x05Table\x12\x34\n\x07headers\x18\x01 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12\x33\n\x04rows\x18\x02 \x03(\x0b\x32%.google.privacy.dlp.v2beta1.Table.Row\x1a\x38\n\x03Row\x12\x31\n\x06values\x18\x01 \x03(\x0b\x32!.google.privacy.dlp.v2beta1.Value\"b\n\rInspectResult\x12\x35\n\x08\x66indings\x18\x01 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.Finding\x12\x1a\n\x12\x66indings_truncated\x18\x02 \x01(\x08\"\xf6\x01\n\x07\x46inding\x12\r\n\x05quote\x18\x01 \x01(\t\x12\x37\n\tinfo_type\x18\x02 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12:\n\nlikelihood\x18\x03 \x01(\x0e\x32&.google.privacy.dlp.v2beta1.Likelihood\x12\x36\n\x08location\x18\x04 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.Location\x12/\n\x0b\x63reate_time\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\"\xf2\x02\n\x08Location\x12\x35\n\nbyte_range\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Range\x12:\n\x0f\x63odepoint_range\x18\x02 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Range\x12>\n\x0bimage_boxes\x18\x03 \x03(\x0b\x32).google.privacy.dlp.v2beta1.ImageLocation\x12\x39\n\nrecord_key\x18\x04 \x01(\x0b\x32%.google.privacy.dlp.v2beta1.RecordKey\x12\x35\n\x08\x66ield_id\x18\x05 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12\x41\n\x0etable_location\x18\x06 \x01(\x0b\x32).google.privacy.dlp.v2beta1.TableLocation\"\"\n\rTableLocation\x12\x11\n\trow_index\x18\x01 \x01(\x03\"#\n\x05Range\x12\r\n\x05start\x18\x01 \x01(\x03\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x03\"I\n\rImageLocation\x12\x0b\n\x03top\x18\x01 \x01(\x05\x12\x0c\n\x04left\x18\x02 \x01(\x05\x12\r\n\x05width\x18\x03 \x01(\x05\x12\x0e\n\x06height\x18\x04 \x01(\x05\"\xe7\x04\n\x14RedactContentRequest\x12\x41\n\x0einspect_config\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectConfig\x12\x36\n\x05items\x18\x02 \x03(\x0b\x32\'.google.privacy.dlp.v2beta1.ContentItem\x12W\n\x0freplace_configs\x18\x03 \x03(\x0b\x32>.google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig\x12\x66\n\x17image_redaction_configs\x18\x04 \x03(\x0b\x32\x45.google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig\x1a^\n\rReplaceConfig\x12\x37\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12\x14\n\x0creplace_with\x18\x02 \x01(\t\x1a\xb2\x01\n\x14ImageRedactionConfig\x12\x39\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoTypeH\x00\x12\x19\n\x0fredact_all_text\x18\x02 \x01(\x08H\x00\x12:\n\x0fredaction_color\x18\x03 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.ColorB\x08\n\x06target\"1\n\x05\x43olor\x12\x0b\n\x03red\x18\x01 \x01(\x02\x12\r\n\x05green\x18\x02 \x01(\x02\x12\x0c\n\x04\x62lue\x18\x03 \x01(\x02\"O\n\x15RedactContentResponse\x12\x36\n\x05items\x18\x01 \x03(\x0b\x32\'.google.privacy.dlp.v2beta1.ContentItem\"\xde\x01\n\x18\x44\x65identifyContentRequest\x12G\n\x11\x64\x65identify_config\x18\x01 \x01(\x0b\x32,.google.privacy.dlp.v2beta1.DeidentifyConfig\x12\x41\n\x0einspect_config\x18\x02 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectConfig\x12\x36\n\x05items\x18\x03 \x03(\x0b\x32\'.google.privacy.dlp.v2beta1.ContentItem\"\x9b\x01\n\x19\x44\x65identifyContentResponse\x12\x36\n\x05items\x18\x01 \x03(\x0b\x32\'.google.privacy.dlp.v2beta1.ContentItem\x12\x46\n\tsummaries\x18\x02 \x03(\x0b\x32\x33.google.privacy.dlp.v2beta1.DeidentificationSummary\"\x92\x01\n\x15InspectContentRequest\x12\x41\n\x0einspect_config\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectConfig\x12\x36\n\x05items\x18\x02 \x03(\x0b\x32\'.google.privacy.dlp.v2beta1.ContentItem\"T\n\x16InspectContentResponse\x12:\n\x07results\x18\x01 \x03(\x0b\x32).google.privacy.dlp.v2beta1.InspectResult\"\xb4\x02\n\x1d\x43reateInspectOperationRequest\x12\x41\n\x0einspect_config\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectConfig\x12\x41\n\x0estorage_config\x18\x02 \x01(\x0b\x32).google.privacy.dlp.v2beta1.StorageConfig\x12\x46\n\routput_config\x18\x03 \x01(\x0b\x32/.google.privacy.dlp.v2beta1.OutputStorageConfig\x12\x45\n\x10operation_config\x18\x05 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.OperationConfig\"\x9f\x01\n\x13OutputStorageConfig\x12:\n\x05table\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.BigQueryTableH\x00\x12\x44\n\x0cstorage_path\x18\x02 \x01(\x0b\x32,.google.privacy.dlp.v2beta1.CloudStoragePathH\x00\x42\x06\n\x04type\"\\\n\x12InfoTypeStatistics\x12\x37\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12\r\n\x05\x63ount\x18\x02 \x01(\x03\"\xb2\x03\n\x18InspectOperationMetadata\x12\x17\n\x0fprocessed_bytes\x18\x01 \x01(\x03\x12\x1d\n\x15total_estimated_bytes\x18\x04 \x01(\x03\x12G\n\x0finfo_type_stats\x18\x02 \x03(\x0b\x32..google.privacy.dlp.v2beta1.InfoTypeStatistics\x12/\n\x0b\x63reate_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12I\n\x16request_inspect_config\x18\x05 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectConfig\x12I\n\x16request_storage_config\x18\x06 \x01(\x0b\x32).google.privacy.dlp.v2beta1.StorageConfig\x12N\n\x15request_output_config\x18\x07 \x01(\x0b\x32/.google.privacy.dlp.v2beta1.OutputStorageConfig\"&\n\x16InspectOperationResult\x12\x0c\n\x04name\x18\x01 \x01(\t\"a\n\x1aListInspectFindingsRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x12\n\npage_token\x18\x03 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x04 \x01(\t\"q\n\x1bListInspectFindingsResponse\x12\x39\n\x06result\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.InspectResult\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t\"~\n\x13InfoTypeDescription\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x02 \x01(\t\x12\x43\n\ncategories\x18\x03 \x03(\x0b\x32/.google.privacy.dlp.v2beta1.CategoryDescription\"?\n\x14ListInfoTypesRequest\x12\x10\n\x08\x63\x61tegory\x18\x01 \x01(\t\x12\x15\n\rlanguage_code\x18\x02 \x01(\t\"\\\n\x15ListInfoTypesResponse\x12\x43\n\ninfo_types\x18\x01 \x03(\x0b\x32/.google.privacy.dlp.v2beta1.InfoTypeDescription\"9\n\x13\x43\x61tegoryDescription\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x02 \x01(\t\"2\n\x19ListRootCategoriesRequest\x12\x15\n\rlanguage_code\x18\x01 \x01(\t\"a\n\x1aListRootCategoriesResponse\x12\x43\n\ncategories\x18\x01 \x03(\x0b\x32/.google.privacy.dlp.v2beta1.CategoryDescription\"\xa2\x01\n\x1c\x41nalyzeDataSourceRiskRequest\x12\x41\n\x0eprivacy_metric\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.PrivacyMetric\x12?\n\x0csource_table\x18\x03 \x01(\x0b\x32).google.privacy.dlp.v2beta1.BigQueryTable\"\xc2\x06\n\rPrivacyMetric\x12`\n\x16numerical_stats_config\x18\x01 \x01(\x0b\x32>.google.privacy.dlp.v2beta1.PrivacyMetric.NumericalStatsConfigH\x00\x12\x64\n\x18\x63\x61tegorical_stats_config\x18\x02 \x01(\x0b\x32@.google.privacy.dlp.v2beta1.PrivacyMetric.CategoricalStatsConfigH\x00\x12X\n\x12k_anonymity_config\x18\x03 \x01(\x0b\x32:.google.privacy.dlp.v2beta1.PrivacyMetric.KAnonymityConfigH\x00\x12X\n\x12l_diversity_config\x18\x04 \x01(\x0b\x32:.google.privacy.dlp.v2beta1.PrivacyMetric.LDiversityConfigH\x00\x1aJ\n\x14NumericalStatsConfig\x12\x32\n\x05\x66ield\x18\x01 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x1aL\n\x16\x43\x61tegoricalStatsConfig\x12\x32\n\x05\x66ield\x18\x01 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x1a\x83\x01\n\x10KAnonymityConfig\x12\x36\n\tquasi_ids\x18\x01 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12\x37\n\tentity_id\x18\x02 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.EntityId\x1a\x8c\x01\n\x10LDiversityConfig\x12\x36\n\tquasi_ids\x18\x01 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12@\n\x13sensitive_attribute\x18\x02 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldIdB\x06\n\x04type\"\xe8\x01\n\x1dRiskAnalysisOperationMetadata\x12/\n\x0b\x63reate_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12K\n\x18requested_privacy_metric\x18\x02 \x01(\x0b\x32).google.privacy.dlp.v2beta1.PrivacyMetric\x12I\n\x16requested_source_table\x18\x03 \x01(\x0b\x32).google.privacy.dlp.v2beta1.BigQueryTable\"\xeb\x11\n\x1bRiskAnalysisOperationResult\x12n\n\x16numerical_stats_result\x18\x03 \x01(\x0b\x32L.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResultH\x00\x12r\n\x18\x63\x61tegorical_stats_result\x18\x04 \x01(\x0b\x32N.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResultH\x00\x12\x66\n\x12k_anonymity_result\x18\x05 \x01(\x0b\x32H.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResultH\x00\x12\x66\n\x12l_diversity_result\x18\x06 \x01(\x0b\x32H.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResultH\x00\x1a\xbe\x01\n\x14NumericalStatsResult\x12\x34\n\tmin_value\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\x34\n\tmax_value\x18\x02 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12:\n\x0fquantile_values\x18\x04 \x03(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x1a\xfa\x02\n\x16\x43\x61tegoricalStatsResult\x12\x99\x01\n!value_frequency_histogram_buckets\x18\x05 \x03(\x0b\x32n.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket\x1a\xc3\x01\n\x1f\x43\x61tegoricalStatsHistogramBucket\x12#\n\x1bvalue_frequency_lower_bound\x18\x01 \x01(\x03\x12#\n\x1bvalue_frequency_upper_bound\x18\x02 \x01(\x03\x12\x13\n\x0b\x62ucket_size\x18\x03 \x01(\x03\x12\x41\n\rbucket_values\x18\x04 \x03(\x0b\x32*.google.privacy.dlp.v2beta1.ValueFrequency\x1a\xa6\x04\n\x10KAnonymityResult\x12\x8f\x01\n#equivalence_class_histogram_buckets\x18\x05 \x03(\x0b\x32\x62.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket\x1ay\n\x1aKAnonymityEquivalenceClass\x12;\n\x10quasi_ids_values\x18\x01 \x03(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\x1e\n\x16\x65quivalence_class_size\x18\x02 \x01(\x03\x1a\x84\x02\n\x19KAnonymityHistogramBucket\x12*\n\"equivalence_class_size_lower_bound\x18\x01 \x01(\x03\x12*\n\"equivalence_class_size_upper_bound\x18\x02 \x01(\x03\x12\x13\n\x0b\x62ucket_size\x18\x03 \x01(\x03\x12z\n\rbucket_values\x18\x04 \x03(\x0b\x32\x63.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass\x1a\xa6\x05\n\x10LDiversityResult\x12\x97\x01\n+sensitive_value_frequency_histogram_buckets\x18\x05 \x03(\x0b\x32\x62.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket\x1a\xea\x01\n\x1aLDiversityEquivalenceClass\x12;\n\x10quasi_ids_values\x18\x01 \x03(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\x1e\n\x16\x65quivalence_class_size\x18\x02 \x01(\x03\x12%\n\x1dnum_distinct_sensitive_values\x18\x03 \x01(\x03\x12H\n\x14top_sensitive_values\x18\x04 \x03(\x0b\x32*.google.privacy.dlp.v2beta1.ValueFrequency\x1a\x8a\x02\n\x19LDiversityHistogramBucket\x12-\n%sensitive_value_frequency_lower_bound\x18\x01 \x01(\x03\x12-\n%sensitive_value_frequency_upper_bound\x18\x02 \x01(\x03\x12\x13\n\x0b\x62ucket_size\x18\x03 \x01(\x03\x12z\n\rbucket_values\x18\x04 \x03(\x0b\x32\x63.google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClassB\x08\n\x06result\"Q\n\x0eValueFrequency\x12\x30\n\x05value\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\r\n\x05\x63ount\x18\x02 \x01(\x03\"\xfe\x01\n\x05Value\x12\x17\n\rinteger_value\x18\x01 \x01(\x03H\x00\x12\x15\n\x0b\x66loat_value\x18\x02 \x01(\x01H\x00\x12\x16\n\x0cstring_value\x18\x03 \x01(\tH\x00\x12\x17\n\rboolean_value\x18\x04 \x01(\x08H\x00\x12\x35\n\x0ftimestamp_value\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00\x12,\n\ntime_value\x18\x06 \x01(\x0b\x32\x16.google.type.TimeOfDayH\x00\x12\'\n\ndate_value\x18\x07 \x01(\x0b\x32\x11.google.type.DateH\x00\x42\x06\n\x04type\"\xd3\x01\n\x10\x44\x65identifyConfig\x12X\n\x19info_type_transformations\x18\x01 \x01(\x0b\x32\x33.google.privacy.dlp.v2beta1.InfoTypeTransformationsH\x00\x12S\n\x16record_transformations\x18\x02 \x01(\x0b\x32\x31.google.privacy.dlp.v2beta1.RecordTransformationsH\x00\x42\x10\n\x0etransformation\"\x84\x06\n\x17PrimitiveTransformation\x12H\n\x0ereplace_config\x18\x01 \x01(\x0b\x32..google.privacy.dlp.v2beta1.ReplaceValueConfigH\x00\x12\x41\n\rredact_config\x18\x02 \x01(\x0b\x32(.google.privacy.dlp.v2beta1.RedactConfigH\x00\x12P\n\x15\x63haracter_mask_config\x18\x03 \x01(\x0b\x32/.google.privacy.dlp.v2beta1.CharacterMaskConfigH\x00\x12^\n\x1d\x63rypto_replace_ffx_fpe_config\x18\x04 \x01(\x0b\x32\x35.google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfigH\x00\x12[\n\x1b\x66ixed_size_bucketing_config\x18\x05 \x01(\x0b\x32\x34.google.privacy.dlp.v2beta1.FixedSizeBucketingConfigH\x00\x12G\n\x10\x62ucketing_config\x18\x06 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.BucketingConfigH\x00\x12^\n\x1dreplace_with_info_type_config\x18\x07 \x01(\x0b\x32\x35.google.privacy.dlp.v2beta1.ReplaceWithInfoTypeConfigH\x00\x12\x46\n\x10time_part_config\x18\x08 \x01(\x0b\x32*.google.privacy.dlp.v2beta1.TimePartConfigH\x00\x12J\n\x12\x63rypto_hash_config\x18\t \x01(\x0b\x32,.google.privacy.dlp.v2beta1.CryptoHashConfigH\x00\x42\x10\n\x0etransformation\"\xe1\x01\n\x0eTimePartConfig\x12L\n\x0fpart_to_extract\x18\x01 \x01(\x0e\x32\x33.google.privacy.dlp.v2beta1.TimePartConfig.TimePart\"\x80\x01\n\x08TimePart\x12\x19\n\x15TIME_PART_UNSPECIFIED\x10\x00\x12\x08\n\x04YEAR\x10\x01\x12\t\n\x05MONTH\x10\x02\x12\x10\n\x0c\x44\x41Y_OF_MONTH\x10\x03\x12\x0f\n\x0b\x44\x41Y_OF_WEEK\x10\x04\x12\x10\n\x0cWEEK_OF_YEAR\x10\x05\x12\x0f\n\x0bHOUR_OF_DAY\x10\x06\"M\n\x10\x43ryptoHashConfig\x12\x39\n\ncrypto_key\x18\x01 \x01(\x0b\x32%.google.privacy.dlp.v2beta1.CryptoKey\"J\n\x12ReplaceValueConfig\x12\x34\n\tnew_value\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\"\x1b\n\x19ReplaceWithInfoTypeConfig\"\x0e\n\x0cRedactConfig\"\xaa\x02\n\rCharsToIgnore\x12\x1c\n\x12\x63haracters_to_skip\x18\x01 \x01(\tH\x00\x12_\n\x1b\x63ommon_characters_to_ignore\x18\x02 \x01(\x0e\x32\x38.google.privacy.dlp.v2beta1.CharsToIgnore.CharacterGroupH\x00\"\x8b\x01\n\x0e\x43haracterGroup\x12\x1f\n\x1b\x43HARACTER_GROUP_UNSPECIFIED\x10\x00\x12\x0b\n\x07NUMERIC\x10\x01\x12\x14\n\x10\x41LPHA_UPPER_CASE\x10\x02\x12\x14\n\x10\x41LPHA_LOWER_CASE\x10\x03\x12\x0f\n\x0bPUNCTUATION\x10\x04\x12\x0e\n\nWHITESPACE\x10\x05\x42\x0c\n\ncharacters\"\xa8\x01\n\x13\x43haracterMaskConfig\x12\x19\n\x11masking_character\x18\x01 \x01(\t\x12\x16\n\x0enumber_to_mask\x18\x02 \x01(\x05\x12\x15\n\rreverse_order\x18\x03 \x01(\x08\x12G\n\x14\x63haracters_to_ignore\x18\x04 \x03(\x0b\x32).google.privacy.dlp.v2beta1.CharsToIgnore\"\x9f\x01\n\x18\x46ixedSizeBucketingConfig\x12\x36\n\x0blower_bound\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\x36\n\x0bupper_bound\x18\x02 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12\x13\n\x0b\x62ucket_size\x18\x03 \x01(\x01\"\xff\x01\n\x0f\x42ucketingConfig\x12\x43\n\x07\x62uckets\x18\x01 \x03(\x0b\x32\x32.google.privacy.dlp.v2beta1.BucketingConfig.Bucket\x1a\xa6\x01\n\x06\x42ucket\x12.\n\x03min\x18\x01 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12.\n\x03max\x18\x02 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x12<\n\x11replacement_value\x18\x03 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\"\xc5\x03\n\x19\x43ryptoReplaceFfxFpeConfig\x12\x39\n\ncrypto_key\x18\x01 \x01(\x0b\x32%.google.privacy.dlp.v2beta1.CryptoKey\x12\x34\n\x07\x63ontext\x18\x02 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12h\n\x0f\x63ommon_alphabet\x18\x04 \x01(\x0e\x32M.google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.FfxCommonNativeAlphabetH\x00\x12\x19\n\x0f\x63ustom_alphabet\x18\x05 \x01(\tH\x00\x12\x0f\n\x05radix\x18\x06 \x01(\x05H\x00\"\x94\x01\n\x17\x46\x66xCommonNativeAlphabet\x12*\n&FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED\x10\x00\x12\x0b\n\x07NUMERIC\x10\x01\x12\x0f\n\x0bHEXADECIMAL\x10\x02\x12\x1c\n\x18UPPER_CASE_ALPHA_NUMERIC\x10\x03\x12\x11\n\rALPHA_NUMERIC\x10\x04\x42\n\n\x08\x61lphabet\"\xe7\x01\n\tCryptoKey\x12\x43\n\ttransient\x18\x01 \x01(\x0b\x32..google.privacy.dlp.v2beta1.TransientCryptoKeyH\x00\x12\x43\n\tunwrapped\x18\x02 \x01(\x0b\x32..google.privacy.dlp.v2beta1.UnwrappedCryptoKeyH\x00\x12\x46\n\x0bkms_wrapped\x18\x03 \x01(\x0b\x32/.google.privacy.dlp.v2beta1.KmsWrappedCryptoKeyH\x00\x42\x08\n\x06source\"\"\n\x12TransientCryptoKey\x12\x0c\n\x04name\x18\x01 \x01(\t\"!\n\x12UnwrappedCryptoKey\x12\x0b\n\x03key\x18\x01 \x01(\x0c\"C\n\x13KmsWrappedCryptoKey\x12\x13\n\x0bwrapped_key\x18\x01 \x01(\x0c\x12\x17\n\x0f\x63rypto_key_name\x18\x02 \x01(\t\"\xaa\x02\n\x17InfoTypeTransformations\x12\x63\n\x0ftransformations\x18\x01 \x03(\x0b\x32J.google.privacy.dlp.v2beta1.InfoTypeTransformations.InfoTypeTransformation\x1a\xa9\x01\n\x16InfoTypeTransformation\x12\x38\n\ninfo_types\x18\x01 \x03(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12U\n\x18primitive_transformation\x18\x02 \x01(\x0b\x32\x33.google.privacy.dlp.v2beta1.PrimitiveTransformation\"\xcf\x02\n\x13\x46ieldTransformation\x12\x33\n\x06\x66ields\x18\x01 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12>\n\tcondition\x18\x03 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.RecordCondition\x12W\n\x18primitive_transformation\x18\x04 \x01(\x0b\x32\x33.google.privacy.dlp.v2beta1.PrimitiveTransformationH\x00\x12X\n\x19info_type_transformations\x18\x05 \x01(\x0b\x32\x33.google.privacy.dlp.v2beta1.InfoTypeTransformationsH\x00\x42\x10\n\x0etransformation\"\xb3\x01\n\x15RecordTransformations\x12N\n\x15\x66ield_transformations\x18\x01 \x03(\x0b\x32/.google.privacy.dlp.v2beta1.FieldTransformation\x12J\n\x13record_suppressions\x18\x02 \x03(\x0b\x32-.google.privacy.dlp.v2beta1.RecordSuppression\"S\n\x11RecordSuppression\x12>\n\tcondition\x18\x01 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.RecordCondition\"\xf5\x04\n\x0fRecordCondition\x12L\n\x0b\x65xpressions\x18\x03 \x01(\x0b\x32\x37.google.privacy.dlp.v2beta1.RecordCondition.Expressions\x1a\xb3\x01\n\tCondition\x12\x32\n\x05\x66ield\x18\x01 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12@\n\x08operator\x18\x03 \x01(\x0e\x32..google.privacy.dlp.v2beta1.RelationalOperator\x12\x30\n\x05value\x18\x04 \x01(\x0b\x32!.google.privacy.dlp.v2beta1.Value\x1aW\n\nConditions\x12I\n\nconditions\x18\x01 \x03(\x0b\x32\x35.google.privacy.dlp.v2beta1.RecordCondition.Condition\x1a\x84\x02\n\x0b\x45xpressions\x12\x61\n\x10logical_operator\x18\x01 \x01(\x0e\x32G.google.privacy.dlp.v2beta1.RecordCondition.Expressions.LogicalOperator\x12L\n\nconditions\x18\x03 \x01(\x0b\x32\x36.google.privacy.dlp.v2beta1.RecordCondition.ConditionsH\x00\"<\n\x0fLogicalOperator\x12 \n\x1cLOGICAL_OPERATOR_UNSPECIFIED\x10\x00\x12\x07\n\x03\x41ND\x10\x01\x42\x06\n\x04type\"\x89\x01\n\x17\x44\x65identificationSummary\x12\x19\n\x11transformed_bytes\x18\x02 \x01(\x03\x12S\n\x18transformation_summaries\x18\x03 \x03(\x0b\x32\x31.google.privacy.dlp.v2beta1.TransformationSummary\"\xa7\x05\n\x15TransformationSummary\x12\x37\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12\x32\n\x05\x66ield\x18\x02 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\x12K\n\x0etransformation\x18\x03 \x01(\x0b\x32\x33.google.privacy.dlp.v2beta1.PrimitiveTransformation\x12N\n\x15\x66ield_transformations\x18\x05 \x03(\x0b\x32/.google.privacy.dlp.v2beta1.FieldTransformation\x12\x46\n\x0frecord_suppress\x18\x06 \x01(\x0b\x32-.google.privacy.dlp.v2beta1.RecordSuppression\x12P\n\x07results\x18\x04 \x03(\x0b\x32?.google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult\x1a\x89\x01\n\rSummaryResult\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x12X\n\x04\x63ode\x18\x02 \x01(\x0e\x32J.google.privacy.dlp.v2beta1.TransformationSummary.TransformationResultCode\x12\x0f\n\x07\x64\x65tails\x18\x03 \x01(\t\"^\n\x18TransformationResultCode\x12*\n&TRANSFORMATION_RESULT_CODE_UNSPECIFIED\x10\x00\x12\x0b\n\x07SUCCESS\x10\x01\x12\t\n\x05\x45RROR\x10\x02*t\n\nLikelihood\x12\x1a\n\x16LIKELIHOOD_UNSPECIFIED\x10\x00\x12\x11\n\rVERY_UNLIKELY\x10\x01\x12\x0c\n\x08UNLIKELY\x10\x02\x12\x0c\n\x08POSSIBLE\x10\x03\x12\n\n\x06LIKELY\x10\x04\x12\x0f\n\x0bVERY_LIKELY\x10\x05*\xbb\x01\n\x12RelationalOperator\x12#\n\x1fRELATIONAL_OPERATOR_UNSPECIFIED\x10\x00\x12\x0c\n\x08\x45QUAL_TO\x10\x01\x12\x10\n\x0cNOT_EQUAL_TO\x10\x02\x12\x10\n\x0cGREATER_THAN\x10\x03\x12\r\n\tLESS_THAN\x10\x04\x12\x1a\n\x16GREATER_THAN_OR_EQUALS\x10\x05\x12\x17\n\x13LESS_THAN_OR_EQUALS\x10\x06\x12\n\n\x06\x45XISTS\x10\x07\x32\xbc\n\n\nDlpService\x12\x9c\x01\n\x0eInspectContent\x12\x31.google.privacy.dlp.v2beta1.InspectContentRequest\x1a\x32.google.privacy.dlp.v2beta1.InspectContentResponse\"#\x82\xd3\xe4\x93\x02\x1d\"\x18/v2beta1/content:inspect:\x01*\x12\x98\x01\n\rRedactContent\x12\x30.google.privacy.dlp.v2beta1.RedactContentRequest\x1a\x31.google.privacy.dlp.v2beta1.RedactContentResponse\"\"\x82\xd3\xe4\x93\x02\x1c\"\x17/v2beta1/content:redact:\x01*\x12\xa8\x01\n\x11\x44\x65identifyContent\x12\x34.google.privacy.dlp.v2beta1.DeidentifyContentRequest\x1a\x35.google.privacy.dlp.v2beta1.DeidentifyContentResponse\"&\x82\xd3\xe4\x93\x02 \"\x1b/v2beta1/content:deidentify:\x01*\x12\x9a\x01\n\x16\x43reateInspectOperation\x12\x39.google.privacy.dlp.v2beta1.CreateInspectOperationRequest\x1a\x1d.google.longrunning.Operation\"&\x82\xd3\xe4\x93\x02 \"\x1b/v2beta1/inspect/operations:\x01*\x12\x98\x01\n\x15\x41nalyzeDataSourceRisk\x12\x38.google.privacy.dlp.v2beta1.AnalyzeDataSourceRiskRequest\x1a\x1d.google.longrunning.Operation\"&\x82\xd3\xe4\x93\x02 \"\x1b/v2beta1/dataSource:analyze:\x01*\x12\xba\x01\n\x13ListInspectFindings\x12\x36.google.privacy.dlp.v2beta1.ListInspectFindingsRequest\x1a\x37.google.privacy.dlp.v2beta1.ListInspectFindingsResponse\"2\x82\xd3\xe4\x93\x02,\x12*/v2beta1/{name=inspect/results/*}/findings\x12\xac\x01\n\rListInfoTypes\x12\x30.google.privacy.dlp.v2beta1.ListInfoTypesRequest\x1a\x31.google.privacy.dlp.v2beta1.ListInfoTypesResponse\"6\x82\xd3\xe4\x93\x02\x30\x12./v2beta1/rootCategories/{category=*}/infoTypes\x12\xa4\x01\n\x12ListRootCategories\x12\x35.google.privacy.dlp.v2beta1.ListRootCategoriesRequest\x1a\x36.google.privacy.dlp.v2beta1.ListRootCategoriesResponse\"\x1f\x82\xd3\xe4\x93\x02\x19\x12\x17/v2beta1/rootCategoriesB\x86\x01\n\x1e\x63om.google.privacy.dlp.v2beta1B\x08\x44lpProtoP\x01Z=google.golang.org/genproto/googleapis/privacy/dlp/v2beta1;dlp\xaa\x02\x18Google.Cloud.Dlp.V2Beta1b\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_longrunning_dot_operations__pb2.DESCRIPTOR,google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2.DESCRIPTOR,google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR,google_dot_type_dot_date__pb2.DESCRIPTOR,google_dot_type_dot_timeofday__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +_LIKELIHOOD = _descriptor.EnumDescriptor( + name='Likelihood', + full_name='google.privacy.dlp.v2beta1.Likelihood', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='LIKELIHOOD_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='VERY_UNLIKELY', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UNLIKELY', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='POSSIBLE', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LIKELY', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='VERY_LIKELY', index=5, number=5, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=14477, + serialized_end=14593, +) +_sym_db.RegisterEnumDescriptor(_LIKELIHOOD) + +Likelihood = enum_type_wrapper.EnumTypeWrapper(_LIKELIHOOD) +_RELATIONALOPERATOR = _descriptor.EnumDescriptor( + name='RelationalOperator', + full_name='google.privacy.dlp.v2beta1.RelationalOperator', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='RELATIONAL_OPERATOR_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='EQUAL_TO', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NOT_EQUAL_TO', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='GREATER_THAN', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LESS_THAN', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='GREATER_THAN_OR_EQUALS', index=5, number=5, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LESS_THAN_OR_EQUALS', index=6, number=6, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='EXISTS', index=7, number=7, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=14596, + serialized_end=14783, +) +_sym_db.RegisterEnumDescriptor(_RELATIONALOPERATOR) + +RelationalOperator = enum_type_wrapper.EnumTypeWrapper(_RELATIONALOPERATOR) +LIKELIHOOD_UNSPECIFIED = 0 +VERY_UNLIKELY = 1 +UNLIKELY = 2 +POSSIBLE = 3 +LIKELY = 4 +VERY_LIKELY = 5 +RELATIONAL_OPERATOR_UNSPECIFIED = 0 +EQUAL_TO = 1 +NOT_EQUAL_TO = 2 +GREATER_THAN = 3 +LESS_THAN = 4 +GREATER_THAN_OR_EQUALS = 5 +LESS_THAN_OR_EQUALS = 6 +EXISTS = 7 + + +_TIMEPARTCONFIG_TIMEPART = _descriptor.EnumDescriptor( + name='TimePart', + full_name='google.privacy.dlp.v2beta1.TimePartConfig.TimePart', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='TIME_PART_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='YEAR', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MONTH', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DAY_OF_MONTH', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DAY_OF_WEEK', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='WEEK_OF_YEAR', index=5, number=5, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='HOUR_OF_DAY', index=6, number=6, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=10065, + serialized_end=10193, +) +_sym_db.RegisterEnumDescriptor(_TIMEPARTCONFIG_TIMEPART) + +_CHARSTOIGNORE_CHARACTERGROUP = _descriptor.EnumDescriptor( + name='CharacterGroup', + full_name='google.privacy.dlp.v2beta1.CharsToIgnore.CharacterGroup', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='CHARACTER_GROUP_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NUMERIC', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ALPHA_UPPER_CASE', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ALPHA_LOWER_CASE', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PUNCTUATION', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='WHITESPACE', index=5, number=5, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=10541, + serialized_end=10680, +) +_sym_db.RegisterEnumDescriptor(_CHARSTOIGNORE_CHARACTERGROUP) + +_CRYPTOREPLACEFFXFPECONFIG_FFXCOMMONNATIVEALPHABET = _descriptor.EnumDescriptor( + name='FfxCommonNativeAlphabet', + full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.FfxCommonNativeAlphabet', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NUMERIC', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='HEXADECIMAL', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UPPER_CASE_ALPHA_NUMERIC', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ALPHA_NUMERIC', index=4, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11581, + serialized_end=11729, +) +_sym_db.RegisterEnumDescriptor(_CRYPTOREPLACEFFXFPECONFIG_FFXCOMMONNATIVEALPHABET) + +_RECORDCONDITION_EXPRESSIONS_LOGICALOPERATOR = _descriptor.EnumDescriptor( + name='LogicalOperator', + full_name='google.privacy.dlp.v2beta1.RecordCondition.Expressions.LogicalOperator', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='LOGICAL_OPERATOR_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AND', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=13585, + serialized_end=13645, +) +_sym_db.RegisterEnumDescriptor(_RECORDCONDITION_EXPRESSIONS_LOGICALOPERATOR) + +_TRANSFORMATIONSUMMARY_TRANSFORMATIONRESULTCODE = _descriptor.EnumDescriptor( + name='TransformationResultCode', + full_name='google.privacy.dlp.v2beta1.TransformationSummary.TransformationResultCode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='TRANSFORMATION_RESULT_CODE_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUCCESS', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ERROR', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=14381, + serialized_end=14475, +) +_sym_db.RegisterEnumDescriptor(_TRANSFORMATIONSUMMARY_TRANSFORMATIONRESULTCODE) + + +_INSPECTCONFIG_INFOTYPELIMIT = _descriptor.Descriptor( + name='InfoTypeLimit', + full_name='google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_findings', full_name='google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit.max_findings', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=678, + serialized_end=772, +) + +_INSPECTCONFIG = _descriptor.Descriptor( + name='InspectConfig', + full_name='google.privacy.dlp.v2beta1.InspectConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_types', full_name='google.privacy.dlp.v2beta1.InspectConfig.info_types', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='min_likelihood', full_name='google.privacy.dlp.v2beta1.InspectConfig.min_likelihood', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_findings', full_name='google.privacy.dlp.v2beta1.InspectConfig.max_findings', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='include_quote', full_name='google.privacy.dlp.v2beta1.InspectConfig.include_quote', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exclude_types', full_name='google.privacy.dlp.v2beta1.InspectConfig.exclude_types', index=4, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='info_type_limits', full_name='google.privacy.dlp.v2beta1.InspectConfig.info_type_limits', index=5, + number=7, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='custom_info_types', full_name='google.privacy.dlp.v2beta1.InspectConfig.custom_info_types', index=6, + number=8, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_INSPECTCONFIG_INFOTYPELIMIT, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=317, + serialized_end=772, +) + + +_OPERATIONCONFIG = _descriptor.Descriptor( + name='OperationConfig', + full_name='google.privacy.dlp.v2beta1.OperationConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='max_item_findings', full_name='google.privacy.dlp.v2beta1.OperationConfig.max_item_findings', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=774, + serialized_end=818, +) + + +_CONTENTITEM = _descriptor.Descriptor( + name='ContentItem', + full_name='google.privacy.dlp.v2beta1.ContentItem', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.ContentItem.type', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='google.privacy.dlp.v2beta1.ContentItem.data', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.privacy.dlp.v2beta1.ContentItem.value', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='table', full_name='google.privacy.dlp.v2beta1.ContentItem.table', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='data_item', full_name='google.privacy.dlp.v2beta1.ContentItem.data_item', + index=0, containing_type=None, fields=[]), + ], + serialized_start=820, + serialized_end=945, +) + + +_TABLE_ROW = _descriptor.Descriptor( + name='Row', + full_name='google.privacy.dlp.v2beta1.Table.Row', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='values', full_name='google.privacy.dlp.v2beta1.Table.Row.values', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1064, + serialized_end=1120, +) + +_TABLE = _descriptor.Descriptor( + name='Table', + full_name='google.privacy.dlp.v2beta1.Table', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='headers', full_name='google.privacy.dlp.v2beta1.Table.headers', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rows', full_name='google.privacy.dlp.v2beta1.Table.rows', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_TABLE_ROW, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=948, + serialized_end=1120, +) + + +_INSPECTRESULT = _descriptor.Descriptor( + name='InspectResult', + full_name='google.privacy.dlp.v2beta1.InspectResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='findings', full_name='google.privacy.dlp.v2beta1.InspectResult.findings', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='findings_truncated', full_name='google.privacy.dlp.v2beta1.InspectResult.findings_truncated', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1122, + serialized_end=1220, +) + + +_FINDING = _descriptor.Descriptor( + name='Finding', + full_name='google.privacy.dlp.v2beta1.Finding', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='quote', full_name='google.privacy.dlp.v2beta1.Finding.quote', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.Finding.info_type', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='likelihood', full_name='google.privacy.dlp.v2beta1.Finding.likelihood', index=2, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='location', full_name='google.privacy.dlp.v2beta1.Finding.location', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='create_time', full_name='google.privacy.dlp.v2beta1.Finding.create_time', index=4, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1223, + serialized_end=1469, +) + + +_LOCATION = _descriptor.Descriptor( + name='Location', + full_name='google.privacy.dlp.v2beta1.Location', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='byte_range', full_name='google.privacy.dlp.v2beta1.Location.byte_range', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='codepoint_range', full_name='google.privacy.dlp.v2beta1.Location.codepoint_range', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='image_boxes', full_name='google.privacy.dlp.v2beta1.Location.image_boxes', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='record_key', full_name='google.privacy.dlp.v2beta1.Location.record_key', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='field_id', full_name='google.privacy.dlp.v2beta1.Location.field_id', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='table_location', full_name='google.privacy.dlp.v2beta1.Location.table_location', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1472, + serialized_end=1842, +) + + +_TABLELOCATION = _descriptor.Descriptor( + name='TableLocation', + full_name='google.privacy.dlp.v2beta1.TableLocation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='row_index', full_name='google.privacy.dlp.v2beta1.TableLocation.row_index', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1844, + serialized_end=1878, +) + + +_RANGE = _descriptor.Descriptor( + name='Range', + full_name='google.privacy.dlp.v2beta1.Range', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='start', full_name='google.privacy.dlp.v2beta1.Range.start', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end', full_name='google.privacy.dlp.v2beta1.Range.end', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1880, + serialized_end=1915, +) + + +_IMAGELOCATION = _descriptor.Descriptor( + name='ImageLocation', + full_name='google.privacy.dlp.v2beta1.ImageLocation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='top', full_name='google.privacy.dlp.v2beta1.ImageLocation.top', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='left', full_name='google.privacy.dlp.v2beta1.ImageLocation.left', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='google.privacy.dlp.v2beta1.ImageLocation.width', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='google.privacy.dlp.v2beta1.ImageLocation.height', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1917, + serialized_end=1990, +) + + +_REDACTCONTENTREQUEST_REPLACECONFIG = _descriptor.Descriptor( + name='ReplaceConfig', + full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='replace_with', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig.replace_with', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2333, + serialized_end=2427, +) + +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG = _descriptor.Descriptor( + name='ImageRedactionConfig', + full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='redact_all_text', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig.redact_all_text', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='redaction_color', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig.redaction_color', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='target', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig.target', + index=0, containing_type=None, fields=[]), + ], + serialized_start=2430, + serialized_end=2608, +) + +_REDACTCONTENTREQUEST = _descriptor.Descriptor( + name='RedactContentRequest', + full_name='google.privacy.dlp.v2beta1.RedactContentRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='inspect_config', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.inspect_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='items', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.items', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='replace_configs', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.replace_configs', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='image_redaction_configs', full_name='google.privacy.dlp.v2beta1.RedactContentRequest.image_redaction_configs', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_REDACTCONTENTREQUEST_REPLACECONFIG, _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1993, + serialized_end=2608, +) + + +_COLOR = _descriptor.Descriptor( + name='Color', + full_name='google.privacy.dlp.v2beta1.Color', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='red', full_name='google.privacy.dlp.v2beta1.Color.red', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='green', full_name='google.privacy.dlp.v2beta1.Color.green', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blue', full_name='google.privacy.dlp.v2beta1.Color.blue', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2610, + serialized_end=2659, +) + + +_REDACTCONTENTRESPONSE = _descriptor.Descriptor( + name='RedactContentResponse', + full_name='google.privacy.dlp.v2beta1.RedactContentResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='items', full_name='google.privacy.dlp.v2beta1.RedactContentResponse.items', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2661, + serialized_end=2740, +) + + +_DEIDENTIFYCONTENTREQUEST = _descriptor.Descriptor( + name='DeidentifyContentRequest', + full_name='google.privacy.dlp.v2beta1.DeidentifyContentRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='deidentify_config', full_name='google.privacy.dlp.v2beta1.DeidentifyContentRequest.deidentify_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='inspect_config', full_name='google.privacy.dlp.v2beta1.DeidentifyContentRequest.inspect_config', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='items', full_name='google.privacy.dlp.v2beta1.DeidentifyContentRequest.items', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2743, + serialized_end=2965, +) + + +_DEIDENTIFYCONTENTRESPONSE = _descriptor.Descriptor( + name='DeidentifyContentResponse', + full_name='google.privacy.dlp.v2beta1.DeidentifyContentResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='items', full_name='google.privacy.dlp.v2beta1.DeidentifyContentResponse.items', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='summaries', full_name='google.privacy.dlp.v2beta1.DeidentifyContentResponse.summaries', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2968, + serialized_end=3123, +) + + +_INSPECTCONTENTREQUEST = _descriptor.Descriptor( + name='InspectContentRequest', + full_name='google.privacy.dlp.v2beta1.InspectContentRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='inspect_config', full_name='google.privacy.dlp.v2beta1.InspectContentRequest.inspect_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='items', full_name='google.privacy.dlp.v2beta1.InspectContentRequest.items', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3126, + serialized_end=3272, +) + + +_INSPECTCONTENTRESPONSE = _descriptor.Descriptor( + name='InspectContentResponse', + full_name='google.privacy.dlp.v2beta1.InspectContentResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='results', full_name='google.privacy.dlp.v2beta1.InspectContentResponse.results', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3274, + serialized_end=3358, +) + + +_CREATEINSPECTOPERATIONREQUEST = _descriptor.Descriptor( + name='CreateInspectOperationRequest', + full_name='google.privacy.dlp.v2beta1.CreateInspectOperationRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='inspect_config', full_name='google.privacy.dlp.v2beta1.CreateInspectOperationRequest.inspect_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='storage_config', full_name='google.privacy.dlp.v2beta1.CreateInspectOperationRequest.storage_config', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='output_config', full_name='google.privacy.dlp.v2beta1.CreateInspectOperationRequest.output_config', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='operation_config', full_name='google.privacy.dlp.v2beta1.CreateInspectOperationRequest.operation_config', index=3, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3361, + serialized_end=3669, +) + + +_OUTPUTSTORAGECONFIG = _descriptor.Descriptor( + name='OutputStorageConfig', + full_name='google.privacy.dlp.v2beta1.OutputStorageConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table', full_name='google.privacy.dlp.v2beta1.OutputStorageConfig.table', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='storage_path', full_name='google.privacy.dlp.v2beta1.OutputStorageConfig.storage_path', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.OutputStorageConfig.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=3672, + serialized_end=3831, +) + + +_INFOTYPESTATISTICS = _descriptor.Descriptor( + name='InfoTypeStatistics', + full_name='google.privacy.dlp.v2beta1.InfoTypeStatistics', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.InfoTypeStatistics.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='count', full_name='google.privacy.dlp.v2beta1.InfoTypeStatistics.count', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3833, + serialized_end=3925, +) + + +_INSPECTOPERATIONMETADATA = _descriptor.Descriptor( + name='InspectOperationMetadata', + full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='processed_bytes', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.processed_bytes', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='total_estimated_bytes', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.total_estimated_bytes', index=1, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='info_type_stats', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.info_type_stats', index=2, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='create_time', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.create_time', index=3, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='request_inspect_config', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.request_inspect_config', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='request_storage_config', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.request_storage_config', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='request_output_config', full_name='google.privacy.dlp.v2beta1.InspectOperationMetadata.request_output_config', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3928, + serialized_end=4362, +) + + +_INSPECTOPERATIONRESULT = _descriptor.Descriptor( + name='InspectOperationResult', + full_name='google.privacy.dlp.v2beta1.InspectOperationResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.InspectOperationResult.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4364, + serialized_end=4402, +) + + +_LISTINSPECTFINDINGSREQUEST = _descriptor.Descriptor( + name='ListInspectFindingsRequest', + full_name='google.privacy.dlp.v2beta1.ListInspectFindingsRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_size', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsRequest.page_size', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_token', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsRequest.page_token', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='filter', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsRequest.filter', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4404, + serialized_end=4501, +) + + +_LISTINSPECTFINDINGSRESPONSE = _descriptor.Descriptor( + name='ListInspectFindingsResponse', + full_name='google.privacy.dlp.v2beta1.ListInspectFindingsResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='result', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsResponse.result', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='next_page_token', full_name='google.privacy.dlp.v2beta1.ListInspectFindingsResponse.next_page_token', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4503, + serialized_end=4616, +) + + +_INFOTYPEDESCRIPTION = _descriptor.Descriptor( + name='InfoTypeDescription', + full_name='google.privacy.dlp.v2beta1.InfoTypeDescription', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.InfoTypeDescription.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='display_name', full_name='google.privacy.dlp.v2beta1.InfoTypeDescription.display_name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='categories', full_name='google.privacy.dlp.v2beta1.InfoTypeDescription.categories', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4618, + serialized_end=4744, +) + + +_LISTINFOTYPESREQUEST = _descriptor.Descriptor( + name='ListInfoTypesRequest', + full_name='google.privacy.dlp.v2beta1.ListInfoTypesRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='category', full_name='google.privacy.dlp.v2beta1.ListInfoTypesRequest.category', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='language_code', full_name='google.privacy.dlp.v2beta1.ListInfoTypesRequest.language_code', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4746, + serialized_end=4809, +) + + +_LISTINFOTYPESRESPONSE = _descriptor.Descriptor( + name='ListInfoTypesResponse', + full_name='google.privacy.dlp.v2beta1.ListInfoTypesResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_types', full_name='google.privacy.dlp.v2beta1.ListInfoTypesResponse.info_types', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4811, + serialized_end=4903, +) + + +_CATEGORYDESCRIPTION = _descriptor.Descriptor( + name='CategoryDescription', + full_name='google.privacy.dlp.v2beta1.CategoryDescription', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.CategoryDescription.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='display_name', full_name='google.privacy.dlp.v2beta1.CategoryDescription.display_name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4905, + serialized_end=4962, +) + + +_LISTROOTCATEGORIESREQUEST = _descriptor.Descriptor( + name='ListRootCategoriesRequest', + full_name='google.privacy.dlp.v2beta1.ListRootCategoriesRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='language_code', full_name='google.privacy.dlp.v2beta1.ListRootCategoriesRequest.language_code', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4964, + serialized_end=5014, +) + + +_LISTROOTCATEGORIESRESPONSE = _descriptor.Descriptor( + name='ListRootCategoriesResponse', + full_name='google.privacy.dlp.v2beta1.ListRootCategoriesResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='categories', full_name='google.privacy.dlp.v2beta1.ListRootCategoriesResponse.categories', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5016, + serialized_end=5113, +) + + +_ANALYZEDATASOURCERISKREQUEST = _descriptor.Descriptor( + name='AnalyzeDataSourceRiskRequest', + full_name='google.privacy.dlp.v2beta1.AnalyzeDataSourceRiskRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='privacy_metric', full_name='google.privacy.dlp.v2beta1.AnalyzeDataSourceRiskRequest.privacy_metric', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='source_table', full_name='google.privacy.dlp.v2beta1.AnalyzeDataSourceRiskRequest.source_table', index=1, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5116, + serialized_end=5278, +) + + +_PRIVACYMETRIC_NUMERICALSTATSCONFIG = _descriptor.Descriptor( + name='NumericalStatsConfig', + full_name='google.privacy.dlp.v2beta1.PrivacyMetric.NumericalStatsConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='field', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.NumericalStatsConfig.field', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5678, + serialized_end=5752, +) + +_PRIVACYMETRIC_CATEGORICALSTATSCONFIG = _descriptor.Descriptor( + name='CategoricalStatsConfig', + full_name='google.privacy.dlp.v2beta1.PrivacyMetric.CategoricalStatsConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='field', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.CategoricalStatsConfig.field', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5754, + serialized_end=5830, +) + +_PRIVACYMETRIC_KANONYMITYCONFIG = _descriptor.Descriptor( + name='KAnonymityConfig', + full_name='google.privacy.dlp.v2beta1.PrivacyMetric.KAnonymityConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='quasi_ids', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.KAnonymityConfig.quasi_ids', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='entity_id', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.KAnonymityConfig.entity_id', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5833, + serialized_end=5964, +) + +_PRIVACYMETRIC_LDIVERSITYCONFIG = _descriptor.Descriptor( + name='LDiversityConfig', + full_name='google.privacy.dlp.v2beta1.PrivacyMetric.LDiversityConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='quasi_ids', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.LDiversityConfig.quasi_ids', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sensitive_attribute', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.LDiversityConfig.sensitive_attribute', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5967, + serialized_end=6107, +) + +_PRIVACYMETRIC = _descriptor.Descriptor( + name='PrivacyMetric', + full_name='google.privacy.dlp.v2beta1.PrivacyMetric', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='numerical_stats_config', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.numerical_stats_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='categorical_stats_config', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.categorical_stats_config', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='k_anonymity_config', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.k_anonymity_config', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='l_diversity_config', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.l_diversity_config', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_PRIVACYMETRIC_NUMERICALSTATSCONFIG, _PRIVACYMETRIC_CATEGORICALSTATSCONFIG, _PRIVACYMETRIC_KANONYMITYCONFIG, _PRIVACYMETRIC_LDIVERSITYCONFIG, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.PrivacyMetric.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=5281, + serialized_end=6115, +) + + +_RISKANALYSISOPERATIONMETADATA = _descriptor.Descriptor( + name='RiskAnalysisOperationMetadata', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationMetadata', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='create_time', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationMetadata.create_time', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='requested_privacy_metric', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationMetadata.requested_privacy_metric', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='requested_source_table', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationMetadata.requested_source_table', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6118, + serialized_end=6350, +) + + +_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT = _descriptor.Descriptor( + name='NumericalStatsResult', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='min_value', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResult.min_value', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_value', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResult.max_value', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='quantile_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResult.quantile_values', index=2, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6821, + serialized_end=7011, +) + +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET = _descriptor.Descriptor( + name='CategoricalStatsHistogramBucket', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='value_frequency_lower_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket.value_frequency_lower_bound', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value_frequency_upper_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket.value_frequency_upper_bound', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_size', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket.bucket_size', index=2, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket.bucket_values', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7197, + serialized_end=7392, +) + +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT = _descriptor.Descriptor( + name='CategoricalStatsResult', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='value_frequency_histogram_buckets', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.value_frequency_histogram_buckets', index=0, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7014, + serialized_end=7392, +) + +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS = _descriptor.Descriptor( + name='KAnonymityEquivalenceClass', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='quasi_ids_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass.quasi_ids_values', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='equivalence_class_size', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass.equivalence_class_size', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7561, + serialized_end=7682, +) + +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET = _descriptor.Descriptor( + name='KAnonymityHistogramBucket', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='equivalence_class_size_lower_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket.equivalence_class_size_lower_bound', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='equivalence_class_size_upper_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket.equivalence_class_size_upper_bound', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_size', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket.bucket_size', index=2, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket.bucket_values', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7685, + serialized_end=7945, +) + +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT = _descriptor.Descriptor( + name='KAnonymityResult', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='equivalence_class_histogram_buckets', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.equivalence_class_histogram_buckets', index=0, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS, _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7395, + serialized_end=7945, +) + +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS = _descriptor.Descriptor( + name='LDiversityEquivalenceClass', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='quasi_ids_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass.quasi_ids_values', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='equivalence_class_size', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass.equivalence_class_size', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_distinct_sensitive_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass.num_distinct_sensitive_values', index=2, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='top_sensitive_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass.top_sensitive_values', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=8123, + serialized_end=8357, +) + +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET = _descriptor.Descriptor( + name='LDiversityHistogramBucket', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='sensitive_value_frequency_lower_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket.sensitive_value_frequency_lower_bound', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sensitive_value_frequency_upper_bound', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket.sensitive_value_frequency_upper_bound', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_size', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket.bucket_size', index=2, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_values', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket.bucket_values', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=8360, + serialized_end=8626, +) + +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT = _descriptor.Descriptor( + name='LDiversityResult', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='sensitive_value_frequency_histogram_buckets', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.sensitive_value_frequency_histogram_buckets', index=0, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS, _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7948, + serialized_end=8626, +) + +_RISKANALYSISOPERATIONRESULT = _descriptor.Descriptor( + name='RiskAnalysisOperationResult', + full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='numerical_stats_result', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.numerical_stats_result', index=0, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='categorical_stats_result', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.categorical_stats_result', index=1, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='k_anonymity_result', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.k_anonymity_result', index=2, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='l_diversity_result', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.l_diversity_result', index=3, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT, _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT, _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT, _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='result', full_name='google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.result', + index=0, containing_type=None, fields=[]), + ], + serialized_start=6353, + serialized_end=8636, +) + + +_VALUEFREQUENCY = _descriptor.Descriptor( + name='ValueFrequency', + full_name='google.privacy.dlp.v2beta1.ValueFrequency', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='google.privacy.dlp.v2beta1.ValueFrequency.value', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='count', full_name='google.privacy.dlp.v2beta1.ValueFrequency.count', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=8638, + serialized_end=8719, +) + + +_VALUE = _descriptor.Descriptor( + name='Value', + full_name='google.privacy.dlp.v2beta1.Value', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='integer_value', full_name='google.privacy.dlp.v2beta1.Value.integer_value', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='float_value', full_name='google.privacy.dlp.v2beta1.Value.float_value', index=1, + number=2, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='string_value', full_name='google.privacy.dlp.v2beta1.Value.string_value', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='boolean_value', full_name='google.privacy.dlp.v2beta1.Value.boolean_value', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='timestamp_value', full_name='google.privacy.dlp.v2beta1.Value.timestamp_value', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='time_value', full_name='google.privacy.dlp.v2beta1.Value.time_value', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='date_value', full_name='google.privacy.dlp.v2beta1.Value.date_value', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.Value.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=8722, + serialized_end=8976, +) + + +_DEIDENTIFYCONFIG = _descriptor.Descriptor( + name='DeidentifyConfig', + full_name='google.privacy.dlp.v2beta1.DeidentifyConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type_transformations', full_name='google.privacy.dlp.v2beta1.DeidentifyConfig.info_type_transformations', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='record_transformations', full_name='google.privacy.dlp.v2beta1.DeidentifyConfig.record_transformations', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='transformation', full_name='google.privacy.dlp.v2beta1.DeidentifyConfig.transformation', + index=0, containing_type=None, fields=[]), + ], + serialized_start=8979, + serialized_end=9190, +) + + +_PRIMITIVETRANSFORMATION = _descriptor.Descriptor( + name='PrimitiveTransformation', + full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='replace_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.replace_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='redact_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.redact_config', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='character_mask_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.character_mask_config', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crypto_replace_ffx_fpe_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.crypto_replace_ffx_fpe_config', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fixed_size_bucketing_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.fixed_size_bucketing_config', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucketing_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.bucketing_config', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='replace_with_info_type_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.replace_with_info_type_config', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='time_part_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.time_part_config', index=7, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crypto_hash_config', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.crypto_hash_config', index=8, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='transformation', full_name='google.privacy.dlp.v2beta1.PrimitiveTransformation.transformation', + index=0, containing_type=None, fields=[]), + ], + serialized_start=9193, + serialized_end=9965, +) + + +_TIMEPARTCONFIG = _descriptor.Descriptor( + name='TimePartConfig', + full_name='google.privacy.dlp.v2beta1.TimePartConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='part_to_extract', full_name='google.privacy.dlp.v2beta1.TimePartConfig.part_to_extract', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _TIMEPARTCONFIG_TIMEPART, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=9968, + serialized_end=10193, +) + + +_CRYPTOHASHCONFIG = _descriptor.Descriptor( + name='CryptoHashConfig', + full_name='google.privacy.dlp.v2beta1.CryptoHashConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='crypto_key', full_name='google.privacy.dlp.v2beta1.CryptoHashConfig.crypto_key', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10195, + serialized_end=10272, +) + + +_REPLACEVALUECONFIG = _descriptor.Descriptor( + name='ReplaceValueConfig', + full_name='google.privacy.dlp.v2beta1.ReplaceValueConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='new_value', full_name='google.privacy.dlp.v2beta1.ReplaceValueConfig.new_value', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10274, + serialized_end=10348, +) + + +_REPLACEWITHINFOTYPECONFIG = _descriptor.Descriptor( + name='ReplaceWithInfoTypeConfig', + full_name='google.privacy.dlp.v2beta1.ReplaceWithInfoTypeConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10350, + serialized_end=10377, +) + + +_REDACTCONFIG = _descriptor.Descriptor( + name='RedactConfig', + full_name='google.privacy.dlp.v2beta1.RedactConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10379, + serialized_end=10393, +) + + +_CHARSTOIGNORE = _descriptor.Descriptor( + name='CharsToIgnore', + full_name='google.privacy.dlp.v2beta1.CharsToIgnore', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='characters_to_skip', full_name='google.privacy.dlp.v2beta1.CharsToIgnore.characters_to_skip', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='common_characters_to_ignore', full_name='google.privacy.dlp.v2beta1.CharsToIgnore.common_characters_to_ignore', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _CHARSTOIGNORE_CHARACTERGROUP, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='characters', full_name='google.privacy.dlp.v2beta1.CharsToIgnore.characters', + index=0, containing_type=None, fields=[]), + ], + serialized_start=10396, + serialized_end=10694, +) + + +_CHARACTERMASKCONFIG = _descriptor.Descriptor( + name='CharacterMaskConfig', + full_name='google.privacy.dlp.v2beta1.CharacterMaskConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='masking_character', full_name='google.privacy.dlp.v2beta1.CharacterMaskConfig.masking_character', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='number_to_mask', full_name='google.privacy.dlp.v2beta1.CharacterMaskConfig.number_to_mask', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reverse_order', full_name='google.privacy.dlp.v2beta1.CharacterMaskConfig.reverse_order', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='characters_to_ignore', full_name='google.privacy.dlp.v2beta1.CharacterMaskConfig.characters_to_ignore', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10697, + serialized_end=10865, +) + + +_FIXEDSIZEBUCKETINGCONFIG = _descriptor.Descriptor( + name='FixedSizeBucketingConfig', + full_name='google.privacy.dlp.v2beta1.FixedSizeBucketingConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='lower_bound', full_name='google.privacy.dlp.v2beta1.FixedSizeBucketingConfig.lower_bound', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='upper_bound', full_name='google.privacy.dlp.v2beta1.FixedSizeBucketingConfig.upper_bound', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bucket_size', full_name='google.privacy.dlp.v2beta1.FixedSizeBucketingConfig.bucket_size', index=2, + number=3, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=10868, + serialized_end=11027, +) + + +_BUCKETINGCONFIG_BUCKET = _descriptor.Descriptor( + name='Bucket', + full_name='google.privacy.dlp.v2beta1.BucketingConfig.Bucket', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='min', full_name='google.privacy.dlp.v2beta1.BucketingConfig.Bucket.min', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max', full_name='google.privacy.dlp.v2beta1.BucketingConfig.Bucket.max', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='replacement_value', full_name='google.privacy.dlp.v2beta1.BucketingConfig.Bucket.replacement_value', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=11119, + serialized_end=11285, +) + +_BUCKETINGCONFIG = _descriptor.Descriptor( + name='BucketingConfig', + full_name='google.privacy.dlp.v2beta1.BucketingConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='buckets', full_name='google.privacy.dlp.v2beta1.BucketingConfig.buckets', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_BUCKETINGCONFIG_BUCKET, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=11030, + serialized_end=11285, +) + + +_CRYPTOREPLACEFFXFPECONFIG = _descriptor.Descriptor( + name='CryptoReplaceFfxFpeConfig', + full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='crypto_key', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.crypto_key', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='context', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.context', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='common_alphabet', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.common_alphabet', index=2, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='custom_alphabet', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.custom_alphabet', index=3, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='radix', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.radix', index=4, + number=6, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _CRYPTOREPLACEFFXFPECONFIG_FFXCOMMONNATIVEALPHABET, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='alphabet', full_name='google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig.alphabet', + index=0, containing_type=None, fields=[]), + ], + serialized_start=11288, + serialized_end=11741, +) + + +_CRYPTOKEY = _descriptor.Descriptor( + name='CryptoKey', + full_name='google.privacy.dlp.v2beta1.CryptoKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='transient', full_name='google.privacy.dlp.v2beta1.CryptoKey.transient', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='unwrapped', full_name='google.privacy.dlp.v2beta1.CryptoKey.unwrapped', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kms_wrapped', full_name='google.privacy.dlp.v2beta1.CryptoKey.kms_wrapped', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='source', full_name='google.privacy.dlp.v2beta1.CryptoKey.source', + index=0, containing_type=None, fields=[]), + ], + serialized_start=11744, + serialized_end=11975, +) + + +_TRANSIENTCRYPTOKEY = _descriptor.Descriptor( + name='TransientCryptoKey', + full_name='google.privacy.dlp.v2beta1.TransientCryptoKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.TransientCryptoKey.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=11977, + serialized_end=12011, +) + + +_UNWRAPPEDCRYPTOKEY = _descriptor.Descriptor( + name='UnwrappedCryptoKey', + full_name='google.privacy.dlp.v2beta1.UnwrappedCryptoKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='google.privacy.dlp.v2beta1.UnwrappedCryptoKey.key', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12013, + serialized_end=12046, +) + + +_KMSWRAPPEDCRYPTOKEY = _descriptor.Descriptor( + name='KmsWrappedCryptoKey', + full_name='google.privacy.dlp.v2beta1.KmsWrappedCryptoKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='wrapped_key', full_name='google.privacy.dlp.v2beta1.KmsWrappedCryptoKey.wrapped_key', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crypto_key_name', full_name='google.privacy.dlp.v2beta1.KmsWrappedCryptoKey.crypto_key_name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12048, + serialized_end=12115, +) + + +_INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION = _descriptor.Descriptor( + name='InfoTypeTransformation', + full_name='google.privacy.dlp.v2beta1.InfoTypeTransformations.InfoTypeTransformation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_types', full_name='google.privacy.dlp.v2beta1.InfoTypeTransformations.InfoTypeTransformation.info_types', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='primitive_transformation', full_name='google.privacy.dlp.v2beta1.InfoTypeTransformations.InfoTypeTransformation.primitive_transformation', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12247, + serialized_end=12416, +) + +_INFOTYPETRANSFORMATIONS = _descriptor.Descriptor( + name='InfoTypeTransformations', + full_name='google.privacy.dlp.v2beta1.InfoTypeTransformations', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='transformations', full_name='google.privacy.dlp.v2beta1.InfoTypeTransformations.transformations', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12118, + serialized_end=12416, +) + + +_FIELDTRANSFORMATION = _descriptor.Descriptor( + name='FieldTransformation', + full_name='google.privacy.dlp.v2beta1.FieldTransformation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='fields', full_name='google.privacy.dlp.v2beta1.FieldTransformation.fields', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='condition', full_name='google.privacy.dlp.v2beta1.FieldTransformation.condition', index=1, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='primitive_transformation', full_name='google.privacy.dlp.v2beta1.FieldTransformation.primitive_transformation', index=2, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='info_type_transformations', full_name='google.privacy.dlp.v2beta1.FieldTransformation.info_type_transformations', index=3, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='transformation', full_name='google.privacy.dlp.v2beta1.FieldTransformation.transformation', + index=0, containing_type=None, fields=[]), + ], + serialized_start=12419, + serialized_end=12754, +) + + +_RECORDTRANSFORMATIONS = _descriptor.Descriptor( + name='RecordTransformations', + full_name='google.privacy.dlp.v2beta1.RecordTransformations', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='field_transformations', full_name='google.privacy.dlp.v2beta1.RecordTransformations.field_transformations', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='record_suppressions', full_name='google.privacy.dlp.v2beta1.RecordTransformations.record_suppressions', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12757, + serialized_end=12936, +) + + +_RECORDSUPPRESSION = _descriptor.Descriptor( + name='RecordSuppression', + full_name='google.privacy.dlp.v2beta1.RecordSuppression', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='condition', full_name='google.privacy.dlp.v2beta1.RecordSuppression.condition', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=12938, + serialized_end=13021, +) + + +_RECORDCONDITION_CONDITION = _descriptor.Descriptor( + name='Condition', + full_name='google.privacy.dlp.v2beta1.RecordCondition.Condition', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='field', full_name='google.privacy.dlp.v2beta1.RecordCondition.Condition.field', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='operator', full_name='google.privacy.dlp.v2beta1.RecordCondition.Condition.operator', index=1, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.privacy.dlp.v2beta1.RecordCondition.Condition.value', index=2, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=13122, + serialized_end=13301, +) + +_RECORDCONDITION_CONDITIONS = _descriptor.Descriptor( + name='Conditions', + full_name='google.privacy.dlp.v2beta1.RecordCondition.Conditions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='conditions', full_name='google.privacy.dlp.v2beta1.RecordCondition.Conditions.conditions', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=13303, + serialized_end=13390, +) + +_RECORDCONDITION_EXPRESSIONS = _descriptor.Descriptor( + name='Expressions', + full_name='google.privacy.dlp.v2beta1.RecordCondition.Expressions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='logical_operator', full_name='google.privacy.dlp.v2beta1.RecordCondition.Expressions.logical_operator', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='conditions', full_name='google.privacy.dlp.v2beta1.RecordCondition.Expressions.conditions', index=1, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _RECORDCONDITION_EXPRESSIONS_LOGICALOPERATOR, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.RecordCondition.Expressions.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=13393, + serialized_end=13653, +) + +_RECORDCONDITION = _descriptor.Descriptor( + name='RecordCondition', + full_name='google.privacy.dlp.v2beta1.RecordCondition', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='expressions', full_name='google.privacy.dlp.v2beta1.RecordCondition.expressions', index=0, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_RECORDCONDITION_CONDITION, _RECORDCONDITION_CONDITIONS, _RECORDCONDITION_EXPRESSIONS, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=13024, + serialized_end=13653, +) + + +_DEIDENTIFICATIONSUMMARY = _descriptor.Descriptor( + name='DeidentificationSummary', + full_name='google.privacy.dlp.v2beta1.DeidentificationSummary', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='transformed_bytes', full_name='google.privacy.dlp.v2beta1.DeidentificationSummary.transformed_bytes', index=0, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transformation_summaries', full_name='google.privacy.dlp.v2beta1.DeidentificationSummary.transformation_summaries', index=1, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=13656, + serialized_end=13793, +) + + +_TRANSFORMATIONSUMMARY_SUMMARYRESULT = _descriptor.Descriptor( + name='SummaryResult', + full_name='google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='count', full_name='google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult.count', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='code', full_name='google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult.code', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='details', full_name='google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult.details', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=14242, + serialized_end=14379, +) + +_TRANSFORMATIONSUMMARY = _descriptor.Descriptor( + name='TransformationSummary', + full_name='google.privacy.dlp.v2beta1.TransformationSummary', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.TransformationSummary.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='field', full_name='google.privacy.dlp.v2beta1.TransformationSummary.field', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transformation', full_name='google.privacy.dlp.v2beta1.TransformationSummary.transformation', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='field_transformations', full_name='google.privacy.dlp.v2beta1.TransformationSummary.field_transformations', index=3, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='record_suppress', full_name='google.privacy.dlp.v2beta1.TransformationSummary.record_suppress', index=4, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='results', full_name='google.privacy.dlp.v2beta1.TransformationSummary.results', index=5, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_TRANSFORMATIONSUMMARY_SUMMARYRESULT, ], + enum_types=[ + _TRANSFORMATIONSUMMARY_TRANSFORMATIONRESULTCODE, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=13796, + serialized_end=14475, +) + +_INSPECTCONFIG_INFOTYPELIMIT.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_INSPECTCONFIG_INFOTYPELIMIT.containing_type = _INSPECTCONFIG +_INSPECTCONFIG.fields_by_name['info_types'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_INSPECTCONFIG.fields_by_name['min_likelihood'].enum_type = _LIKELIHOOD +_INSPECTCONFIG.fields_by_name['info_type_limits'].message_type = _INSPECTCONFIG_INFOTYPELIMIT +_INSPECTCONFIG.fields_by_name['custom_info_types'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._CUSTOMINFOTYPE +_CONTENTITEM.fields_by_name['table'].message_type = _TABLE +_CONTENTITEM.oneofs_by_name['data_item'].fields.append( + _CONTENTITEM.fields_by_name['data']) +_CONTENTITEM.fields_by_name['data'].containing_oneof = _CONTENTITEM.oneofs_by_name['data_item'] +_CONTENTITEM.oneofs_by_name['data_item'].fields.append( + _CONTENTITEM.fields_by_name['value']) +_CONTENTITEM.fields_by_name['value'].containing_oneof = _CONTENTITEM.oneofs_by_name['data_item'] +_CONTENTITEM.oneofs_by_name['data_item'].fields.append( + _CONTENTITEM.fields_by_name['table']) +_CONTENTITEM.fields_by_name['table'].containing_oneof = _CONTENTITEM.oneofs_by_name['data_item'] +_TABLE_ROW.fields_by_name['values'].message_type = _VALUE +_TABLE_ROW.containing_type = _TABLE +_TABLE.fields_by_name['headers'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_TABLE.fields_by_name['rows'].message_type = _TABLE_ROW +_INSPECTRESULT.fields_by_name['findings'].message_type = _FINDING +_FINDING.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_FINDING.fields_by_name['likelihood'].enum_type = _LIKELIHOOD +_FINDING.fields_by_name['location'].message_type = _LOCATION +_FINDING.fields_by_name['create_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_LOCATION.fields_by_name['byte_range'].message_type = _RANGE +_LOCATION.fields_by_name['codepoint_range'].message_type = _RANGE +_LOCATION.fields_by_name['image_boxes'].message_type = _IMAGELOCATION +_LOCATION.fields_by_name['record_key'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._RECORDKEY +_LOCATION.fields_by_name['field_id'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_LOCATION.fields_by_name['table_location'].message_type = _TABLELOCATION +_REDACTCONTENTREQUEST_REPLACECONFIG.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_REDACTCONTENTREQUEST_REPLACECONFIG.containing_type = _REDACTCONTENTREQUEST +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['redaction_color'].message_type = _COLOR +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.containing_type = _REDACTCONTENTREQUEST +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.oneofs_by_name['target'].fields.append( + _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['info_type']) +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['info_type'].containing_oneof = _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.oneofs_by_name['target'] +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.oneofs_by_name['target'].fields.append( + _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['redact_all_text']) +_REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.fields_by_name['redact_all_text'].containing_oneof = _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG.oneofs_by_name['target'] +_REDACTCONTENTREQUEST.fields_by_name['inspect_config'].message_type = _INSPECTCONFIG +_REDACTCONTENTREQUEST.fields_by_name['items'].message_type = _CONTENTITEM +_REDACTCONTENTREQUEST.fields_by_name['replace_configs'].message_type = _REDACTCONTENTREQUEST_REPLACECONFIG +_REDACTCONTENTREQUEST.fields_by_name['image_redaction_configs'].message_type = _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG +_REDACTCONTENTRESPONSE.fields_by_name['items'].message_type = _CONTENTITEM +_DEIDENTIFYCONTENTREQUEST.fields_by_name['deidentify_config'].message_type = _DEIDENTIFYCONFIG +_DEIDENTIFYCONTENTREQUEST.fields_by_name['inspect_config'].message_type = _INSPECTCONFIG +_DEIDENTIFYCONTENTREQUEST.fields_by_name['items'].message_type = _CONTENTITEM +_DEIDENTIFYCONTENTRESPONSE.fields_by_name['items'].message_type = _CONTENTITEM +_DEIDENTIFYCONTENTRESPONSE.fields_by_name['summaries'].message_type = _DEIDENTIFICATIONSUMMARY +_INSPECTCONTENTREQUEST.fields_by_name['inspect_config'].message_type = _INSPECTCONFIG +_INSPECTCONTENTREQUEST.fields_by_name['items'].message_type = _CONTENTITEM +_INSPECTCONTENTRESPONSE.fields_by_name['results'].message_type = _INSPECTRESULT +_CREATEINSPECTOPERATIONREQUEST.fields_by_name['inspect_config'].message_type = _INSPECTCONFIG +_CREATEINSPECTOPERATIONREQUEST.fields_by_name['storage_config'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._STORAGECONFIG +_CREATEINSPECTOPERATIONREQUEST.fields_by_name['output_config'].message_type = _OUTPUTSTORAGECONFIG +_CREATEINSPECTOPERATIONREQUEST.fields_by_name['operation_config'].message_type = _OPERATIONCONFIG +_OUTPUTSTORAGECONFIG.fields_by_name['table'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._BIGQUERYTABLE +_OUTPUTSTORAGECONFIG.fields_by_name['storage_path'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._CLOUDSTORAGEPATH +_OUTPUTSTORAGECONFIG.oneofs_by_name['type'].fields.append( + _OUTPUTSTORAGECONFIG.fields_by_name['table']) +_OUTPUTSTORAGECONFIG.fields_by_name['table'].containing_oneof = _OUTPUTSTORAGECONFIG.oneofs_by_name['type'] +_OUTPUTSTORAGECONFIG.oneofs_by_name['type'].fields.append( + _OUTPUTSTORAGECONFIG.fields_by_name['storage_path']) +_OUTPUTSTORAGECONFIG.fields_by_name['storage_path'].containing_oneof = _OUTPUTSTORAGECONFIG.oneofs_by_name['type'] +_INFOTYPESTATISTICS.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_INSPECTOPERATIONMETADATA.fields_by_name['info_type_stats'].message_type = _INFOTYPESTATISTICS +_INSPECTOPERATIONMETADATA.fields_by_name['create_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_INSPECTOPERATIONMETADATA.fields_by_name['request_inspect_config'].message_type = _INSPECTCONFIG +_INSPECTOPERATIONMETADATA.fields_by_name['request_storage_config'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._STORAGECONFIG +_INSPECTOPERATIONMETADATA.fields_by_name['request_output_config'].message_type = _OUTPUTSTORAGECONFIG +_LISTINSPECTFINDINGSRESPONSE.fields_by_name['result'].message_type = _INSPECTRESULT +_INFOTYPEDESCRIPTION.fields_by_name['categories'].message_type = _CATEGORYDESCRIPTION +_LISTINFOTYPESRESPONSE.fields_by_name['info_types'].message_type = _INFOTYPEDESCRIPTION +_LISTROOTCATEGORIESRESPONSE.fields_by_name['categories'].message_type = _CATEGORYDESCRIPTION +_ANALYZEDATASOURCERISKREQUEST.fields_by_name['privacy_metric'].message_type = _PRIVACYMETRIC +_ANALYZEDATASOURCERISKREQUEST.fields_by_name['source_table'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._BIGQUERYTABLE +_PRIVACYMETRIC_NUMERICALSTATSCONFIG.fields_by_name['field'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_PRIVACYMETRIC_NUMERICALSTATSCONFIG.containing_type = _PRIVACYMETRIC +_PRIVACYMETRIC_CATEGORICALSTATSCONFIG.fields_by_name['field'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_PRIVACYMETRIC_CATEGORICALSTATSCONFIG.containing_type = _PRIVACYMETRIC +_PRIVACYMETRIC_KANONYMITYCONFIG.fields_by_name['quasi_ids'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_PRIVACYMETRIC_KANONYMITYCONFIG.fields_by_name['entity_id'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._ENTITYID +_PRIVACYMETRIC_KANONYMITYCONFIG.containing_type = _PRIVACYMETRIC +_PRIVACYMETRIC_LDIVERSITYCONFIG.fields_by_name['quasi_ids'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_PRIVACYMETRIC_LDIVERSITYCONFIG.fields_by_name['sensitive_attribute'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_PRIVACYMETRIC_LDIVERSITYCONFIG.containing_type = _PRIVACYMETRIC +_PRIVACYMETRIC.fields_by_name['numerical_stats_config'].message_type = _PRIVACYMETRIC_NUMERICALSTATSCONFIG +_PRIVACYMETRIC.fields_by_name['categorical_stats_config'].message_type = _PRIVACYMETRIC_CATEGORICALSTATSCONFIG +_PRIVACYMETRIC.fields_by_name['k_anonymity_config'].message_type = _PRIVACYMETRIC_KANONYMITYCONFIG +_PRIVACYMETRIC.fields_by_name['l_diversity_config'].message_type = _PRIVACYMETRIC_LDIVERSITYCONFIG +_PRIVACYMETRIC.oneofs_by_name['type'].fields.append( + _PRIVACYMETRIC.fields_by_name['numerical_stats_config']) +_PRIVACYMETRIC.fields_by_name['numerical_stats_config'].containing_oneof = _PRIVACYMETRIC.oneofs_by_name['type'] +_PRIVACYMETRIC.oneofs_by_name['type'].fields.append( + _PRIVACYMETRIC.fields_by_name['categorical_stats_config']) +_PRIVACYMETRIC.fields_by_name['categorical_stats_config'].containing_oneof = _PRIVACYMETRIC.oneofs_by_name['type'] +_PRIVACYMETRIC.oneofs_by_name['type'].fields.append( + _PRIVACYMETRIC.fields_by_name['k_anonymity_config']) +_PRIVACYMETRIC.fields_by_name['k_anonymity_config'].containing_oneof = _PRIVACYMETRIC.oneofs_by_name['type'] +_PRIVACYMETRIC.oneofs_by_name['type'].fields.append( + _PRIVACYMETRIC.fields_by_name['l_diversity_config']) +_PRIVACYMETRIC.fields_by_name['l_diversity_config'].containing_oneof = _PRIVACYMETRIC.oneofs_by_name['type'] +_RISKANALYSISOPERATIONMETADATA.fields_by_name['create_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_RISKANALYSISOPERATIONMETADATA.fields_by_name['requested_privacy_metric'].message_type = _PRIVACYMETRIC +_RISKANALYSISOPERATIONMETADATA.fields_by_name['requested_source_table'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._BIGQUERYTABLE +_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT.fields_by_name['min_value'].message_type = _VALUE +_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT.fields_by_name['max_value'].message_type = _VALUE +_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT.fields_by_name['quantile_values'].message_type = _VALUE +_RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT.containing_type = _RISKANALYSISOPERATIONRESULT +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET.fields_by_name['bucket_values'].message_type = _VALUEFREQUENCY +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET.containing_type = _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT.fields_by_name['value_frequency_histogram_buckets'].message_type = _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET +_RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT.containing_type = _RISKANALYSISOPERATIONRESULT +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS.fields_by_name['quasi_ids_values'].message_type = _VALUE +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS.containing_type = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET.fields_by_name['bucket_values'].message_type = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET.containing_type = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT.fields_by_name['equivalence_class_histogram_buckets'].message_type = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET +_RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT.containing_type = _RISKANALYSISOPERATIONRESULT +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS.fields_by_name['quasi_ids_values'].message_type = _VALUE +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS.fields_by_name['top_sensitive_values'].message_type = _VALUEFREQUENCY +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS.containing_type = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET.fields_by_name['bucket_values'].message_type = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET.containing_type = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT.fields_by_name['sensitive_value_frequency_histogram_buckets'].message_type = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET +_RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT.containing_type = _RISKANALYSISOPERATIONRESULT +_RISKANALYSISOPERATIONRESULT.fields_by_name['numerical_stats_result'].message_type = _RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT +_RISKANALYSISOPERATIONRESULT.fields_by_name['categorical_stats_result'].message_type = _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT +_RISKANALYSISOPERATIONRESULT.fields_by_name['k_anonymity_result'].message_type = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT +_RISKANALYSISOPERATIONRESULT.fields_by_name['l_diversity_result'].message_type = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT +_RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'].fields.append( + _RISKANALYSISOPERATIONRESULT.fields_by_name['numerical_stats_result']) +_RISKANALYSISOPERATIONRESULT.fields_by_name['numerical_stats_result'].containing_oneof = _RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'] +_RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'].fields.append( + _RISKANALYSISOPERATIONRESULT.fields_by_name['categorical_stats_result']) +_RISKANALYSISOPERATIONRESULT.fields_by_name['categorical_stats_result'].containing_oneof = _RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'] +_RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'].fields.append( + _RISKANALYSISOPERATIONRESULT.fields_by_name['k_anonymity_result']) +_RISKANALYSISOPERATIONRESULT.fields_by_name['k_anonymity_result'].containing_oneof = _RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'] +_RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'].fields.append( + _RISKANALYSISOPERATIONRESULT.fields_by_name['l_diversity_result']) +_RISKANALYSISOPERATIONRESULT.fields_by_name['l_diversity_result'].containing_oneof = _RISKANALYSISOPERATIONRESULT.oneofs_by_name['result'] +_VALUEFREQUENCY.fields_by_name['value'].message_type = _VALUE +_VALUE.fields_by_name['timestamp_value'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_VALUE.fields_by_name['time_value'].message_type = google_dot_type_dot_timeofday__pb2._TIMEOFDAY +_VALUE.fields_by_name['date_value'].message_type = google_dot_type_dot_date__pb2._DATE +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['integer_value']) +_VALUE.fields_by_name['integer_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['float_value']) +_VALUE.fields_by_name['float_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['string_value']) +_VALUE.fields_by_name['string_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['boolean_value']) +_VALUE.fields_by_name['boolean_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['timestamp_value']) +_VALUE.fields_by_name['timestamp_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['time_value']) +_VALUE.fields_by_name['time_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_VALUE.oneofs_by_name['type'].fields.append( + _VALUE.fields_by_name['date_value']) +_VALUE.fields_by_name['date_value'].containing_oneof = _VALUE.oneofs_by_name['type'] +_DEIDENTIFYCONFIG.fields_by_name['info_type_transformations'].message_type = _INFOTYPETRANSFORMATIONS +_DEIDENTIFYCONFIG.fields_by_name['record_transformations'].message_type = _RECORDTRANSFORMATIONS +_DEIDENTIFYCONFIG.oneofs_by_name['transformation'].fields.append( + _DEIDENTIFYCONFIG.fields_by_name['info_type_transformations']) +_DEIDENTIFYCONFIG.fields_by_name['info_type_transformations'].containing_oneof = _DEIDENTIFYCONFIG.oneofs_by_name['transformation'] +_DEIDENTIFYCONFIG.oneofs_by_name['transformation'].fields.append( + _DEIDENTIFYCONFIG.fields_by_name['record_transformations']) +_DEIDENTIFYCONFIG.fields_by_name['record_transformations'].containing_oneof = _DEIDENTIFYCONFIG.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.fields_by_name['replace_config'].message_type = _REPLACEVALUECONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['redact_config'].message_type = _REDACTCONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['character_mask_config'].message_type = _CHARACTERMASKCONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['crypto_replace_ffx_fpe_config'].message_type = _CRYPTOREPLACEFFXFPECONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['fixed_size_bucketing_config'].message_type = _FIXEDSIZEBUCKETINGCONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['bucketing_config'].message_type = _BUCKETINGCONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['replace_with_info_type_config'].message_type = _REPLACEWITHINFOTYPECONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['time_part_config'].message_type = _TIMEPARTCONFIG +_PRIMITIVETRANSFORMATION.fields_by_name['crypto_hash_config'].message_type = _CRYPTOHASHCONFIG +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['replace_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['replace_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['redact_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['redact_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['character_mask_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['character_mask_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['crypto_replace_ffx_fpe_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['crypto_replace_ffx_fpe_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['fixed_size_bucketing_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['fixed_size_bucketing_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['bucketing_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['bucketing_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['replace_with_info_type_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['replace_with_info_type_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['time_part_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['time_part_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _PRIMITIVETRANSFORMATION.fields_by_name['crypto_hash_config']) +_PRIMITIVETRANSFORMATION.fields_by_name['crypto_hash_config'].containing_oneof = _PRIMITIVETRANSFORMATION.oneofs_by_name['transformation'] +_TIMEPARTCONFIG.fields_by_name['part_to_extract'].enum_type = _TIMEPARTCONFIG_TIMEPART +_TIMEPARTCONFIG_TIMEPART.containing_type = _TIMEPARTCONFIG +_CRYPTOHASHCONFIG.fields_by_name['crypto_key'].message_type = _CRYPTOKEY +_REPLACEVALUECONFIG.fields_by_name['new_value'].message_type = _VALUE +_CHARSTOIGNORE.fields_by_name['common_characters_to_ignore'].enum_type = _CHARSTOIGNORE_CHARACTERGROUP +_CHARSTOIGNORE_CHARACTERGROUP.containing_type = _CHARSTOIGNORE +_CHARSTOIGNORE.oneofs_by_name['characters'].fields.append( + _CHARSTOIGNORE.fields_by_name['characters_to_skip']) +_CHARSTOIGNORE.fields_by_name['characters_to_skip'].containing_oneof = _CHARSTOIGNORE.oneofs_by_name['characters'] +_CHARSTOIGNORE.oneofs_by_name['characters'].fields.append( + _CHARSTOIGNORE.fields_by_name['common_characters_to_ignore']) +_CHARSTOIGNORE.fields_by_name['common_characters_to_ignore'].containing_oneof = _CHARSTOIGNORE.oneofs_by_name['characters'] +_CHARACTERMASKCONFIG.fields_by_name['characters_to_ignore'].message_type = _CHARSTOIGNORE +_FIXEDSIZEBUCKETINGCONFIG.fields_by_name['lower_bound'].message_type = _VALUE +_FIXEDSIZEBUCKETINGCONFIG.fields_by_name['upper_bound'].message_type = _VALUE +_BUCKETINGCONFIG_BUCKET.fields_by_name['min'].message_type = _VALUE +_BUCKETINGCONFIG_BUCKET.fields_by_name['max'].message_type = _VALUE +_BUCKETINGCONFIG_BUCKET.fields_by_name['replacement_value'].message_type = _VALUE +_BUCKETINGCONFIG_BUCKET.containing_type = _BUCKETINGCONFIG +_BUCKETINGCONFIG.fields_by_name['buckets'].message_type = _BUCKETINGCONFIG_BUCKET +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['crypto_key'].message_type = _CRYPTOKEY +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['context'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['common_alphabet'].enum_type = _CRYPTOREPLACEFFXFPECONFIG_FFXCOMMONNATIVEALPHABET +_CRYPTOREPLACEFFXFPECONFIG_FFXCOMMONNATIVEALPHABET.containing_type = _CRYPTOREPLACEFFXFPECONFIG +_CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'].fields.append( + _CRYPTOREPLACEFFXFPECONFIG.fields_by_name['common_alphabet']) +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['common_alphabet'].containing_oneof = _CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'] +_CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'].fields.append( + _CRYPTOREPLACEFFXFPECONFIG.fields_by_name['custom_alphabet']) +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['custom_alphabet'].containing_oneof = _CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'] +_CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'].fields.append( + _CRYPTOREPLACEFFXFPECONFIG.fields_by_name['radix']) +_CRYPTOREPLACEFFXFPECONFIG.fields_by_name['radix'].containing_oneof = _CRYPTOREPLACEFFXFPECONFIG.oneofs_by_name['alphabet'] +_CRYPTOKEY.fields_by_name['transient'].message_type = _TRANSIENTCRYPTOKEY +_CRYPTOKEY.fields_by_name['unwrapped'].message_type = _UNWRAPPEDCRYPTOKEY +_CRYPTOKEY.fields_by_name['kms_wrapped'].message_type = _KMSWRAPPEDCRYPTOKEY +_CRYPTOKEY.oneofs_by_name['source'].fields.append( + _CRYPTOKEY.fields_by_name['transient']) +_CRYPTOKEY.fields_by_name['transient'].containing_oneof = _CRYPTOKEY.oneofs_by_name['source'] +_CRYPTOKEY.oneofs_by_name['source'].fields.append( + _CRYPTOKEY.fields_by_name['unwrapped']) +_CRYPTOKEY.fields_by_name['unwrapped'].containing_oneof = _CRYPTOKEY.oneofs_by_name['source'] +_CRYPTOKEY.oneofs_by_name['source'].fields.append( + _CRYPTOKEY.fields_by_name['kms_wrapped']) +_CRYPTOKEY.fields_by_name['kms_wrapped'].containing_oneof = _CRYPTOKEY.oneofs_by_name['source'] +_INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION.fields_by_name['info_types'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION.fields_by_name['primitive_transformation'].message_type = _PRIMITIVETRANSFORMATION +_INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION.containing_type = _INFOTYPETRANSFORMATIONS +_INFOTYPETRANSFORMATIONS.fields_by_name['transformations'].message_type = _INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION +_FIELDTRANSFORMATION.fields_by_name['fields'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_FIELDTRANSFORMATION.fields_by_name['condition'].message_type = _RECORDCONDITION +_FIELDTRANSFORMATION.fields_by_name['primitive_transformation'].message_type = _PRIMITIVETRANSFORMATION +_FIELDTRANSFORMATION.fields_by_name['info_type_transformations'].message_type = _INFOTYPETRANSFORMATIONS +_FIELDTRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _FIELDTRANSFORMATION.fields_by_name['primitive_transformation']) +_FIELDTRANSFORMATION.fields_by_name['primitive_transformation'].containing_oneof = _FIELDTRANSFORMATION.oneofs_by_name['transformation'] +_FIELDTRANSFORMATION.oneofs_by_name['transformation'].fields.append( + _FIELDTRANSFORMATION.fields_by_name['info_type_transformations']) +_FIELDTRANSFORMATION.fields_by_name['info_type_transformations'].containing_oneof = _FIELDTRANSFORMATION.oneofs_by_name['transformation'] +_RECORDTRANSFORMATIONS.fields_by_name['field_transformations'].message_type = _FIELDTRANSFORMATION +_RECORDTRANSFORMATIONS.fields_by_name['record_suppressions'].message_type = _RECORDSUPPRESSION +_RECORDSUPPRESSION.fields_by_name['condition'].message_type = _RECORDCONDITION +_RECORDCONDITION_CONDITION.fields_by_name['field'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_RECORDCONDITION_CONDITION.fields_by_name['operator'].enum_type = _RELATIONALOPERATOR +_RECORDCONDITION_CONDITION.fields_by_name['value'].message_type = _VALUE +_RECORDCONDITION_CONDITION.containing_type = _RECORDCONDITION +_RECORDCONDITION_CONDITIONS.fields_by_name['conditions'].message_type = _RECORDCONDITION_CONDITION +_RECORDCONDITION_CONDITIONS.containing_type = _RECORDCONDITION +_RECORDCONDITION_EXPRESSIONS.fields_by_name['logical_operator'].enum_type = _RECORDCONDITION_EXPRESSIONS_LOGICALOPERATOR +_RECORDCONDITION_EXPRESSIONS.fields_by_name['conditions'].message_type = _RECORDCONDITION_CONDITIONS +_RECORDCONDITION_EXPRESSIONS.containing_type = _RECORDCONDITION +_RECORDCONDITION_EXPRESSIONS_LOGICALOPERATOR.containing_type = _RECORDCONDITION_EXPRESSIONS +_RECORDCONDITION_EXPRESSIONS.oneofs_by_name['type'].fields.append( + _RECORDCONDITION_EXPRESSIONS.fields_by_name['conditions']) +_RECORDCONDITION_EXPRESSIONS.fields_by_name['conditions'].containing_oneof = _RECORDCONDITION_EXPRESSIONS.oneofs_by_name['type'] +_RECORDCONDITION.fields_by_name['expressions'].message_type = _RECORDCONDITION_EXPRESSIONS +_DEIDENTIFICATIONSUMMARY.fields_by_name['transformation_summaries'].message_type = _TRANSFORMATIONSUMMARY +_TRANSFORMATIONSUMMARY_SUMMARYRESULT.fields_by_name['code'].enum_type = _TRANSFORMATIONSUMMARY_TRANSFORMATIONRESULTCODE +_TRANSFORMATIONSUMMARY_SUMMARYRESULT.containing_type = _TRANSFORMATIONSUMMARY +_TRANSFORMATIONSUMMARY.fields_by_name['info_type'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._INFOTYPE +_TRANSFORMATIONSUMMARY.fields_by_name['field'].message_type = google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_storage__pb2._FIELDID +_TRANSFORMATIONSUMMARY.fields_by_name['transformation'].message_type = _PRIMITIVETRANSFORMATION +_TRANSFORMATIONSUMMARY.fields_by_name['field_transformations'].message_type = _FIELDTRANSFORMATION +_TRANSFORMATIONSUMMARY.fields_by_name['record_suppress'].message_type = _RECORDSUPPRESSION +_TRANSFORMATIONSUMMARY.fields_by_name['results'].message_type = _TRANSFORMATIONSUMMARY_SUMMARYRESULT +_TRANSFORMATIONSUMMARY_TRANSFORMATIONRESULTCODE.containing_type = _TRANSFORMATIONSUMMARY +DESCRIPTOR.message_types_by_name['InspectConfig'] = _INSPECTCONFIG +DESCRIPTOR.message_types_by_name['OperationConfig'] = _OPERATIONCONFIG +DESCRIPTOR.message_types_by_name['ContentItem'] = _CONTENTITEM +DESCRIPTOR.message_types_by_name['Table'] = _TABLE +DESCRIPTOR.message_types_by_name['InspectResult'] = _INSPECTRESULT +DESCRIPTOR.message_types_by_name['Finding'] = _FINDING +DESCRIPTOR.message_types_by_name['Location'] = _LOCATION +DESCRIPTOR.message_types_by_name['TableLocation'] = _TABLELOCATION +DESCRIPTOR.message_types_by_name['Range'] = _RANGE +DESCRIPTOR.message_types_by_name['ImageLocation'] = _IMAGELOCATION +DESCRIPTOR.message_types_by_name['RedactContentRequest'] = _REDACTCONTENTREQUEST +DESCRIPTOR.message_types_by_name['Color'] = _COLOR +DESCRIPTOR.message_types_by_name['RedactContentResponse'] = _REDACTCONTENTRESPONSE +DESCRIPTOR.message_types_by_name['DeidentifyContentRequest'] = _DEIDENTIFYCONTENTREQUEST +DESCRIPTOR.message_types_by_name['DeidentifyContentResponse'] = _DEIDENTIFYCONTENTRESPONSE +DESCRIPTOR.message_types_by_name['InspectContentRequest'] = _INSPECTCONTENTREQUEST +DESCRIPTOR.message_types_by_name['InspectContentResponse'] = _INSPECTCONTENTRESPONSE +DESCRIPTOR.message_types_by_name['CreateInspectOperationRequest'] = _CREATEINSPECTOPERATIONREQUEST +DESCRIPTOR.message_types_by_name['OutputStorageConfig'] = _OUTPUTSTORAGECONFIG +DESCRIPTOR.message_types_by_name['InfoTypeStatistics'] = _INFOTYPESTATISTICS +DESCRIPTOR.message_types_by_name['InspectOperationMetadata'] = _INSPECTOPERATIONMETADATA +DESCRIPTOR.message_types_by_name['InspectOperationResult'] = _INSPECTOPERATIONRESULT +DESCRIPTOR.message_types_by_name['ListInspectFindingsRequest'] = _LISTINSPECTFINDINGSREQUEST +DESCRIPTOR.message_types_by_name['ListInspectFindingsResponse'] = _LISTINSPECTFINDINGSRESPONSE +DESCRIPTOR.message_types_by_name['InfoTypeDescription'] = _INFOTYPEDESCRIPTION +DESCRIPTOR.message_types_by_name['ListInfoTypesRequest'] = _LISTINFOTYPESREQUEST +DESCRIPTOR.message_types_by_name['ListInfoTypesResponse'] = _LISTINFOTYPESRESPONSE +DESCRIPTOR.message_types_by_name['CategoryDescription'] = _CATEGORYDESCRIPTION +DESCRIPTOR.message_types_by_name['ListRootCategoriesRequest'] = _LISTROOTCATEGORIESREQUEST +DESCRIPTOR.message_types_by_name['ListRootCategoriesResponse'] = _LISTROOTCATEGORIESRESPONSE +DESCRIPTOR.message_types_by_name['AnalyzeDataSourceRiskRequest'] = _ANALYZEDATASOURCERISKREQUEST +DESCRIPTOR.message_types_by_name['PrivacyMetric'] = _PRIVACYMETRIC +DESCRIPTOR.message_types_by_name['RiskAnalysisOperationMetadata'] = _RISKANALYSISOPERATIONMETADATA +DESCRIPTOR.message_types_by_name['RiskAnalysisOperationResult'] = _RISKANALYSISOPERATIONRESULT +DESCRIPTOR.message_types_by_name['ValueFrequency'] = _VALUEFREQUENCY +DESCRIPTOR.message_types_by_name['Value'] = _VALUE +DESCRIPTOR.message_types_by_name['DeidentifyConfig'] = _DEIDENTIFYCONFIG +DESCRIPTOR.message_types_by_name['PrimitiveTransformation'] = _PRIMITIVETRANSFORMATION +DESCRIPTOR.message_types_by_name['TimePartConfig'] = _TIMEPARTCONFIG +DESCRIPTOR.message_types_by_name['CryptoHashConfig'] = _CRYPTOHASHCONFIG +DESCRIPTOR.message_types_by_name['ReplaceValueConfig'] = _REPLACEVALUECONFIG +DESCRIPTOR.message_types_by_name['ReplaceWithInfoTypeConfig'] = _REPLACEWITHINFOTYPECONFIG +DESCRIPTOR.message_types_by_name['RedactConfig'] = _REDACTCONFIG +DESCRIPTOR.message_types_by_name['CharsToIgnore'] = _CHARSTOIGNORE +DESCRIPTOR.message_types_by_name['CharacterMaskConfig'] = _CHARACTERMASKCONFIG +DESCRIPTOR.message_types_by_name['FixedSizeBucketingConfig'] = _FIXEDSIZEBUCKETINGCONFIG +DESCRIPTOR.message_types_by_name['BucketingConfig'] = _BUCKETINGCONFIG +DESCRIPTOR.message_types_by_name['CryptoReplaceFfxFpeConfig'] = _CRYPTOREPLACEFFXFPECONFIG +DESCRIPTOR.message_types_by_name['CryptoKey'] = _CRYPTOKEY +DESCRIPTOR.message_types_by_name['TransientCryptoKey'] = _TRANSIENTCRYPTOKEY +DESCRIPTOR.message_types_by_name['UnwrappedCryptoKey'] = _UNWRAPPEDCRYPTOKEY +DESCRIPTOR.message_types_by_name['KmsWrappedCryptoKey'] = _KMSWRAPPEDCRYPTOKEY +DESCRIPTOR.message_types_by_name['InfoTypeTransformations'] = _INFOTYPETRANSFORMATIONS +DESCRIPTOR.message_types_by_name['FieldTransformation'] = _FIELDTRANSFORMATION +DESCRIPTOR.message_types_by_name['RecordTransformations'] = _RECORDTRANSFORMATIONS +DESCRIPTOR.message_types_by_name['RecordSuppression'] = _RECORDSUPPRESSION +DESCRIPTOR.message_types_by_name['RecordCondition'] = _RECORDCONDITION +DESCRIPTOR.message_types_by_name['DeidentificationSummary'] = _DEIDENTIFICATIONSUMMARY +DESCRIPTOR.message_types_by_name['TransformationSummary'] = _TRANSFORMATIONSUMMARY +DESCRIPTOR.enum_types_by_name['Likelihood'] = _LIKELIHOOD +DESCRIPTOR.enum_types_by_name['RelationalOperator'] = _RELATIONALOPERATOR + +InspectConfig = _reflection.GeneratedProtocolMessageType('InspectConfig', (_message.Message,), dict( + + InfoTypeLimit = _reflection.GeneratedProtocolMessageType('InfoTypeLimit', (_message.Message,), dict( + DESCRIPTOR = _INSPECTCONFIG_INFOTYPELIMIT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Max findings configuration per info type, per content item or long + running operation. + + + Attributes: + info_type: + Type of information the findings limit applies to. Only one + limit per info\_type should be provided. If InfoTypeLimit does + not have an info\_type, the DLP API applies the limit against + all info\_types that are found but not specified in another + InfoTypeLimit. + max_findings: + Max findings limit for the given infoType. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit) + )) + , + DESCRIPTOR = _INSPECTCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Configuration description of the scanning process. When used with + redactContent only info\_types and min\_likelihood are currently used. + + + Attributes: + info_types: + Restricts what info\_types to look for. The values must + correspond to InfoType values returned by ListInfoTypes or + found in documentation. Empty info\_types runs all enabled + detectors. + min_likelihood: + Only returns findings equal or above this threshold. + max_findings: + Limits the number of findings per content item or long running + operation. + include_quote: + When true, a contextual quote from the data that triggered a + finding is included in the response; see Finding.quote. + exclude_types: + When true, excludes type information of the findings. + info_type_limits: + Configuration of findings limit given for specified info + types. + custom_info_types: + Custom info types provided by the user. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectConfig) + )) +_sym_db.RegisterMessage(InspectConfig) +_sym_db.RegisterMessage(InspectConfig.InfoTypeLimit) + +OperationConfig = _reflection.GeneratedProtocolMessageType('OperationConfig', (_message.Message,), dict( + DESCRIPTOR = _OPERATIONCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Additional configuration for inspect long running operations. + + + Attributes: + max_item_findings: + Max number of findings per file, Datastore entity, or database + row. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.OperationConfig) + )) +_sym_db.RegisterMessage(OperationConfig) + +ContentItem = _reflection.GeneratedProtocolMessageType('ContentItem', (_message.Message,), dict( + DESCRIPTOR = _CONTENTITEM, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Container structure for the content to inspect. + + + Attributes: + type: + Type of the content, as defined in Content-Type HTTP header. + Supported types are: all "text" types, octet streams, PNG + images, JPEG images. + data_item: + Data of the item either in the byte array or UTF-8 string + form. + data: + Content data to inspect or redact. + value: + String data to inspect or redact. + table: + Structured content for inspection. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ContentItem) + )) +_sym_db.RegisterMessage(ContentItem) + +Table = _reflection.GeneratedProtocolMessageType('Table', (_message.Message,), dict( + + Row = _reflection.GeneratedProtocolMessageType('Row', (_message.Message,), dict( + DESCRIPTOR = _TABLE_ROW, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Table.Row) + )) + , + DESCRIPTOR = _TABLE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Structured content to inspect. Up to 50,000 ``Value``\ s per request + allowed. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Table) + )) +_sym_db.RegisterMessage(Table) +_sym_db.RegisterMessage(Table.Row) + +InspectResult = _reflection.GeneratedProtocolMessageType('InspectResult', (_message.Message,), dict( + DESCRIPTOR = _INSPECTRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """All the findings for a single scanned item. + + + Attributes: + findings: + List of findings for an item. + findings_truncated: + If true, then this item might have more findings than were + returned, and the findings returned are an arbitrary subset of + all findings. The findings list might be truncated because the + input items were too large, or because the server reached the + maximum amount of resources allowed for a single API call. For + best results, divide the input into smaller batches. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectResult) + )) +_sym_db.RegisterMessage(InspectResult) + +Finding = _reflection.GeneratedProtocolMessageType('Finding', (_message.Message,), dict( + DESCRIPTOR = _FINDING, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Container structure describing a single finding within a string or + image. + + + Attributes: + quote: + The specific string that may be potentially sensitive info. + info_type: + The specific type of info the string might be. + likelihood: + Estimate of how likely it is that the info\_type is correct. + location: + Location of the info found. + create_time: + Timestamp when finding was detected. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Finding) + )) +_sym_db.RegisterMessage(Finding) + +Location = _reflection.GeneratedProtocolMessageType('Location', (_message.Message,), dict( + DESCRIPTOR = _LOCATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Specifies the location of a finding within its source item. + + + Attributes: + byte_range: + Zero-based byte offsets within a content item. + codepoint_range: + Character offsets within a content item, included when content + type is a text. Default charset assumed to be UTF-8. + image_boxes: + Location within an image's pixels. + record_key: + Key of the finding. + field_id: + Field id of the field containing the finding. + table_location: + Location within a ``ContentItem.Table``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Location) + )) +_sym_db.RegisterMessage(Location) + +TableLocation = _reflection.GeneratedProtocolMessageType('TableLocation', (_message.Message,), dict( + DESCRIPTOR = _TABLELOCATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Location of a finding within a ``ContentItem.Table``. + + + Attributes: + row_index: + The zero-based index of the row where the finding is located. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.TableLocation) + )) +_sym_db.RegisterMessage(TableLocation) + +Range = _reflection.GeneratedProtocolMessageType('Range', (_message.Message,), dict( + DESCRIPTOR = _RANGE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Generic half-open interval [start, end) + + + Attributes: + start: + Index of the first character of the range (inclusive). + end: + Index of the last character of the range (exclusive). + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Range) + )) +_sym_db.RegisterMessage(Range) + +ImageLocation = _reflection.GeneratedProtocolMessageType('ImageLocation', (_message.Message,), dict( + DESCRIPTOR = _IMAGELOCATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Bounding box encompassing detected text within an image. + + + Attributes: + top: + Top coordinate of the bounding box. (0,0) is upper left. + left: + Left coordinate of the bounding box. (0,0) is upper left. + width: + Width of the bounding box in pixels. + height: + Height of the bounding box in pixels. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ImageLocation) + )) +_sym_db.RegisterMessage(ImageLocation) + +RedactContentRequest = _reflection.GeneratedProtocolMessageType('RedactContentRequest', (_message.Message,), dict( + + ReplaceConfig = _reflection.GeneratedProtocolMessageType('ReplaceConfig', (_message.Message,), dict( + DESCRIPTOR = _REDACTCONTENTREQUEST_REPLACECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Attributes: + info_type: + Type of information to replace. Only one ReplaceConfig per + info\_type should be provided. If ReplaceConfig does not have + an info\_type, the DLP API matches it against all info\_types + that are found but not specified in another ReplaceConfig. + replace_with: + Content replacing sensitive information of given type. Max 256 + chars. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RedactContentRequest.ReplaceConfig) + )) + , + + ImageRedactionConfig = _reflection.GeneratedProtocolMessageType('ImageRedactionConfig', (_message.Message,), dict( + DESCRIPTOR = _REDACTCONTENTREQUEST_IMAGEREDACTIONCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Configuration for determining how redaction of images should occur. + + + Attributes: + target: + Type of information to redact from images. + info_type: + Only one per info\_type should be provided per request. If not + specified, and redact\_all\_text is false, the DLP API will + redact all text that it matches against all info\_types that + are found, but not specified in another ImageRedactionConfig. + redact_all_text: + If true, all text found in the image, regardless whether it + matches an info\_type, is redacted. + redaction_color: + The color to use when redacting content from an image. If not + specified, the default is black. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RedactContentRequest.ImageRedactionConfig) + )) + , + DESCRIPTOR = _REDACTCONTENTREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request to search for potentially sensitive info in a list of items and + replace it with a default or provided content. + + + Attributes: + inspect_config: + Configuration for the inspector. + items: + The list of items to inspect. Up to 100 are allowed per + request. + replace_configs: + The strings to replace findings text findings with. Must + specify at least one of these or one ImageRedactionConfig if + redacting images. + image_redaction_configs: + The configuration for specifying what content to redact from + images. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RedactContentRequest) + )) +_sym_db.RegisterMessage(RedactContentRequest) +_sym_db.RegisterMessage(RedactContentRequest.ReplaceConfig) +_sym_db.RegisterMessage(RedactContentRequest.ImageRedactionConfig) + +Color = _reflection.GeneratedProtocolMessageType('Color', (_message.Message,), dict( + DESCRIPTOR = _COLOR, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Represents a color in the RGB color space. + + + Attributes: + red: + The amount of red in the color as a value in the interval [0, + 1]. + green: + The amount of green in the color as a value in the interval + [0, 1]. + blue: + The amount of blue in the color as a value in the interval [0, + 1]. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Color) + )) +_sym_db.RegisterMessage(Color) + +RedactContentResponse = _reflection.GeneratedProtocolMessageType('RedactContentResponse', (_message.Message,), dict( + DESCRIPTOR = _REDACTCONTENTRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Results of redacting a list of items. + + + Attributes: + items: + The redacted content. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RedactContentResponse) + )) +_sym_db.RegisterMessage(RedactContentResponse) + +DeidentifyContentRequest = _reflection.GeneratedProtocolMessageType('DeidentifyContentRequest', (_message.Message,), dict( + DESCRIPTOR = _DEIDENTIFYCONTENTREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request to de-identify a list of items. + + + Attributes: + deidentify_config: + Configuration for the de-identification of the list of content + items. + inspect_config: + Configuration for the inspector. + items: + The list of items to inspect. Up to 100 are allowed per + request. All items will be treated as text/\*. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DeidentifyContentRequest) + )) +_sym_db.RegisterMessage(DeidentifyContentRequest) + +DeidentifyContentResponse = _reflection.GeneratedProtocolMessageType('DeidentifyContentResponse', (_message.Message,), dict( + DESCRIPTOR = _DEIDENTIFYCONTENTRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Results of de-identifying a list of items. + + + Attributes: + summaries: + A review of the transformations that took place for each item. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DeidentifyContentResponse) + )) +_sym_db.RegisterMessage(DeidentifyContentResponse) + +InspectContentRequest = _reflection.GeneratedProtocolMessageType('InspectContentRequest', (_message.Message,), dict( + DESCRIPTOR = _INSPECTCONTENTREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request to search for potentially sensitive info in a list of items. + + + Attributes: + inspect_config: + Configuration for the inspector. + items: + The list of items to inspect. Items in a single request are + considered "related" unless + inspect\_config.independent\_inputs is true. Up to 100 are + allowed per request. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectContentRequest) + )) +_sym_db.RegisterMessage(InspectContentRequest) + +InspectContentResponse = _reflection.GeneratedProtocolMessageType('InspectContentResponse', (_message.Message,), dict( + DESCRIPTOR = _INSPECTCONTENTRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Results of inspecting a list of items. + + + Attributes: + results: + Each content\_item from the request has a result in this list, + in the same order as the request. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectContentResponse) + )) +_sym_db.RegisterMessage(InspectContentResponse) + +CreateInspectOperationRequest = _reflection.GeneratedProtocolMessageType('CreateInspectOperationRequest', (_message.Message,), dict( + DESCRIPTOR = _CREATEINSPECTOPERATIONREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request for scheduling a scan of a data subset from a Google Platform + data repository. + + + Attributes: + inspect_config: + Configuration for the inspector. + storage_config: + Specification of the data set to process. + output_config: + Optional location to store findings. + operation_config: + Additional configuration settings for long running operations. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CreateInspectOperationRequest) + )) +_sym_db.RegisterMessage(CreateInspectOperationRequest) + +OutputStorageConfig = _reflection.GeneratedProtocolMessageType('OutputStorageConfig', (_message.Message,), dict( + DESCRIPTOR = _OUTPUTSTORAGECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Cloud repository for storing output. + + + Attributes: + table: + Store findings in a new table in the dataset. + storage_path: + The path to a Google Cloud Storage location to store output. + The bucket must already exist and the Google APIs service + account for DLP must have write permission to write to the + given bucket. Results are split over multiple csv files with + each file name matching the pattern + "[operation\_id]\_[count].csv", for example + ``3094877188788974909_1.csv``. The ``operation_id`` matches + the identifier for the Operation, and the ``count`` is a + counter used for tracking the number of files written. The + CSV file(s) contain the following columns regardless of + storage type scanned: - id - info\_type - likelihood - byte + size of finding - quote - timestamp For Cloud Storage the + next columns are: - file\_path - start\_offset For Cloud + Datastore the next columns are: - project\_id - + namespace\_id - path - column\_name - offset For BigQuery + the next columns are: - row\_number - project\_id - + dataset\_id - table\_id + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.OutputStorageConfig) + )) +_sym_db.RegisterMessage(OutputStorageConfig) + +InfoTypeStatistics = _reflection.GeneratedProtocolMessageType('InfoTypeStatistics', (_message.Message,), dict( + DESCRIPTOR = _INFOTYPESTATISTICS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Statistics regarding a specific InfoType. + + + Attributes: + info_type: + The type of finding this stat is for. + count: + Number of findings for this info type. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InfoTypeStatistics) + )) +_sym_db.RegisterMessage(InfoTypeStatistics) + +InspectOperationMetadata = _reflection.GeneratedProtocolMessageType('InspectOperationMetadata', (_message.Message,), dict( + DESCRIPTOR = _INSPECTOPERATIONMETADATA, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Metadata returned within GetOperation for an inspect request. + + + Attributes: + processed_bytes: + Total size in bytes that were processed. + total_estimated_bytes: + Estimate of the number of bytes to process. + create_time: + The time which this request was started. + request_inspect_config: + The inspect config used to create the Operation. + request_storage_config: + The storage config used to create the Operation. + request_output_config: + Optional location to store findings. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectOperationMetadata) + )) +_sym_db.RegisterMessage(InspectOperationMetadata) + +InspectOperationResult = _reflection.GeneratedProtocolMessageType('InspectOperationResult', (_message.Message,), dict( + DESCRIPTOR = _INSPECTOPERATIONRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The operational data. + + + Attributes: + name: + The server-assigned name, which is only unique within the same + service that originally returns it. If you use the default + HTTP mapping, the ``name`` should have the format of + ``inspect/results/{id}``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InspectOperationResult) + )) +_sym_db.RegisterMessage(InspectOperationResult) + +ListInspectFindingsRequest = _reflection.GeneratedProtocolMessageType('ListInspectFindingsRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTINSPECTFINDINGSREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request for the list of results in a given inspect operation. + + + Attributes: + name: + Identifier of the results set returned as metadata of the + longrunning operation created by a call to InspectDataSource. + Should be in the format of ``inspect/results/{id}``. + page_size: + Maximum number of results to return. If 0, the implementation + selects a reasonable value. + page_token: + The value returned by the last + ``ListInspectFindingsResponse``; indicates that this is a + continuation of a prior ``ListInspectFindings`` call, and that + the system should return the next page of data. + filter: + Restricts findings to items that match. Supports info\_type + and likelihood. Examples: - info\_type=EMAIL\_ADDRESS - + info\_type=PHONE\_NUMBER,EMAIL\_ADDRESS - + likelihood=VERY\_LIKELY - likelihood=VERY\_LIKELY,LIKELY - + info\_type=EMAIL\_ADDRESS,likelihood=VERY\_LIKELY,LIKELY + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListInspectFindingsRequest) + )) +_sym_db.RegisterMessage(ListInspectFindingsRequest) + +ListInspectFindingsResponse = _reflection.GeneratedProtocolMessageType('ListInspectFindingsResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTINSPECTFINDINGSRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Response to the ListInspectFindings request. + + + Attributes: + result: + The results. + next_page_token: + If not empty, indicates that there may be more results that + match the request; this value should be passed in a new + ``ListInspectFindingsRequest``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListInspectFindingsResponse) + )) +_sym_db.RegisterMessage(ListInspectFindingsResponse) + +InfoTypeDescription = _reflection.GeneratedProtocolMessageType('InfoTypeDescription', (_message.Message,), dict( + DESCRIPTOR = _INFOTYPEDESCRIPTION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Description of the information type (infoType). + + + Attributes: + name: + Internal name of the infoType. + display_name: + Human readable form of the infoType name. + categories: + List of categories this infoType belongs to. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InfoTypeDescription) + )) +_sym_db.RegisterMessage(InfoTypeDescription) + +ListInfoTypesRequest = _reflection.GeneratedProtocolMessageType('ListInfoTypesRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTINFOTYPESREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request for the list of info types belonging to a given category, or all + supported info types if no category is specified. + + + Attributes: + category: + Category name as returned by ListRootCategories. + language_code: + Optional BCP-47 language code for localized info type friendly + names. If omitted, or if localized strings are not available, + en-US strings will be returned. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListInfoTypesRequest) + )) +_sym_db.RegisterMessage(ListInfoTypesRequest) + +ListInfoTypesResponse = _reflection.GeneratedProtocolMessageType('ListInfoTypesResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTINFOTYPESRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Response to the ListInfoTypes request. + + + Attributes: + info_types: + Set of sensitive info types belonging to a category. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListInfoTypesResponse) + )) +_sym_db.RegisterMessage(ListInfoTypesResponse) + +CategoryDescription = _reflection.GeneratedProtocolMessageType('CategoryDescription', (_message.Message,), dict( + DESCRIPTOR = _CATEGORYDESCRIPTION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Info Type Category description. + + + Attributes: + name: + Internal name of the category. + display_name: + Human readable form of the category name. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CategoryDescription) + )) +_sym_db.RegisterMessage(CategoryDescription) + +ListRootCategoriesRequest = _reflection.GeneratedProtocolMessageType('ListRootCategoriesRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTROOTCATEGORIESREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request for root categories of Info Types supported by the API. Example + values might include "FINANCE", "HEALTH", "FAST", "DEFAULT". + + + Attributes: + language_code: + Optional language code for localized friendly category names. + If omitted or if localized strings are not available, en-US + strings will be returned. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListRootCategoriesRequest) + )) +_sym_db.RegisterMessage(ListRootCategoriesRequest) + +ListRootCategoriesResponse = _reflection.GeneratedProtocolMessageType('ListRootCategoriesResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTROOTCATEGORIESRESPONSE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Response for ListRootCategories request. + + + Attributes: + categories: + List of all into type categories supported by the API. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ListRootCategoriesResponse) + )) +_sym_db.RegisterMessage(ListRootCategoriesResponse) + +AnalyzeDataSourceRiskRequest = _reflection.GeneratedProtocolMessageType('AnalyzeDataSourceRiskRequest', (_message.Message,), dict( + DESCRIPTOR = _ANALYZEDATASOURCERISKREQUEST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Request for creating a risk analysis operation. + + + Attributes: + privacy_metric: + Privacy metric to compute. + source_table: + Input dataset to compute metrics over. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.AnalyzeDataSourceRiskRequest) + )) +_sym_db.RegisterMessage(AnalyzeDataSourceRiskRequest) + +PrivacyMetric = _reflection.GeneratedProtocolMessageType('PrivacyMetric', (_message.Message,), dict( + + NumericalStatsConfig = _reflection.GeneratedProtocolMessageType('NumericalStatsConfig', (_message.Message,), dict( + DESCRIPTOR = _PRIVACYMETRIC_NUMERICALSTATSCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Compute numerical stats over an individual column, including min, max, + and quantiles. + + + Attributes: + field: + Field to compute numerical stats on. Supported types are + integer, float, date, datetime, timestamp, time. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrivacyMetric.NumericalStatsConfig) + )) + , + + CategoricalStatsConfig = _reflection.GeneratedProtocolMessageType('CategoricalStatsConfig', (_message.Message,), dict( + DESCRIPTOR = _PRIVACYMETRIC_CATEGORICALSTATSCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Compute numerical stats over an individual column, including number of + distinct values and value count distribution. + + + Attributes: + field: + Field to compute categorical stats on. All column types are + supported except for arrays and structs. However, it may be + more informative to use NumericalStats when the field type is + supported, depending on the data. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrivacyMetric.CategoricalStatsConfig) + )) + , + + KAnonymityConfig = _reflection.GeneratedProtocolMessageType('KAnonymityConfig', (_message.Message,), dict( + DESCRIPTOR = _PRIVACYMETRIC_KANONYMITYCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """k-anonymity metric, used for analysis of reidentification risk. + + + Attributes: + quasi_ids: + Set of fields to compute k-anonymity over. When multiple + fields are specified, they are considered a single composite + key. Structs and repeated data types are not supported; + however, nested fields are supported so long as they are not + structs themselves or nested within a repeated field. + entity_id: + Optional message indicating that each distinct ``EntityId`` + should not contribute to the k-anonymity count more than once + per equivalence class. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrivacyMetric.KAnonymityConfig) + )) + , + + LDiversityConfig = _reflection.GeneratedProtocolMessageType('LDiversityConfig', (_message.Message,), dict( + DESCRIPTOR = _PRIVACYMETRIC_LDIVERSITYCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """l-diversity metric, used for analysis of reidentification risk. + + + Attributes: + quasi_ids: + Set of quasi-identifiers indicating how equivalence classes + are defined for the l-diversity computation. When multiple + fields are specified, they are considered a single composite + key. + sensitive_attribute: + Sensitive field for computing the l-value. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrivacyMetric.LDiversityConfig) + )) + , + DESCRIPTOR = _PRIVACYMETRIC, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Privacy metric to compute for reidentification risk analysis. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrivacyMetric) + )) +_sym_db.RegisterMessage(PrivacyMetric) +_sym_db.RegisterMessage(PrivacyMetric.NumericalStatsConfig) +_sym_db.RegisterMessage(PrivacyMetric.CategoricalStatsConfig) +_sym_db.RegisterMessage(PrivacyMetric.KAnonymityConfig) +_sym_db.RegisterMessage(PrivacyMetric.LDiversityConfig) + +RiskAnalysisOperationMetadata = _reflection.GeneratedProtocolMessageType('RiskAnalysisOperationMetadata', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONMETADATA, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Metadata returned within the + ```riskAnalysis.operations.get`` `__ + for risk analysis. + + + Attributes: + create_time: + The time which this request was started. + requested_privacy_metric: + Privacy metric to compute. + requested_source_table: + Input dataset to compute metrics over. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationMetadata) + )) +_sym_db.RegisterMessage(RiskAnalysisOperationMetadata) + +RiskAnalysisOperationResult = _reflection.GeneratedProtocolMessageType('RiskAnalysisOperationResult', (_message.Message,), dict( + + NumericalStatsResult = _reflection.GeneratedProtocolMessageType('NumericalStatsResult', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_NUMERICALSTATSRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Result of the numerical stats computation. + + + Attributes: + min_value: + Minimum value appearing in the column. + max_value: + Maximum value appearing in the column. + quantile_values: + List of 99 values that partition the set of field values into + 100 equal sized buckets. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.NumericalStatsResult) + )) + , + + CategoricalStatsResult = _reflection.GeneratedProtocolMessageType('CategoricalStatsResult', (_message.Message,), dict( + + CategoricalStatsHistogramBucket = _reflection.GeneratedProtocolMessageType('CategoricalStatsHistogramBucket', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT_CATEGORICALSTATSHISTOGRAMBUCKET, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Histogram bucket of value frequencies in the column. + + + Attributes: + value_frequency_lower_bound: + Lower bound on the value frequency of the values in this + bucket. + value_frequency_upper_bound: + Upper bound on the value frequency of the values in this + bucket. + bucket_size: + Total number of records in this bucket. + bucket_values: + Sample of value frequencies in this bucket. The total number + of values returned per bucket is capped at 20. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket) + )) + , + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_CATEGORICALSTATSRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Result of the categorical stats computation. + + + Attributes: + value_frequency_histogram_buckets: + Histogram of value frequencies in the column. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.CategoricalStatsResult) + )) + , + + KAnonymityResult = _reflection.GeneratedProtocolMessageType('KAnonymityResult', (_message.Message,), dict( + + KAnonymityEquivalenceClass = _reflection.GeneratedProtocolMessageType('KAnonymityEquivalenceClass', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYEQUIVALENCECLASS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The set of columns' values that share the same k-anonymity value. + + + Attributes: + quasi_ids_values: + Set of values defining the equivalence class. One value per + quasi-identifier column in the original KAnonymity metric + message. The order is always the same as the original request. + equivalence_class_size: + Size of the equivalence class, for example number of rows with + the above set of values. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass) + )) + , + + KAnonymityHistogramBucket = _reflection.GeneratedProtocolMessageType('KAnonymityHistogramBucket', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT_KANONYMITYHISTOGRAMBUCKET, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Histogram bucket of equivalence class sizes in the table. + + + Attributes: + equivalence_class_size_lower_bound: + Lower bound on the size of the equivalence classes in this + bucket. + equivalence_class_size_upper_bound: + Upper bound on the size of the equivalence classes in this + bucket. + bucket_size: + Total number of records in this bucket. + bucket_values: + Sample of equivalence classes in this bucket. The total number + of classes returned per bucket is capped at 20. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket) + )) + , + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_KANONYMITYRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Result of the k-anonymity computation. + + + Attributes: + equivalence_class_histogram_buckets: + Histogram of k-anonymity equivalence classes. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.KAnonymityResult) + )) + , + + LDiversityResult = _reflection.GeneratedProtocolMessageType('LDiversityResult', (_message.Message,), dict( + + LDiversityEquivalenceClass = _reflection.GeneratedProtocolMessageType('LDiversityEquivalenceClass', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYEQUIVALENCECLASS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The set of columns' values that share the same l-diversity value. + + + Attributes: + quasi_ids_values: + Quasi-identifier values defining the k-anonymity equivalence + class. The order is always the same as the original request. + equivalence_class_size: + Size of the k-anonymity equivalence class. + num_distinct_sensitive_values: + Number of distinct sensitive values in this equivalence class. + top_sensitive_values: + Estimated frequencies of top sensitive values. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass) + )) + , + + LDiversityHistogramBucket = _reflection.GeneratedProtocolMessageType('LDiversityHistogramBucket', (_message.Message,), dict( + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT_LDIVERSITYHISTOGRAMBUCKET, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Histogram bucket of sensitive value frequencies in the table. + + + Attributes: + sensitive_value_frequency_lower_bound: + Lower bound on the sensitive value frequencies of the + equivalence classes in this bucket. + sensitive_value_frequency_upper_bound: + Upper bound on the sensitive value frequencies of the + equivalence classes in this bucket. + bucket_size: + Total number of records in this bucket. + bucket_values: + Sample of equivalence classes in this bucket. The total number + of classes returned per bucket is capped at 20. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket) + )) + , + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT_LDIVERSITYRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Result of the l-diversity computation. + + + Attributes: + sensitive_value_frequency_histogram_buckets: + Histogram of l-diversity equivalence class sensitive value + frequencies. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult.LDiversityResult) + )) + , + DESCRIPTOR = _RISKANALYSISOPERATIONRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Result of a risk analysis + ```Operation`` `__ + request. + + + Attributes: + result: + Values associated with this metric. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RiskAnalysisOperationResult) + )) +_sym_db.RegisterMessage(RiskAnalysisOperationResult) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.NumericalStatsResult) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.CategoricalStatsResult) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.CategoricalStatsResult.CategoricalStatsHistogramBucket) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.KAnonymityResult) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.KAnonymityResult.KAnonymityEquivalenceClass) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.KAnonymityResult.KAnonymityHistogramBucket) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.LDiversityResult) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.LDiversityResult.LDiversityEquivalenceClass) +_sym_db.RegisterMessage(RiskAnalysisOperationResult.LDiversityResult.LDiversityHistogramBucket) + +ValueFrequency = _reflection.GeneratedProtocolMessageType('ValueFrequency', (_message.Message,), dict( + DESCRIPTOR = _VALUEFREQUENCY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A value of a field, including its frequency. + + + Attributes: + value: + A value contained in the field in question. + count: + How many times the value is contained in the field. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ValueFrequency) + )) +_sym_db.RegisterMessage(ValueFrequency) + +Value = _reflection.GeneratedProtocolMessageType('Value', (_message.Message,), dict( + DESCRIPTOR = _VALUE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Set of primitive values supported by the system. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Value) + )) +_sym_db.RegisterMessage(Value) + +DeidentifyConfig = _reflection.GeneratedProtocolMessageType('DeidentifyConfig', (_message.Message,), dict( + DESCRIPTOR = _DEIDENTIFYCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The configuration that controls how the data will change. + + + Attributes: + info_type_transformations: + Treat the dataset as free-form text and apply the same free + text transformation everywhere. + record_transformations: + Treat the dataset as structured. Transformations can be + applied to specific locations within structured datasets, such + as transforming a column within a table. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DeidentifyConfig) + )) +_sym_db.RegisterMessage(DeidentifyConfig) + +PrimitiveTransformation = _reflection.GeneratedProtocolMessageType('PrimitiveTransformation', (_message.Message,), dict( + DESCRIPTOR = _PRIMITIVETRANSFORMATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A rule for transforming a value. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PrimitiveTransformation) + )) +_sym_db.RegisterMessage(PrimitiveTransformation) + +TimePartConfig = _reflection.GeneratedProtocolMessageType('TimePartConfig', (_message.Message,), dict( + DESCRIPTOR = _TIMEPARTCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """For use with ``Date``, ``Timestamp``, and ``TimeOfDay``, extract or + preserve a portion of the value. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.TimePartConfig) + )) +_sym_db.RegisterMessage(TimePartConfig) + +CryptoHashConfig = _reflection.GeneratedProtocolMessageType('CryptoHashConfig', (_message.Message,), dict( + DESCRIPTOR = _CRYPTOHASHCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Pseudonymization method that generates surrogates via cryptographic + hashing. Uses SHA-256. Outputs a 32 byte digest as an uppercase hex + string (for example, 41D1567F7F99F1DC2A5FAB886DEE5BEE). Currently, only + string and integer values can be hashed. + + + Attributes: + crypto_key: + The key used by the hash function. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CryptoHashConfig) + )) +_sym_db.RegisterMessage(CryptoHashConfig) + +ReplaceValueConfig = _reflection.GeneratedProtocolMessageType('ReplaceValueConfig', (_message.Message,), dict( + DESCRIPTOR = _REPLACEVALUECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Replace each input value with a given ``Value``. + + + Attributes: + new_value: + Value to replace it with. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ReplaceValueConfig) + )) +_sym_db.RegisterMessage(ReplaceValueConfig) + +ReplaceWithInfoTypeConfig = _reflection.GeneratedProtocolMessageType('ReplaceWithInfoTypeConfig', (_message.Message,), dict( + DESCRIPTOR = _REPLACEWITHINFOTYPECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Replace each matching finding with the name of the info\_type. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.ReplaceWithInfoTypeConfig) + )) +_sym_db.RegisterMessage(ReplaceWithInfoTypeConfig) + +RedactConfig = _reflection.GeneratedProtocolMessageType('RedactConfig', (_message.Message,), dict( + DESCRIPTOR = _REDACTCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Redact a given value. For example, if used with an + ``InfoTypeTransformation`` transforming PHONE\_NUMBER, and input 'My + phone number is 206-555-0123', the output would be 'My phone number is + '. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RedactConfig) + )) +_sym_db.RegisterMessage(RedactConfig) + +CharsToIgnore = _reflection.GeneratedProtocolMessageType('CharsToIgnore', (_message.Message,), dict( + DESCRIPTOR = _CHARSTOIGNORE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Characters to skip when doing deidentification of a value. These will be + left alone and skipped. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CharsToIgnore) + )) +_sym_db.RegisterMessage(CharsToIgnore) + +CharacterMaskConfig = _reflection.GeneratedProtocolMessageType('CharacterMaskConfig', (_message.Message,), dict( + DESCRIPTOR = _CHARACTERMASKCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Partially mask a string by replacing a given number of characters with a + fixed character. Masking can start from the beginning or end of the + string. This can be used on data of any type (numbers, longs, and so on) + and when de-identifying structured data we'll attempt to preserve the + original data's type. (This allows you to take a long like 123 and + modify it to a string like \*\*3. + + + Attributes: + masking_character: + Character to mask the sensitive values—for example, "*" for an + alphabetic string such as name, or "0" for a numeric string + such as ZIP code or credit card number. String must have + length 1. If not supplied, we will default to "*" for strings, + 0 for digits. + number_to_mask: + Number of characters to mask. If not set, all matching chars + will be masked. Skipped characters do not count towards this + tally. + reverse_order: + Mask characters in reverse order. For example, if + ``masking_character`` is '0', number\_to\_mask is 14, and + ``reverse_order`` is false, then 1234-5678-9012-3456 -> + 00000000000000-3456 If ``masking_character`` is '*', + ``number_to_mask`` is 3, and ``reverse_order`` is true, then + 12345 -> 12*\ \*\* + characters_to_ignore: + When masking a string, items in this list will be skipped when + replacing. For example, if your string is 555-555-5555 and you + ask us to skip ``-`` and mask 5 chars with \* we would produce + \*\*\ *-*\ 55-5555. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CharacterMaskConfig) + )) +_sym_db.RegisterMessage(CharacterMaskConfig) + +FixedSizeBucketingConfig = _reflection.GeneratedProtocolMessageType('FixedSizeBucketingConfig', (_message.Message,), dict( + DESCRIPTOR = _FIXEDSIZEBUCKETINGCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Buckets values based on fixed size ranges. The Bucketing transformation + can provide all of this functionality, but requires more configuration. + This message is provided as a convenience to the user for simple + bucketing strategies. The resulting value will be a hyphenated string of + lower\_bound-upper\_bound. This can be used on data of type: double, + long. If the bound Value type differs from the type of data being + transformed, we will first attempt converting the type of the data to be + transformed to match the type of the bound before comparing. + + + Attributes: + lower_bound: + Lower bound value of buckets. All values less than + ``lower_bound`` are grouped together into a single bucket; for + example if ``lower_bound`` = 10, then all values less than 10 + are replaced with the value “-10”. [Required]. + upper_bound: + Upper bound value of buckets. All values greater than + upper\_bound are grouped together into a single bucket; for + example if ``upper_bound`` = 89, then all values greater than + 89 are replaced with the value “89+”. [Required]. + bucket_size: + Size of each bucket (except for minimum and maximum buckets). + So if ``lower_bound`` = 10, ``upper_bound`` = 89, and + ``bucket_size`` = 10, then the following buckets would be + used: -10, 10-20, 20-30, 30-40, 40-50, 50-60, 60-70, 70-80, + 80-89, 89+. Precision up to 2 decimals works. [Required]. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.FixedSizeBucketingConfig) + )) +_sym_db.RegisterMessage(FixedSizeBucketingConfig) + +BucketingConfig = _reflection.GeneratedProtocolMessageType('BucketingConfig', (_message.Message,), dict( + + Bucket = _reflection.GeneratedProtocolMessageType('Bucket', (_message.Message,), dict( + DESCRIPTOR = _BUCKETINGCONFIG_BUCKET, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Buckets represented as ranges, along with replacement values. Ranges + must be non-overlapping. + + + Attributes: + min: + Lower bound of the range, inclusive. Type should be the same + as max if used. + max: + Upper bound of the range, exclusive; type must match min. + replacement_value: + Replacement value for this bucket. If not provided the default + behavior will be to hyphenate the min-max range. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.BucketingConfig.Bucket) + )) + , + DESCRIPTOR = _BUCKETINGCONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Generalization function that buckets values based on ranges. The ranges + and replacement values are dynamically provided by the user for custom + behavior, such as 1-30 -> LOW 31-65 -> MEDIUM 66-100 -> HIGH This can be + used on data of type: number, long, string, timestamp. If the bound + ``Value`` type differs from the type of data being transformed, we will + first attempt converting the type of the data to be transformed to match + the type of the bound before comparing. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.BucketingConfig) + )) +_sym_db.RegisterMessage(BucketingConfig) +_sym_db.RegisterMessage(BucketingConfig.Bucket) + +CryptoReplaceFfxFpeConfig = _reflection.GeneratedProtocolMessageType('CryptoReplaceFfxFpeConfig', (_message.Message,), dict( + DESCRIPTOR = _CRYPTOREPLACEFFXFPECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Replaces an identifier with a surrogate using FPE with the FFX mode of + operation. The identifier must be representable by the US-ASCII + character set. For a given crypto key and context, the same identifier + will be replaced with the same surrogate. Identifiers must be at least + two characters long. In the case that the identifier is the empty + string, it will be skipped. + + + Attributes: + crypto_key: + The key used by the encryption algorithm. [required] + context: + A context may be used for higher security since the same + identifier in two different contexts likely will be given a + distinct surrogate. The principle is that the likeliness is + inversely related to the ratio of the number of distinct + identifiers per context over the number of possible + surrogates: As long as this ratio is small, the likehood is + large. If the context is not set, a default tweak will be + used. If the context is set but: 1. there is no record + present when transforming a given value or 2. the field is not + present when transforming a given value, a default tweak will + be used. Note that case (1) is expected when an + ``InfoTypeTransformation`` is applied to both structured and + non-structured ``ContentItem``\ s. Currently, the referenced + field may be of value type integer or string. The tweak is + constructed as a sequence of bytes in big endian byte order + such that: - a 64 bit integer is encoded followed by a + single byte of value 1 - a string is encoded in UTF-8 format + followed by a single byte of value 2 This is also known as + the 'tweak', as in tweakable encryption. + custom_alphabet: + This is supported by mapping these to the alphanumeric + characters that the FFX mode natively supports. This happens + before/after encryption/decryption. Each character listed must + appear only once. Number of characters must be in the range + [2, 62]. This must be encoded as ASCII. The order of + characters does not matter. + radix: + The native way to select the alphabet. Must be in the range + [2, 62]. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CryptoReplaceFfxFpeConfig) + )) +_sym_db.RegisterMessage(CryptoReplaceFfxFpeConfig) + +CryptoKey = _reflection.GeneratedProtocolMessageType('CryptoKey', (_message.Message,), dict( + DESCRIPTOR = _CRYPTOKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """This is a data encryption key (DEK) (as opposed to a key encryption key + (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set + an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an + attacker cannot unwrap the data crypto key. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CryptoKey) + )) +_sym_db.RegisterMessage(CryptoKey) + +TransientCryptoKey = _reflection.GeneratedProtocolMessageType('TransientCryptoKey', (_message.Message,), dict( + DESCRIPTOR = _TRANSIENTCRYPTOKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Use this to have a random data crypto key generated. It will be + discarded after the operation/request finishes. + + + Attributes: + name: + Name of the key. [required] This is an arbitrary string used + to differentiate different keys. A unique key is generated per + name: two separate ``TransientCryptoKey`` protos share the + same generated key if their names are the same. When the data + crypto key is generated, this name is not used in any way + (repeating the api call will result in a different key being + generated). + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.TransientCryptoKey) + )) +_sym_db.RegisterMessage(TransientCryptoKey) + +UnwrappedCryptoKey = _reflection.GeneratedProtocolMessageType('UnwrappedCryptoKey', (_message.Message,), dict( + DESCRIPTOR = _UNWRAPPEDCRYPTOKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Using raw keys is prone to security risks due to accidentally leaking + the key. Choose another type of key if possible. + + + Attributes: + key: + The AES 128/192/256 bit key. [required] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.UnwrappedCryptoKey) + )) +_sym_db.RegisterMessage(UnwrappedCryptoKey) + +KmsWrappedCryptoKey = _reflection.GeneratedProtocolMessageType('KmsWrappedCryptoKey', (_message.Message,), dict( + DESCRIPTOR = _KMSWRAPPEDCRYPTOKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Include to use an existing data crypto key wrapped by KMS. Authorization + requires the following IAM permissions when sending a request to perform + a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt + + + Attributes: + wrapped_key: + The wrapped data crypto key. [required] + crypto_key_name: + The resource name of the KMS CryptoKey to use for unwrapping. + [required] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.KmsWrappedCryptoKey) + )) +_sym_db.RegisterMessage(KmsWrappedCryptoKey) + +InfoTypeTransformations = _reflection.GeneratedProtocolMessageType('InfoTypeTransformations', (_message.Message,), dict( + + InfoTypeTransformation = _reflection.GeneratedProtocolMessageType('InfoTypeTransformation', (_message.Message,), dict( + DESCRIPTOR = _INFOTYPETRANSFORMATIONS_INFOTYPETRANSFORMATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A transformation to apply to text that is identified as a specific + info\_type. + + + Attributes: + info_types: + Info types to apply the transformation to. Empty list will + match all available info types for this transformation. + primitive_transformation: + Primitive transformation to apply to the info type. [required] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InfoTypeTransformations.InfoTypeTransformation) + )) + , + DESCRIPTOR = _INFOTYPETRANSFORMATIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A type of transformation that will scan unstructured text and apply + various ``PrimitiveTransformation``\ s to each finding, where the + transformation is applied to only values that were identified as a + specific info\_type. + + + Attributes: + transformations: + Transformation for each info type. Cannot specify more than + one for a given info type. [required] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InfoTypeTransformations) + )) +_sym_db.RegisterMessage(InfoTypeTransformations) +_sym_db.RegisterMessage(InfoTypeTransformations.InfoTypeTransformation) + +FieldTransformation = _reflection.GeneratedProtocolMessageType('FieldTransformation', (_message.Message,), dict( + DESCRIPTOR = _FIELDTRANSFORMATION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The transformation to apply to the field. + + + Attributes: + fields: + Input field(s) to apply the transformation to. [required] + condition: + Only apply the transformation if the condition evaluates to + true for the given ``RecordCondition``. The conditions are + allowed to reference fields that are not used in the actual + transformation. [optional] Example Use Cases: - Apply a + different bucket transformation to an age column if the zip + code column for the same record is within a specific range. - + Redact a field if the date of birth field is greater than 85. + transformation: + Transformation to apply. [required] + primitive_transformation: + Apply the transformation to the entire field. + info_type_transformations: + Treat the contents of the field as free text, and selectively + transform content that matches an ``InfoType``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.FieldTransformation) + )) +_sym_db.RegisterMessage(FieldTransformation) + +RecordTransformations = _reflection.GeneratedProtocolMessageType('RecordTransformations', (_message.Message,), dict( + DESCRIPTOR = _RECORDTRANSFORMATIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A type of transformation that is applied over structured data such as a + table. + + + Attributes: + field_transformations: + Transform the record by applying various field + transformations. + record_suppressions: + Configuration defining which records get suppressed entirely. + Records that match any suppression rule are omitted from the + output [optional]. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordTransformations) + )) +_sym_db.RegisterMessage(RecordTransformations) + +RecordSuppression = _reflection.GeneratedProtocolMessageType('RecordSuppression', (_message.Message,), dict( + DESCRIPTOR = _RECORDSUPPRESSION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Configuration to suppress records whose suppression conditions evaluate + to true. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordSuppression) + )) +_sym_db.RegisterMessage(RecordSuppression) + +RecordCondition = _reflection.GeneratedProtocolMessageType('RecordCondition', (_message.Message,), dict( + + Condition = _reflection.GeneratedProtocolMessageType('Condition', (_message.Message,), dict( + DESCRIPTOR = _RECORDCONDITION_CONDITION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordCondition.Condition) + )) + , + + Conditions = _reflection.GeneratedProtocolMessageType('Conditions', (_message.Message,), dict( + DESCRIPTOR = _RECORDCONDITION_CONDITIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordCondition.Conditions) + )) + , + + Expressions = _reflection.GeneratedProtocolMessageType('Expressions', (_message.Message,), dict( + DESCRIPTOR = _RECORDCONDITION_EXPRESSIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A collection of expressions + + + Attributes: + logical_operator: + The operator to apply to the result of conditions. Default and + currently only supported value is ``AND``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordCondition.Expressions) + )) + , + DESCRIPTOR = _RECORDCONDITION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """The field type of ``value`` and ``field`` do not need to match to be + considered equal, but not all comparisons are possible. + + A ``value`` of type: + + - ``string`` can be compared against all other types + - ``boolean`` can only be compared against other booleans + - ``integer`` can be compared against doubles or a string if the string + value can be parsed as an integer. + - ``double`` can be compared against integers or a string if the string + can be parsed as a double. + - ``Timestamp`` can be compared against strings in RFC 3339 date string + format. + - ``TimeOfDay`` can be compared against timestamps and strings in the + format of 'HH:mm:ss'. + + If we fail to compare do to type mismatch, a warning will be given and + the condition will evaluate to false. + + + Attributes: + field: + Field within the record this condition is evaluated against. + [required] + operator: + Operator used to compare the field or info type to the value. + [required] + value: + Value to compare against. [Required, except for ``EXISTS`` + tests.] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordCondition) + )) +_sym_db.RegisterMessage(RecordCondition) +_sym_db.RegisterMessage(RecordCondition.Condition) +_sym_db.RegisterMessage(RecordCondition.Conditions) +_sym_db.RegisterMessage(RecordCondition.Expressions) + +DeidentificationSummary = _reflection.GeneratedProtocolMessageType('DeidentificationSummary', (_message.Message,), dict( + DESCRIPTOR = _DEIDENTIFICATIONSUMMARY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """High level summary of deidentification. + + + Attributes: + transformed_bytes: + Total size in bytes that were transformed in some way. + transformation_summaries: + Transformations applied to the dataset. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DeidentificationSummary) + )) +_sym_db.RegisterMessage(DeidentificationSummary) + +TransformationSummary = _reflection.GeneratedProtocolMessageType('TransformationSummary', (_message.Message,), dict( + + SummaryResult = _reflection.GeneratedProtocolMessageType('SummaryResult', (_message.Message,), dict( + DESCRIPTOR = _TRANSFORMATIONSUMMARY_SUMMARYRESULT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """A collection that informs the user the number of times a particular + ``TransformationResultCode`` and error details occurred. + + + Attributes: + details: + A place for warnings or errors to show up if a transformation + didn't work as expected. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.TransformationSummary.SummaryResult) + )) + , + DESCRIPTOR = _TRANSFORMATIONSUMMARY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2' + , + __doc__ = """Summary of a single tranformation. + + + Attributes: + info_type: + Set if the transformation was limited to a specific + info\_type. + field: + Set if the transformation was limited to a specific FieldId. + transformation: + The specific transformation these stats apply to. + field_transformations: + The field transformation that was applied. This list will + contain multiple only in the case of errors. + record_suppress: + The specific suppression option these stats apply to. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.TransformationSummary) + )) +_sym_db.RegisterMessage(TransformationSummary) +_sym_db.RegisterMessage(TransformationSummary.SummaryResult) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\036com.google.privacy.dlp.v2beta1B\010DlpProtoP\001Z=google.golang.org/genproto/googleapis/privacy/dlp/v2beta1;dlp\252\002\030Google.Cloud.Dlp.V2Beta1')) +try: + # THESE ELEMENTS WILL BE DEPRECATED. + # Please use the generated *_pb2_grpc.py files instead. + import grpc + from grpc.beta import implementations as beta_implementations + from grpc.beta import interfaces as beta_interfaces + from grpc.framework.common import cardinality + from grpc.framework.interfaces.face import utilities as face_utilities + + + class DlpServiceStub(object): + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.InspectContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/InspectContent', + request_serializer=InspectContentRequest.SerializeToString, + response_deserializer=InspectContentResponse.FromString, + ) + self.RedactContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/RedactContent', + request_serializer=RedactContentRequest.SerializeToString, + response_deserializer=RedactContentResponse.FromString, + ) + self.DeidentifyContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/DeidentifyContent', + request_serializer=DeidentifyContentRequest.SerializeToString, + response_deserializer=DeidentifyContentResponse.FromString, + ) + self.CreateInspectOperation = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/CreateInspectOperation', + request_serializer=CreateInspectOperationRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.AnalyzeDataSourceRisk = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/AnalyzeDataSourceRisk', + request_serializer=AnalyzeDataSourceRiskRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.ListInspectFindings = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListInspectFindings', + request_serializer=ListInspectFindingsRequest.SerializeToString, + response_deserializer=ListInspectFindingsResponse.FromString, + ) + self.ListInfoTypes = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListInfoTypes', + request_serializer=ListInfoTypesRequest.SerializeToString, + response_deserializer=ListInfoTypesResponse.FromString, + ) + self.ListRootCategories = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListRootCategories', + request_serializer=ListRootCategoriesRequest.SerializeToString, + response_deserializer=ListRootCategoriesResponse.FromString, + ) + + + class DlpServiceServicer(object): + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + + def InspectContent(self, request, context): + """Finds potentially sensitive info in a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RedactContent(self, request, context): + """Redacts potentially sensitive info from a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeidentifyContent(self, request, context): + """De-identifies potentially sensitive info from a list of strings. + This method has limits on input size and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateInspectOperation(self, request, context): + """Schedules a job scanning content in a Google Cloud Platform data + repository. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AnalyzeDataSourceRisk(self, request, context): + """Schedules a job to compute risk analysis metrics over content in a Google + Cloud Platform repository. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListInspectFindings(self, request, context): + """Returns list of results for given inspect operation result set id. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListInfoTypes(self, request, context): + """Returns sensitive information types for given category. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListRootCategories(self, request, context): + """Returns the list of root categories of sensitive information. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + + def add_DlpServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'InspectContent': grpc.unary_unary_rpc_method_handler( + servicer.InspectContent, + request_deserializer=InspectContentRequest.FromString, + response_serializer=InspectContentResponse.SerializeToString, + ), + 'RedactContent': grpc.unary_unary_rpc_method_handler( + servicer.RedactContent, + request_deserializer=RedactContentRequest.FromString, + response_serializer=RedactContentResponse.SerializeToString, + ), + 'DeidentifyContent': grpc.unary_unary_rpc_method_handler( + servicer.DeidentifyContent, + request_deserializer=DeidentifyContentRequest.FromString, + response_serializer=DeidentifyContentResponse.SerializeToString, + ), + 'CreateInspectOperation': grpc.unary_unary_rpc_method_handler( + servicer.CreateInspectOperation, + request_deserializer=CreateInspectOperationRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'AnalyzeDataSourceRisk': grpc.unary_unary_rpc_method_handler( + servicer.AnalyzeDataSourceRisk, + request_deserializer=AnalyzeDataSourceRiskRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'ListInspectFindings': grpc.unary_unary_rpc_method_handler( + servicer.ListInspectFindings, + request_deserializer=ListInspectFindingsRequest.FromString, + response_serializer=ListInspectFindingsResponse.SerializeToString, + ), + 'ListInfoTypes': grpc.unary_unary_rpc_method_handler( + servicer.ListInfoTypes, + request_deserializer=ListInfoTypesRequest.FromString, + response_serializer=ListInfoTypesResponse.SerializeToString, + ), + 'ListRootCategories': grpc.unary_unary_rpc_method_handler( + servicer.ListRootCategories, + request_deserializer=ListRootCategoriesRequest.FromString, + response_serializer=ListRootCategoriesResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'google.privacy.dlp.v2beta1.DlpService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + class BetaDlpServiceServicer(object): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This class was generated + only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0.""" + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + def InspectContent(self, request, context): + """Finds potentially sensitive info in a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def RedactContent(self, request, context): + """Redacts potentially sensitive info from a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def DeidentifyContent(self, request, context): + """De-identifies potentially sensitive info from a list of strings. + This method has limits on input size and output size. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def CreateInspectOperation(self, request, context): + """Schedules a job scanning content in a Google Cloud Platform data + repository. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def AnalyzeDataSourceRisk(self, request, context): + """Schedules a job to compute risk analysis metrics over content in a Google + Cloud Platform repository. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def ListInspectFindings(self, request, context): + """Returns list of results for given inspect operation result set id. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def ListInfoTypes(self, request, context): + """Returns sensitive information types for given category. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def ListRootCategories(self, request, context): + """Returns the list of root categories of sensitive information. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + + + class BetaDlpServiceStub(object): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This class was generated + only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0.""" + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + def InspectContent(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Finds potentially sensitive info in a list of strings. + This method has limits on input size, processing time, and output size. + """ + raise NotImplementedError() + InspectContent.future = None + def RedactContent(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Redacts potentially sensitive info from a list of strings. + This method has limits on input size, processing time, and output size. + """ + raise NotImplementedError() + RedactContent.future = None + def DeidentifyContent(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """De-identifies potentially sensitive info from a list of strings. + This method has limits on input size and output size. + """ + raise NotImplementedError() + DeidentifyContent.future = None + def CreateInspectOperation(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Schedules a job scanning content in a Google Cloud Platform data + repository. + """ + raise NotImplementedError() + CreateInspectOperation.future = None + def AnalyzeDataSourceRisk(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Schedules a job to compute risk analysis metrics over content in a Google + Cloud Platform repository. + """ + raise NotImplementedError() + AnalyzeDataSourceRisk.future = None + def ListInspectFindings(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Returns list of results for given inspect operation result set id. + """ + raise NotImplementedError() + ListInspectFindings.future = None + def ListInfoTypes(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Returns sensitive information types for given category. + """ + raise NotImplementedError() + ListInfoTypes.future = None + def ListRootCategories(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Returns the list of root categories of sensitive information. + """ + raise NotImplementedError() + ListRootCategories.future = None + + + def beta_create_DlpService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This function was + generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" + request_deserializers = { + ('google.privacy.dlp.v2beta1.DlpService', 'AnalyzeDataSourceRisk'): AnalyzeDataSourceRiskRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'CreateInspectOperation'): CreateInspectOperationRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'DeidentifyContent'): DeidentifyContentRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'InspectContent'): InspectContentRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInfoTypes'): ListInfoTypesRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInspectFindings'): ListInspectFindingsRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListRootCategories'): ListRootCategoriesRequest.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'RedactContent'): RedactContentRequest.FromString, + } + response_serializers = { + ('google.privacy.dlp.v2beta1.DlpService', 'AnalyzeDataSourceRisk'): google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'CreateInspectOperation'): google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'DeidentifyContent'): DeidentifyContentResponse.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'InspectContent'): InspectContentResponse.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInfoTypes'): ListInfoTypesResponse.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInspectFindings'): ListInspectFindingsResponse.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListRootCategories'): ListRootCategoriesResponse.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'RedactContent'): RedactContentResponse.SerializeToString, + } + method_implementations = { + ('google.privacy.dlp.v2beta1.DlpService', 'AnalyzeDataSourceRisk'): face_utilities.unary_unary_inline(servicer.AnalyzeDataSourceRisk), + ('google.privacy.dlp.v2beta1.DlpService', 'CreateInspectOperation'): face_utilities.unary_unary_inline(servicer.CreateInspectOperation), + ('google.privacy.dlp.v2beta1.DlpService', 'DeidentifyContent'): face_utilities.unary_unary_inline(servicer.DeidentifyContent), + ('google.privacy.dlp.v2beta1.DlpService', 'InspectContent'): face_utilities.unary_unary_inline(servicer.InspectContent), + ('google.privacy.dlp.v2beta1.DlpService', 'ListInfoTypes'): face_utilities.unary_unary_inline(servicer.ListInfoTypes), + ('google.privacy.dlp.v2beta1.DlpService', 'ListInspectFindings'): face_utilities.unary_unary_inline(servicer.ListInspectFindings), + ('google.privacy.dlp.v2beta1.DlpService', 'ListRootCategories'): face_utilities.unary_unary_inline(servicer.ListRootCategories), + ('google.privacy.dlp.v2beta1.DlpService', 'RedactContent'): face_utilities.unary_unary_inline(servicer.RedactContent), + } + server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) + return beta_implementations.server(method_implementations, options=server_options) + + + def beta_create_DlpService_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This function was + generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" + request_serializers = { + ('google.privacy.dlp.v2beta1.DlpService', 'AnalyzeDataSourceRisk'): AnalyzeDataSourceRiskRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'CreateInspectOperation'): CreateInspectOperationRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'DeidentifyContent'): DeidentifyContentRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'InspectContent'): InspectContentRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInfoTypes'): ListInfoTypesRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInspectFindings'): ListInspectFindingsRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListRootCategories'): ListRootCategoriesRequest.SerializeToString, + ('google.privacy.dlp.v2beta1.DlpService', 'RedactContent'): RedactContentRequest.SerializeToString, + } + response_deserializers = { + ('google.privacy.dlp.v2beta1.DlpService', 'AnalyzeDataSourceRisk'): google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'CreateInspectOperation'): google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'DeidentifyContent'): DeidentifyContentResponse.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'InspectContent'): InspectContentResponse.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInfoTypes'): ListInfoTypesResponse.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListInspectFindings'): ListInspectFindingsResponse.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'ListRootCategories'): ListRootCategoriesResponse.FromString, + ('google.privacy.dlp.v2beta1.DlpService', 'RedactContent'): RedactContentResponse.FromString, + } + cardinalities = { + 'AnalyzeDataSourceRisk': cardinality.Cardinality.UNARY_UNARY, + 'CreateInspectOperation': cardinality.Cardinality.UNARY_UNARY, + 'DeidentifyContent': cardinality.Cardinality.UNARY_UNARY, + 'InspectContent': cardinality.Cardinality.UNARY_UNARY, + 'ListInfoTypes': cardinality.Cardinality.UNARY_UNARY, + 'ListInspectFindings': cardinality.Cardinality.UNARY_UNARY, + 'ListRootCategories': cardinality.Cardinality.UNARY_UNARY, + 'RedactContent': cardinality.Cardinality.UNARY_UNARY, + } + stub_options = beta_implementations.stub_options(host=host, metadata_transformer=metadata_transformer, request_serializers=request_serializers, response_deserializers=response_deserializers, thread_pool=pool, thread_pool_size=pool_size) + return beta_implementations.dynamic_stub(channel, 'google.privacy.dlp.v2beta1.DlpService', cardinalities, options=stub_options) +except ImportError: + pass +# @@protoc_insertion_point(module_scope) diff --git a/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2_grpc.py b/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2_grpc.py new file mode 100644 index 000000000000..fb7e81816d82 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/proto/dlp_pb2_grpc.py @@ -0,0 +1,181 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +import grpc + +import google.cloud.privacy.dlp_v2beta1.proto.dlp_pb2 as google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2 +import google.longrunning.operations_pb2 as google_dot_longrunning_dot_operations__pb2 + + +class DlpServiceStub(object): + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.InspectContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/InspectContent', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.InspectContentRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.InspectContentResponse.FromString, + ) + self.RedactContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/RedactContent', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.RedactContentRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.RedactContentResponse.FromString, + ) + self.DeidentifyContent = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/DeidentifyContent', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.DeidentifyContentRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.DeidentifyContentResponse.FromString, + ) + self.CreateInspectOperation = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/CreateInspectOperation', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.CreateInspectOperationRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.AnalyzeDataSourceRisk = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/AnalyzeDataSourceRisk', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.AnalyzeDataSourceRiskRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.ListInspectFindings = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListInspectFindings', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInspectFindingsRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInspectFindingsResponse.FromString, + ) + self.ListInfoTypes = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListInfoTypes', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInfoTypesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInfoTypesResponse.FromString, + ) + self.ListRootCategories = channel.unary_unary( + '/google.privacy.dlp.v2beta1.DlpService/ListRootCategories', + request_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListRootCategoriesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListRootCategoriesResponse.FromString, + ) + + +class DlpServiceServicer(object): + """The DLP API is a service that allows clients + to detect the presence of Personally Identifiable Information (PII) and other + privacy-sensitive data in user-supplied, unstructured data streams, like text + blocks or images. + The service also includes methods for sensitive data redaction and + scheduling of data scans on Google Cloud Platform based data sets. + """ + + def InspectContent(self, request, context): + """Finds potentially sensitive info in a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RedactContent(self, request, context): + """Redacts potentially sensitive info from a list of strings. + This method has limits on input size, processing time, and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeidentifyContent(self, request, context): + """De-identifies potentially sensitive info from a list of strings. + This method has limits on input size and output size. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateInspectOperation(self, request, context): + """Schedules a job scanning content in a Google Cloud Platform data + repository. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AnalyzeDataSourceRisk(self, request, context): + """Schedules a job to compute risk analysis metrics over content in a Google + Cloud Platform repository. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListInspectFindings(self, request, context): + """Returns list of results for given inspect operation result set id. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListInfoTypes(self, request, context): + """Returns sensitive information types for given category. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListRootCategories(self, request, context): + """Returns the list of root categories of sensitive information. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_DlpServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'InspectContent': grpc.unary_unary_rpc_method_handler( + servicer.InspectContent, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.InspectContentRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.InspectContentResponse.SerializeToString, + ), + 'RedactContent': grpc.unary_unary_rpc_method_handler( + servicer.RedactContent, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.RedactContentRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.RedactContentResponse.SerializeToString, + ), + 'DeidentifyContent': grpc.unary_unary_rpc_method_handler( + servicer.DeidentifyContent, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.DeidentifyContentRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.DeidentifyContentResponse.SerializeToString, + ), + 'CreateInspectOperation': grpc.unary_unary_rpc_method_handler( + servicer.CreateInspectOperation, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.CreateInspectOperationRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'AnalyzeDataSourceRisk': grpc.unary_unary_rpc_method_handler( + servicer.AnalyzeDataSourceRisk, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.AnalyzeDataSourceRiskRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'ListInspectFindings': grpc.unary_unary_rpc_method_handler( + servicer.ListInspectFindings, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInspectFindingsRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInspectFindingsResponse.SerializeToString, + ), + 'ListInfoTypes': grpc.unary_unary_rpc_method_handler( + servicer.ListInfoTypes, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInfoTypesRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListInfoTypesResponse.SerializeToString, + ), + 'ListRootCategories': grpc.unary_unary_rpc_method_handler( + servicer.ListRootCategories, + request_deserializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListRootCategoriesRequest.FromString, + response_serializer=google_dot_cloud_dot_privacy_dot_dlp__v2beta1_dot_proto_dot_dlp__pb2.ListRootCategoriesResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'google.privacy.dlp.v2beta1.DlpService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2.py b/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2.py new file mode 100644 index 000000000000..c6748d158199 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2.py @@ -0,0 +1,1326 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/privacy/dlp_v2beta1/proto/storage.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/cloud/privacy/dlp_v2beta1/proto/storage.proto', + package='google.privacy.dlp.v2beta1', + syntax='proto3', + serialized_pb=_b('\n4google/cloud/privacy/dlp_v2beta1/proto/storage.proto\x12\x1agoogle.privacy.dlp.v2beta1\x1a\x1cgoogle/api/annotations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x18\n\x08InfoType\x12\x0c\n\x04name\x18\x01 \x01(\t\"\xa7\x02\n\x0e\x43ustomInfoType\x12\x37\n\tinfo_type\x18\x01 \x01(\x0b\x32$.google.privacy.dlp.v2beta1.InfoType\x12K\n\ndictionary\x18\x02 \x01(\x0b\x32\x35.google.privacy.dlp.v2beta1.CustomInfoType.DictionaryH\x00\x1a\x86\x01\n\nDictionary\x12S\n\tword_list\x18\x01 \x01(\x0b\x32>.google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.WordListH\x00\x1a\x19\n\x08WordList\x12\r\n\x05words\x18\x01 \x03(\tB\x08\n\x06sourceB\x06\n\x04type\"\x1e\n\x07\x46ieldId\x12\x13\n\x0b\x63olumn_name\x18\x01 \x01(\t\"7\n\x0bPartitionId\x12\x12\n\nproject_id\x18\x02 \x01(\t\x12\x14\n\x0cnamespace_id\x18\x04 \x01(\t\"\x1e\n\x0eKindExpression\x12\x0c\n\x04name\x18\x01 \x01(\t\"!\n\x11PropertyReference\x12\x0c\n\x04name\x18\x02 \x01(\t\"M\n\nProjection\x12?\n\x08property\x18\x01 \x01(\x0b\x32-.google.privacy.dlp.v2beta1.PropertyReference\"\xc7\x01\n\x10\x44\x61tastoreOptions\x12=\n\x0cpartition_id\x18\x01 \x01(\x0b\x32\'.google.privacy.dlp.v2beta1.PartitionId\x12\x38\n\x04kind\x18\x02 \x01(\x0b\x32*.google.privacy.dlp.v2beta1.KindExpression\x12:\n\nprojection\x18\x03 \x03(\x0b\x32&.google.privacy.dlp.v2beta1.Projection\"x\n\x13\x43loudStorageOptions\x12I\n\x08\x66ile_set\x18\x01 \x01(\x0b\x32\x37.google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet\x1a\x16\n\x07\x46ileSet\x12\x0b\n\x03url\x18\x01 \x01(\t\" \n\x10\x43loudStoragePath\x12\x0c\n\x04path\x18\x01 \x01(\t\"\x96\x01\n\x0f\x42igQueryOptions\x12\x42\n\x0ftable_reference\x18\x01 \x01(\x0b\x32).google.privacy.dlp.v2beta1.BigQueryTable\x12?\n\x12identifying_fields\x18\x02 \x03(\x0b\x32#.google.privacy.dlp.v2beta1.FieldId\"\xfe\x01\n\rStorageConfig\x12I\n\x11\x64\x61tastore_options\x18\x02 \x01(\x0b\x32,.google.privacy.dlp.v2beta1.DatastoreOptionsH\x00\x12P\n\x15\x63loud_storage_options\x18\x03 \x01(\x0b\x32/.google.privacy.dlp.v2beta1.CloudStorageOptionsH\x00\x12H\n\x11\x62ig_query_options\x18\x04 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.BigQueryOptionsH\x00\x42\x06\n\x04type\":\n\x0f\x43loudStorageKey\x12\x11\n\tfile_path\x18\x01 \x01(\t\x12\x14\n\x0cstart_offset\x18\x02 \x01(\x03\"C\n\x0c\x44\x61tastoreKey\x12\x33\n\nentity_key\x18\x01 \x01(\x0b\x32\x1f.google.privacy.dlp.v2beta1.Key\"\xc5\x01\n\x03Key\x12=\n\x0cpartition_id\x18\x01 \x01(\x0b\x32\'.google.privacy.dlp.v2beta1.PartitionId\x12\x39\n\x04path\x18\x02 \x03(\x0b\x32+.google.privacy.dlp.v2beta1.Key.PathElement\x1a\x44\n\x0bPathElement\x12\x0c\n\x04kind\x18\x01 \x01(\t\x12\x0c\n\x02id\x18\x02 \x01(\x03H\x00\x12\x0e\n\x04name\x18\x03 \x01(\tH\x00\x42\t\n\x07id_type\"\xa0\x01\n\tRecordKey\x12H\n\x11\x63loud_storage_key\x18\x01 \x01(\x0b\x32+.google.privacy.dlp.v2beta1.CloudStorageKeyH\x00\x12\x41\n\rdatastore_key\x18\x02 \x01(\x0b\x32(.google.privacy.dlp.v2beta1.DatastoreKeyH\x00\x42\x06\n\x04type\"I\n\rBigQueryTable\x12\x12\n\nproject_id\x18\x01 \x01(\t\x12\x12\n\ndataset_id\x18\x02 \x01(\t\x12\x10\n\x08table_id\x18\x03 \x01(\t\">\n\x08\x45ntityId\x12\x32\n\x05\x66ield\x18\x01 \x01(\x0b\x32#.google.privacy.dlp.v2beta1.FieldIdB\x88\x01\n\x1e\x63om.google.privacy.dlp.v2beta1B\nDlpStorageP\x01Z=google.golang.org/genproto/googleapis/privacy/dlp/v2beta1;dlp\xaa\x02\x18Google.Cloud.Dlp.V2Beta1b\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_INFOTYPE = _descriptor.Descriptor( + name='InfoType', + full_name='google.privacy.dlp.v2beta1.InfoType', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.InfoType.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=147, + serialized_end=171, +) + + +_CUSTOMINFOTYPE_DICTIONARY_WORDLIST = _descriptor.Descriptor( + name='WordList', + full_name='google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.WordList', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='words', full_name='google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.WordList.words', index=0, + number=1, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=426, + serialized_end=451, +) + +_CUSTOMINFOTYPE_DICTIONARY = _descriptor.Descriptor( + name='Dictionary', + full_name='google.privacy.dlp.v2beta1.CustomInfoType.Dictionary', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='word_list', full_name='google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.word_list', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_CUSTOMINFOTYPE_DICTIONARY_WORDLIST, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='source', full_name='google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.source', + index=0, containing_type=None, fields=[]), + ], + serialized_start=327, + serialized_end=461, +) + +_CUSTOMINFOTYPE = _descriptor.Descriptor( + name='CustomInfoType', + full_name='google.privacy.dlp.v2beta1.CustomInfoType', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='info_type', full_name='google.privacy.dlp.v2beta1.CustomInfoType.info_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dictionary', full_name='google.privacy.dlp.v2beta1.CustomInfoType.dictionary', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_CUSTOMINFOTYPE_DICTIONARY, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.CustomInfoType.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=174, + serialized_end=469, +) + + +_FIELDID = _descriptor.Descriptor( + name='FieldId', + full_name='google.privacy.dlp.v2beta1.FieldId', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='column_name', full_name='google.privacy.dlp.v2beta1.FieldId.column_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=471, + serialized_end=501, +) + + +_PARTITIONID = _descriptor.Descriptor( + name='PartitionId', + full_name='google.privacy.dlp.v2beta1.PartitionId', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='project_id', full_name='google.privacy.dlp.v2beta1.PartitionId.project_id', index=0, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='namespace_id', full_name='google.privacy.dlp.v2beta1.PartitionId.namespace_id', index=1, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=503, + serialized_end=558, +) + + +_KINDEXPRESSION = _descriptor.Descriptor( + name='KindExpression', + full_name='google.privacy.dlp.v2beta1.KindExpression', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.KindExpression.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=560, + serialized_end=590, +) + + +_PROPERTYREFERENCE = _descriptor.Descriptor( + name='PropertyReference', + full_name='google.privacy.dlp.v2beta1.PropertyReference', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.PropertyReference.name', index=0, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=592, + serialized_end=625, +) + + +_PROJECTION = _descriptor.Descriptor( + name='Projection', + full_name='google.privacy.dlp.v2beta1.Projection', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='property', full_name='google.privacy.dlp.v2beta1.Projection.property', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=627, + serialized_end=704, +) + + +_DATASTOREOPTIONS = _descriptor.Descriptor( + name='DatastoreOptions', + full_name='google.privacy.dlp.v2beta1.DatastoreOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='partition_id', full_name='google.privacy.dlp.v2beta1.DatastoreOptions.partition_id', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kind', full_name='google.privacy.dlp.v2beta1.DatastoreOptions.kind', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='projection', full_name='google.privacy.dlp.v2beta1.DatastoreOptions.projection', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=707, + serialized_end=906, +) + + +_CLOUDSTORAGEOPTIONS_FILESET = _descriptor.Descriptor( + name='FileSet', + full_name='google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='url', full_name='google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet.url', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1006, + serialized_end=1028, +) + +_CLOUDSTORAGEOPTIONS = _descriptor.Descriptor( + name='CloudStorageOptions', + full_name='google.privacy.dlp.v2beta1.CloudStorageOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='file_set', full_name='google.privacy.dlp.v2beta1.CloudStorageOptions.file_set', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_CLOUDSTORAGEOPTIONS_FILESET, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=908, + serialized_end=1028, +) + + +_CLOUDSTORAGEPATH = _descriptor.Descriptor( + name='CloudStoragePath', + full_name='google.privacy.dlp.v2beta1.CloudStoragePath', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='path', full_name='google.privacy.dlp.v2beta1.CloudStoragePath.path', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1030, + serialized_end=1062, +) + + +_BIGQUERYOPTIONS = _descriptor.Descriptor( + name='BigQueryOptions', + full_name='google.privacy.dlp.v2beta1.BigQueryOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_reference', full_name='google.privacy.dlp.v2beta1.BigQueryOptions.table_reference', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='identifying_fields', full_name='google.privacy.dlp.v2beta1.BigQueryOptions.identifying_fields', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1065, + serialized_end=1215, +) + + +_STORAGECONFIG = _descriptor.Descriptor( + name='StorageConfig', + full_name='google.privacy.dlp.v2beta1.StorageConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='datastore_options', full_name='google.privacy.dlp.v2beta1.StorageConfig.datastore_options', index=0, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cloud_storage_options', full_name='google.privacy.dlp.v2beta1.StorageConfig.cloud_storage_options', index=1, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='big_query_options', full_name='google.privacy.dlp.v2beta1.StorageConfig.big_query_options', index=2, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.StorageConfig.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=1218, + serialized_end=1472, +) + + +_CLOUDSTORAGEKEY = _descriptor.Descriptor( + name='CloudStorageKey', + full_name='google.privacy.dlp.v2beta1.CloudStorageKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='file_path', full_name='google.privacy.dlp.v2beta1.CloudStorageKey.file_path', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='start_offset', full_name='google.privacy.dlp.v2beta1.CloudStorageKey.start_offset', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1474, + serialized_end=1532, +) + + +_DATASTOREKEY = _descriptor.Descriptor( + name='DatastoreKey', + full_name='google.privacy.dlp.v2beta1.DatastoreKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='entity_key', full_name='google.privacy.dlp.v2beta1.DatastoreKey.entity_key', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1534, + serialized_end=1601, +) + + +_KEY_PATHELEMENT = _descriptor.Descriptor( + name='PathElement', + full_name='google.privacy.dlp.v2beta1.Key.PathElement', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='kind', full_name='google.privacy.dlp.v2beta1.Key.PathElement.kind', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='id', full_name='google.privacy.dlp.v2beta1.Key.PathElement.id', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='name', full_name='google.privacy.dlp.v2beta1.Key.PathElement.name', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='id_type', full_name='google.privacy.dlp.v2beta1.Key.PathElement.id_type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=1733, + serialized_end=1801, +) + +_KEY = _descriptor.Descriptor( + name='Key', + full_name='google.privacy.dlp.v2beta1.Key', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='partition_id', full_name='google.privacy.dlp.v2beta1.Key.partition_id', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='path', full_name='google.privacy.dlp.v2beta1.Key.path', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_KEY_PATHELEMENT, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1604, + serialized_end=1801, +) + + +_RECORDKEY = _descriptor.Descriptor( + name='RecordKey', + full_name='google.privacy.dlp.v2beta1.RecordKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='cloud_storage_key', full_name='google.privacy.dlp.v2beta1.RecordKey.cloud_storage_key', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='datastore_key', full_name='google.privacy.dlp.v2beta1.RecordKey.datastore_key', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='type', full_name='google.privacy.dlp.v2beta1.RecordKey.type', + index=0, containing_type=None, fields=[]), + ], + serialized_start=1804, + serialized_end=1964, +) + + +_BIGQUERYTABLE = _descriptor.Descriptor( + name='BigQueryTable', + full_name='google.privacy.dlp.v2beta1.BigQueryTable', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='project_id', full_name='google.privacy.dlp.v2beta1.BigQueryTable.project_id', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dataset_id', full_name='google.privacy.dlp.v2beta1.BigQueryTable.dataset_id', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='table_id', full_name='google.privacy.dlp.v2beta1.BigQueryTable.table_id', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1966, + serialized_end=2039, +) + + +_ENTITYID = _descriptor.Descriptor( + name='EntityId', + full_name='google.privacy.dlp.v2beta1.EntityId', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='field', full_name='google.privacy.dlp.v2beta1.EntityId.field', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2041, + serialized_end=2103, +) + +_CUSTOMINFOTYPE_DICTIONARY_WORDLIST.containing_type = _CUSTOMINFOTYPE_DICTIONARY +_CUSTOMINFOTYPE_DICTIONARY.fields_by_name['word_list'].message_type = _CUSTOMINFOTYPE_DICTIONARY_WORDLIST +_CUSTOMINFOTYPE_DICTIONARY.containing_type = _CUSTOMINFOTYPE +_CUSTOMINFOTYPE_DICTIONARY.oneofs_by_name['source'].fields.append( + _CUSTOMINFOTYPE_DICTIONARY.fields_by_name['word_list']) +_CUSTOMINFOTYPE_DICTIONARY.fields_by_name['word_list'].containing_oneof = _CUSTOMINFOTYPE_DICTIONARY.oneofs_by_name['source'] +_CUSTOMINFOTYPE.fields_by_name['info_type'].message_type = _INFOTYPE +_CUSTOMINFOTYPE.fields_by_name['dictionary'].message_type = _CUSTOMINFOTYPE_DICTIONARY +_CUSTOMINFOTYPE.oneofs_by_name['type'].fields.append( + _CUSTOMINFOTYPE.fields_by_name['dictionary']) +_CUSTOMINFOTYPE.fields_by_name['dictionary'].containing_oneof = _CUSTOMINFOTYPE.oneofs_by_name['type'] +_PROJECTION.fields_by_name['property'].message_type = _PROPERTYREFERENCE +_DATASTOREOPTIONS.fields_by_name['partition_id'].message_type = _PARTITIONID +_DATASTOREOPTIONS.fields_by_name['kind'].message_type = _KINDEXPRESSION +_DATASTOREOPTIONS.fields_by_name['projection'].message_type = _PROJECTION +_CLOUDSTORAGEOPTIONS_FILESET.containing_type = _CLOUDSTORAGEOPTIONS +_CLOUDSTORAGEOPTIONS.fields_by_name['file_set'].message_type = _CLOUDSTORAGEOPTIONS_FILESET +_BIGQUERYOPTIONS.fields_by_name['table_reference'].message_type = _BIGQUERYTABLE +_BIGQUERYOPTIONS.fields_by_name['identifying_fields'].message_type = _FIELDID +_STORAGECONFIG.fields_by_name['datastore_options'].message_type = _DATASTOREOPTIONS +_STORAGECONFIG.fields_by_name['cloud_storage_options'].message_type = _CLOUDSTORAGEOPTIONS +_STORAGECONFIG.fields_by_name['big_query_options'].message_type = _BIGQUERYOPTIONS +_STORAGECONFIG.oneofs_by_name['type'].fields.append( + _STORAGECONFIG.fields_by_name['datastore_options']) +_STORAGECONFIG.fields_by_name['datastore_options'].containing_oneof = _STORAGECONFIG.oneofs_by_name['type'] +_STORAGECONFIG.oneofs_by_name['type'].fields.append( + _STORAGECONFIG.fields_by_name['cloud_storage_options']) +_STORAGECONFIG.fields_by_name['cloud_storage_options'].containing_oneof = _STORAGECONFIG.oneofs_by_name['type'] +_STORAGECONFIG.oneofs_by_name['type'].fields.append( + _STORAGECONFIG.fields_by_name['big_query_options']) +_STORAGECONFIG.fields_by_name['big_query_options'].containing_oneof = _STORAGECONFIG.oneofs_by_name['type'] +_DATASTOREKEY.fields_by_name['entity_key'].message_type = _KEY +_KEY_PATHELEMENT.containing_type = _KEY +_KEY_PATHELEMENT.oneofs_by_name['id_type'].fields.append( + _KEY_PATHELEMENT.fields_by_name['id']) +_KEY_PATHELEMENT.fields_by_name['id'].containing_oneof = _KEY_PATHELEMENT.oneofs_by_name['id_type'] +_KEY_PATHELEMENT.oneofs_by_name['id_type'].fields.append( + _KEY_PATHELEMENT.fields_by_name['name']) +_KEY_PATHELEMENT.fields_by_name['name'].containing_oneof = _KEY_PATHELEMENT.oneofs_by_name['id_type'] +_KEY.fields_by_name['partition_id'].message_type = _PARTITIONID +_KEY.fields_by_name['path'].message_type = _KEY_PATHELEMENT +_RECORDKEY.fields_by_name['cloud_storage_key'].message_type = _CLOUDSTORAGEKEY +_RECORDKEY.fields_by_name['datastore_key'].message_type = _DATASTOREKEY +_RECORDKEY.oneofs_by_name['type'].fields.append( + _RECORDKEY.fields_by_name['cloud_storage_key']) +_RECORDKEY.fields_by_name['cloud_storage_key'].containing_oneof = _RECORDKEY.oneofs_by_name['type'] +_RECORDKEY.oneofs_by_name['type'].fields.append( + _RECORDKEY.fields_by_name['datastore_key']) +_RECORDKEY.fields_by_name['datastore_key'].containing_oneof = _RECORDKEY.oneofs_by_name['type'] +_ENTITYID.fields_by_name['field'].message_type = _FIELDID +DESCRIPTOR.message_types_by_name['InfoType'] = _INFOTYPE +DESCRIPTOR.message_types_by_name['CustomInfoType'] = _CUSTOMINFOTYPE +DESCRIPTOR.message_types_by_name['FieldId'] = _FIELDID +DESCRIPTOR.message_types_by_name['PartitionId'] = _PARTITIONID +DESCRIPTOR.message_types_by_name['KindExpression'] = _KINDEXPRESSION +DESCRIPTOR.message_types_by_name['PropertyReference'] = _PROPERTYREFERENCE +DESCRIPTOR.message_types_by_name['Projection'] = _PROJECTION +DESCRIPTOR.message_types_by_name['DatastoreOptions'] = _DATASTOREOPTIONS +DESCRIPTOR.message_types_by_name['CloudStorageOptions'] = _CLOUDSTORAGEOPTIONS +DESCRIPTOR.message_types_by_name['CloudStoragePath'] = _CLOUDSTORAGEPATH +DESCRIPTOR.message_types_by_name['BigQueryOptions'] = _BIGQUERYOPTIONS +DESCRIPTOR.message_types_by_name['StorageConfig'] = _STORAGECONFIG +DESCRIPTOR.message_types_by_name['CloudStorageKey'] = _CLOUDSTORAGEKEY +DESCRIPTOR.message_types_by_name['DatastoreKey'] = _DATASTOREKEY +DESCRIPTOR.message_types_by_name['Key'] = _KEY +DESCRIPTOR.message_types_by_name['RecordKey'] = _RECORDKEY +DESCRIPTOR.message_types_by_name['BigQueryTable'] = _BIGQUERYTABLE +DESCRIPTOR.message_types_by_name['EntityId'] = _ENTITYID + +InfoType = _reflection.GeneratedProtocolMessageType('InfoType', (_message.Message,), dict( + DESCRIPTOR = _INFOTYPE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Type of information detected by the API. + + + Attributes: + name: + Name of the information type. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.InfoType) + )) +_sym_db.RegisterMessage(InfoType) + +CustomInfoType = _reflection.GeneratedProtocolMessageType('CustomInfoType', (_message.Message,), dict( + + Dictionary = _reflection.GeneratedProtocolMessageType('Dictionary', (_message.Message,), dict( + + WordList = _reflection.GeneratedProtocolMessageType('WordList', (_message.Message,), dict( + DESCRIPTOR = _CUSTOMINFOTYPE_DICTIONARY_WORDLIST, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Message defining a list of words or phrases to search for in the data. + + + Attributes: + words: + Words or phrases defining the dictionary. The dictionary must + contain at least one phrase and every phrase must contain at + least 2 characters that are letters or digits. [required] + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CustomInfoType.Dictionary.WordList) + )) + , + DESCRIPTOR = _CUSTOMINFOTYPE_DICTIONARY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Custom information type based on a dictionary of words or phrases. This + can be used to match sensitive information specific to the data, such as + a list of employee IDs or job titles. + + Dictionary words are case-insensitive and all characters other than + letters and digits in the unicode `Basic Multilingual + Plane `__ + will be replaced with whitespace when scanning for matches, so the + dictionary phrase "Sam Johnson" will match all three phrases "sam + johnson", "Sam, Johnson", and "Sam (Johnson)". Additionally, the + characters surrounding any match must be of a different type than the + adjacent characters within the word, so letters must be next to + non-letters and digits next to non-digits. For example, the dictionary + word "jen" will match the first three letters of the text "jen123" but + will return no matches for "jennifer". + + Dictionary words containing a large number of characters that are not + letters or digits may result in unexpected findings because such + characters are treated as whitespace. + + + Attributes: + word_list: + List of words or phrases to search for. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CustomInfoType.Dictionary) + )) + , + DESCRIPTOR = _CUSTOMINFOTYPE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Custom information type provided by the user. Used to find + domain-specific sensitive information configurable to the data in + question. + + + Attributes: + info_type: + Info type configuration. All custom info types must have + configurations that do not conflict with built-in info types + or other custom info types. + dictionary: + Dictionary-based custom info type. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CustomInfoType) + )) +_sym_db.RegisterMessage(CustomInfoType) +_sym_db.RegisterMessage(CustomInfoType.Dictionary) +_sym_db.RegisterMessage(CustomInfoType.Dictionary.WordList) + +FieldId = _reflection.GeneratedProtocolMessageType('FieldId', (_message.Message,), dict( + DESCRIPTOR = _FIELDID, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """General identifier of a data field in a storage service. + + + Attributes: + column_name: + Name describing the field. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.FieldId) + )) +_sym_db.RegisterMessage(FieldId) + +PartitionId = _reflection.GeneratedProtocolMessageType('PartitionId', (_message.Message,), dict( + DESCRIPTOR = _PARTITIONID, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Datastore partition ID. A partition ID identifies a grouping of + entities. The grouping is always by project and namespace, however the + namespace ID may be empty. + + A partition ID contains several dimensions: project ID and namespace ID. + + + Attributes: + project_id: + The ID of the project to which the entities belong. + namespace_id: + If not empty, the ID of the namespace to which the entities + belong. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PartitionId) + )) +_sym_db.RegisterMessage(PartitionId) + +KindExpression = _reflection.GeneratedProtocolMessageType('KindExpression', (_message.Message,), dict( + DESCRIPTOR = _KINDEXPRESSION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A representation of a Datastore kind. + + + Attributes: + name: + The name of the kind. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.KindExpression) + )) +_sym_db.RegisterMessage(KindExpression) + +PropertyReference = _reflection.GeneratedProtocolMessageType('PropertyReference', (_message.Message,), dict( + DESCRIPTOR = _PROPERTYREFERENCE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A reference to a property relative to the Datastore kind expressions. + + + Attributes: + name: + The name of the property. If name includes "."s, it may be + interpreted as a property name path. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.PropertyReference) + )) +_sym_db.RegisterMessage(PropertyReference) + +Projection = _reflection.GeneratedProtocolMessageType('Projection', (_message.Message,), dict( + DESCRIPTOR = _PROJECTION, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A representation of a Datastore property in a projection. + + + Attributes: + property: + The property to project. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Projection) + )) +_sym_db.RegisterMessage(Projection) + +DatastoreOptions = _reflection.GeneratedProtocolMessageType('DatastoreOptions', (_message.Message,), dict( + DESCRIPTOR = _DATASTOREOPTIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Options defining a data set within Google Cloud Datastore. + + + Attributes: + partition_id: + A partition ID identifies a grouping of entities. The grouping + is always by project and namespace, however the namespace ID + may be empty. + kind: + The kind to process. + projection: + Properties to scan. If none are specified, all properties will + be scanned by default. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DatastoreOptions) + )) +_sym_db.RegisterMessage(DatastoreOptions) + +CloudStorageOptions = _reflection.GeneratedProtocolMessageType('CloudStorageOptions', (_message.Message,), dict( + + FileSet = _reflection.GeneratedProtocolMessageType('FileSet', (_message.Message,), dict( + DESCRIPTOR = _CLOUDSTORAGEOPTIONS_FILESET, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Set of files to scan. + + + Attributes: + url: + The url, in the format ``gs:///``. Trailing + wildcard in the path is allowed. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet) + )) + , + DESCRIPTOR = _CLOUDSTORAGEOPTIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Options defining a file or a set of files (path ending with \*) within a + Google Cloud Storage bucket. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CloudStorageOptions) + )) +_sym_db.RegisterMessage(CloudStorageOptions) +_sym_db.RegisterMessage(CloudStorageOptions.FileSet) + +CloudStoragePath = _reflection.GeneratedProtocolMessageType('CloudStoragePath', (_message.Message,), dict( + DESCRIPTOR = _CLOUDSTORAGEPATH, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A location in Cloud Storage. + + + Attributes: + path: + The url, in the format of ``gs://bucket/``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CloudStoragePath) + )) +_sym_db.RegisterMessage(CloudStoragePath) + +BigQueryOptions = _reflection.GeneratedProtocolMessageType('BigQueryOptions', (_message.Message,), dict( + DESCRIPTOR = _BIGQUERYOPTIONS, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Options defining BigQuery table and row identifiers. + + + Attributes: + table_reference: + Complete BigQuery table reference. + identifying_fields: + References to fields uniquely identifying rows within the + table. Nested fields in the format, like + ``person.birthdate.year``, are allowed. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.BigQueryOptions) + )) +_sym_db.RegisterMessage(BigQueryOptions) + +StorageConfig = _reflection.GeneratedProtocolMessageType('StorageConfig', (_message.Message,), dict( + DESCRIPTOR = _STORAGECONFIG, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Shared message indicating Cloud storage type. + + + Attributes: + datastore_options: + Google Cloud Datastore options specification. + cloud_storage_options: + Google Cloud Storage options specification. + big_query_options: + BigQuery options specification. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.StorageConfig) + )) +_sym_db.RegisterMessage(StorageConfig) + +CloudStorageKey = _reflection.GeneratedProtocolMessageType('CloudStorageKey', (_message.Message,), dict( + DESCRIPTOR = _CLOUDSTORAGEKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Record key for a finding in a Cloud Storage file. + + + Attributes: + file_path: + Path to the file. + start_offset: + Byte offset of the referenced data in the file. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.CloudStorageKey) + )) +_sym_db.RegisterMessage(CloudStorageKey) + +DatastoreKey = _reflection.GeneratedProtocolMessageType('DatastoreKey', (_message.Message,), dict( + DESCRIPTOR = _DATASTOREKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Record key for a finding in Cloud Datastore. + + + Attributes: + entity_key: + Datastore entity key. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.DatastoreKey) + )) +_sym_db.RegisterMessage(DatastoreKey) + +Key = _reflection.GeneratedProtocolMessageType('Key', (_message.Message,), dict( + + PathElement = _reflection.GeneratedProtocolMessageType('PathElement', (_message.Message,), dict( + DESCRIPTOR = _KEY_PATHELEMENT, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A (kind, ID/name) pair used to construct a key path. + + If either name or ID is set, the element is complete. If neither is set, + the element is incomplete. + + + Attributes: + kind: + The kind of the entity. A kind matching regex ``__.*__`` is + reserved/read-only. A kind must not contain more than 1500 + bytes when UTF-8 encoded. Cannot be ``""``. + id_type: + The type of ID. + id: + The auto-allocated ID of the entity. Never equal to zero. + Values less than zero are discouraged and may not be supported + in the future. + name: + The name of the entity. A name matching regex ``__.*__`` is + reserved/read-only. A name must not be more than 1500 bytes + when UTF-8 encoded. Cannot be ``""``. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Key.PathElement) + )) + , + DESCRIPTOR = _KEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """A unique identifier for a Datastore entity. If a key's partition ID or + any of its path kinds or names are reserved/read-only, the key is + reserved/read-only. A reserved/read-only key is forbidden in certain + documented contexts. + + + Attributes: + partition_id: + Entities are partitioned into subsets, currently identified by + a project ID and namespace ID. Queries are scoped to a single + partition. + path: + The entity path. An entity path consists of one or more + elements composed of a kind and a string or numerical + identifier, which identify entities. The first element + identifies a *root entity*, the second element identifies a + *child* of the root entity, the third element identifies a + child of the second entity, and so forth. The entities + identified by all prefixes of the path are called the + element's *ancestors*. A path can never be empty, and a path + can have at most 100 elements. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.Key) + )) +_sym_db.RegisterMessage(Key) +_sym_db.RegisterMessage(Key.PathElement) + +RecordKey = _reflection.GeneratedProtocolMessageType('RecordKey', (_message.Message,), dict( + DESCRIPTOR = _RECORDKEY, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Message for a unique key indicating a record that contains a finding. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.RecordKey) + )) +_sym_db.RegisterMessage(RecordKey) + +BigQueryTable = _reflection.GeneratedProtocolMessageType('BigQueryTable', (_message.Message,), dict( + DESCRIPTOR = _BIGQUERYTABLE, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """Message defining the location of a BigQuery table. A table is uniquely + identified by its project\_id, dataset\_id, and table\_name. Within a + query a table is often referenced with a string in the format of: + ``:.`` or + ``..``. + + + Attributes: + project_id: + The Google Cloud Platform project ID of the project containing + the table. If omitted, project ID is inferred from the API + call. + dataset_id: + Dataset ID of the table. + table_id: + Name of the table. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.BigQueryTable) + )) +_sym_db.RegisterMessage(BigQueryTable) + +EntityId = _reflection.GeneratedProtocolMessageType('EntityId', (_message.Message,), dict( + DESCRIPTOR = _ENTITYID, + __module__ = 'google.cloud.privacy.dlp_v2beta1.proto.storage_pb2' + , + __doc__ = """An entity in a dataset is a field or set of fields that correspond to a + single person. For example, in medical records the ``EntityId`` might be + a patient identifier, or for financial records it might be an account + identifier. This message is used when generalizations or analysis must + be consistent across multiple rows pertaining to the same entity. + + + Attributes: + field: + Composite key indicating which field contains the entity + identifier. + """, + # @@protoc_insertion_point(class_scope:google.privacy.dlp.v2beta1.EntityId) + )) +_sym_db.RegisterMessage(EntityId) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\036com.google.privacy.dlp.v2beta1B\nDlpStorageP\001Z=google.golang.org/genproto/googleapis/privacy/dlp/v2beta1;dlp\252\002\030Google.Cloud.Dlp.V2Beta1')) +try: + # THESE ELEMENTS WILL BE DEPRECATED. + # Please use the generated *_pb2_grpc.py files instead. + import grpc + from grpc.beta import implementations as beta_implementations + from grpc.beta import interfaces as beta_interfaces + from grpc.framework.common import cardinality + from grpc.framework.interfaces.face import utilities as face_utilities +except ImportError: + pass +# @@protoc_insertion_point(module_scope) diff --git a/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2_grpc.py b/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2_grpc.py new file mode 100644 index 000000000000..a89435267cb2 --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/proto/storage_pb2_grpc.py @@ -0,0 +1,3 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +import grpc + diff --git a/dlp/google/cloud/dlp_v2beta1/types.py b/dlp/google/cloud/dlp_v2beta1/types.py new file mode 100644 index 000000000000..5e6a65a555ee --- /dev/null +++ b/dlp/google/cloud/dlp_v2beta1/types.py @@ -0,0 +1,51 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +import sys + +from google.api_core.protobuf_helpers import get_messages + +from google.api import http_pb2 +from google.cloud.dlp_v2beta1.proto import dlp_pb2 +from google.cloud.dlp_v2beta1.proto import storage_pb2 +from google.longrunning import operations_pb2 +from google.protobuf import any_pb2 +from google.protobuf import descriptor_pb2 +from google.protobuf import empty_pb2 +from google.protobuf import timestamp_pb2 +from google.rpc import status_pb2 +from google.type import date_pb2 +from google.type import timeofday_pb2 + +names = [] +for module in ( + http_pb2, + dlp_pb2, + storage_pb2, + operations_pb2, + any_pb2, + descriptor_pb2, + empty_pb2, + timestamp_pb2, + status_pb2, + date_pb2, + timeofday_pb2, +): + for name, message in get_messages(module).items(): + message.__module__ = 'google.cloud.dlp_v2beta1.types' + setattr(sys.modules[__name__], name, message) + names.append(name) + +__all__ = tuple(sorted(names)) diff --git a/dlp/nox.py b/dlp/nox.py new file mode 100644 index 000000000000..7ee75eca7b1f --- /dev/null +++ b/dlp/nox.py @@ -0,0 +1,61 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +import os + +import nox + + +@nox.session +@nox.parametrize('python_version', ['2.7', '3.4', '3.5', '3.6']) +def unit_tests(session, python_version): + """Run the unit test suite.""" + + session.interpreter = 'python{}'.format(python_version) + + session.virtualenv_dirname = 'unit-' + python_version + + session.install('pytest') + session.install('-e', '.') + + session.run('py.test', '--quiet', os.path.join('tests', 'unit')) + + +@nox.session +@nox.parametrize('python_version', ['2.7', '3.6']) +def system_tests(session, python_version): + """Run the system test suite.""" + + if not os.environ.get('GOOGLE_APPLICATION_CREDENTIALS', ''): + session.skip('Credentials must be set via environment variable.') + + session.interpreter = 'python{}'.format(python_version) + + session.virtualenv_dirname = 'sys-' + python_version + + session.install('pytest') + session.install('-e', '.') + + session.run('py.test', '--quiet', os.path.join('tests', 'system'), + *session.posargs) + + +@nox.session +def lint_setup_py(session): + """Verify that setup.py is valid (including RST check).""" + session.interpreter = 'python3.6' + session.install('docutils', 'pygments') + session.run('python', 'setup.py', 'check', '--restructuredtext', + '--strict') diff --git a/dlp/setup.cfg b/dlp/setup.cfg new file mode 100644 index 000000000000..2a9acf13daa9 --- /dev/null +++ b/dlp/setup.cfg @@ -0,0 +1,2 @@ +[bdist_wheel] +universal = 1 diff --git a/dlp/setup.py b/dlp/setup.py new file mode 100644 index 000000000000..d371830d80ff --- /dev/null +++ b/dlp/setup.py @@ -0,0 +1,48 @@ +"""A setup module for the GAPIC DLP API library. + +See: +https://packaging.python.org/en/latest/distributing.html +https://github.com/pypa/sampleproject +""" + +from setuptools import setup, find_packages +import io +import sys + +install_requires = [ + 'google-api-core>=0.1.0, <0.2.0dev', + 'google-auth>=1.0.2, <2.0dev', + 'googleapis-common-protos[grpc]>=1.5.2, <2.0dev', + 'requests>=2.18.4, <3.0dev', +] + +with io.open('README.rst', 'r', encoding='utf-8') as readme_file: + long_description = readme_file.read() + +setup( + name='google-cloud-dlp', + version='0.15.4', + author='Google Inc', + author_email='googleapis-packages@google.com', + classifiers=[ + 'Intended Audience :: Developers', + 'Development Status :: 3 - Alpha', + 'Intended Audience :: Developers', + 'License :: OSI Approved :: Apache Software License', + 'Programming Language :: Python', + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.4', + 'Programming Language :: Python :: 3.5', + 'Programming Language :: Python :: 3.6', + 'Programming Language :: Python :: Implementation :: CPython', + ], + description='GAPIC library for the DLP API', + include_package_data=True, + long_description=long_description, + install_requires=install_requires, + license='Apache 2.0', + packages=find_packages(), + namespace_packages=['google', 'google.cloud'], + url='https://github.com/googleapis/googleapis') diff --git a/dlp/tests/system/gapic/v2beta1/test_system_dlp_service_v2beta1.py b/dlp/tests/system/gapic/v2beta1/test_system_dlp_service_v2beta1.py new file mode 100644 index 000000000000..1fd9a04d9fcb --- /dev/null +++ b/dlp/tests/system/gapic/v2beta1/test_system_dlp_service_v2beta1.py @@ -0,0 +1,32 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import time + +from google.cloud import dlp_v2beta1 +from google.cloud.dlp_v2beta1 import enums +from google.cloud.dlp_v2beta1.proto import dlp_pb2 + + +class TestSystemDlpService(object): + def test_inspect_content(self): + + client = dlp_v2beta1.DlpServiceClient() + min_likelihood = enums.Likelihood.POSSIBLE + inspect_config = {'min_likelihood': min_likelihood} + type_ = 'text/plain' + value = 'my phone number is 215-512-1212' + items_element = {'type': type_, 'value': value} + items = [items_element] + response = client.inspect_content(inspect_config, items) diff --git a/dlp/tests/unit/gapic/v2beta1/test_dlp_service_client_v2beta1.py b/dlp/tests/unit/gapic/v2beta1/test_dlp_service_client_v2beta1.py new file mode 100644 index 000000000000..24fed947d2a7 --- /dev/null +++ b/dlp/tests/unit/gapic/v2beta1/test_dlp_service_client_v2beta1.py @@ -0,0 +1,410 @@ +# Copyright 2017, Google LLC All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Unit tests.""" + +import pytest + +from google.rpc import status_pb2 + +from google.cloud import dlp_v2beta1 +from google.cloud.dlp_v2beta1.proto import dlp_pb2 +from google.cloud.dlp_v2beta1.proto import storage_pb2 +from google.longrunning import operations_pb2 + + +class MultiCallableStub(object): + """Stub for the grpc.UnaryUnaryMultiCallable interface.""" + + def __init__(self, method, channel_stub): + self.method = method + self.channel_stub = channel_stub + + def __call__(self, request, timeout=None, metadata=None, credentials=None): + self.channel_stub.requests.append((self.method, request)) + + response = None + if self.channel_stub.responses: + response = self.channel_stub.responses.pop() + + if isinstance(response, Exception): + raise response + + if response: + return response + + +class ChannelStub(object): + """Stub for the grpc.Channel interface.""" + + def __init__(self, responses=[]): + self.responses = responses + self.requests = [] + + def unary_unary(self, + method, + request_serializer=None, + response_deserializer=None): + return MultiCallableStub(method, self) + + +class CustomException(Exception): + pass + + +class TestDlpServiceClient(object): + def test_inspect_content(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.InspectContentResponse(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + response = client.inspect_content(inspect_config, items) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.InspectContentRequest( + inspect_config=inspect_config, items=items) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_inspect_content_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + with pytest.raises(CustomException): + client.inspect_content(inspect_config, items) + + def test_redact_content(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.RedactContentResponse(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + response = client.redact_content(inspect_config, items) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.RedactContentRequest( + inspect_config=inspect_config, items=items) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_redact_content_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + type_ = 'text/plain' + value = 'My email is example@example.com.' + items_element = {'type': type_, 'value': value} + items = [items_element] + + with pytest.raises(CustomException): + client.redact_content(inspect_config, items) + + def test_deidentify_content(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.DeidentifyContentResponse( + **expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + deidentify_config = {} + inspect_config = {} + items = [] + + response = client.deidentify_content(deidentify_config, inspect_config, + items) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.DeidentifyContentRequest( + deidentify_config=deidentify_config, + inspect_config=inspect_config, + items=items) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_deidentify_content_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + deidentify_config = {} + inspect_config = {} + items = [] + + with pytest.raises(CustomException): + client.deidentify_content(deidentify_config, inspect_config, items) + + def test_analyze_data_source_risk(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.RiskAnalysisOperationResult( + **expected_response) + operation = operations_pb2.Operation( + name='operations/test_analyze_data_source_risk', done=True) + operation.response.Pack(expected_response) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + privacy_metric = {} + source_table = {} + + response = client.analyze_data_source_risk(privacy_metric, + source_table) + result = response.result() + assert expected_response == result + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.AnalyzeDataSourceRiskRequest( + privacy_metric=privacy_metric, source_table=source_table) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_analyze_data_source_risk_exception(self): + # Setup Response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name='operations/test_analyze_data_source_risk_exception', + done=True) + operation.error.CopyFrom(error) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + privacy_metric = {} + source_table = {} + + response = client.analyze_data_source_risk(privacy_metric, + source_table) + exception = response.exception() + assert exception.errors[0] == error + + def test_create_inspect_operation(self): + # Setup Expected Response + name_2 = 'name2-1052831874' + expected_response = {'name': name_2} + expected_response = dlp_pb2.InspectOperationResult(**expected_response) + operation = operations_pb2.Operation( + name='operations/test_create_inspect_operation', done=True) + operation.response.Pack(expected_response) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + url = 'gs://example_bucket/example_file.png' + file_set = {'url': url} + cloud_storage_options = {'file_set': file_set} + storage_config = {'cloud_storage_options': cloud_storage_options} + output_config = {} + + response = client.create_inspect_operation( + inspect_config, storage_config, output_config) + result = response.result() + assert expected_response == result + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.CreateInspectOperationRequest( + inspect_config=inspect_config, + storage_config=storage_config, + output_config=output_config) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_create_inspect_operation_exception(self): + # Setup Response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name='operations/test_create_inspect_operation_exception', + done=True) + operation.error.CopyFrom(error) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + name = 'EMAIL_ADDRESS' + info_types_element = {'name': name} + info_types = [info_types_element] + inspect_config = {'info_types': info_types} + url = 'gs://example_bucket/example_file.png' + file_set = {'url': url} + cloud_storage_options = {'file_set': file_set} + storage_config = {'cloud_storage_options': cloud_storage_options} + output_config = {} + + response = client.create_inspect_operation( + inspect_config, storage_config, output_config) + exception = response.exception() + assert exception.errors[0] == error + + def test_list_inspect_findings(self): + # Setup Expected Response + next_page_token = 'nextPageToken-1530815211' + expected_response = {'next_page_token': next_page_token} + expected_response = dlp_pb2.ListInspectFindingsResponse( + **expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + name = client.result_path('[RESULT]') + + response = client.list_inspect_findings(name) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.ListInspectFindingsRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_list_inspect_findings_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + name = client.result_path('[RESULT]') + + with pytest.raises(CustomException): + client.list_inspect_findings(name) + + def test_list_info_types(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.ListInfoTypesResponse(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + category = 'PII' + language_code = 'en' + + response = client.list_info_types(category, language_code) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.ListInfoTypesRequest( + category=category, language_code=language_code) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_list_info_types_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + category = 'PII' + language_code = 'en' + + with pytest.raises(CustomException): + client.list_info_types(category, language_code) + + def test_list_root_categories(self): + # Setup Expected Response + expected_response = {} + expected_response = dlp_pb2.ListRootCategoriesResponse( + **expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup Request + language_code = 'en' + + response = client.list_root_categories(language_code) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = dlp_pb2.ListRootCategoriesRequest( + language_code=language_code) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_list_root_categories_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + client = dlp_v2beta1.DlpServiceClient(channel=channel) + + # Setup request + language_code = 'en' + + with pytest.raises(CustomException): + client.list_root_categories(language_code)