snowflake-connector-python 4.4.0__cp314-cp314-win_amd64.whl

snowflake/connector/util_text.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import base64
+import hashlib
+import logging
+import random
+import re
+import string
+from io import StringIO
+from pathlib import Path
+from typing import Any, Sequence
+
+COMMENT_PATTERN_RE = re.compile(r"^\s*\-\-")
+EMPTY_LINE_RE = re.compile(r"^\s*$")
+
+_logger = logging.getLogger(__name__)
+
+
+class SQLDelimiter:
+    """Class that wraps a SQL delimiter string.
+
+    Since split_statements is a generator this mutable object will allow it change while executing.
+    """
+
+    def __str__(self) -> str:
+        return self.sql_delimiter
+
+    def __init__(self, sql_delimiter: str = ";") -> None:
+        """Initializes SQLDelimiter with a string."""
+        self.sql_delimiter = sql_delimiter
+
+
+def split_statements(
+    buf: StringIO,
+    remove_comments: bool = False,
+    delimiter: SQLDelimiter | None = None,
+):
+    """Splits a stream into SQL statements (ends with a semicolon) or commands (!...).
+
+    Args:
+        buf: Unicode data stream.
+        remove_comments: Whether or not to remove all comments (Default value = False).
+        delimiter: The delimiter string that separates SQL commands from each other.
+
+    Yields:
+        A SQL statement or a command.
+    """
+    if delimiter is None:
+        delimiter = SQLDelimiter()  # Use default delimiter if none was given.
+    in_quote = False
+    ch_quote = None
+    in_comment = False
+    in_double_dollars = False
+    previous_delimiter = None
+
+    line = buf.readline()
+    if isinstance(line, bytes):
+        raise TypeError("Input data must not be binary type.")
+
+    statement = []
+    while line != "":
+        col = 0
+        col0 = 0
+        len_line = len(line)
+        sql_delimiter = delimiter.sql_delimiter
+        if not previous_delimiter or sql_delimiter != previous_delimiter:
+            # Only (re)compile new Regexes if they should be
+            escaped_delim = re.escape(sql_delimiter)
+            # Special characters possible in the sql delimiter are '_', '/' and ';'. If a delimiter does not end, or
+            # start with a special character then look for word separation with \b regex.
+            if re.match(r"\w", sql_delimiter[0]):
+                RE_START = re.compile(rf"^[^\w$]?{escaped_delim}")
+            else:
+                RE_START = re.compile(rf"^.?{escaped_delim}")
+            if re.match(r"\w", sql_delimiter[-1]):
+                RE_END = re.compile(rf"{escaped_delim}[^\w$]?$")
+            else:
+                RE_END = re.compile(rf"{escaped_delim}.?$")
+            previous_delimiter = sql_delimiter
+        while True:
+            if col >= len_line:
+                if col0 < col:
+                    if not in_comment and not in_quote and not in_double_dollars:
+                        statement.append((line[col0:col], True))
+                        if len(statement) == 1 and statement[0][0] == "":
+                            statement = []
+                        break
+                    elif not in_comment and (in_quote or in_double_dollars):
+                        statement.append((line[col0:col], True))
+                    elif not remove_comments:
+                        statement.append((line[col0:col], False))
+                break
+            elif in_comment:
+                if line[col:].startswith("*/"):
+                    in_comment = False
+                    if not remove_comments:
+                        statement.append((line[col0 : col + 2], False))
+                    col += 2
+                    col0 = col
+                else:
+                    col += 1
+            elif in_double_dollars:
+                if line[col:].startswith("$$"):
+                    in_double_dollars = False
+                    statement.append((line[col0 : col + 2], False))
+                    col += 2
+                    col0 = col
+                else:
+                    col += 1
+            elif in_quote:
+                if (
+                    line[col] == "\\"
+                    and col < len_line - 1
+                    and line[col + 1] in (ch_quote, "\\")
+                ):
+                    col += 2
+                elif line[col] == ch_quote:
+                    if (
+                        col < len_line - 1
+                        and line[col + 1] != ch_quote
+                        or col == len_line - 1
+                    ):
+                        # exits quote
+                        in_quote = False
+                        statement.append((line[col0 : col + 1], True))
+                        col += 1
+                        col0 = col
+                    else:
+                        # escaped quote and still in quote
+                        col += 2
+                else:
+                    col += 1
+            else:
+                if line[col] in ("'", '"'):
+                    in_quote = True
+                    ch_quote = line[col]
+                    col += 1
+                elif line[col] in (" ", "\t"):
+                    statement.append((line[col0 : col + 1], True))
+                    col += 1
+                    col0 = col
+                elif line[col:].startswith("--"):
+                    statement.append((line[col0:col], True))
+                    if not remove_comments:
+                        # keep the comment
+                        statement.append((line[col:], False))
+                    else:
+                        statement.append(("\n", True))
+                    col = len_line + 1
+                    col0 = col
+                elif line[col:].startswith("/*") and not line[col0:].startswith(
+                    "file://"
+                ):
+                    if not remove_comments:
+                        statement.append((line[col0 : col + 2], False))
+                    else:
+                        statement.append((line[col0:col], False))
+                    col += 2
+                    col0 = col
+                    in_comment = True
+                elif line[col:].startswith("$$"):
+                    statement.append((line[col0 : col + 2], True))
+                    col += 2
+                    col0 = col
+                    in_double_dollars = True
+                elif (
+                    RE_START.match(line[col - 1 : col + len(sql_delimiter)])
+                    if col > 0
+                    else (RE_START.match(line[col : col + len(sql_delimiter)]))
+                ) and (RE_END.match(line[col : col + len(sql_delimiter) + 1])):
+                    statement.append((line[col0:col] + ";", True))
+                    col += len(sql_delimiter)
+                    try:
+                        if line[col] == ">":
+                            col += 1
+                            statement[-1] = (statement[-1][0] + ">", statement[-1][1])
+                    except IndexError:
+                        pass
+                    if COMMENT_PATTERN_RE.match(line[col:]) or EMPTY_LINE_RE.match(
+                        line[col:]
+                    ):
+                        if not remove_comments:
+                            # keep the comment
+                            statement.append((line[col:], False))
+                        col = len_line
+                    while col < len_line and line[col] in (" ", "\t"):
+                        col += 1
+                    yield _concatenate_statements(statement)
+                    col0 = col
+                    statement = []
+                elif col == 0 and line[col] == "!":  # command
+                    if len(statement) > 0:
+                        yield _concatenate_statements(statement)
+                        statement = []
+                    yield (
+                        line.strip()[: -len(sql_delimiter)]
+                        if line.strip().endswith(sql_delimiter)
+                        else line.strip()
+                    ).strip(), False
+                    break
+                else:
+                    col += 1
+        line = buf.readline()
+
+    if len(statement) > 0:
+        yield _concatenate_statements(statement)
+
+
+def _concatenate_statements(
+    statement_list: list[tuple[str, bool]]
+) -> tuple[str, bool | None]:
+    """Concatenate statements.
+
+    Each statement should be a tuple of statement and is_put_or_get.
+
+    The is_put_or_get is set to True if the statement is PUT or GET otherwise False for valid statement.
+    None is set if the statement is empty or comment only.
+
+    Args:
+        statement_list: List of statement parts.
+
+    Returns:
+        Tuple of statements and whether they are PUT or GET.
+    """
+    valid_statement_list = []
+    is_put_or_get = None
+    for text, is_statement in statement_list:
+        valid_statement_list.append(text)
+        if is_put_or_get is None and is_statement and len(text.strip()) >= 3:
+            is_put_or_get = text[:3].upper() in ("PUT", "GET")
+    return "".join(valid_statement_list).strip(), is_put_or_get
+
+
+def construct_hostname(region: str | None, account: str) -> str:
+    """Constructs hostname from region and account."""
+
+    def _is_china_region(r: str) -> bool:
+        # This is consistent with the Go driver:
+        # https://github.com/snowflakedb/gosnowflake/blob/f20a46475dce322f3f6b97b4a72f2807571e750b/dsn.go#L535
+        return r.lower().startswith("cn-")
+
+    if region == "us-west-2":
+        region = ""
+    if region:
+        if account.find(".") > 0:
+            account = account[0 : account.find(".")]
+        top_level_domain = "cn" if _is_china_region(region) else "com"
+        host = f"{account}.{region}.snowflakecomputing.{top_level_domain}"
+    else:
+        top_level_domain = "com"
+        if account.find(".") > 0 and _is_china_region(account.split(".")[1]):
+            top_level_domain = "cn"
+        host = f"{account}.snowflakecomputing.{top_level_domain}"
+    return host
+
+
+def parse_account(account):
+    url_parts = account.split(".")
+    # if this condition is true, then we have some extra
+    # stuff in the account field.
+    if len(url_parts) > 1:
+        if url_parts[1] == "global":
+            # remove external ID from account
+            parsed_account = url_parts[0][0 : url_parts[0].rfind("-")]
+        else:
+            # remove region subdomain
+            parsed_account = url_parts[0]
+    else:
+        parsed_account = account
+
+    return parsed_account
+
+
+def random_string(
+    length: int = 10,
+    prefix: str = "",
+    suffix: str = "",
+    choices: Sequence[str] = string.ascii_lowercase,
+) -> str:
+    """Our convenience function to generate random string for object names.
+
+    Args:
+        length: How many random characters to choose from choices.
+        prefix: Prefix to add to random string generated.
+        suffix: Suffix to add to random string generated.
+        choices: A generator of things to choose from.
+    """
+    random_part = "".join([random.Random().choice(choices) for _ in range(length)])
+    return "".join([prefix, random_part, suffix])
+
+
+def _base64_bytes_to_str(x) -> str | None:
+    return base64.b64encode(x).decode("utf-8") if x else None
+
+
+def get_md5_for_integrity(text: str | bytes) -> bytes:
+    # MD5 should not be used for security reasons - only integrity is safe and allowed
+    if isinstance(text, str):
+        text = text.encode("utf-8")
+    # Usedforsecurity=False added to support FIPS envs as well
+    md5 = hashlib.md5(usedforsecurity=False)
+    md5.update(text)
+    return md5.digest()
+
+
+def expand_tilde(path_to_expand: Any) -> Any:
+    try:
+        path_to_expand = (
+            str(Path(path_to_expand).expanduser())
+            if isinstance(path_to_expand, str)
+            else path_to_expand
+        )
+    except Exception as e:
+        # user home could not be resolved
+        _logger.debug(
+            "User home could not be determined, not expanding tilde. Exception: %s", e
+        )
+
+    return path_to_expand

snowflake/connector/vendored/__init__.py

@@ -0,0 +1,3 @@
+#
+# Copyright (c) 2012-2021 Snowflake Computing Inc. All rights reserved.
+#

snowflake/connector/vendored/requests/LICENSE

@@ -0,0 +1,175 @@
+
+                                 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.

snowflake/connector/vendored/requests/__init__.py

@@ -0,0 +1,184 @@
+#   __
+#  /__)  _  _     _   _ _/   _
+# / (   (- (/ (/ (- _)  /  _)
+#          /
+
+"""
+Requests HTTP Library
+~~~~~~~~~~~~~~~~~~~~~
+
+Requests is an HTTP library, written in Python, for human beings.
+Basic GET usage:
+
+   >>> import requests
+   >>> r = requests.get('https://www.python.org')
+   >>> r.status_code
+   200
+   >>> b'Python is a programming language' in r.content
+   True
+
+... or POST:
+
+   >>> payload = dict(key1='value1', key2='value2')
+   >>> r = requests.post('https://httpbin.org/post', data=payload)
+   >>> print(r.text)
+   {
+     ...
+     "form": {
+       "key1": "value1",
+       "key2": "value2"
+     },
+     ...
+   }
+
+The other HTTP methods are supported - see `requests.api`. Full documentation
+is at <https://requests.readthedocs.io>.
+
+:copyright: (c) 2017 by Kenneth Reitz.
+:license: Apache 2.0, see LICENSE for more details.
+"""
+
+import warnings
+
+from .. import urllib3
+
+from .exceptions import RequestsDependencyWarning
+
+try:
+    from charset_normalizer import __version__ as charset_normalizer_version
+except ImportError:
+    charset_normalizer_version = None
+
+try:
+    from chardet import __version__ as chardet_version
+except ImportError:
+    chardet_version = None
+
+
+def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version):
+    urllib3_version = urllib3_version.split(".")
+    assert urllib3_version != ["dev"]  # Verify urllib3 isn't installed from git.
+
+    # Sometimes, urllib3 only reports its version as 16.1.
+    if len(urllib3_version) == 2:
+        urllib3_version.append("0")
+
+    # Check urllib3 for compatibility.
+    major, minor, patch = urllib3_version  # noqa: F811
+    major, minor, patch = int(major), int(minor), int(patch)
+    # urllib3 >= 1.21.1
+    assert major >= 1
+    if major == 1:
+        assert minor >= 21
+
+    # Check charset_normalizer for compatibility.
+    if chardet_version:
+        major, minor, patch = chardet_version.split(".")[:3]
+        major, minor, patch = int(major), int(minor), int(patch)
+        # chardet_version >= 3.0.2, < 6.0.0
+        assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0)
+    elif charset_normalizer_version:
+        major, minor, patch = charset_normalizer_version.split(".")[:3]
+        major, minor, patch = int(major), int(minor), int(patch)
+        # charset_normalizer >= 2.0.0 < 4.0.0
+        assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0)
+    else:
+        warnings.warn(
+            "Unable to find acceptable character detection dependency "
+            "(chardet or charset_normalizer).",
+            RequestsDependencyWarning,
+        )
+
+
+def _check_cryptography(cryptography_version):
+    # cryptography < 1.3.4
+    try:
+        cryptography_version = list(map(int, cryptography_version.split(".")))
+    except ValueError:
+        return
+
+    if cryptography_version < [1, 3, 4]:
+        warning = "Old version of cryptography ({}) may cause slowdown.".format(
+            cryptography_version
+        )
+        warnings.warn(warning, RequestsDependencyWarning)
+
+
+# Check imported dependencies for compatibility.
+try:
+    check_compatibility(
+        urllib3.__version__, chardet_version, charset_normalizer_version
+    )
+except (AssertionError, ValueError):
+    warnings.warn(
+        "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported "
+        "version!".format(
+            urllib3.__version__, chardet_version, charset_normalizer_version
+        ),
+        RequestsDependencyWarning,
+    )
+
+# Attempt to enable urllib3's fallback for SNI support
+# if the standard library doesn't support SNI or the
+# 'ssl' library isn't available.
+try:
+    try:
+        import ssl
+    except ImportError:
+        ssl = None
+
+    if not getattr(ssl, "HAS_SNI", False):
+        from ..urllib3.contrib import pyopenssl
+
+        pyopenssl.inject_into_urllib3()
+
+        # Check cryptography version
+        from cryptography import __version__ as cryptography_version
+
+        _check_cryptography(cryptography_version)
+except ImportError:
+    pass
+
+# urllib3's DependencyWarnings should be silenced.
+from ..urllib3.exceptions import DependencyWarning
+
+warnings.simplefilter("ignore", DependencyWarning)
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+from logging import NullHandler
+
+from . import packages, utils
+from .__version__ import (
+    __author__,
+    __author_email__,
+    __build__,
+    __cake__,
+    __copyright__,
+    __description__,
+    __license__,
+    __title__,
+    __url__,
+    __version__,
+)
+from .api import delete, get, head, options, patch, post, put, request
+from .exceptions import (
+    ConnectionError,
+    ConnectTimeout,
+    FileModeWarning,
+    HTTPError,
+    JSONDecodeError,
+    ReadTimeout,
+    RequestException,
+    Timeout,
+    TooManyRedirects,
+    URLRequired,
+)
+from .models import PreparedRequest, Request, Response
+from .sessions import Session, session
+from .status_codes import codes
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+# FileModeWarnings go off per the default.
+warnings.simplefilter("default", FileModeWarning, append=True)