[0-9]+(?:\.[0-9]+)*) # release segment
- (?P # pre-release
- [-_\.]?
- (?Palpha|a|beta|b|preview|pre|c|rc)
- [-_\.]?
- (?P[0-9]+)?
- )?
- (?P # post release
- (?:-(?P[0-9]+))
- |
- (?:
- [-_\.]?
- (?Ppost|rev|r)
- [-_\.]?
- (?P[0-9]+)?
- )
- )?
- (?P # dev release
- [-_\.]?
- (?Pdev)
- [-_\.]?
- (?P[0-9]+)?
- )?
- )
- (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
-"""
-
-VERSION_PATTERN = _VERSION_PATTERN
-"""
-A string containing the regular expression used to match a valid version.
-
-The pattern is not anchored at either end, and is intended for embedding in larger
-expressions (for example, matching a version number as part of a file name). The
-regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
-flags set.
-
-:meta hide-value:
-"""
-
-
-class Version(_BaseVersion):
- """This class abstracts handling of a project's versions.
-
- A :class:`Version` instance is comparison aware and can be compared and
- sorted using the standard Python interfaces.
-
- >>> v1 = Version("1.0a5")
- >>> v2 = Version("1.0")
- >>> v1
-
- >>> v2
-
- >>> v1 < v2
- True
- >>> v1 == v2
- False
- >>> v1 > v2
- False
- >>> v1 >= v2
- False
- >>> v1 <= v2
- True
- """
-
- _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
- _key: CmpKey
-
- def __init__(self, version: str) -> None:
- """Initialize a Version object.
-
- :param version:
- The string representation of a version which will be parsed and normalized
- before use.
- :raises InvalidVersion:
- If the ``version`` does not conform to PEP 440 in any way then this
- exception will be raised.
- """
-
- # Validate the version and parse it into pieces
- match = self._regex.search(version)
- if not match:
- raise InvalidVersion(f"Invalid version: {version!r}")
-
- # Store the parsed out pieces of the version
- self._version = _Version(
- epoch=int(match.group("epoch")) if match.group("epoch") else 0,
- release=tuple(int(i) for i in match.group("release").split(".")),
- pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
- post=_parse_letter_version(
- match.group("post_l"), match.group("post_n1") or match.group("post_n2")
- ),
- dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
- local=_parse_local_version(match.group("local")),
- )
-
- # Generate a key which will be used for sorting
- self._key = _cmpkey(
- self._version.epoch,
- self._version.release,
- self._version.pre,
- self._version.post,
- self._version.dev,
- self._version.local,
- )
-
- def __repr__(self) -> str:
- """A representation of the Version that shows all internal state.
-
- >>> Version('1.0.0')
-
- """
- return f""
-
- def __str__(self) -> str:
- """A string representation of the version that can be round-tripped.
-
- >>> str(Version("1.0a5"))
- '1.0a5'
- """
- parts = []
-
- # Epoch
- if self.epoch != 0:
- parts.append(f"{self.epoch}!")
-
- # Release segment
- parts.append(".".join(str(x) for x in self.release))
-
- # Pre-release
- if self.pre is not None:
- parts.append("".join(str(x) for x in self.pre))
-
- # Post-release
- if self.post is not None:
- parts.append(f".post{self.post}")
-
- # Development release
- if self.dev is not None:
- parts.append(f".dev{self.dev}")
-
- # Local version segment
- if self.local is not None:
- parts.append(f"+{self.local}")
-
- return "".join(parts)
-
- @property
- def epoch(self) -> int:
- """The epoch of the version.
-
- >>> Version("2.0.0").epoch
- 0
- >>> Version("1!2.0.0").epoch
- 1
- """
- return self._version.epoch
-
- @property
- def release(self) -> tuple[int, ...]:
- """The components of the "release" segment of the version.
-
- >>> Version("1.2.3").release
- (1, 2, 3)
- >>> Version("2.0.0").release
- (2, 0, 0)
- >>> Version("1!2.0.0.post0").release
- (2, 0, 0)
-
- Includes trailing zeroes but not the epoch or any pre-release / development /
- post-release suffixes.
- """
- return self._version.release
-
- @property
- def pre(self) -> tuple[str, int] | None:
- """The pre-release segment of the version.
-
- >>> print(Version("1.2.3").pre)
- None
- >>> Version("1.2.3a1").pre
- ('a', 1)
- >>> Version("1.2.3b1").pre
- ('b', 1)
- >>> Version("1.2.3rc1").pre
- ('rc', 1)
- """
- return self._version.pre
-
- @property
- def post(self) -> int | None:
- """The post-release number of the version.
-
- >>> print(Version("1.2.3").post)
- None
- >>> Version("1.2.3.post1").post
- 1
- """
- return self._version.post[1] if self._version.post else None
-
- @property
- def dev(self) -> int | None:
- """The development number of the version.
-
- >>> print(Version("1.2.3").dev)
- None
- >>> Version("1.2.3.dev1").dev
- 1
- """
- return self._version.dev[1] if self._version.dev else None
-
- @property
- def local(self) -> str | None:
- """The local version segment of the version.
-
- >>> print(Version("1.2.3").local)
- None
- >>> Version("1.2.3+abc").local
- 'abc'
- """
- if self._version.local:
- return ".".join(str(x) for x in self._version.local)
- else:
- return None
-
- @property
- def public(self) -> str:
- """The public portion of the version.
-
- >>> Version("1.2.3").public
- '1.2.3'
- >>> Version("1.2.3+abc").public
- '1.2.3'
- >>> Version("1!1.2.3dev1+abc").public
- '1!1.2.3.dev1'
- """
- return str(self).split("+", 1)[0]
-
- @property
- def base_version(self) -> str:
- """The "base version" of the version.
-
- >>> Version("1.2.3").base_version
- '1.2.3'
- >>> Version("1.2.3+abc").base_version
- '1.2.3'
- >>> Version("1!1.2.3dev1+abc").base_version
- '1!1.2.3'
-
- The "base version" is the public version of the project without any pre or post
- release markers.
- """
- parts = []
-
- # Epoch
- if self.epoch != 0:
- parts.append(f"{self.epoch}!")
-
- # Release segment
- parts.append(".".join(str(x) for x in self.release))
-
- return "".join(parts)
-
- @property
- def is_prerelease(self) -> bool:
- """Whether this version is a pre-release.
-
- >>> Version("1.2.3").is_prerelease
- False
- >>> Version("1.2.3a1").is_prerelease
- True
- >>> Version("1.2.3b1").is_prerelease
- True
- >>> Version("1.2.3rc1").is_prerelease
- True
- >>> Version("1.2.3dev1").is_prerelease
- True
- """
- return self.dev is not None or self.pre is not None
-
- @property
- def is_postrelease(self) -> bool:
- """Whether this version is a post-release.
-
- >>> Version("1.2.3").is_postrelease
- False
- >>> Version("1.2.3.post1").is_postrelease
- True
- """
- return self.post is not None
-
- @property
- def is_devrelease(self) -> bool:
- """Whether this version is a development release.
-
- >>> Version("1.2.3").is_devrelease
- False
- >>> Version("1.2.3.dev1").is_devrelease
- True
- """
- return self.dev is not None
-
- @property
- def major(self) -> int:
- """The first item of :attr:`release` or ``0`` if unavailable.
-
- >>> Version("1.2.3").major
- 1
- """
- return self.release[0] if len(self.release) >= 1 else 0
-
- @property
- def minor(self) -> int:
- """The second item of :attr:`release` or ``0`` if unavailable.
-
- >>> Version("1.2.3").minor
- 2
- >>> Version("1").minor
- 0
- """
- return self.release[1] if len(self.release) >= 2 else 0
-
- @property
- def micro(self) -> int:
- """The third item of :attr:`release` or ``0`` if unavailable.
-
- >>> Version("1.2.3").micro
- 3
- >>> Version("1").micro
- 0
- """
- return self.release[2] if len(self.release) >= 3 else 0
-
-
-class _TrimmedRelease(Version):
- @property
- def release(self) -> tuple[int, ...]:
- """
- Release segment without any trailing zeros.
-
- >>> _TrimmedRelease('1.0.0').release
- (1,)
- >>> _TrimmedRelease('0.0').release
- (0,)
- """
- rel = super().release
- nonzeros = (index for index, val in enumerate(rel) if val)
- last_nonzero = max(nonzeros, default=0)
- return rel[: last_nonzero + 1]
-
-
-def _parse_letter_version(
- letter: str | None, number: str | bytes | SupportsInt | None
-) -> tuple[str, int] | None:
- if letter:
- # We consider there to be an implicit 0 in a pre-release if there is
- # not a numeral associated with it.
- if number is None:
- number = 0
-
- # We normalize any letters to their lower case form
- letter = letter.lower()
-
- # We consider some words to be alternate spellings of other words and
- # in those cases we want to normalize the spellings to our preferred
- # spelling.
- if letter == "alpha":
- letter = "a"
- elif letter == "beta":
- letter = "b"
- elif letter in ["c", "pre", "preview"]:
- letter = "rc"
- elif letter in ["rev", "r"]:
- letter = "post"
-
- return letter, int(number)
-
- assert not letter
- if number:
- # We assume if we are given a number, but we are not given a letter
- # then this is using the implicit post release syntax (e.g. 1.0-1)
- letter = "post"
-
- return letter, int(number)
-
- return None
-
-
-_local_version_separators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local: str | None) -> LocalType | None:
- """
- Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
- """
- if local is not None:
- return tuple(
- part.lower() if not part.isdigit() else int(part)
- for part in _local_version_separators.split(local)
- )
- return None
-
-
-def _cmpkey(
- epoch: int,
- release: tuple[int, ...],
- pre: tuple[str, int] | None,
- post: tuple[str, int] | None,
- dev: tuple[str, int] | None,
- local: LocalType | None,
-) -> CmpKey:
- # When we compare a release version, we want to compare it with all of the
- # trailing zeros removed. So we'll use a reverse the list, drop all the now
- # leading zeros until we come to something non zero, then take the rest
- # re-reverse it back into the correct order and make it a tuple and use
- # that for our sorting key.
- _release = tuple(
- reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
- )
-
- # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
- # We'll do this by abusing the pre segment, but we _only_ want to do this
- # if there is not a pre or a post segment. If we have one of those then
- # the normal sorting rules will handle this case correctly.
- if pre is None and post is None and dev is not None:
- _pre: CmpPrePostDevType = NegativeInfinity
- # Versions without a pre-release (except as noted above) should sort after
- # those with one.
- elif pre is None:
- _pre = Infinity
- else:
- _pre = pre
-
- # Versions without a post segment should sort before those with one.
- if post is None:
- _post: CmpPrePostDevType = NegativeInfinity
-
- else:
- _post = post
-
- # Versions without a development segment should sort after those with one.
- if dev is None:
- _dev: CmpPrePostDevType = Infinity
-
- else:
- _dev = dev
-
- if local is None:
- # Versions without a local segment should sort before those with one.
- _local: CmpLocalType = NegativeInfinity
- else:
- # Versions with a local segment need that segment parsed to implement
- # the sorting rules in PEP440.
- # - Alpha numeric segments sort before numeric segments
- # - Alpha numeric segments sort lexicographically
- # - Numeric segments sort numerically
- # - Shorter versions sort before longer versions when the prefixes
- # match exactly
- _local = tuple(
- (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
- )
-
- return epoch, _release, _pre, _post, _dev, _local
diff --git a/lib/requests-2.31.0.dist-info/INSTALLER b/lib/requests-2.31.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e..0000000
--- a/lib/requests-2.31.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/lib/requests-2.31.0.dist-info/LICENSE b/lib/requests-2.31.0.dist-info/LICENSE
deleted file mode 100644
index 67db858..0000000
--- a/lib/requests-2.31.0.dist-info/LICENSE
+++ /dev/null
@@ -1,175 +0,0 @@
-
- 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.
diff --git a/lib/requests-2.31.0.dist-info/METADATA b/lib/requests-2.31.0.dist-info/METADATA
deleted file mode 100644
index 05779fa..0000000
--- a/lib/requests-2.31.0.dist-info/METADATA
+++ /dev/null
@@ -1,122 +0,0 @@
-Metadata-Version: 2.1
-Name: requests
-Version: 2.31.0
-Summary: Python HTTP for Humans.
-Home-page: https://requests.readthedocs.io
-Author: Kenneth Reitz
-Author-email: me@kennethreitz.org
-License: Apache 2.0
-Project-URL: Documentation, https://requests.readthedocs.io
-Project-URL: Source, https://github.com/psf/requests
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: charset-normalizer (<4,>=2)
-Requires-Dist: idna (<4,>=2.5)
-Requires-Dist: urllib3 (<3,>=1.21.1)
-Requires-Dist: certifi (>=2017.4.17)
-Provides-Extra: security
-Provides-Extra: socks
-Requires-Dist: PySocks (!=1.5.7,>=1.5.6) ; extra == 'socks'
-Provides-Extra: use_chardet_on_py3
-Requires-Dist: chardet (<6,>=3.0.2) ; extra == 'use_chardet_on_py3'
-
-# Requests
-
-**Requests** is a simple, yet elegant, HTTP library.
-
-```python
->>> import requests
->>> r = requests.get('https://httpbin.org/basic-auth/user/pass', auth=('user', 'pass'))
->>> r.status_code
-200
->>> r.headers['content-type']
-'application/json; charset=utf8'
->>> r.encoding
-'utf-8'
->>> r.text
-'{"authenticated": true, ...'
->>> r.json()
-{'authenticated': True, ...}
-```
-
-Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your `PUT` & `POST` data — but nowadays, just use the `json` method!
-
-Requests is one of the most downloaded Python packages today, pulling in around `30M downloads / week`— according to GitHub, Requests is currently [depended upon](https://github.com/psf/requests/network/dependents?package_id=UGFja2FnZS01NzA4OTExNg%3D%3D) by `1,000,000+` repositories. You may certainly put your trust in this code.
-
-[](https://pepy.tech/project/requests)
-[](https://pypi.org/project/requests)
-[](https://github.com/psf/requests/graphs/contributors)
-
-## Installing Requests and Supported Versions
-
-Requests is available on PyPI:
-
-```console
-$ python -m pip install requests
-```
-
-Requests officially supports Python 3.7+.
-
-## Supported Features & Best–Practices
-
-Requests is ready for the demands of building robust and reliable HTTP–speaking applications, for the needs of today.
-
-- Keep-Alive & Connection Pooling
-- International Domains and URLs
-- Sessions with Cookie Persistence
-- Browser-style TLS/SSL Verification
-- Basic & Digest Authentication
-- Familiar `dict`–like Cookies
-- Automatic Content Decompression and Decoding
-- Multi-part File Uploads
-- SOCKS Proxy Support
-- Connection Timeouts
-- Streaming Downloads
-- Automatic honoring of `.netrc`
-- Chunked HTTP Requests
-
-## API Reference and User Guide available on [Read the Docs](https://requests.readthedocs.io)
-
-[](https://requests.readthedocs.io)
-
-## Cloning the repository
-
-When cloning the Requests repository, you may need to add the `-c
-fetch.fsck.badTimezone=ignore` flag to avoid an error about a bad commit (see
-[this issue](https://github.com/psf/requests/issues/2690) for more background):
-
-```shell
-git clone -c fetch.fsck.badTimezone=ignore https://github.com/psf/requests.git
-```
-
-You can also apply this setting to your global Git config:
-
-```shell
-git config --global fetch.fsck.badTimezone ignore
-```
-
----
-
-[](https://kennethreitz.org) [](https://www.python.org/psf)
-
-
diff --git a/lib/requests-2.31.0.dist-info/RECORD b/lib/requests-2.31.0.dist-info/RECORD
deleted file mode 100644
index a96cfad..0000000
--- a/lib/requests-2.31.0.dist-info/RECORD
+++ /dev/null
@@ -1,43 +0,0 @@
-requests-2.31.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-requests-2.31.0.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-requests-2.31.0.dist-info/METADATA,sha256=eCPokOnbb0FROLrfl0R5EpDvdufsb9CaN4noJH__54I,4634
-requests-2.31.0.dist-info/RECORD,,
-requests-2.31.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-requests-2.31.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-requests-2.31.0.dist-info/top_level.txt,sha256=fMSVmHfb5rbGOo6xv-O_tUX6j-WyixssE-SnwcDRxNQ,9
-requests/__init__.py,sha256=LvmKhjIz8mHaKXthC2Mv5ykZ1d92voyf3oJpd-VuAig,4963
-requests/__pycache__/__init__.cpython-38.pyc,,
-requests/__pycache__/__version__.cpython-38.pyc,,
-requests/__pycache__/_internal_utils.cpython-38.pyc,,
-requests/__pycache__/adapters.cpython-38.pyc,,
-requests/__pycache__/api.cpython-38.pyc,,
-requests/__pycache__/auth.cpython-38.pyc,,
-requests/__pycache__/certs.cpython-38.pyc,,
-requests/__pycache__/compat.cpython-38.pyc,,
-requests/__pycache__/cookies.cpython-38.pyc,,
-requests/__pycache__/exceptions.cpython-38.pyc,,
-requests/__pycache__/help.cpython-38.pyc,,
-requests/__pycache__/hooks.cpython-38.pyc,,
-requests/__pycache__/models.cpython-38.pyc,,
-requests/__pycache__/packages.cpython-38.pyc,,
-requests/__pycache__/sessions.cpython-38.pyc,,
-requests/__pycache__/status_codes.cpython-38.pyc,,
-requests/__pycache__/structures.cpython-38.pyc,,
-requests/__pycache__/utils.cpython-38.pyc,,
-requests/__version__.py,sha256=ssI3Ezt7PaxgkOW45GhtwPUclo_SO_ygtIm4A74IOfw,435
-requests/_internal_utils.py,sha256=nMQymr4hs32TqVo5AbCrmcJEhvPUh7xXlluyqwslLiQ,1495
-requests/adapters.py,sha256=v_FmjU5KZ76k-YttShZYB5RprIzhhL8Y3zgW9p4eBQ8,19553
-requests/api.py,sha256=q61xcXq4tmiImrvcSVLTbFyCiD2F-L_-hWKGbz4y8vg,6449
-requests/auth.py,sha256=h-HLlVx9j8rKV5hfSAycP2ApOSglTz77R0tz7qCbbEE,10187
-requests/certs.py,sha256=Z9Sb410Anv6jUFTyss0jFFhU6xst8ctELqfy8Ev23gw,429
-requests/compat.py,sha256=yxntVOSEHGMrn7FNr_32EEam1ZNAdPRdSE13_yaHzTk,1451
-requests/cookies.py,sha256=kD3kNEcCj-mxbtf5fJsSaT86eGoEYpD3X0CSgpzl7BM,18560
-requests/exceptions.py,sha256=DhveFBclVjTRxhRduVpO-GbMYMID2gmjdLfNEqNpI_U,3811
-requests/help.py,sha256=gPX5d_H7Xd88aDABejhqGgl9B1VFRTt5BmiYvL3PzIQ,3875
-requests/hooks.py,sha256=CiuysiHA39V5UfcCBXFIx83IrDpuwfN9RcTUgv28ftQ,733
-requests/models.py,sha256=-DlKi0or8gFAM6VzutobXvvBW_2wrJuOF5NfndTIddA,35223
-requests/packages.py,sha256=DXgv-FJIczZITmv0vEBAhWj4W-5CGCIN_ksvgR17Dvs,957
-requests/sessions.py,sha256=-LvTzrPtetSTrR3buxu4XhdgMrJFLB1q5D7P--L2Xhw,30373
-requests/status_codes.py,sha256=FvHmT5uH-_uimtRz5hH9VCbt7VV-Nei2J9upbej6j8g,4235
-requests/structures.py,sha256=-IbmhVz06S-5aPSZuUthZ6-6D9XOjRuTXHOabY041XM,2912
-requests/utils.py,sha256=6sx2X3cIVA8BgWOg8odxFy-_lbWDFETU8HI4fU4Rmqw,33448
diff --git a/lib/requests-2.31.0.dist-info/REQUESTED b/lib/requests-2.31.0.dist-info/REQUESTED
deleted file mode 100644
index e69de29..0000000
diff --git a/lib/requests-2.31.0.dist-info/WHEEL b/lib/requests-2.31.0.dist-info/WHEEL
deleted file mode 100644
index 1f37c02..0000000
--- a/lib/requests-2.31.0.dist-info/WHEEL
+++ /dev/null
@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-
diff --git a/lib/requests-2.31.0.dist-info/top_level.txt b/lib/requests-2.31.0.dist-info/top_level.txt
deleted file mode 100644
index f229360..0000000
--- a/lib/requests-2.31.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-requests
diff --git a/lib/requests/__init__.py b/lib/requests/__init__.py
deleted file mode 100644
index 300a16c..0000000
--- a/lib/requests/__init__.py
+++ /dev/null
@@ -1,180 +0,0 @@
-# __
-# /__) _ _ _ _ _/ _
-# / ( (- (/ (/ (- _) / _)
-# /
-
-"""
-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 .
-
-:copyright: (c) 2017 by Kenneth Reitz.
-:license: Apache 2.0, see LICENSE for more details.
-"""
-
-import warnings
-
-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:
- raise Exception("You need either charset_normalizer or chardet installed")
-
-
-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)
diff --git a/lib/requests/__version__.py b/lib/requests/__version__.py
deleted file mode 100644
index 5063c3f..0000000
--- a/lib/requests/__version__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# .-. .-. .-. . . .-. .-. .-. .-.
-# |( |- |.| | | |- `-. | `-.
-# ' ' `-' `-`.`-' `-' `-' ' `-'
-
-__title__ = "requests"
-__description__ = "Python HTTP for Humans."
-__url__ = "https://requests.readthedocs.io"
-__version__ = "2.31.0"
-__build__ = 0x023100
-__author__ = "Kenneth Reitz"
-__author_email__ = "me@kennethreitz.org"
-__license__ = "Apache 2.0"
-__copyright__ = "Copyright Kenneth Reitz"
-__cake__ = "\u2728 \U0001f370 \u2728"
diff --git a/lib/requests/_internal_utils.py b/lib/requests/_internal_utils.py
deleted file mode 100644
index f2cf635..0000000
--- a/lib/requests/_internal_utils.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-requests._internal_utils
-~~~~~~~~~~~~~~
-
-Provides utility functions that are consumed internally by Requests
-which depend on extremely few external helpers (such as compat)
-"""
-import re
-
-from .compat import builtin_str
-
-_VALID_HEADER_NAME_RE_BYTE = re.compile(rb"^[^:\s][^:\r\n]*$")
-_VALID_HEADER_NAME_RE_STR = re.compile(r"^[^:\s][^:\r\n]*$")
-_VALID_HEADER_VALUE_RE_BYTE = re.compile(rb"^\S[^\r\n]*$|^$")
-_VALID_HEADER_VALUE_RE_STR = re.compile(r"^\S[^\r\n]*$|^$")
-
-_HEADER_VALIDATORS_STR = (_VALID_HEADER_NAME_RE_STR, _VALID_HEADER_VALUE_RE_STR)
-_HEADER_VALIDATORS_BYTE = (_VALID_HEADER_NAME_RE_BYTE, _VALID_HEADER_VALUE_RE_BYTE)
-HEADER_VALIDATORS = {
- bytes: _HEADER_VALIDATORS_BYTE,
- str: _HEADER_VALIDATORS_STR,
-}
-
-
-def to_native_string(string, encoding="ascii"):
- """Given a string object, regardless of type, returns a representation of
- that string in the native string type, encoding and decoding where
- necessary. This assumes ASCII unless told otherwise.
- """
- if isinstance(string, builtin_str):
- out = string
- else:
- out = string.decode(encoding)
-
- return out
-
-
-def unicode_is_ascii(u_string):
- """Determine if unicode string only contains ASCII characters.
-
- :param str u_string: unicode string to check. Must be unicode
- and not Python 2 `str`.
- :rtype: bool
- """
- assert isinstance(u_string, str)
- try:
- u_string.encode("ascii")
- return True
- except UnicodeEncodeError:
- return False
diff --git a/lib/requests/adapters.py b/lib/requests/adapters.py
deleted file mode 100644
index 78e3bb6..0000000
--- a/lib/requests/adapters.py
+++ /dev/null
@@ -1,538 +0,0 @@
-"""
-requests.adapters
-~~~~~~~~~~~~~~~~~
-
-This module contains the transport adapters that Requests uses to define
-and maintain connections.
-"""
-
-import os.path
-import socket # noqa: F401
-
-from urllib3.exceptions import ClosedPoolError, ConnectTimeoutError
-from urllib3.exceptions import HTTPError as _HTTPError
-from urllib3.exceptions import InvalidHeader as _InvalidHeader
-from urllib3.exceptions import (
- LocationValueError,
- MaxRetryError,
- NewConnectionError,
- ProtocolError,
-)
-from urllib3.exceptions import ProxyError as _ProxyError
-from urllib3.exceptions import ReadTimeoutError, ResponseError
-from urllib3.exceptions import SSLError as _SSLError
-from urllib3.poolmanager import PoolManager, proxy_from_url
-from urllib3.util import Timeout as TimeoutSauce
-from urllib3.util import parse_url
-from urllib3.util.retry import Retry
-
-from .auth import _basic_auth_str
-from .compat import basestring, urlparse
-from .cookies import extract_cookies_to_jar
-from .exceptions import (
- ConnectionError,
- ConnectTimeout,
- InvalidHeader,
- InvalidProxyURL,
- InvalidSchema,
- InvalidURL,
- ProxyError,
- ReadTimeout,
- RetryError,
- SSLError,
-)
-from .models import Response
-from .structures import CaseInsensitiveDict
-from .utils import (
- DEFAULT_CA_BUNDLE_PATH,
- extract_zipped_paths,
- get_auth_from_url,
- get_encoding_from_headers,
- prepend_scheme_if_needed,
- select_proxy,
- urldefragauth,
-)
-
-try:
- from urllib3.contrib.socks import SOCKSProxyManager
-except ImportError:
-
- def SOCKSProxyManager(*args, **kwargs):
- raise InvalidSchema("Missing dependencies for SOCKS support.")
-
-
-DEFAULT_POOLBLOCK = False
-DEFAULT_POOLSIZE = 10
-DEFAULT_RETRIES = 0
-DEFAULT_POOL_TIMEOUT = None
-
-
-class BaseAdapter:
- """The Base Transport Adapter"""
-
- def __init__(self):
- super().__init__()
-
- def send(
- self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
- ):
- """Sends PreparedRequest object. Returns Response object.
-
- :param request: The :class:`PreparedRequest ` being sent.
- :param stream: (optional) Whether to stream the request content.
- :param timeout: (optional) How long to wait for the server to send
- data before giving up, as a float, or a :ref:`(connect timeout,
- read timeout) ` tuple.
- :type timeout: float or tuple
- :param verify: (optional) Either a boolean, in which case it controls whether we verify
- the server's TLS certificate, or a string, in which case it must be a path
- to a CA bundle to use
- :param cert: (optional) Any user-provided SSL certificate to be trusted.
- :param proxies: (optional) The proxies dictionary to apply to the request.
- """
- raise NotImplementedError
-
- def close(self):
- """Cleans up adapter specific items."""
- raise NotImplementedError
-
-
-class HTTPAdapter(BaseAdapter):
- """The built-in HTTP Adapter for urllib3.
-
- Provides a general-case interface for Requests sessions to contact HTTP and
- HTTPS urls by implementing the Transport Adapter interface. This class will
- usually be created by the :class:`Session ` class under the
- covers.
-
- :param pool_connections: The number of urllib3 connection pools to cache.
- :param pool_maxsize: The maximum number of connections to save in the pool.
- :param max_retries: The maximum number of retries each connection
- should attempt. Note, this applies only to failed DNS lookups, socket
- connections and connection timeouts, never to requests where data has
- made it to the server. By default, Requests does not retry failed
- connections. If you need granular control over the conditions under
- which we retry a request, import urllib3's ``Retry`` class and pass
- that instead.
- :param pool_block: Whether the connection pool should block for connections.
-
- Usage::
-
- >>> import requests
- >>> s = requests.Session()
- >>> a = requests.adapters.HTTPAdapter(max_retries=3)
- >>> s.mount('http://', a)
- """
-
- __attrs__ = [
- "max_retries",
- "config",
- "_pool_connections",
- "_pool_maxsize",
- "_pool_block",
- ]
-
- def __init__(
- self,
- pool_connections=DEFAULT_POOLSIZE,
- pool_maxsize=DEFAULT_POOLSIZE,
- max_retries=DEFAULT_RETRIES,
- pool_block=DEFAULT_POOLBLOCK,
- ):
- if max_retries == DEFAULT_RETRIES:
- self.max_retries = Retry(0, read=False)
- else:
- self.max_retries = Retry.from_int(max_retries)
- self.config = {}
- self.proxy_manager = {}
-
- super().__init__()
-
- self._pool_connections = pool_connections
- self._pool_maxsize = pool_maxsize
- self._pool_block = pool_block
-
- self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
-
- def __getstate__(self):
- return {attr: getattr(self, attr, None) for attr in self.__attrs__}
-
- def __setstate__(self, state):
- # Can't handle by adding 'proxy_manager' to self.__attrs__ because
- # self.poolmanager uses a lambda function, which isn't pickleable.
- self.proxy_manager = {}
- self.config = {}
-
- for attr, value in state.items():
- setattr(self, attr, value)
-
- self.init_poolmanager(
- self._pool_connections, self._pool_maxsize, block=self._pool_block
- )
-
- def init_poolmanager(
- self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs
- ):
- """Initializes a urllib3 PoolManager.
-
- This method should not be called from user code, and is only
- exposed for use when subclassing the
- :class:`HTTPAdapter `.
-
- :param connections: The number of urllib3 connection pools to cache.
- :param maxsize: The maximum number of connections to save in the pool.
- :param block: Block when no free connections are available.
- :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
- """
- # save these values for pickling
- self._pool_connections = connections
- self._pool_maxsize = maxsize
- self._pool_block = block
-
- self.poolmanager = PoolManager(
- num_pools=connections,
- maxsize=maxsize,
- block=block,
- **pool_kwargs,
- )
-
- def proxy_manager_for(self, proxy, **proxy_kwargs):
- """Return urllib3 ProxyManager for the given proxy.
-
- This method should not be called from user code, and is only
- exposed for use when subclassing the
- :class:`HTTPAdapter `.
-
- :param proxy: The proxy to return a urllib3 ProxyManager for.
- :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
- :returns: ProxyManager
- :rtype: urllib3.ProxyManager
- """
- if proxy in self.proxy_manager:
- manager = self.proxy_manager[proxy]
- elif proxy.lower().startswith("socks"):
- username, password = get_auth_from_url(proxy)
- manager = self.proxy_manager[proxy] = SOCKSProxyManager(
- proxy,
- username=username,
- password=password,
- num_pools=self._pool_connections,
- maxsize=self._pool_maxsize,
- block=self._pool_block,
- **proxy_kwargs,
- )
- else:
- proxy_headers = self.proxy_headers(proxy)
- manager = self.proxy_manager[proxy] = proxy_from_url(
- proxy,
- proxy_headers=proxy_headers,
- num_pools=self._pool_connections,
- maxsize=self._pool_maxsize,
- block=self._pool_block,
- **proxy_kwargs,
- )
-
- return manager
-
- def cert_verify(self, conn, url, verify, cert):
- """Verify a SSL certificate. This method should not be called from user
- code, and is only exposed for use when subclassing the
- :class:`HTTPAdapter `.
-
- :param conn: The urllib3 connection object associated with the cert.
- :param url: The requested URL.
- :param verify: Either a boolean, in which case it controls whether we verify
- the server's TLS certificate, or a string, in which case it must be a path
- to a CA bundle to use
- :param cert: The SSL certificate to verify.
- """
- if url.lower().startswith("https") and verify:
-
- cert_loc = None
-
- # Allow self-specified cert location.
- if verify is not True:
- cert_loc = verify
-
- if not cert_loc:
- cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
-
- if not cert_loc or not os.path.exists(cert_loc):
- raise OSError(
- f"Could not find a suitable TLS CA certificate bundle, "
- f"invalid path: {cert_loc}"
- )
-
- conn.cert_reqs = "CERT_REQUIRED"
-
- if not os.path.isdir(cert_loc):
- conn.ca_certs = cert_loc
- else:
- conn.ca_cert_dir = cert_loc
- else:
- conn.cert_reqs = "CERT_NONE"
- conn.ca_certs = None
- conn.ca_cert_dir = None
-
- if cert:
- if not isinstance(cert, basestring):
- conn.cert_file = cert[0]
- conn.key_file = cert[1]
- else:
- conn.cert_file = cert
- conn.key_file = None
- if conn.cert_file and not os.path.exists(conn.cert_file):
- raise OSError(
- f"Could not find the TLS certificate file, "
- f"invalid path: {conn.cert_file}"
- )
- if conn.key_file and not os.path.exists(conn.key_file):
- raise OSError(
- f"Could not find the TLS key file, invalid path: {conn.key_file}"
- )
-
- def build_response(self, req, resp):
- """Builds a :class:`Response ` object from a urllib3
- response. This should not be called from user code, and is only exposed
- for use when subclassing the
- :class:`HTTPAdapter `
-
- :param req: The :class:`PreparedRequest ` used to generate the response.
- :param resp: The urllib3 response object.
- :rtype: requests.Response
- """
- response = Response()
-
- # Fallback to None if there's no status_code, for whatever reason.
- response.status_code = getattr(resp, "status", None)
-
- # Make headers case-insensitive.
- response.headers = CaseInsensitiveDict(getattr(resp, "headers", {}))
-
- # Set encoding.
- response.encoding = get_encoding_from_headers(response.headers)
- response.raw = resp
- response.reason = response.raw.reason
-
- if isinstance(req.url, bytes):
- response.url = req.url.decode("utf-8")
- else:
- response.url = req.url
-
- # Add new cookies from the server.
- extract_cookies_to_jar(response.cookies, req, resp)
-
- # Give the Response some context.
- response.request = req
- response.connection = self
-
- return response
-
- def get_connection(self, url, proxies=None):
- """Returns a urllib3 connection for the given URL. This should not be
- called from user code, and is only exposed for use when subclassing the
- :class:`HTTPAdapter `.
-
- :param url: The URL to connect to.
- :param proxies: (optional) A Requests-style dictionary of proxies used on this request.
- :rtype: urllib3.ConnectionPool
- """
- proxy = select_proxy(url, proxies)
-
- if proxy:
- proxy = prepend_scheme_if_needed(proxy, "http")
- proxy_url = parse_url(proxy)
- if not proxy_url.host:
- raise InvalidProxyURL(
- "Please check proxy URL. It is malformed "
- "and could be missing the host."
- )
- proxy_manager = self.proxy_manager_for(proxy)
- conn = proxy_manager.connection_from_url(url)
- else:
- # Only scheme should be lower case
- parsed = urlparse(url)
- url = parsed.geturl()
- conn = self.poolmanager.connection_from_url(url)
-
- return conn
-
- def close(self):
- """Disposes of any internal state.
-
- Currently, this closes the PoolManager and any active ProxyManager,
- which closes any pooled connections.
- """
- self.poolmanager.clear()
- for proxy in self.proxy_manager.values():
- proxy.clear()
-
- def request_url(self, request, proxies):
- """Obtain the url to use when making the final request.
-
- If the message is being sent through a HTTP proxy, the full URL has to
- be used. Otherwise, we should only use the path portion of the URL.
-
- This should not be called from user code, and is only exposed for use
- when subclassing the
- :class:`HTTPAdapter `.
-
- :param request: The :class:`PreparedRequest ` being sent.
- :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
- :rtype: str
- """
- proxy = select_proxy(request.url, proxies)
- scheme = urlparse(request.url).scheme
-
- is_proxied_http_request = proxy and scheme != "https"
- using_socks_proxy = False
- if proxy:
- proxy_scheme = urlparse(proxy).scheme.lower()
- using_socks_proxy = proxy_scheme.startswith("socks")
-
- url = request.path_url
- if is_proxied_http_request and not using_socks_proxy:
- url = urldefragauth(request.url)
-
- return url
-
- def add_headers(self, request, **kwargs):
- """Add any headers needed by the connection. As of v2.0 this does
- nothing by default, but is left for overriding by users that subclass
- the :class:`HTTPAdapter `.
-
- This should not be called from user code, and is only exposed for use
- when subclassing the
- :class:`HTTPAdapter `.
-
- :param request: The :class:`PreparedRequest ` to add headers to.
- :param kwargs: The keyword arguments from the call to send().
- """
- pass
-
- def proxy_headers(self, proxy):
- """Returns a dictionary of the headers to add to any request sent
- through a proxy. This works with urllib3 magic to ensure that they are
- correctly sent to the proxy, rather than in a tunnelled request if
- CONNECT is being used.
-
- This should not be called from user code, and is only exposed for use
- when subclassing the
- :class:`HTTPAdapter `.
-
- :param proxy: The url of the proxy being used for this request.
- :rtype: dict
- """
- headers = {}
- username, password = get_auth_from_url(proxy)
-
- if username:
- headers["Proxy-Authorization"] = _basic_auth_str(username, password)
-
- return headers
-
- def send(
- self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
- ):
- """Sends PreparedRequest object. Returns Response object.
-
- :param request: The :class:`PreparedRequest ` being sent.
- :param stream: (optional) Whether to stream the request content.
- :param timeout: (optional) How long to wait for the server to send
- data before giving up, as a float, or a :ref:`(connect timeout,
- read timeout) ` tuple.
- :type timeout: float or tuple or urllib3 Timeout object
- :param verify: (optional) Either a boolean, in which case it controls whether
- we verify the server's TLS certificate, or a string, in which case it
- must be a path to a CA bundle to use
- :param cert: (optional) Any user-provided SSL certificate to be trusted.
- :param proxies: (optional) The proxies dictionary to apply to the request.
- :rtype: requests.Response
- """
-
- try:
- conn = self.get_connection(request.url, proxies)
- except LocationValueError as e:
- raise InvalidURL(e, request=request)
-
- self.cert_verify(conn, request.url, verify, cert)
- url = self.request_url(request, proxies)
- self.add_headers(
- request,
- stream=stream,
- timeout=timeout,
- verify=verify,
- cert=cert,
- proxies=proxies,
- )
-
- chunked = not (request.body is None or "Content-Length" in request.headers)
-
- if isinstance(timeout, tuple):
- try:
- connect, read = timeout
- timeout = TimeoutSauce(connect=connect, read=read)
- except ValueError:
- raise ValueError(
- f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, "
- f"or a single float to set both timeouts to the same value."
- )
- elif isinstance(timeout, TimeoutSauce):
- pass
- else:
- timeout = TimeoutSauce(connect=timeout, read=timeout)
-
- try:
- resp = conn.urlopen(
- method=request.method,
- url=url,
- body=request.body,
- headers=request.headers,
- redirect=False,
- assert_same_host=False,
- preload_content=False,
- decode_content=False,
- retries=self.max_retries,
- timeout=timeout,
- chunked=chunked,
- )
-
- except (ProtocolError, OSError) as err:
- raise ConnectionError(err, request=request)
-
- except MaxRetryError as e:
- if isinstance(e.reason, ConnectTimeoutError):
- # TODO: Remove this in 3.0.0: see #2811
- if not isinstance(e.reason, NewConnectionError):
- raise ConnectTimeout(e, request=request)
-
- if isinstance(e.reason, ResponseError):
- raise RetryError(e, request=request)
-
- if isinstance(e.reason, _ProxyError):
- raise ProxyError(e, request=request)
-
- if isinstance(e.reason, _SSLError):
- # This branch is for urllib3 v1.22 and later.
- raise SSLError(e, request=request)
-
- raise ConnectionError(e, request=request)
-
- except ClosedPoolError as e:
- raise ConnectionError(e, request=request)
-
- except _ProxyError as e:
- raise ProxyError(e)
-
- except (_SSLError, _HTTPError) as e:
- if isinstance(e, _SSLError):
- # This branch is for urllib3 versions earlier than v1.22
- raise SSLError(e, request=request)
- elif isinstance(e, ReadTimeoutError):
- raise ReadTimeout(e, request=request)
- elif isinstance(e, _InvalidHeader):
- raise InvalidHeader(e, request=request)
- else:
- raise
-
- return self.build_response(request, resp)
diff --git a/lib/requests/api.py b/lib/requests/api.py
deleted file mode 100644
index cd0b3ee..0000000
--- a/lib/requests/api.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""
-requests.api
-~~~~~~~~~~~~
-
-This module implements the Requests API.
-
-:copyright: (c) 2012 by Kenneth Reitz.
-:license: Apache2, see LICENSE for more details.
-"""
-
-from . import sessions
-
-
-def request(method, url, **kwargs):
- """Constructs and sends a :class:`Request `.
-
- :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
- :param url: URL for the new :class:`Request` object.
- :param params: (optional) Dictionary, list of tuples or bytes to send
- in the query string for the :class:`Request`.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
- :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
- :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
- :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
- ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
- or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
- defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
- to add for the file.
- :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
- :param timeout: (optional) How many seconds to wait for the server to send data
- before giving up, as a float, or a :ref:`(connect timeout, read
- timeout) ` tuple.
- :type timeout: float or tuple
- :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
- :type allow_redirects: bool
- :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
- :param verify: (optional) Either a boolean, in which case it controls whether we verify
- the server's TLS certificate, or a string, in which case it must be a path
- to a CA bundle to use. Defaults to ``True``.
- :param stream: (optional) if ``False``, the response content will be immediately downloaded.
- :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
- :return: :class:`Response ` object
- :rtype: requests.Response
-
- Usage::
-
- >>> import requests
- >>> req = requests.request('GET', 'https://httpbin.org/get')
- >>> req
-
- """
-
- # By using the 'with' statement we are sure the session is closed, thus we
- # avoid leaving sockets open which can trigger a ResourceWarning in some
- # cases, and look like a memory leak in others.
- with sessions.Session() as session:
- return session.request(method=method, url=url, **kwargs)
-
-
-def get(url, params=None, **kwargs):
- r"""Sends a GET request.
-
- :param url: URL for the new :class:`Request` object.
- :param params: (optional) Dictionary, list of tuples or bytes to send
- in the query string for the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("get", url, params=params, **kwargs)
-
-
-def options(url, **kwargs):
- r"""Sends an OPTIONS request.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("options", url, **kwargs)
-
-
-def head(url, **kwargs):
- r"""Sends a HEAD request.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes. If
- `allow_redirects` is not provided, it will be set to `False` (as
- opposed to the default :meth:`request` behavior).
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- kwargs.setdefault("allow_redirects", False)
- return request("head", url, **kwargs)
-
-
-def post(url, data=None, json=None, **kwargs):
- r"""Sends a POST request.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("post", url, data=data, json=json, **kwargs)
-
-
-def put(url, data=None, **kwargs):
- r"""Sends a PUT request.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("put", url, data=data, **kwargs)
-
-
-def patch(url, data=None, **kwargs):
- r"""Sends a PATCH request.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("patch", url, data=data, **kwargs)
-
-
-def delete(url, **kwargs):
- r"""Sends a DELETE request.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :return: :class:`Response ` object
- :rtype: requests.Response
- """
-
- return request("delete", url, **kwargs)
diff --git a/lib/requests/auth.py b/lib/requests/auth.py
deleted file mode 100644
index 9733686..0000000
--- a/lib/requests/auth.py
+++ /dev/null
@@ -1,315 +0,0 @@
-"""
-requests.auth
-~~~~~~~~~~~~~
-
-This module contains the authentication handlers for Requests.
-"""
-
-import hashlib
-import os
-import re
-import threading
-import time
-import warnings
-from base64 import b64encode
-
-from ._internal_utils import to_native_string
-from .compat import basestring, str, urlparse
-from .cookies import extract_cookies_to_jar
-from .utils import parse_dict_header
-
-CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded"
-CONTENT_TYPE_MULTI_PART = "multipart/form-data"
-
-
-def _basic_auth_str(username, password):
- """Returns a Basic Auth string."""
-
- # "I want us to put a big-ol' comment on top of it that
- # says that this behaviour is dumb but we need to preserve
- # it because people are relying on it."
- # - Lukasa
- #
- # These are here solely to maintain backwards compatibility
- # for things like ints. This will be removed in 3.0.0.
- if not isinstance(username, basestring):
- warnings.warn(
- "Non-string usernames will no longer be supported in Requests "
- "3.0.0. Please convert the object you've passed in ({!r}) to "
- "a string or bytes object in the near future to avoid "
- "problems.".format(username),
- category=DeprecationWarning,
- )
- username = str(username)
-
- if not isinstance(password, basestring):
- warnings.warn(
- "Non-string passwords will no longer be supported in Requests "
- "3.0.0. Please convert the object you've passed in ({!r}) to "
- "a string or bytes object in the near future to avoid "
- "problems.".format(type(password)),
- category=DeprecationWarning,
- )
- password = str(password)
- # -- End Removal --
-
- if isinstance(username, str):
- username = username.encode("latin1")
-
- if isinstance(password, str):
- password = password.encode("latin1")
-
- authstr = "Basic " + to_native_string(
- b64encode(b":".join((username, password))).strip()
- )
-
- return authstr
-
-
-class AuthBase:
- """Base class that all auth implementations derive from"""
-
- def __call__(self, r):
- raise NotImplementedError("Auth hooks must be callable.")
-
-
-class HTTPBasicAuth(AuthBase):
- """Attaches HTTP Basic Authentication to the given Request object."""
-
- def __init__(self, username, password):
- self.username = username
- self.password = password
-
- def __eq__(self, other):
- return all(
- [
- self.username == getattr(other, "username", None),
- self.password == getattr(other, "password", None),
- ]
- )
-
- def __ne__(self, other):
- return not self == other
-
- def __call__(self, r):
- r.headers["Authorization"] = _basic_auth_str(self.username, self.password)
- return r
-
-
-class HTTPProxyAuth(HTTPBasicAuth):
- """Attaches HTTP Proxy Authentication to a given Request object."""
-
- def __call__(self, r):
- r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password)
- return r
-
-
-class HTTPDigestAuth(AuthBase):
- """Attaches HTTP Digest Authentication to the given Request object."""
-
- def __init__(self, username, password):
- self.username = username
- self.password = password
- # Keep state in per-thread local storage
- self._thread_local = threading.local()
-
- def init_per_thread_state(self):
- # Ensure state is initialized just once per-thread
- if not hasattr(self._thread_local, "init"):
- self._thread_local.init = True
- self._thread_local.last_nonce = ""
- self._thread_local.nonce_count = 0
- self._thread_local.chal = {}
- self._thread_local.pos = None
- self._thread_local.num_401_calls = None
-
- def build_digest_header(self, method, url):
- """
- :rtype: str
- """
-
- realm = self._thread_local.chal["realm"]
- nonce = self._thread_local.chal["nonce"]
- qop = self._thread_local.chal.get("qop")
- algorithm = self._thread_local.chal.get("algorithm")
- opaque = self._thread_local.chal.get("opaque")
- hash_utf8 = None
-
- if algorithm is None:
- _algorithm = "MD5"
- else:
- _algorithm = algorithm.upper()
- # lambdas assume digest modules are imported at the top level
- if _algorithm == "MD5" or _algorithm == "MD5-SESS":
-
- def md5_utf8(x):
- if isinstance(x, str):
- x = x.encode("utf-8")
- return hashlib.md5(x).hexdigest()
-
- hash_utf8 = md5_utf8
- elif _algorithm == "SHA":
-
- def sha_utf8(x):
- if isinstance(x, str):
- x = x.encode("utf-8")
- return hashlib.sha1(x).hexdigest()
-
- hash_utf8 = sha_utf8
- elif _algorithm == "SHA-256":
-
- def sha256_utf8(x):
- if isinstance(x, str):
- x = x.encode("utf-8")
- return hashlib.sha256(x).hexdigest()
-
- hash_utf8 = sha256_utf8
- elif _algorithm == "SHA-512":
-
- def sha512_utf8(x):
- if isinstance(x, str):
- x = x.encode("utf-8")
- return hashlib.sha512(x).hexdigest()
-
- hash_utf8 = sha512_utf8
-
- KD = lambda s, d: hash_utf8(f"{s}:{d}") # noqa:E731
-
- if hash_utf8 is None:
- return None
-
- # XXX not implemented yet
- entdig = None
- p_parsed = urlparse(url)
- #: path is request-uri defined in RFC 2616 which should not be empty
- path = p_parsed.path or "/"
- if p_parsed.query:
- path += f"?{p_parsed.query}"
-
- A1 = f"{self.username}:{realm}:{self.password}"
- A2 = f"{method}:{path}"
-
- HA1 = hash_utf8(A1)
- HA2 = hash_utf8(A2)
-
- if nonce == self._thread_local.last_nonce:
- self._thread_local.nonce_count += 1
- else:
- self._thread_local.nonce_count = 1
- ncvalue = f"{self._thread_local.nonce_count:08x}"
- s = str(self._thread_local.nonce_count).encode("utf-8")
- s += nonce.encode("utf-8")
- s += time.ctime().encode("utf-8")
- s += os.urandom(8)
-
- cnonce = hashlib.sha1(s).hexdigest()[:16]
- if _algorithm == "MD5-SESS":
- HA1 = hash_utf8(f"{HA1}:{nonce}:{cnonce}")
-
- if not qop:
- respdig = KD(HA1, f"{nonce}:{HA2}")
- elif qop == "auth" or "auth" in qop.split(","):
- noncebit = f"{nonce}:{ncvalue}:{cnonce}:auth:{HA2}"
- respdig = KD(HA1, noncebit)
- else:
- # XXX handle auth-int.
- return None
-
- self._thread_local.last_nonce = nonce
-
- # XXX should the partial digests be encoded too?
- base = (
- f'username="{self.username}", realm="{realm}", nonce="{nonce}", '
- f'uri="{path}", response="{respdig}"'
- )
- if opaque:
- base += f', opaque="{opaque}"'
- if algorithm:
- base += f', algorithm="{algorithm}"'
- if entdig:
- base += f', digest="{entdig}"'
- if qop:
- base += f', qop="auth", nc={ncvalue}, cnonce="{cnonce}"'
-
- return f"Digest {base}"
-
- def handle_redirect(self, r, **kwargs):
- """Reset num_401_calls counter on redirects."""
- if r.is_redirect:
- self._thread_local.num_401_calls = 1
-
- def handle_401(self, r, **kwargs):
- """
- Takes the given response and tries digest-auth, if needed.
-
- :rtype: requests.Response
- """
-
- # If response is not 4xx, do not auth
- # See https://github.com/psf/requests/issues/3772
- if not 400 <= r.status_code < 500:
- self._thread_local.num_401_calls = 1
- return r
-
- if self._thread_local.pos is not None:
- # Rewind the file position indicator of the body to where
- # it was to resend the request.
- r.request.body.seek(self._thread_local.pos)
- s_auth = r.headers.get("www-authenticate", "")
-
- if "digest" in s_auth.lower() and self._thread_local.num_401_calls < 2:
-
- self._thread_local.num_401_calls += 1
- pat = re.compile(r"digest ", flags=re.IGNORECASE)
- self._thread_local.chal = parse_dict_header(pat.sub("", s_auth, count=1))
-
- # Consume content and release the original connection
- # to allow our new request to reuse the same one.
- r.content
- r.close()
- prep = r.request.copy()
- extract_cookies_to_jar(prep._cookies, r.request, r.raw)
- prep.prepare_cookies(prep._cookies)
-
- prep.headers["Authorization"] = self.build_digest_header(
- prep.method, prep.url
- )
- _r = r.connection.send(prep, **kwargs)
- _r.history.append(r)
- _r.request = prep
-
- return _r
-
- self._thread_local.num_401_calls = 1
- return r
-
- def __call__(self, r):
- # Initialize per-thread state, if needed
- self.init_per_thread_state()
- # If we have a saved nonce, skip the 401
- if self._thread_local.last_nonce:
- r.headers["Authorization"] = self.build_digest_header(r.method, r.url)
- try:
- self._thread_local.pos = r.body.tell()
- except AttributeError:
- # In the case of HTTPDigestAuth being reused and the body of
- # the previous request was a file-like object, pos has the
- # file position of the previous body. Ensure it's set to
- # None.
- self._thread_local.pos = None
- r.register_hook("response", self.handle_401)
- r.register_hook("response", self.handle_redirect)
- self._thread_local.num_401_calls = 1
-
- return r
-
- def __eq__(self, other):
- return all(
- [
- self.username == getattr(other, "username", None),
- self.password == getattr(other, "password", None),
- ]
- )
-
- def __ne__(self, other):
- return not self == other
diff --git a/lib/requests/certs.py b/lib/requests/certs.py
deleted file mode 100644
index be422c3..0000000
--- a/lib/requests/certs.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-
-"""
-requests.certs
-~~~~~~~~~~~~~~
-
-This module returns the preferred default CA certificate bundle. There is
-only one — the one from the certifi package.
-
-If you are packaging Requests, e.g., for a Linux distribution or a managed
-environment, you can change the definition of where() to return a separately
-packaged CA bundle.
-"""
-from certifi import where
-
-if __name__ == "__main__":
- print(where())
diff --git a/lib/requests/compat.py b/lib/requests/compat.py
deleted file mode 100644
index 6776163..0000000
--- a/lib/requests/compat.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""
-requests.compat
-~~~~~~~~~~~~~~~
-
-This module previously handled import compatibility issues
-between Python 2 and Python 3. It remains for backwards
-compatibility until the next major version.
-"""
-
-try:
- import chardet
-except ImportError:
- import charset_normalizer as chardet
-
-import sys
-
-# -------
-# Pythons
-# -------
-
-# Syntax sugar.
-_ver = sys.version_info
-
-#: Python 2.x?
-is_py2 = _ver[0] == 2
-
-#: Python 3.x?
-is_py3 = _ver[0] == 3
-
-# json/simplejson module import resolution
-has_simplejson = False
-try:
- import simplejson as json
-
- has_simplejson = True
-except ImportError:
- import json
-
-if has_simplejson:
- from simplejson import JSONDecodeError
-else:
- from json import JSONDecodeError
-
-# Keep OrderedDict for backwards compatibility.
-from collections import OrderedDict
-from collections.abc import Callable, Mapping, MutableMapping
-from http import cookiejar as cookielib
-from http.cookies import Morsel
-from io import StringIO
-
-# --------------
-# Legacy Imports
-# --------------
-from urllib.parse import (
- quote,
- quote_plus,
- unquote,
- unquote_plus,
- urldefrag,
- urlencode,
- urljoin,
- urlparse,
- urlsplit,
- urlunparse,
-)
-from urllib.request import (
- getproxies,
- getproxies_environment,
- parse_http_list,
- proxy_bypass,
- proxy_bypass_environment,
-)
-
-builtin_str = str
-str = str
-bytes = bytes
-basestring = (str, bytes)
-numeric_types = (int, float)
-integer_types = (int,)
diff --git a/lib/requests/cookies.py b/lib/requests/cookies.py
deleted file mode 100644
index bf54ab2..0000000
--- a/lib/requests/cookies.py
+++ /dev/null
@@ -1,561 +0,0 @@
-"""
-requests.cookies
-~~~~~~~~~~~~~~~~
-
-Compatibility code to be able to use `cookielib.CookieJar` with requests.
-
-requests.utils imports from here, so be careful with imports.
-"""
-
-import calendar
-import copy
-import time
-
-from ._internal_utils import to_native_string
-from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse
-
-try:
- import threading
-except ImportError:
- import dummy_threading as threading
-
-
-class MockRequest:
- """Wraps a `requests.Request` to mimic a `urllib2.Request`.
-
- The code in `cookielib.CookieJar` expects this interface in order to correctly
- manage cookie policies, i.e., determine whether a cookie can be set, given the
- domains of the request and the cookie.
-
- The original request object is read-only. The client is responsible for collecting
- the new headers via `get_new_headers()` and interpreting them appropriately. You
- probably want `get_cookie_header`, defined below.
- """
-
- def __init__(self, request):
- self._r = request
- self._new_headers = {}
- self.type = urlparse(self._r.url).scheme
-
- def get_type(self):
- return self.type
-
- def get_host(self):
- return urlparse(self._r.url).netloc
-
- def get_origin_req_host(self):
- return self.get_host()
-
- def get_full_url(self):
- # Only return the response's URL if the user hadn't set the Host
- # header
- if not self._r.headers.get("Host"):
- return self._r.url
- # If they did set it, retrieve it and reconstruct the expected domain
- host = to_native_string(self._r.headers["Host"], encoding="utf-8")
- parsed = urlparse(self._r.url)
- # Reconstruct the URL as we expect it
- return urlunparse(
- [
- parsed.scheme,
- host,
- parsed.path,
- parsed.params,
- parsed.query,
- parsed.fragment,
- ]
- )
-
- def is_unverifiable(self):
- return True
-
- def has_header(self, name):
- return name in self._r.headers or name in self._new_headers
-
- def get_header(self, name, default=None):
- return self._r.headers.get(name, self._new_headers.get(name, default))
-
- def add_header(self, key, val):
- """cookielib has no legitimate use for this method; add it back if you find one."""
- raise NotImplementedError(
- "Cookie headers should be added with add_unredirected_header()"
- )
-
- def add_unredirected_header(self, name, value):
- self._new_headers[name] = value
-
- def get_new_headers(self):
- return self._new_headers
-
- @property
- def unverifiable(self):
- return self.is_unverifiable()
-
- @property
- def origin_req_host(self):
- return self.get_origin_req_host()
-
- @property
- def host(self):
- return self.get_host()
-
-
-class MockResponse:
- """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
-
- ...what? Basically, expose the parsed HTTP headers from the server response
- the way `cookielib` expects to see them.
- """
-
- def __init__(self, headers):
- """Make a MockResponse for `cookielib` to read.
-
- :param headers: a httplib.HTTPMessage or analogous carrying the headers
- """
- self._headers = headers
-
- def info(self):
- return self._headers
-
- def getheaders(self, name):
- self._headers.getheaders(name)
-
-
-def extract_cookies_to_jar(jar, request, response):
- """Extract the cookies from the response into a CookieJar.
-
- :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
- :param request: our own requests.Request object
- :param response: urllib3.HTTPResponse object
- """
- if not (hasattr(response, "_original_response") and response._original_response):
- return
- # the _original_response field is the wrapped httplib.HTTPResponse object,
- req = MockRequest(request)
- # pull out the HTTPMessage with the headers and put it in the mock:
- res = MockResponse(response._original_response.msg)
- jar.extract_cookies(res, req)
-
-
-def get_cookie_header(jar, request):
- """
- Produce an appropriate Cookie header string to be sent with `request`, or None.
-
- :rtype: str
- """
- r = MockRequest(request)
- jar.add_cookie_header(r)
- return r.get_new_headers().get("Cookie")
-
-
-def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
- """Unsets a cookie by name, by default over all domains and paths.
-
- Wraps CookieJar.clear(), is O(n).
- """
- clearables = []
- for cookie in cookiejar:
- if cookie.name != name:
- continue
- if domain is not None and domain != cookie.domain:
- continue
- if path is not None and path != cookie.path:
- continue
- clearables.append((cookie.domain, cookie.path, cookie.name))
-
- for domain, path, name in clearables:
- cookiejar.clear(domain, path, name)
-
-
-class CookieConflictError(RuntimeError):
- """There are two cookies that meet the criteria specified in the cookie jar.
- Use .get and .set and include domain and path args in order to be more specific.
- """
-
-
-class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
- """Compatibility class; is a cookielib.CookieJar, but exposes a dict
- interface.
-
- This is the CookieJar we create by default for requests and sessions that
- don't specify one, since some clients may expect response.cookies and
- session.cookies to support dict operations.
-
- Requests does not use the dict interface internally; it's just for
- compatibility with external client code. All requests code should work
- out of the box with externally provided instances of ``CookieJar``, e.g.
- ``LWPCookieJar`` and ``FileCookieJar``.
-
- Unlike a regular CookieJar, this class is pickleable.
-
- .. warning:: dictionary operations that are normally O(1) may be O(n).
- """
-
- def get(self, name, default=None, domain=None, path=None):
- """Dict-like get() that also supports optional domain and path args in
- order to resolve naming collisions from using one cookie jar over
- multiple domains.
-
- .. warning:: operation is O(n), not O(1).
- """
- try:
- return self._find_no_duplicates(name, domain, path)
- except KeyError:
- return default
-
- def set(self, name, value, **kwargs):
- """Dict-like set() that also supports optional domain and path args in
- order to resolve naming collisions from using one cookie jar over
- multiple domains.
- """
- # support client code that unsets cookies by assignment of a None value:
- if value is None:
- remove_cookie_by_name(
- self, name, domain=kwargs.get("domain"), path=kwargs.get("path")
- )
- return
-
- if isinstance(value, Morsel):
- c = morsel_to_cookie(value)
- else:
- c = create_cookie(name, value, **kwargs)
- self.set_cookie(c)
- return c
-
- def iterkeys(self):
- """Dict-like iterkeys() that returns an iterator of names of cookies
- from the jar.
-
- .. seealso:: itervalues() and iteritems().
- """
- for cookie in iter(self):
- yield cookie.name
-
- def keys(self):
- """Dict-like keys() that returns a list of names of cookies from the
- jar.
-
- .. seealso:: values() and items().
- """
- return list(self.iterkeys())
-
- def itervalues(self):
- """Dict-like itervalues() that returns an iterator of values of cookies
- from the jar.
-
- .. seealso:: iterkeys() and iteritems().
- """
- for cookie in iter(self):
- yield cookie.value
-
- def values(self):
- """Dict-like values() that returns a list of values of cookies from the
- jar.
-
- .. seealso:: keys() and items().
- """
- return list(self.itervalues())
-
- def iteritems(self):
- """Dict-like iteritems() that returns an iterator of name-value tuples
- from the jar.
-
- .. seealso:: iterkeys() and itervalues().
- """
- for cookie in iter(self):
- yield cookie.name, cookie.value
-
- def items(self):
- """Dict-like items() that returns a list of name-value tuples from the
- jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
- vanilla python dict of key value pairs.
-
- .. seealso:: keys() and values().
- """
- return list(self.iteritems())
-
- def list_domains(self):
- """Utility method to list all the domains in the jar."""
- domains = []
- for cookie in iter(self):
- if cookie.domain not in domains:
- domains.append(cookie.domain)
- return domains
-
- def list_paths(self):
- """Utility method to list all the paths in the jar."""
- paths = []
- for cookie in iter(self):
- if cookie.path not in paths:
- paths.append(cookie.path)
- return paths
-
- def multiple_domains(self):
- """Returns True if there are multiple domains in the jar.
- Returns False otherwise.
-
- :rtype: bool
- """
- domains = []
- for cookie in iter(self):
- if cookie.domain is not None and cookie.domain in domains:
- return True
- domains.append(cookie.domain)
- return False # there is only one domain in jar
-
- def get_dict(self, domain=None, path=None):
- """Takes as an argument an optional domain and path and returns a plain
- old Python dict of name-value pairs of cookies that meet the
- requirements.
-
- :rtype: dict
- """
- dictionary = {}
- for cookie in iter(self):
- if (domain is None or cookie.domain == domain) and (
- path is None or cookie.path == path
- ):
- dictionary[cookie.name] = cookie.value
- return dictionary
-
- def __contains__(self, name):
- try:
- return super().__contains__(name)
- except CookieConflictError:
- return True
-
- def __getitem__(self, name):
- """Dict-like __getitem__() for compatibility with client code. Throws
- exception if there are more than one cookie with name. In that case,
- use the more explicit get() method instead.
-
- .. warning:: operation is O(n), not O(1).
- """
- return self._find_no_duplicates(name)
-
- def __setitem__(self, name, value):
- """Dict-like __setitem__ for compatibility with client code. Throws
- exception if there is already a cookie of that name in the jar. In that
- case, use the more explicit set() method instead.
- """
- self.set(name, value)
-
- def __delitem__(self, name):
- """Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
- ``remove_cookie_by_name()``.
- """
- remove_cookie_by_name(self, name)
-
- def set_cookie(self, cookie, *args, **kwargs):
- if (
- hasattr(cookie.value, "startswith")
- and cookie.value.startswith('"')
- and cookie.value.endswith('"')
- ):
- cookie.value = cookie.value.replace('\\"', "")
- return super().set_cookie(cookie, *args, **kwargs)
-
- def update(self, other):
- """Updates this jar with cookies from another CookieJar or dict-like"""
- if isinstance(other, cookielib.CookieJar):
- for cookie in other:
- self.set_cookie(copy.copy(cookie))
- else:
- super().update(other)
-
- def _find(self, name, domain=None, path=None):
- """Requests uses this method internally to get cookie values.
-
- If there are conflicting cookies, _find arbitrarily chooses one.
- See _find_no_duplicates if you want an exception thrown if there are
- conflicting cookies.
-
- :param name: a string containing name of cookie
- :param domain: (optional) string containing domain of cookie
- :param path: (optional) string containing path of cookie
- :return: cookie.value
- """
- for cookie in iter(self):
- if cookie.name == name:
- if domain is None or cookie.domain == domain:
- if path is None or cookie.path == path:
- return cookie.value
-
- raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}")
-
- def _find_no_duplicates(self, name, domain=None, path=None):
- """Both ``__get_item__`` and ``get`` call this function: it's never
- used elsewhere in Requests.
-
- :param name: a string containing name of cookie
- :param domain: (optional) string containing domain of cookie
- :param path: (optional) string containing path of cookie
- :raises KeyError: if cookie is not found
- :raises CookieConflictError: if there are multiple cookies
- that match name and optionally domain and path
- :return: cookie.value
- """
- toReturn = None
- for cookie in iter(self):
- if cookie.name == name:
- if domain is None or cookie.domain == domain:
- if path is None or cookie.path == path:
- if toReturn is not None:
- # if there are multiple cookies that meet passed in criteria
- raise CookieConflictError(
- f"There are multiple cookies with name, {name!r}"
- )
- # we will eventually return this as long as no cookie conflict
- toReturn = cookie.value
-
- if toReturn:
- return toReturn
- raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}")
-
- def __getstate__(self):
- """Unlike a normal CookieJar, this class is pickleable."""
- state = self.__dict__.copy()
- # remove the unpickleable RLock object
- state.pop("_cookies_lock")
- return state
-
- def __setstate__(self, state):
- """Unlike a normal CookieJar, this class is pickleable."""
- self.__dict__.update(state)
- if "_cookies_lock" not in self.__dict__:
- self._cookies_lock = threading.RLock()
-
- def copy(self):
- """Return a copy of this RequestsCookieJar."""
- new_cj = RequestsCookieJar()
- new_cj.set_policy(self.get_policy())
- new_cj.update(self)
- return new_cj
-
- def get_policy(self):
- """Return the CookiePolicy instance used."""
- return self._policy
-
-
-def _copy_cookie_jar(jar):
- if jar is None:
- return None
-
- if hasattr(jar, "copy"):
- # We're dealing with an instance of RequestsCookieJar
- return jar.copy()
- # We're dealing with a generic CookieJar instance
- new_jar = copy.copy(jar)
- new_jar.clear()
- for cookie in jar:
- new_jar.set_cookie(copy.copy(cookie))
- return new_jar
-
-
-def create_cookie(name, value, **kwargs):
- """Make a cookie from underspecified parameters.
-
- By default, the pair of `name` and `value` will be set for the domain ''
- and sent on every request (this is sometimes called a "supercookie").
- """
- result = {
- "version": 0,
- "name": name,
- "value": value,
- "port": None,
- "domain": "",
- "path": "/",
- "secure": False,
- "expires": None,
- "discard": True,
- "comment": None,
- "comment_url": None,
- "rest": {"HttpOnly": None},
- "rfc2109": False,
- }
-
- badargs = set(kwargs) - set(result)
- if badargs:
- raise TypeError(
- f"create_cookie() got unexpected keyword arguments: {list(badargs)}"
- )
-
- result.update(kwargs)
- result["port_specified"] = bool(result["port"])
- result["domain_specified"] = bool(result["domain"])
- result["domain_initial_dot"] = result["domain"].startswith(".")
- result["path_specified"] = bool(result["path"])
-
- return cookielib.Cookie(**result)
-
-
-def morsel_to_cookie(morsel):
- """Convert a Morsel object into a Cookie containing the one k/v pair."""
-
- expires = None
- if morsel["max-age"]:
- try:
- expires = int(time.time() + int(morsel["max-age"]))
- except ValueError:
- raise TypeError(f"max-age: {morsel['max-age']} must be integer")
- elif morsel["expires"]:
- time_template = "%a, %d-%b-%Y %H:%M:%S GMT"
- expires = calendar.timegm(time.strptime(morsel["expires"], time_template))
- return create_cookie(
- comment=morsel["comment"],
- comment_url=bool(morsel["comment"]),
- discard=False,
- domain=morsel["domain"],
- expires=expires,
- name=morsel.key,
- path=morsel["path"],
- port=None,
- rest={"HttpOnly": morsel["httponly"]},
- rfc2109=False,
- secure=bool(morsel["secure"]),
- value=morsel.value,
- version=morsel["version"] or 0,
- )
-
-
-def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
- """Returns a CookieJar from a key/value dictionary.
-
- :param cookie_dict: Dict of key/values to insert into CookieJar.
- :param cookiejar: (optional) A cookiejar to add the cookies to.
- :param overwrite: (optional) If False, will not replace cookies
- already in the jar with new ones.
- :rtype: CookieJar
- """
- if cookiejar is None:
- cookiejar = RequestsCookieJar()
-
- if cookie_dict is not None:
- names_from_jar = [cookie.name for cookie in cookiejar]
- for name in cookie_dict:
- if overwrite or (name not in names_from_jar):
- cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
-
- return cookiejar
-
-
-def merge_cookies(cookiejar, cookies):
- """Add cookies to cookiejar and returns a merged CookieJar.
-
- :param cookiejar: CookieJar object to add the cookies to.
- :param cookies: Dictionary or CookieJar object to be added.
- :rtype: CookieJar
- """
- if not isinstance(cookiejar, cookielib.CookieJar):
- raise ValueError("You can only merge into CookieJar")
-
- if isinstance(cookies, dict):
- cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False)
- elif isinstance(cookies, cookielib.CookieJar):
- try:
- cookiejar.update(cookies)
- except AttributeError:
- for cookie_in_jar in cookies:
- cookiejar.set_cookie(cookie_in_jar)
-
- return cookiejar
diff --git a/lib/requests/exceptions.py b/lib/requests/exceptions.py
deleted file mode 100644
index e1cedf8..0000000
--- a/lib/requests/exceptions.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""
-requests.exceptions
-~~~~~~~~~~~~~~~~~~~
-
-This module contains the set of Requests' exceptions.
-"""
-from urllib3.exceptions import HTTPError as BaseHTTPError
-
-from .compat import JSONDecodeError as CompatJSONDecodeError
-
-
-class RequestException(IOError):
- """There was an ambiguous exception that occurred while handling your
- request.
- """
-
- def __init__(self, *args, **kwargs):
- """Initialize RequestException with `request` and `response` objects."""
- response = kwargs.pop("response", None)
- self.response = response
- self.request = kwargs.pop("request", None)
- if response is not None and not self.request and hasattr(response, "request"):
- self.request = self.response.request
- super().__init__(*args, **kwargs)
-
-
-class InvalidJSONError(RequestException):
- """A JSON error occurred."""
-
-
-class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError):
- """Couldn't decode the text into json"""
-
- def __init__(self, *args, **kwargs):
- """
- Construct the JSONDecodeError instance first with all
- args. Then use it's args to construct the IOError so that
- the json specific args aren't used as IOError specific args
- and the error message from JSONDecodeError is preserved.
- """
- CompatJSONDecodeError.__init__(self, *args)
- InvalidJSONError.__init__(self, *self.args, **kwargs)
-
-
-class HTTPError(RequestException):
- """An HTTP error occurred."""
-
-
-class ConnectionError(RequestException):
- """A Connection error occurred."""
-
-
-class ProxyError(ConnectionError):
- """A proxy error occurred."""
-
-
-class SSLError(ConnectionError):
- """An SSL error occurred."""
-
-
-class Timeout(RequestException):
- """The request timed out.
-
- Catching this error will catch both
- :exc:`~requests.exceptions.ConnectTimeout` and
- :exc:`~requests.exceptions.ReadTimeout` errors.
- """
-
-
-class ConnectTimeout(ConnectionError, Timeout):
- """The request timed out while trying to connect to the remote server.
-
- Requests that produced this error are safe to retry.
- """
-
-
-class ReadTimeout(Timeout):
- """The server did not send any data in the allotted amount of time."""
-
-
-class URLRequired(RequestException):
- """A valid URL is required to make a request."""
-
-
-class TooManyRedirects(RequestException):
- """Too many redirects."""
-
-
-class MissingSchema(RequestException, ValueError):
- """The URL scheme (e.g. http or https) is missing."""
-
-
-class InvalidSchema(RequestException, ValueError):
- """The URL scheme provided is either invalid or unsupported."""
-
-
-class InvalidURL(RequestException, ValueError):
- """The URL provided was somehow invalid."""
-
-
-class InvalidHeader(RequestException, ValueError):
- """The header value provided was somehow invalid."""
-
-
-class InvalidProxyURL(InvalidURL):
- """The proxy URL provided is invalid."""
-
-
-class ChunkedEncodingError(RequestException):
- """The server declared chunked encoding but sent an invalid chunk."""
-
-
-class ContentDecodingError(RequestException, BaseHTTPError):
- """Failed to decode response content."""
-
-
-class StreamConsumedError(RequestException, TypeError):
- """The content for this response was already consumed."""
-
-
-class RetryError(RequestException):
- """Custom retries logic failed"""
-
-
-class UnrewindableBodyError(RequestException):
- """Requests encountered an error when trying to rewind a body."""
-
-
-# Warnings
-
-
-class RequestsWarning(Warning):
- """Base warning for Requests."""
-
-
-class FileModeWarning(RequestsWarning, DeprecationWarning):
- """A file was opened in text mode, but Requests determined its binary length."""
-
-
-class RequestsDependencyWarning(RequestsWarning):
- """An imported dependency doesn't match the expected version range."""
diff --git a/lib/requests/help.py b/lib/requests/help.py
deleted file mode 100644
index 8fbcd65..0000000
--- a/lib/requests/help.py
+++ /dev/null
@@ -1,134 +0,0 @@
-"""Module containing bug report helper(s)."""
-
-import json
-import platform
-import ssl
-import sys
-
-import idna
-import urllib3
-
-from . import __version__ as requests_version
-
-try:
- import charset_normalizer
-except ImportError:
- charset_normalizer = None
-
-try:
- import chardet
-except ImportError:
- chardet = None
-
-try:
- from urllib3.contrib import pyopenssl
-except ImportError:
- pyopenssl = None
- OpenSSL = None
- cryptography = None
-else:
- import cryptography
- import OpenSSL
-
-
-def _implementation():
- """Return a dict with the Python implementation and version.
-
- Provide both the name and the version of the Python implementation
- currently running. For example, on CPython 3.10.3 it will return
- {'name': 'CPython', 'version': '3.10.3'}.
-
- This function works best on CPython and PyPy: in particular, it probably
- doesn't work for Jython or IronPython. Future investigation should be done
- to work out the correct shape of the code for those platforms.
- """
- implementation = platform.python_implementation()
-
- if implementation == "CPython":
- implementation_version = platform.python_version()
- elif implementation == "PyPy":
- implementation_version = "{}.{}.{}".format(
- sys.pypy_version_info.major,
- sys.pypy_version_info.minor,
- sys.pypy_version_info.micro,
- )
- if sys.pypy_version_info.releaselevel != "final":
- implementation_version = "".join(
- [implementation_version, sys.pypy_version_info.releaselevel]
- )
- elif implementation == "Jython":
- implementation_version = platform.python_version() # Complete Guess
- elif implementation == "IronPython":
- implementation_version = platform.python_version() # Complete Guess
- else:
- implementation_version = "Unknown"
-
- return {"name": implementation, "version": implementation_version}
-
-
-def info():
- """Generate information for a bug report."""
- try:
- platform_info = {
- "system": platform.system(),
- "release": platform.release(),
- }
- except OSError:
- platform_info = {
- "system": "Unknown",
- "release": "Unknown",
- }
-
- implementation_info = _implementation()
- urllib3_info = {"version": urllib3.__version__}
- charset_normalizer_info = {"version": None}
- chardet_info = {"version": None}
- if charset_normalizer:
- charset_normalizer_info = {"version": charset_normalizer.__version__}
- if chardet:
- chardet_info = {"version": chardet.__version__}
-
- pyopenssl_info = {
- "version": None,
- "openssl_version": "",
- }
- if OpenSSL:
- pyopenssl_info = {
- "version": OpenSSL.__version__,
- "openssl_version": f"{OpenSSL.SSL.OPENSSL_VERSION_NUMBER:x}",
- }
- cryptography_info = {
- "version": getattr(cryptography, "__version__", ""),
- }
- idna_info = {
- "version": getattr(idna, "__version__", ""),
- }
-
- system_ssl = ssl.OPENSSL_VERSION_NUMBER
- system_ssl_info = {"version": f"{system_ssl:x}" if system_ssl is not None else ""}
-
- return {
- "platform": platform_info,
- "implementation": implementation_info,
- "system_ssl": system_ssl_info,
- "using_pyopenssl": pyopenssl is not None,
- "using_charset_normalizer": chardet is None,
- "pyOpenSSL": pyopenssl_info,
- "urllib3": urllib3_info,
- "chardet": chardet_info,
- "charset_normalizer": charset_normalizer_info,
- "cryptography": cryptography_info,
- "idna": idna_info,
- "requests": {
- "version": requests_version,
- },
- }
-
-
-def main():
- """Pretty-print the bug information as JSON."""
- print(json.dumps(info(), sort_keys=True, indent=2))
-
-
-if __name__ == "__main__":
- main()
diff --git a/lib/requests/hooks.py b/lib/requests/hooks.py
deleted file mode 100644
index d181ba2..0000000
--- a/lib/requests/hooks.py
+++ /dev/null
@@ -1,33 +0,0 @@
-"""
-requests.hooks
-~~~~~~~~~~~~~~
-
-This module provides the capabilities for the Requests hooks system.
-
-Available hooks:
-
-``response``:
- The response generated from a Request.
-"""
-HOOKS = ["response"]
-
-
-def default_hooks():
- return {event: [] for event in HOOKS}
-
-
-# TODO: response is the only one
-
-
-def dispatch_hook(key, hooks, hook_data, **kwargs):
- """Dispatches a hook dictionary on a given piece of data."""
- hooks = hooks or {}
- hooks = hooks.get(key)
- if hooks:
- if hasattr(hooks, "__call__"):
- hooks = [hooks]
- for hook in hooks:
- _hook_data = hook(hook_data, **kwargs)
- if _hook_data is not None:
- hook_data = _hook_data
- return hook_data
diff --git a/lib/requests/models.py b/lib/requests/models.py
deleted file mode 100644
index 617a413..0000000
--- a/lib/requests/models.py
+++ /dev/null
@@ -1,1034 +0,0 @@
-"""
-requests.models
-~~~~~~~~~~~~~~~
-
-This module contains the primary objects that power Requests.
-"""
-
-import datetime
-
-# Import encoding now, to avoid implicit import later.
-# Implicit import within threads may cause LookupError when standard library is in a ZIP,
-# such as in Embedded Python. See https://github.com/psf/requests/issues/3578.
-import encodings.idna # noqa: F401
-from io import UnsupportedOperation
-
-from urllib3.exceptions import (
- DecodeError,
- LocationParseError,
- ProtocolError,
- ReadTimeoutError,
- SSLError,
-)
-from urllib3.fields import RequestField
-from urllib3.filepost import encode_multipart_formdata
-from urllib3.util import parse_url
-
-from ._internal_utils import to_native_string, unicode_is_ascii
-from .auth import HTTPBasicAuth
-from .compat import (
- Callable,
- JSONDecodeError,
- Mapping,
- basestring,
- builtin_str,
- chardet,
- cookielib,
-)
-from .compat import json as complexjson
-from .compat import urlencode, urlsplit, urlunparse
-from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header
-from .exceptions import (
- ChunkedEncodingError,
- ConnectionError,
- ContentDecodingError,
- HTTPError,
- InvalidJSONError,
- InvalidURL,
-)
-from .exceptions import JSONDecodeError as RequestsJSONDecodeError
-from .exceptions import MissingSchema
-from .exceptions import SSLError as RequestsSSLError
-from .exceptions import StreamConsumedError
-from .hooks import default_hooks
-from .status_codes import codes
-from .structures import CaseInsensitiveDict
-from .utils import (
- check_header_validity,
- get_auth_from_url,
- guess_filename,
- guess_json_utf,
- iter_slices,
- parse_header_links,
- requote_uri,
- stream_decode_response_unicode,
- super_len,
- to_key_val_list,
-)
-
-#: The set of HTTP status codes that indicate an automatically
-#: processable redirect.
-REDIRECT_STATI = (
- codes.moved, # 301
- codes.found, # 302
- codes.other, # 303
- codes.temporary_redirect, # 307
- codes.permanent_redirect, # 308
-)
-
-DEFAULT_REDIRECT_LIMIT = 30
-CONTENT_CHUNK_SIZE = 10 * 1024
-ITER_CHUNK_SIZE = 512
-
-
-class RequestEncodingMixin:
- @property
- def path_url(self):
- """Build the path URL to use."""
-
- url = []
-
- p = urlsplit(self.url)
-
- path = p.path
- if not path:
- path = "/"
-
- url.append(path)
-
- query = p.query
- if query:
- url.append("?")
- url.append(query)
-
- return "".join(url)
-
- @staticmethod
- def _encode_params(data):
- """Encode parameters in a piece of data.
-
- Will successfully encode parameters when passed as a dict or a list of
- 2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
- if parameters are supplied as a dict.
- """
-
- if isinstance(data, (str, bytes)):
- return data
- elif hasattr(data, "read"):
- return data
- elif hasattr(data, "__iter__"):
- result = []
- for k, vs in to_key_val_list(data):
- if isinstance(vs, basestring) or not hasattr(vs, "__iter__"):
- vs = [vs]
- for v in vs:
- if v is not None:
- result.append(
- (
- k.encode("utf-8") if isinstance(k, str) else k,
- v.encode("utf-8") if isinstance(v, str) else v,
- )
- )
- return urlencode(result, doseq=True)
- else:
- return data
-
- @staticmethod
- def _encode_files(files, data):
- """Build the body for a multipart/form-data request.
-
- Will successfully encode files when passed as a dict or a list of
- tuples. Order is retained if data is a list of tuples but arbitrary
- if parameters are supplied as a dict.
- The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
- or 4-tuples (filename, fileobj, contentype, custom_headers).
- """
- if not files:
- raise ValueError("Files must be provided.")
- elif isinstance(data, basestring):
- raise ValueError("Data must not be a string.")
-
- new_fields = []
- fields = to_key_val_list(data or {})
- files = to_key_val_list(files or {})
-
- for field, val in fields:
- if isinstance(val, basestring) or not hasattr(val, "__iter__"):
- val = [val]
- for v in val:
- if v is not None:
- # Don't call str() on bytestrings: in Py3 it all goes wrong.
- if not isinstance(v, bytes):
- v = str(v)
-
- new_fields.append(
- (
- field.decode("utf-8")
- if isinstance(field, bytes)
- else field,
- v.encode("utf-8") if isinstance(v, str) else v,
- )
- )
-
- for (k, v) in files:
- # support for explicit filename
- ft = None
- fh = None
- if isinstance(v, (tuple, list)):
- if len(v) == 2:
- fn, fp = v
- elif len(v) == 3:
- fn, fp, ft = v
- else:
- fn, fp, ft, fh = v
- else:
- fn = guess_filename(v) or k
- fp = v
-
- if isinstance(fp, (str, bytes, bytearray)):
- fdata = fp
- elif hasattr(fp, "read"):
- fdata = fp.read()
- elif fp is None:
- continue
- else:
- fdata = fp
-
- rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
- rf.make_multipart(content_type=ft)
- new_fields.append(rf)
-
- body, content_type = encode_multipart_formdata(new_fields)
-
- return body, content_type
-
-
-class RequestHooksMixin:
- def register_hook(self, event, hook):
- """Properly register a hook."""
-
- if event not in self.hooks:
- raise ValueError(f'Unsupported event specified, with event name "{event}"')
-
- if isinstance(hook, Callable):
- self.hooks[event].append(hook)
- elif hasattr(hook, "__iter__"):
- self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
-
- def deregister_hook(self, event, hook):
- """Deregister a previously registered hook.
- Returns True if the hook existed, False if not.
- """
-
- try:
- self.hooks[event].remove(hook)
- return True
- except ValueError:
- return False
-
-
-class Request(RequestHooksMixin):
- """A user-created :class:`Request ` object.
-
- Used to prepare a :class:`PreparedRequest `, which is sent to the server.
-
- :param method: HTTP method to use.
- :param url: URL to send.
- :param headers: dictionary of headers to send.
- :param files: dictionary of {filename: fileobject} files to multipart upload.
- :param data: the body to attach to the request. If a dictionary or
- list of tuples ``[(key, value)]`` is provided, form-encoding will
- take place.
- :param json: json for the body to attach to the request (if files or data is not specified).
- :param params: URL parameters to append to the URL. If a dictionary or
- list of tuples ``[(key, value)]`` is provided, form-encoding will
- take place.
- :param auth: Auth handler or (user, pass) tuple.
- :param cookies: dictionary or CookieJar of cookies to attach to this request.
- :param hooks: dictionary of callback hooks, for internal usage.
-
- Usage::
-
- >>> import requests
- >>> req = requests.Request('GET', 'https://httpbin.org/get')
- >>> req.prepare()
-
- """
-
- def __init__(
- self,
- method=None,
- url=None,
- headers=None,
- files=None,
- data=None,
- params=None,
- auth=None,
- cookies=None,
- hooks=None,
- json=None,
- ):
-
- # Default empty dicts for dict params.
- data = [] if data is None else data
- files = [] if files is None else files
- headers = {} if headers is None else headers
- params = {} if params is None else params
- hooks = {} if hooks is None else hooks
-
- self.hooks = default_hooks()
- for (k, v) in list(hooks.items()):
- self.register_hook(event=k, hook=v)
-
- self.method = method
- self.url = url
- self.headers = headers
- self.files = files
- self.data = data
- self.json = json
- self.params = params
- self.auth = auth
- self.cookies = cookies
-
- def __repr__(self):
- return f""
-
- def prepare(self):
- """Constructs a :class:`PreparedRequest ` for transmission and returns it."""
- p = PreparedRequest()
- p.prepare(
- method=self.method,
- url=self.url,
- headers=self.headers,
- files=self.files,
- data=self.data,
- json=self.json,
- params=self.params,
- auth=self.auth,
- cookies=self.cookies,
- hooks=self.hooks,
- )
- return p
-
-
-class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
- """The fully mutable :class:`PreparedRequest ` object,
- containing the exact bytes that will be sent to the server.
-
- Instances are generated from a :class:`Request ` object, and
- should not be instantiated manually; doing so may produce undesirable
- effects.
-
- Usage::
-
- >>> import requests
- >>> req = requests.Request('GET', 'https://httpbin.org/get')
- >>> r = req.prepare()
- >>> r
-
-
- >>> s = requests.Session()
- >>> s.send(r)
-
- """
-
- def __init__(self):
- #: HTTP verb to send to the server.
- self.method = None
- #: HTTP URL to send the request to.
- self.url = None
- #: dictionary of HTTP headers.
- self.headers = None
- # The `CookieJar` used to create the Cookie header will be stored here
- # after prepare_cookies is called
- self._cookies = None
- #: request body to send to the server.
- self.body = None
- #: dictionary of callback hooks, for internal usage.
- self.hooks = default_hooks()
- #: integer denoting starting position of a readable file-like body.
- self._body_position = None
-
- def prepare(
- self,
- method=None,
- url=None,
- headers=None,
- files=None,
- data=None,
- params=None,
- auth=None,
- cookies=None,
- hooks=None,
- json=None,
- ):
- """Prepares the entire request with the given parameters."""
-
- self.prepare_method(method)
- self.prepare_url(url, params)
- self.prepare_headers(headers)
- self.prepare_cookies(cookies)
- self.prepare_body(data, files, json)
- self.prepare_auth(auth, url)
-
- # Note that prepare_auth must be last to enable authentication schemes
- # such as OAuth to work on a fully prepared request.
-
- # This MUST go after prepare_auth. Authenticators could add a hook
- self.prepare_hooks(hooks)
-
- def __repr__(self):
- return f""
-
- def copy(self):
- p = PreparedRequest()
- p.method = self.method
- p.url = self.url
- p.headers = self.headers.copy() if self.headers is not None else None
- p._cookies = _copy_cookie_jar(self._cookies)
- p.body = self.body
- p.hooks = self.hooks
- p._body_position = self._body_position
- return p
-
- def prepare_method(self, method):
- """Prepares the given HTTP method."""
- self.method = method
- if self.method is not None:
- self.method = to_native_string(self.method.upper())
-
- @staticmethod
- def _get_idna_encoded_host(host):
- import idna
-
- try:
- host = idna.encode(host, uts46=True).decode("utf-8")
- except idna.IDNAError:
- raise UnicodeError
- return host
-
- def prepare_url(self, url, params):
- """Prepares the given HTTP URL."""
- #: Accept objects that have string representations.
- #: We're unable to blindly call unicode/str functions
- #: as this will include the bytestring indicator (b'')
- #: on python 3.x.
- #: https://github.com/psf/requests/pull/2238
- if isinstance(url, bytes):
- url = url.decode("utf8")
- else:
- url = str(url)
-
- # Remove leading whitespaces from url
- url = url.lstrip()
-
- # Don't do any URL preparation for non-HTTP schemes like `mailto`,
- # `data` etc to work around exceptions from `url_parse`, which
- # handles RFC 3986 only.
- if ":" in url and not url.lower().startswith("http"):
- self.url = url
- return
-
- # Support for unicode domain names and paths.
- try:
- scheme, auth, host, port, path, query, fragment = parse_url(url)
- except LocationParseError as e:
- raise InvalidURL(*e.args)
-
- if not scheme:
- raise MissingSchema(
- f"Invalid URL {url!r}: No scheme supplied. "
- f"Perhaps you meant https://{url}?"
- )
-
- if not host:
- raise InvalidURL(f"Invalid URL {url!r}: No host supplied")
-
- # In general, we want to try IDNA encoding the hostname if the string contains
- # non-ASCII characters. This allows users to automatically get the correct IDNA
- # behaviour. For strings containing only ASCII characters, we need to also verify
- # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
- if not unicode_is_ascii(host):
- try:
- host = self._get_idna_encoded_host(host)
- except UnicodeError:
- raise InvalidURL("URL has an invalid label.")
- elif host.startswith(("*", ".")):
- raise InvalidURL("URL has an invalid label.")
-
- # Carefully reconstruct the network location
- netloc = auth or ""
- if netloc:
- netloc += "@"
- netloc += host
- if port:
- netloc += f":{port}"
-
- # Bare domains aren't valid URLs.
- if not path:
- path = "/"
-
- if isinstance(params, (str, bytes)):
- params = to_native_string(params)
-
- enc_params = self._encode_params(params)
- if enc_params:
- if query:
- query = f"{query}&{enc_params}"
- else:
- query = enc_params
-
- url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
- self.url = url
-
- def prepare_headers(self, headers):
- """Prepares the given HTTP headers."""
-
- self.headers = CaseInsensitiveDict()
- if headers:
- for header in headers.items():
- # Raise exception on invalid header value.
- check_header_validity(header)
- name, value = header
- self.headers[to_native_string(name)] = value
-
- def prepare_body(self, data, files, json=None):
- """Prepares the given HTTP body data."""
-
- # Check if file, fo, generator, iterator.
- # If not, run through normal process.
-
- # Nottin' on you.
- body = None
- content_type = None
-
- if not data and json is not None:
- # urllib3 requires a bytes-like body. Python 2's json.dumps
- # provides this natively, but Python 3 gives a Unicode string.
- content_type = "application/json"
-
- try:
- body = complexjson.dumps(json, allow_nan=False)
- except ValueError as ve:
- raise InvalidJSONError(ve, request=self)
-
- if not isinstance(body, bytes):
- body = body.encode("utf-8")
-
- is_stream = all(
- [
- hasattr(data, "__iter__"),
- not isinstance(data, (basestring, list, tuple, Mapping)),
- ]
- )
-
- if is_stream:
- try:
- length = super_len(data)
- except (TypeError, AttributeError, UnsupportedOperation):
- length = None
-
- body = data
-
- if getattr(body, "tell", None) is not None:
- # Record the current file position before reading.
- # This will allow us to rewind a file in the event
- # of a redirect.
- try:
- self._body_position = body.tell()
- except OSError:
- # This differentiates from None, allowing us to catch
- # a failed `tell()` later when trying to rewind the body
- self._body_position = object()
-
- if files:
- raise NotImplementedError(
- "Streamed bodies and files are mutually exclusive."
- )
-
- if length:
- self.headers["Content-Length"] = builtin_str(length)
- else:
- self.headers["Transfer-Encoding"] = "chunked"
- else:
- # Multi-part file uploads.
- if files:
- (body, content_type) = self._encode_files(files, data)
- else:
- if data:
- body = self._encode_params(data)
- if isinstance(data, basestring) or hasattr(data, "read"):
- content_type = None
- else:
- content_type = "application/x-www-form-urlencoded"
-
- self.prepare_content_length(body)
-
- # Add content-type if it wasn't explicitly provided.
- if content_type and ("content-type" not in self.headers):
- self.headers["Content-Type"] = content_type
-
- self.body = body
-
- def prepare_content_length(self, body):
- """Prepare Content-Length header based on request method and body"""
- if body is not None:
- length = super_len(body)
- if length:
- # If length exists, set it. Otherwise, we fallback
- # to Transfer-Encoding: chunked.
- self.headers["Content-Length"] = builtin_str(length)
- elif (
- self.method not in ("GET", "HEAD")
- and self.headers.get("Content-Length") is None
- ):
- # Set Content-Length to 0 for methods that can have a body
- # but don't provide one. (i.e. not GET or HEAD)
- self.headers["Content-Length"] = "0"
-
- def prepare_auth(self, auth, url=""):
- """Prepares the given HTTP auth data."""
-
- # If no Auth is explicitly provided, extract it from the URL first.
- if auth is None:
- url_auth = get_auth_from_url(self.url)
- auth = url_auth if any(url_auth) else None
-
- if auth:
- if isinstance(auth, tuple) and len(auth) == 2:
- # special-case basic HTTP auth
- auth = HTTPBasicAuth(*auth)
-
- # Allow auth to make its changes.
- r = auth(self)
-
- # Update self to reflect the auth changes.
- self.__dict__.update(r.__dict__)
-
- # Recompute Content-Length
- self.prepare_content_length(self.body)
-
- def prepare_cookies(self, cookies):
- """Prepares the given HTTP cookie data.
-
- This function eventually generates a ``Cookie`` header from the
- given cookies using cookielib. Due to cookielib's design, the header
- will not be regenerated if it already exists, meaning this function
- can only be called once for the life of the
- :class:`PreparedRequest ` object. Any subsequent calls
- to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
- header is removed beforehand.
- """
- if isinstance(cookies, cookielib.CookieJar):
- self._cookies = cookies
- else:
- self._cookies = cookiejar_from_dict(cookies)
-
- cookie_header = get_cookie_header(self._cookies, self)
- if cookie_header is not None:
- self.headers["Cookie"] = cookie_header
-
- def prepare_hooks(self, hooks):
- """Prepares the given hooks."""
- # hooks can be passed as None to the prepare method and to this
- # method. To prevent iterating over None, simply use an empty list
- # if hooks is False-y
- hooks = hooks or []
- for event in hooks:
- self.register_hook(event, hooks[event])
-
-
-class Response:
- """The :class:`Response ` object, which contains a
- server's response to an HTTP request.
- """
-
- __attrs__ = [
- "_content",
- "status_code",
- "headers",
- "url",
- "history",
- "encoding",
- "reason",
- "cookies",
- "elapsed",
- "request",
- ]
-
- def __init__(self):
- self._content = False
- self._content_consumed = False
- self._next = None
-
- #: Integer Code of responded HTTP Status, e.g. 404 or 200.
- self.status_code = None
-
- #: Case-insensitive Dictionary of Response Headers.
- #: For example, ``headers['content-encoding']`` will return the
- #: value of a ``'Content-Encoding'`` response header.
- self.headers = CaseInsensitiveDict()
-
- #: File-like object representation of response (for advanced usage).
- #: Use of ``raw`` requires that ``stream=True`` be set on the request.
- #: This requirement does not apply for use internally to Requests.
- self.raw = None
-
- #: Final URL location of Response.
- self.url = None
-
- #: Encoding to decode with when accessing r.text.
- self.encoding = None
-
- #: A list of :class:`Response ` objects from
- #: the history of the Request. Any redirect responses will end
- #: up here. The list is sorted from the oldest to the most recent request.
- self.history = []
-
- #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
- self.reason = None
-
- #: A CookieJar of Cookies the server sent back.
- self.cookies = cookiejar_from_dict({})
-
- #: The amount of time elapsed between sending the request
- #: and the arrival of the response (as a timedelta).
- #: This property specifically measures the time taken between sending
- #: the first byte of the request and finishing parsing the headers. It
- #: is therefore unaffected by consuming the response content or the
- #: value of the ``stream`` keyword argument.
- self.elapsed = datetime.timedelta(0)
-
- #: The :class:`PreparedRequest ` object to which this
- #: is a response.
- self.request = None
-
- def __enter__(self):
- return self
-
- def __exit__(self, *args):
- self.close()
-
- def __getstate__(self):
- # Consume everything; accessing the content attribute makes
- # sure the content has been fully read.
- if not self._content_consumed:
- self.content
-
- return {attr: getattr(self, attr, None) for attr in self.__attrs__}
-
- def __setstate__(self, state):
- for name, value in state.items():
- setattr(self, name, value)
-
- # pickled objects do not have .raw
- setattr(self, "_content_consumed", True)
- setattr(self, "raw", None)
-
- def __repr__(self):
- return f""
-
- def __bool__(self):
- """Returns True if :attr:`status_code` is less than 400.
-
- This attribute checks if the status code of the response is between
- 400 and 600 to see if there was a client error or a server error. If
- the status code, is between 200 and 400, this will return True. This
- is **not** a check to see if the response code is ``200 OK``.
- """
- return self.ok
-
- def __nonzero__(self):
- """Returns True if :attr:`status_code` is less than 400.
-
- This attribute checks if the status code of the response is between
- 400 and 600 to see if there was a client error or a server error. If
- the status code, is between 200 and 400, this will return True. This
- is **not** a check to see if the response code is ``200 OK``.
- """
- return self.ok
-
- def __iter__(self):
- """Allows you to use a response as an iterator."""
- return self.iter_content(128)
-
- @property
- def ok(self):
- """Returns True if :attr:`status_code` is less than 400, False if not.
-
- This attribute checks if the status code of the response is between
- 400 and 600 to see if there was a client error or a server error. If
- the status code is between 200 and 400, this will return True. This
- is **not** a check to see if the response code is ``200 OK``.
- """
- try:
- self.raise_for_status()
- except HTTPError:
- return False
- return True
-
- @property
- def is_redirect(self):
- """True if this Response is a well-formed HTTP redirect that could have
- been processed automatically (by :meth:`Session.resolve_redirects`).
- """
- return "location" in self.headers and self.status_code in REDIRECT_STATI
-
- @property
- def is_permanent_redirect(self):
- """True if this Response one of the permanent versions of redirect."""
- return "location" in self.headers and self.status_code in (
- codes.moved_permanently,
- codes.permanent_redirect,
- )
-
- @property
- def next(self):
- """Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
- return self._next
-
- @property
- def apparent_encoding(self):
- """The apparent encoding, provided by the charset_normalizer or chardet libraries."""
- return chardet.detect(self.content)["encoding"]
-
- def iter_content(self, chunk_size=1, decode_unicode=False):
- """Iterates over the response data. When stream=True is set on the
- request, this avoids reading the content at once into memory for
- large responses. The chunk size is the number of bytes it should
- read into memory. This is not necessarily the length of each item
- returned as decoding can take place.
-
- chunk_size must be of type int or None. A value of None will
- function differently depending on the value of `stream`.
- stream=True will read data as it arrives in whatever size the
- chunks are received. If stream=False, data is returned as
- a single chunk.
-
- If decode_unicode is True, content will be decoded using the best
- available encoding based on the response.
- """
-
- def generate():
- # Special case for urllib3.
- if hasattr(self.raw, "stream"):
- try:
- yield from self.raw.stream(chunk_size, decode_content=True)
- except ProtocolError as e:
- raise ChunkedEncodingError(e)
- except DecodeError as e:
- raise ContentDecodingError(e)
- except ReadTimeoutError as e:
- raise ConnectionError(e)
- except SSLError as e:
- raise RequestsSSLError(e)
- else:
- # Standard file-like object.
- while True:
- chunk = self.raw.read(chunk_size)
- if not chunk:
- break
- yield chunk
-
- self._content_consumed = True
-
- if self._content_consumed and isinstance(self._content, bool):
- raise StreamConsumedError()
- elif chunk_size is not None and not isinstance(chunk_size, int):
- raise TypeError(
- f"chunk_size must be an int, it is instead a {type(chunk_size)}."
- )
- # simulate reading small chunks of the content
- reused_chunks = iter_slices(self._content, chunk_size)
-
- stream_chunks = generate()
-
- chunks = reused_chunks if self._content_consumed else stream_chunks
-
- if decode_unicode:
- chunks = stream_decode_response_unicode(chunks, self)
-
- return chunks
-
- def iter_lines(
- self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None
- ):
- """Iterates over the response data, one line at a time. When
- stream=True is set on the request, this avoids reading the
- content at once into memory for large responses.
-
- .. note:: This method is not reentrant safe.
- """
-
- pending = None
-
- for chunk in self.iter_content(
- chunk_size=chunk_size, decode_unicode=decode_unicode
- ):
-
- if pending is not None:
- chunk = pending + chunk
-
- if delimiter:
- lines = chunk.split(delimiter)
- else:
- lines = chunk.splitlines()
-
- if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
- pending = lines.pop()
- else:
- pending = None
-
- yield from lines
-
- if pending is not None:
- yield pending
-
- @property
- def content(self):
- """Content of the response, in bytes."""
-
- if self._content is False:
- # Read the contents.
- if self._content_consumed:
- raise RuntimeError("The content for this response was already consumed")
-
- if self.status_code == 0 or self.raw is None:
- self._content = None
- else:
- self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b""
-
- self._content_consumed = True
- # don't need to release the connection; that's been handled by urllib3
- # since we exhausted the data.
- return self._content
-
- @property
- def text(self):
- """Content of the response, in unicode.
-
- If Response.encoding is None, encoding will be guessed using
- ``charset_normalizer`` or ``chardet``.
-
- The encoding of the response content is determined based solely on HTTP
- headers, following RFC 2616 to the letter. If you can take advantage of
- non-HTTP knowledge to make a better guess at the encoding, you should
- set ``r.encoding`` appropriately before accessing this property.
- """
-
- # Try charset from content-type
- content = None
- encoding = self.encoding
-
- if not self.content:
- return ""
-
- # Fallback to auto-detected encoding.
- if self.encoding is None:
- encoding = self.apparent_encoding
-
- # Decode unicode from given encoding.
- try:
- content = str(self.content, encoding, errors="replace")
- except (LookupError, TypeError):
- # A LookupError is raised if the encoding was not found which could
- # indicate a misspelling or similar mistake.
- #
- # A TypeError can be raised if encoding is None
- #
- # So we try blindly encoding.
- content = str(self.content, errors="replace")
-
- return content
-
- def json(self, **kwargs):
- r"""Returns the json-encoded content of a response, if any.
-
- :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
- :raises requests.exceptions.JSONDecodeError: If the response body does not
- contain valid json.
- """
-
- if not self.encoding and self.content and len(self.content) > 3:
- # No encoding set. JSON RFC 4627 section 3 states we should expect
- # UTF-8, -16 or -32. Detect which one to use; If the detection or
- # decoding fails, fall back to `self.text` (using charset_normalizer to make
- # a best guess).
- encoding = guess_json_utf(self.content)
- if encoding is not None:
- try:
- return complexjson.loads(self.content.decode(encoding), **kwargs)
- except UnicodeDecodeError:
- # Wrong UTF codec detected; usually because it's not UTF-8
- # but some other 8-bit codec. This is an RFC violation,
- # and the server didn't bother to tell us what codec *was*
- # used.
- pass
- except JSONDecodeError as e:
- raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
-
- try:
- return complexjson.loads(self.text, **kwargs)
- except JSONDecodeError as e:
- # Catch JSON-related errors and raise as requests.JSONDecodeError
- # This aliases json.JSONDecodeError and simplejson.JSONDecodeError
- raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
-
- @property
- def links(self):
- """Returns the parsed header links of the response, if any."""
-
- header = self.headers.get("link")
-
- resolved_links = {}
-
- if header:
- links = parse_header_links(header)
-
- for link in links:
- key = link.get("rel") or link.get("url")
- resolved_links[key] = link
-
- return resolved_links
-
- def raise_for_status(self):
- """Raises :class:`HTTPError`, if one occurred."""
-
- http_error_msg = ""
- if isinstance(self.reason, bytes):
- # We attempt to decode utf-8 first because some servers
- # choose to localize their reason strings. If the string
- # isn't utf-8, we fall back to iso-8859-1 for all other
- # encodings. (See PR #3538)
- try:
- reason = self.reason.decode("utf-8")
- except UnicodeDecodeError:
- reason = self.reason.decode("iso-8859-1")
- else:
- reason = self.reason
-
- if 400 <= self.status_code < 500:
- http_error_msg = (
- f"{self.status_code} Client Error: {reason} for url: {self.url}"
- )
-
- elif 500 <= self.status_code < 600:
- http_error_msg = (
- f"{self.status_code} Server Error: {reason} for url: {self.url}"
- )
-
- if http_error_msg:
- raise HTTPError(http_error_msg, response=self)
-
- def close(self):
- """Releases the connection back to the pool. Once this method has been
- called the underlying ``raw`` object must not be accessed again.
-
- *Note: Should not normally need to be called explicitly.*
- """
- if not self._content_consumed:
- self.raw.close()
-
- release_conn = getattr(self.raw, "release_conn", None)
- if release_conn is not None:
- release_conn()
diff --git a/lib/requests/packages.py b/lib/requests/packages.py
deleted file mode 100644
index 77c45c9..0000000
--- a/lib/requests/packages.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import sys
-
-try:
- import chardet
-except ImportError:
- import warnings
-
- import charset_normalizer as chardet
-
- warnings.filterwarnings("ignore", "Trying to detect", module="charset_normalizer")
-
-# This code exists for backwards compatibility reasons.
-# I don't like it either. Just look the other way. :)
-
-for package in ("urllib3", "idna"):
- locals()[package] = __import__(package)
- # This traversal is apparently necessary such that the identities are
- # preserved (requests.packages.urllib3.* is urllib3.*)
- for mod in list(sys.modules):
- if mod == package or mod.startswith(f"{package}."):
- sys.modules[f"requests.packages.{mod}"] = sys.modules[mod]
-
-target = chardet.__name__
-for mod in list(sys.modules):
- if mod == target or mod.startswith(f"{target}."):
- target = target.replace(target, "chardet")
- sys.modules[f"requests.packages.{target}"] = sys.modules[mod]
-# Kinda cool, though, right?
diff --git a/lib/requests/sessions.py b/lib/requests/sessions.py
deleted file mode 100644
index dbcf2a7..0000000
--- a/lib/requests/sessions.py
+++ /dev/null
@@ -1,833 +0,0 @@
-"""
-requests.sessions
-~~~~~~~~~~~~~~~~~
-
-This module provides a Session object to manage and persist settings across
-requests (cookies, auth, proxies).
-"""
-import os
-import sys
-import time
-from collections import OrderedDict
-from datetime import timedelta
-
-from ._internal_utils import to_native_string
-from .adapters import HTTPAdapter
-from .auth import _basic_auth_str
-from .compat import Mapping, cookielib, urljoin, urlparse
-from .cookies import (
- RequestsCookieJar,
- cookiejar_from_dict,
- extract_cookies_to_jar,
- merge_cookies,
-)
-from .exceptions import (
- ChunkedEncodingError,
- ContentDecodingError,
- InvalidSchema,
- TooManyRedirects,
-)
-from .hooks import default_hooks, dispatch_hook
-
-# formerly defined here, reexposed here for backward compatibility
-from .models import ( # noqa: F401
- DEFAULT_REDIRECT_LIMIT,
- REDIRECT_STATI,
- PreparedRequest,
- Request,
-)
-from .status_codes import codes
-from .structures import CaseInsensitiveDict
-from .utils import ( # noqa: F401
- DEFAULT_PORTS,
- default_headers,
- get_auth_from_url,
- get_environ_proxies,
- get_netrc_auth,
- requote_uri,
- resolve_proxies,
- rewind_body,
- should_bypass_proxies,
- to_key_val_list,
-)
-
-# Preferred clock, based on which one is more accurate on a given system.
-if sys.platform == "win32":
- preferred_clock = time.perf_counter
-else:
- preferred_clock = time.time
-
-
-def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
- """Determines appropriate setting for a given request, taking into account
- the explicit setting on that request, and the setting in the session. If a
- setting is a dictionary, they will be merged together using `dict_class`
- """
-
- if session_setting is None:
- return request_setting
-
- if request_setting is None:
- return session_setting
-
- # Bypass if not a dictionary (e.g. verify)
- if not (
- isinstance(session_setting, Mapping) and isinstance(request_setting, Mapping)
- ):
- return request_setting
-
- merged_setting = dict_class(to_key_val_list(session_setting))
- merged_setting.update(to_key_val_list(request_setting))
-
- # Remove keys that are set to None. Extract keys first to avoid altering
- # the dictionary during iteration.
- none_keys = [k for (k, v) in merged_setting.items() if v is None]
- for key in none_keys:
- del merged_setting[key]
-
- return merged_setting
-
-
-def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict):
- """Properly merges both requests and session hooks.
-
- This is necessary because when request_hooks == {'response': []}, the
- merge breaks Session hooks entirely.
- """
- if session_hooks is None or session_hooks.get("response") == []:
- return request_hooks
-
- if request_hooks is None or request_hooks.get("response") == []:
- return session_hooks
-
- return merge_setting(request_hooks, session_hooks, dict_class)
-
-
-class SessionRedirectMixin:
- def get_redirect_target(self, resp):
- """Receives a Response. Returns a redirect URI or ``None``"""
- # Due to the nature of how requests processes redirects this method will
- # be called at least once upon the original response and at least twice
- # on each subsequent redirect response (if any).
- # If a custom mixin is used to handle this logic, it may be advantageous
- # to cache the redirect location onto the response object as a private
- # attribute.
- if resp.is_redirect:
- location = resp.headers["location"]
- # Currently the underlying http module on py3 decode headers
- # in latin1, but empirical evidence suggests that latin1 is very
- # rarely used with non-ASCII characters in HTTP headers.
- # It is more likely to get UTF8 header rather than latin1.
- # This causes incorrect handling of UTF8 encoded location headers.
- # To solve this, we re-encode the location in latin1.
- location = location.encode("latin1")
- return to_native_string(location, "utf8")
- return None
-
- def should_strip_auth(self, old_url, new_url):
- """Decide whether Authorization header should be removed when redirecting"""
- old_parsed = urlparse(old_url)
- new_parsed = urlparse(new_url)
- if old_parsed.hostname != new_parsed.hostname:
- return True
- # Special case: allow http -> https redirect when using the standard
- # ports. This isn't specified by RFC 7235, but is kept to avoid
- # breaking backwards compatibility with older versions of requests
- # that allowed any redirects on the same host.
- if (
- old_parsed.scheme == "http"
- and old_parsed.port in (80, None)
- and new_parsed.scheme == "https"
- and new_parsed.port in (443, None)
- ):
- return False
-
- # Handle default port usage corresponding to scheme.
- changed_port = old_parsed.port != new_parsed.port
- changed_scheme = old_parsed.scheme != new_parsed.scheme
- default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None)
- if (
- not changed_scheme
- and old_parsed.port in default_port
- and new_parsed.port in default_port
- ):
- return False
-
- # Standard case: root URI must match
- return changed_port or changed_scheme
-
- def resolve_redirects(
- self,
- resp,
- req,
- stream=False,
- timeout=None,
- verify=True,
- cert=None,
- proxies=None,
- yield_requests=False,
- **adapter_kwargs,
- ):
- """Receives a Response. Returns a generator of Responses or Requests."""
-
- hist = [] # keep track of history
-
- url = self.get_redirect_target(resp)
- previous_fragment = urlparse(req.url).fragment
- while url:
- prepared_request = req.copy()
-
- # Update history and keep track of redirects.
- # resp.history must ignore the original request in this loop
- hist.append(resp)
- resp.history = hist[1:]
-
- try:
- resp.content # Consume socket so it can be released
- except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
- resp.raw.read(decode_content=False)
-
- if len(resp.history) >= self.max_redirects:
- raise TooManyRedirects(
- f"Exceeded {self.max_redirects} redirects.", response=resp
- )
-
- # Release the connection back into the pool.
- resp.close()
-
- # Handle redirection without scheme (see: RFC 1808 Section 4)
- if url.startswith("//"):
- parsed_rurl = urlparse(resp.url)
- url = ":".join([to_native_string(parsed_rurl.scheme), url])
-
- # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2)
- parsed = urlparse(url)
- if parsed.fragment == "" and previous_fragment:
- parsed = parsed._replace(fragment=previous_fragment)
- elif parsed.fragment:
- previous_fragment = parsed.fragment
- url = parsed.geturl()
-
- # Facilitate relative 'location' headers, as allowed by RFC 7231.
- # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
- # Compliant with RFC3986, we percent encode the url.
- if not parsed.netloc:
- url = urljoin(resp.url, requote_uri(url))
- else:
- url = requote_uri(url)
-
- prepared_request.url = to_native_string(url)
-
- self.rebuild_method(prepared_request, resp)
-
- # https://github.com/psf/requests/issues/1084
- if resp.status_code not in (
- codes.temporary_redirect,
- codes.permanent_redirect,
- ):
- # https://github.com/psf/requests/issues/3490
- purged_headers = ("Content-Length", "Content-Type", "Transfer-Encoding")
- for header in purged_headers:
- prepared_request.headers.pop(header, None)
- prepared_request.body = None
-
- headers = prepared_request.headers
- headers.pop("Cookie", None)
-
- # Extract any cookies sent on the response to the cookiejar
- # in the new request. Because we've mutated our copied prepared
- # request, use the old one that we haven't yet touched.
- extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
- merge_cookies(prepared_request._cookies, self.cookies)
- prepared_request.prepare_cookies(prepared_request._cookies)
-
- # Rebuild auth and proxy information.
- proxies = self.rebuild_proxies(prepared_request, proxies)
- self.rebuild_auth(prepared_request, resp)
-
- # A failed tell() sets `_body_position` to `object()`. This non-None
- # value ensures `rewindable` will be True, allowing us to raise an
- # UnrewindableBodyError, instead of hanging the connection.
- rewindable = prepared_request._body_position is not None and (
- "Content-Length" in headers or "Transfer-Encoding" in headers
- )
-
- # Attempt to rewind consumed file-like object.
- if rewindable:
- rewind_body(prepared_request)
-
- # Override the original request.
- req = prepared_request
-
- if yield_requests:
- yield req
- else:
-
- resp = self.send(
- req,
- stream=stream,
- timeout=timeout,
- verify=verify,
- cert=cert,
- proxies=proxies,
- allow_redirects=False,
- **adapter_kwargs,
- )
-
- extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)
-
- # extract redirect url, if any, for the next loop
- url = self.get_redirect_target(resp)
- yield resp
-
- def rebuild_auth(self, prepared_request, response):
- """When being redirected we may want to strip authentication from the
- request to avoid leaking credentials. This method intelligently removes
- and reapplies authentication where possible to avoid credential loss.
- """
- headers = prepared_request.headers
- url = prepared_request.url
-
- if "Authorization" in headers and self.should_strip_auth(
- response.request.url, url
- ):
- # If we get redirected to a new host, we should strip out any
- # authentication headers.
- del headers["Authorization"]
-
- # .netrc might have more auth for us on our new host.
- new_auth = get_netrc_auth(url) if self.trust_env else None
- if new_auth is not None:
- prepared_request.prepare_auth(new_auth)
-
- def rebuild_proxies(self, prepared_request, proxies):
- """This method re-evaluates the proxy configuration by considering the
- environment variables. If we are redirected to a URL covered by
- NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
- proxy keys for this URL (in case they were stripped by a previous
- redirect).
-
- This method also replaces the Proxy-Authorization header where
- necessary.
-
- :rtype: dict
- """
- headers = prepared_request.headers
- scheme = urlparse(prepared_request.url).scheme
- new_proxies = resolve_proxies(prepared_request, proxies, self.trust_env)
-
- if "Proxy-Authorization" in headers:
- del headers["Proxy-Authorization"]
-
- try:
- username, password = get_auth_from_url(new_proxies[scheme])
- except KeyError:
- username, password = None, None
-
- # urllib3 handles proxy authorization for us in the standard adapter.
- # Avoid appending this to TLS tunneled requests where it may be leaked.
- if not scheme.startswith('https') and username and password:
- headers["Proxy-Authorization"] = _basic_auth_str(username, password)
-
- return new_proxies
-
- def rebuild_method(self, prepared_request, response):
- """When being redirected we may want to change the method of the request
- based on certain specs or browser behavior.
- """
- method = prepared_request.method
-
- # https://tools.ietf.org/html/rfc7231#section-6.4.4
- if response.status_code == codes.see_other and method != "HEAD":
- method = "GET"
-
- # Do what the browsers do, despite standards...
- # First, turn 302s into GETs.
- if response.status_code == codes.found and method != "HEAD":
- method = "GET"
-
- # Second, if a POST is responded to with a 301, turn it into a GET.
- # This bizarre behaviour is explained in Issue 1704.
- if response.status_code == codes.moved and method == "POST":
- method = "GET"
-
- prepared_request.method = method
-
-
-class Session(SessionRedirectMixin):
- """A Requests session.
-
- Provides cookie persistence, connection-pooling, and configuration.
-
- Basic Usage::
-
- >>> import requests
- >>> s = requests.Session()
- >>> s.get('https://httpbin.org/get')
-
-
- Or as a context manager::
-
- >>> with requests.Session() as s:
- ... s.get('https://httpbin.org/get')
-
- """
-
- __attrs__ = [
- "headers",
- "cookies",
- "auth",
- "proxies",
- "hooks",
- "params",
- "verify",
- "cert",
- "adapters",
- "stream",
- "trust_env",
- "max_redirects",
- ]
-
- def __init__(self):
-
- #: A case-insensitive dictionary of headers to be sent on each
- #: :class:`Request ` sent from this
- #: :class:`Session `.
- self.headers = default_headers()
-
- #: Default Authentication tuple or object to attach to
- #: :class:`Request `.
- self.auth = None
-
- #: Dictionary mapping protocol or protocol and host to the URL of the proxy
- #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
- #: be used on each :class:`Request `.
- self.proxies = {}
-
- #: Event-handling hooks.
- self.hooks = default_hooks()
-
- #: Dictionary of querystring data to attach to each
- #: :class:`Request `. The dictionary values may be lists for
- #: representing multivalued query parameters.
- self.params = {}
-
- #: Stream response content default.
- self.stream = False
-
- #: SSL Verification default.
- #: Defaults to `True`, requiring requests to verify the TLS certificate at the
- #: remote end.
- #: If verify is set to `False`, requests will accept any TLS certificate
- #: presented by the server, and will ignore hostname mismatches and/or
- #: expired certificates, which will make your application vulnerable to
- #: man-in-the-middle (MitM) attacks.
- #: Only set this to `False` for testing.
- self.verify = True
-
- #: SSL client certificate default, if String, path to ssl client
- #: cert file (.pem). If Tuple, ('cert', 'key') pair.
- self.cert = None
-
- #: Maximum number of redirects allowed. If the request exceeds this
- #: limit, a :class:`TooManyRedirects` exception is raised.
- #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
- #: 30.
- self.max_redirects = DEFAULT_REDIRECT_LIMIT
-
- #: Trust environment settings for proxy configuration, default
- #: authentication and similar.
- self.trust_env = True
-
- #: A CookieJar containing all currently outstanding cookies set on this
- #: session. By default it is a
- #: :class:`RequestsCookieJar `, but
- #: may be any other ``cookielib.CookieJar`` compatible object.
- self.cookies = cookiejar_from_dict({})
-
- # Default connection adapters.
- self.adapters = OrderedDict()
- self.mount("https://", HTTPAdapter())
- self.mount("http://", HTTPAdapter())
-
- def __enter__(self):
- return self
-
- def __exit__(self, *args):
- self.close()
-
- def prepare_request(self, request):
- """Constructs a :class:`PreparedRequest ` for
- transmission and returns it. The :class:`PreparedRequest` has settings
- merged from the :class:`Request ` instance and those of the
- :class:`Session`.
-
- :param request: :class:`Request` instance to prepare with this
- session's settings.
- :rtype: requests.PreparedRequest
- """
- cookies = request.cookies or {}
-
- # Bootstrap CookieJar.
- if not isinstance(cookies, cookielib.CookieJar):
- cookies = cookiejar_from_dict(cookies)
-
- # Merge with session cookies
- merged_cookies = merge_cookies(
- merge_cookies(RequestsCookieJar(), self.cookies), cookies
- )
-
- # Set environment's basic authentication if not explicitly set.
- auth = request.auth
- if self.trust_env and not auth and not self.auth:
- auth = get_netrc_auth(request.url)
-
- p = PreparedRequest()
- p.prepare(
- method=request.method.upper(),
- url=request.url,
- files=request.files,
- data=request.data,
- json=request.json,
- headers=merge_setting(
- request.headers, self.headers, dict_class=CaseInsensitiveDict
- ),
- params=merge_setting(request.params, self.params),
- auth=merge_setting(auth, self.auth),
- cookies=merged_cookies,
- hooks=merge_hooks(request.hooks, self.hooks),
- )
- return p
-
- def request(
- self,
- method,
- url,
- params=None,
- data=None,
- headers=None,
- cookies=None,
- files=None,
- auth=None,
- timeout=None,
- allow_redirects=True,
- proxies=None,
- hooks=None,
- stream=None,
- verify=None,
- cert=None,
- json=None,
- ):
- """Constructs a :class:`Request `, prepares it and sends it.
- Returns :class:`Response ` object.
-
- :param method: method for the new :class:`Request` object.
- :param url: URL for the new :class:`Request` object.
- :param params: (optional) Dictionary or bytes to be sent in the query
- string for the :class:`Request`.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) json to send in the body of the
- :class:`Request`.
- :param headers: (optional) Dictionary of HTTP Headers to send with the
- :class:`Request`.
- :param cookies: (optional) Dict or CookieJar object to send with the
- :class:`Request`.
- :param files: (optional) Dictionary of ``'filename': file-like-objects``
- for multipart encoding upload.
- :param auth: (optional) Auth tuple or callable to enable
- Basic/Digest/Custom HTTP Auth.
- :param timeout: (optional) How long to wait for the server to send
- data before giving up, as a float, or a :ref:`(connect timeout,
- read timeout) ` tuple.
- :type timeout: float or tuple
- :param allow_redirects: (optional) Set to True by default.
- :type allow_redirects: bool
- :param proxies: (optional) Dictionary mapping protocol or protocol and
- hostname to the URL of the proxy.
- :param stream: (optional) whether to immediately download the response
- content. Defaults to ``False``.
- :param verify: (optional) Either a boolean, in which case it controls whether we verify
- the server's TLS certificate, or a string, in which case it must be a path
- to a CA bundle to use. Defaults to ``True``. When set to
- ``False``, requests will accept any TLS certificate presented by
- the server, and will ignore hostname mismatches and/or expired
- certificates, which will make your application vulnerable to
- man-in-the-middle (MitM) attacks. Setting verify to ``False``
- may be useful during local development or testing.
- :param cert: (optional) if String, path to ssl client cert file (.pem).
- If Tuple, ('cert', 'key') pair.
- :rtype: requests.Response
- """
- # Create the Request.
- req = Request(
- method=method.upper(),
- url=url,
- headers=headers,
- files=files,
- data=data or {},
- json=json,
- params=params or {},
- auth=auth,
- cookies=cookies,
- hooks=hooks,
- )
- prep = self.prepare_request(req)
-
- proxies = proxies or {}
-
- settings = self.merge_environment_settings(
- prep.url, proxies, stream, verify, cert
- )
-
- # Send the request.
- send_kwargs = {
- "timeout": timeout,
- "allow_redirects": allow_redirects,
- }
- send_kwargs.update(settings)
- resp = self.send(prep, **send_kwargs)
-
- return resp
-
- def get(self, url, **kwargs):
- r"""Sends a GET request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- kwargs.setdefault("allow_redirects", True)
- return self.request("GET", url, **kwargs)
-
- def options(self, url, **kwargs):
- r"""Sends a OPTIONS request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- kwargs.setdefault("allow_redirects", True)
- return self.request("OPTIONS", url, **kwargs)
-
- def head(self, url, **kwargs):
- r"""Sends a HEAD request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- kwargs.setdefault("allow_redirects", False)
- return self.request("HEAD", url, **kwargs)
-
- def post(self, url, data=None, json=None, **kwargs):
- r"""Sends a POST request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param json: (optional) json to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- return self.request("POST", url, data=data, json=json, **kwargs)
-
- def put(self, url, data=None, **kwargs):
- r"""Sends a PUT request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- return self.request("PUT", url, data=data, **kwargs)
-
- def patch(self, url, data=None, **kwargs):
- r"""Sends a PATCH request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param data: (optional) Dictionary, list of tuples, bytes, or file-like
- object to send in the body of the :class:`Request`.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- return self.request("PATCH", url, data=data, **kwargs)
-
- def delete(self, url, **kwargs):
- r"""Sends a DELETE request. Returns :class:`Response` object.
-
- :param url: URL for the new :class:`Request` object.
- :param \*\*kwargs: Optional arguments that ``request`` takes.
- :rtype: requests.Response
- """
-
- return self.request("DELETE", url, **kwargs)
-
- def send(self, request, **kwargs):
- """Send a given PreparedRequest.
-
- :rtype: requests.Response
- """
- # Set defaults that the hooks can utilize to ensure they always have
- # the correct parameters to reproduce the previous request.
- kwargs.setdefault("stream", self.stream)
- kwargs.setdefault("verify", self.verify)
- kwargs.setdefault("cert", self.cert)
- if "proxies" not in kwargs:
- kwargs["proxies"] = resolve_proxies(request, self.proxies, self.trust_env)
-
- # It's possible that users might accidentally send a Request object.
- # Guard against that specific failure case.
- if isinstance(request, Request):
- raise ValueError("You can only send PreparedRequests.")
-
- # Set up variables needed for resolve_redirects and dispatching of hooks
- allow_redirects = kwargs.pop("allow_redirects", True)
- stream = kwargs.get("stream")
- hooks = request.hooks
-
- # Get the appropriate adapter to use
- adapter = self.get_adapter(url=request.url)
-
- # Start time (approximately) of the request
- start = preferred_clock()
-
- # Send the request
- r = adapter.send(request, **kwargs)
-
- # Total elapsed time of the request (approximately)
- elapsed = preferred_clock() - start
- r.elapsed = timedelta(seconds=elapsed)
-
- # Response manipulation hooks
- r = dispatch_hook("response", hooks, r, **kwargs)
-
- # Persist cookies
- if r.history:
-
- # If the hooks create history then we want those cookies too
- for resp in r.history:
- extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
-
- extract_cookies_to_jar(self.cookies, request, r.raw)
-
- # Resolve redirects if allowed.
- if allow_redirects:
- # Redirect resolving generator.
- gen = self.resolve_redirects(r, request, **kwargs)
- history = [resp for resp in gen]
- else:
- history = []
-
- # Shuffle things around if there's history.
- if history:
- # Insert the first (original) request at the start
- history.insert(0, r)
- # Get the last request made
- r = history.pop()
- r.history = history
-
- # If redirects aren't being followed, store the response on the Request for Response.next().
- if not allow_redirects:
- try:
- r._next = next(
- self.resolve_redirects(r, request, yield_requests=True, **kwargs)
- )
- except StopIteration:
- pass
-
- if not stream:
- r.content
-
- return r
-
- def merge_environment_settings(self, url, proxies, stream, verify, cert):
- """
- Check the environment and merge it with some settings.
-
- :rtype: dict
- """
- # Gather clues from the surrounding environment.
- if self.trust_env:
- # Set environment's proxies.
- no_proxy = proxies.get("no_proxy") if proxies is not None else None
- env_proxies = get_environ_proxies(url, no_proxy=no_proxy)
- for (k, v) in env_proxies.items():
- proxies.setdefault(k, v)
-
- # Look for requests environment configuration
- # and be compatible with cURL.
- if verify is True or verify is None:
- verify = (
- os.environ.get("REQUESTS_CA_BUNDLE")
- or os.environ.get("CURL_CA_BUNDLE")
- or verify
- )
-
- # Merge all the kwargs.
- proxies = merge_setting(proxies, self.proxies)
- stream = merge_setting(stream, self.stream)
- verify = merge_setting(verify, self.verify)
- cert = merge_setting(cert, self.cert)
-
- return {"proxies": proxies, "stream": stream, "verify": verify, "cert": cert}
-
- def get_adapter(self, url):
- """
- Returns the appropriate connection adapter for the given URL.
-
- :rtype: requests.adapters.BaseAdapter
- """
- for (prefix, adapter) in self.adapters.items():
-
- if url.lower().startswith(prefix.lower()):
- return adapter
-
- # Nothing matches :-/
- raise InvalidSchema(f"No connection adapters were found for {url!r}")
-
- def close(self):
- """Closes all adapters and as such the session"""
- for v in self.adapters.values():
- v.close()
-
- def mount(self, prefix, adapter):
- """Registers a connection adapter to a prefix.
-
- Adapters are sorted in descending order by prefix length.
- """
- self.adapters[prefix] = adapter
- keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
-
- for key in keys_to_move:
- self.adapters[key] = self.adapters.pop(key)
-
- def __getstate__(self):
- state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
- return state
-
- def __setstate__(self, state):
- for attr, value in state.items():
- setattr(self, attr, value)
-
-
-def session():
- """
- Returns a :class:`Session` for context-management.
-
- .. deprecated:: 1.0.0
-
- This method has been deprecated since version 1.0.0 and is only kept for
- backwards compatibility. New code should use :class:`~requests.sessions.Session`
- to create a session. This may be removed at a future date.
-
- :rtype: Session
- """
- return Session()
diff --git a/lib/requests/status_codes.py b/lib/requests/status_codes.py
deleted file mode 100644
index 4bd072b..0000000
--- a/lib/requests/status_codes.py
+++ /dev/null
@@ -1,128 +0,0 @@
-r"""
-The ``codes`` object defines a mapping from common names for HTTP statuses
-to their numerical codes, accessible either as attributes or as dictionary
-items.
-
-Example::
-
- >>> import requests
- >>> requests.codes['temporary_redirect']
- 307
- >>> requests.codes.teapot
- 418
- >>> requests.codes['\o/']
- 200
-
-Some codes have multiple names, and both upper- and lower-case versions of
-the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
-``codes.okay`` all correspond to the HTTP status code 200.
-"""
-
-from .structures import LookupDict
-
-_codes = {
- # Informational.
- 100: ("continue",),
- 101: ("switching_protocols",),
- 102: ("processing",),
- 103: ("checkpoint",),
- 122: ("uri_too_long", "request_uri_too_long"),
- 200: ("ok", "okay", "all_ok", "all_okay", "all_good", "\\o/", "✓"),
- 201: ("created",),
- 202: ("accepted",),
- 203: ("non_authoritative_info", "non_authoritative_information"),
- 204: ("no_content",),
- 205: ("reset_content", "reset"),
- 206: ("partial_content", "partial"),
- 207: ("multi_status", "multiple_status", "multi_stati", "multiple_stati"),
- 208: ("already_reported",),
- 226: ("im_used",),
- # Redirection.
- 300: ("multiple_choices",),
- 301: ("moved_permanently", "moved", "\\o-"),
- 302: ("found",),
- 303: ("see_other", "other"),
- 304: ("not_modified",),
- 305: ("use_proxy",),
- 306: ("switch_proxy",),
- 307: ("temporary_redirect", "temporary_moved", "temporary"),
- 308: (
- "permanent_redirect",
- "resume_incomplete",
- "resume",
- ), # "resume" and "resume_incomplete" to be removed in 3.0
- # Client Error.
- 400: ("bad_request", "bad"),
- 401: ("unauthorized",),
- 402: ("payment_required", "payment"),
- 403: ("forbidden",),
- 404: ("not_found", "-o-"),
- 405: ("method_not_allowed", "not_allowed"),
- 406: ("not_acceptable",),
- 407: ("proxy_authentication_required", "proxy_auth", "proxy_authentication"),
- 408: ("request_timeout", "timeout"),
- 409: ("conflict",),
- 410: ("gone",),
- 411: ("length_required",),
- 412: ("precondition_failed", "precondition"),
- 413: ("request_entity_too_large",),
- 414: ("request_uri_too_large",),
- 415: ("unsupported_media_type", "unsupported_media", "media_type"),
- 416: (
- "requested_range_not_satisfiable",
- "requested_range",
- "range_not_satisfiable",
- ),
- 417: ("expectation_failed",),
- 418: ("im_a_teapot", "teapot", "i_am_a_teapot"),
- 421: ("misdirected_request",),
- 422: ("unprocessable_entity", "unprocessable"),
- 423: ("locked",),
- 424: ("failed_dependency", "dependency"),
- 425: ("unordered_collection", "unordered"),
- 426: ("upgrade_required", "upgrade"),
- 428: ("precondition_required", "precondition"),
- 429: ("too_many_requests", "too_many"),
- 431: ("header_fields_too_large", "fields_too_large"),
- 444: ("no_response", "none"),
- 449: ("retry_with", "retry"),
- 450: ("blocked_by_windows_parental_controls", "parental_controls"),
- 451: ("unavailable_for_legal_reasons", "legal_reasons"),
- 499: ("client_closed_request",),
- # Server Error.
- 500: ("internal_server_error", "server_error", "/o\\", "✗"),
- 501: ("not_implemented",),
- 502: ("bad_gateway",),
- 503: ("service_unavailable", "unavailable"),
- 504: ("gateway_timeout",),
- 505: ("http_version_not_supported", "http_version"),
- 506: ("variant_also_negotiates",),
- 507: ("insufficient_storage",),
- 509: ("bandwidth_limit_exceeded", "bandwidth"),
- 510: ("not_extended",),
- 511: ("network_authentication_required", "network_auth", "network_authentication"),
-}
-
-codes = LookupDict(name="status_codes")
-
-
-def _init():
- for code, titles in _codes.items():
- for title in titles:
- setattr(codes, title, code)
- if not title.startswith(("\\", "/")):
- setattr(codes, title.upper(), code)
-
- def doc(code):
- names = ", ".join(f"``{n}``" for n in _codes[code])
- return "* %d: %s" % (code, names)
-
- global __doc__
- __doc__ = (
- __doc__ + "\n" + "\n".join(doc(code) for code in sorted(_codes))
- if __doc__ is not None
- else None
- )
-
-
-_init()
diff --git a/lib/requests/structures.py b/lib/requests/structures.py
deleted file mode 100644
index 188e13e..0000000
--- a/lib/requests/structures.py
+++ /dev/null
@@ -1,99 +0,0 @@
-"""
-requests.structures
-~~~~~~~~~~~~~~~~~~~
-
-Data structures that power Requests.
-"""
-
-from collections import OrderedDict
-
-from .compat import Mapping, MutableMapping
-
-
-class CaseInsensitiveDict(MutableMapping):
- """A case-insensitive ``dict``-like object.
-
- Implements all methods and operations of
- ``MutableMapping`` as well as dict's ``copy``. Also
- provides ``lower_items``.
-
- All keys are expected to be strings. The structure remembers the
- case of the last key to be set, and ``iter(instance)``,
- ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
- will contain case-sensitive keys. However, querying and contains
- testing is case insensitive::
-
- cid = CaseInsensitiveDict()
- cid['Accept'] = 'application/json'
- cid['aCCEPT'] == 'application/json' # True
- list(cid) == ['Accept'] # True
-
- For example, ``headers['content-encoding']`` will return the
- value of a ``'Content-Encoding'`` response header, regardless
- of how the header name was originally stored.
-
- If the constructor, ``.update``, or equality comparison
- operations are given keys that have equal ``.lower()``s, the
- behavior is undefined.
- """
-
- def __init__(self, data=None, **kwargs):
- self._store = OrderedDict()
- if data is None:
- data = {}
- self.update(data, **kwargs)
-
- def __setitem__(self, key, value):
- # Use the lowercased key for lookups, but store the actual
- # key alongside the value.
- self._store[key.lower()] = (key, value)
-
- def __getitem__(self, key):
- return self._store[key.lower()][1]
-
- def __delitem__(self, key):
- del self._store[key.lower()]
-
- def __iter__(self):
- return (casedkey for casedkey, mappedvalue in self._store.values())
-
- def __len__(self):
- return len(self._store)
-
- def lower_items(self):
- """Like iteritems(), but with all lowercase keys."""
- return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
-
- def __eq__(self, other):
- if isinstance(other, Mapping):
- other = CaseInsensitiveDict(other)
- else:
- return NotImplemented
- # Compare insensitively
- return dict(self.lower_items()) == dict(other.lower_items())
-
- # Copy is required
- def copy(self):
- return CaseInsensitiveDict(self._store.values())
-
- def __repr__(self):
- return str(dict(self.items()))
-
-
-class LookupDict(dict):
- """Dictionary lookup object."""
-
- def __init__(self, name=None):
- self.name = name
- super().__init__()
-
- def __repr__(self):
- return f""
-
- def __getitem__(self, key):
- # We allow fall-through here, so values default to None
-
- return self.__dict__.get(key, None)
-
- def get(self, key, default=None):
- return self.__dict__.get(key, default)
diff --git a/lib/requests/utils.py b/lib/requests/utils.py
deleted file mode 100644
index a367417..0000000
--- a/lib/requests/utils.py
+++ /dev/null
@@ -1,1094 +0,0 @@
-"""
-requests.utils
-~~~~~~~~~~~~~~
-
-This module provides utility functions that are used within Requests
-that are also useful for external consumption.
-"""
-
-import codecs
-import contextlib
-import io
-import os
-import re
-import socket
-import struct
-import sys
-import tempfile
-import warnings
-import zipfile
-from collections import OrderedDict
-
-from urllib3.util import make_headers, parse_url
-
-from . import certs
-from .__version__ import __version__
-
-# to_native_string is unused here, but imported here for backwards compatibility
-from ._internal_utils import ( # noqa: F401
- _HEADER_VALIDATORS_BYTE,
- _HEADER_VALIDATORS_STR,
- HEADER_VALIDATORS,
- to_native_string,
-)
-from .compat import (
- Mapping,
- basestring,
- bytes,
- getproxies,
- getproxies_environment,
- integer_types,
-)
-from .compat import parse_http_list as _parse_list_header
-from .compat import (
- proxy_bypass,
- proxy_bypass_environment,
- quote,
- str,
- unquote,
- urlparse,
- urlunparse,
-)
-from .cookies import cookiejar_from_dict
-from .exceptions import (
- FileModeWarning,
- InvalidHeader,
- InvalidURL,
- UnrewindableBodyError,
-)
-from .structures import CaseInsensitiveDict
-
-NETRC_FILES = (".netrc", "_netrc")
-
-DEFAULT_CA_BUNDLE_PATH = certs.where()
-
-DEFAULT_PORTS = {"http": 80, "https": 443}
-
-# Ensure that ', ' is used to preserve previous delimiter behavior.
-DEFAULT_ACCEPT_ENCODING = ", ".join(
- re.split(r",\s*", make_headers(accept_encoding=True)["accept-encoding"])
-)
-
-
-if sys.platform == "win32":
- # provide a proxy_bypass version on Windows without DNS lookups
-
- def proxy_bypass_registry(host):
- try:
- import winreg
- except ImportError:
- return False
-
- try:
- internetSettings = winreg.OpenKey(
- winreg.HKEY_CURRENT_USER,
- r"Software\Microsoft\Windows\CurrentVersion\Internet Settings",
- )
- # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it
- proxyEnable = int(winreg.QueryValueEx(internetSettings, "ProxyEnable")[0])
- # ProxyOverride is almost always a string
- proxyOverride = winreg.QueryValueEx(internetSettings, "ProxyOverride")[0]
- except (OSError, ValueError):
- return False
- if not proxyEnable or not proxyOverride:
- return False
-
- # make a check value list from the registry entry: replace the
- # '' string by the localhost entry and the corresponding
- # canonical entry.
- proxyOverride = proxyOverride.split(";")
- # now check if we match one of the registry values.
- for test in proxyOverride:
- if test == "":
- if "." not in host:
- return True
- test = test.replace(".", r"\.") # mask dots
- test = test.replace("*", r".*") # change glob sequence
- test = test.replace("?", r".") # change glob char
- if re.match(test, host, re.I):
- return True
- return False
-
- def proxy_bypass(host): # noqa
- """Return True, if the host should be bypassed.
-
- Checks proxy settings gathered from the environment, if specified,
- or the registry.
- """
- if getproxies_environment():
- return proxy_bypass_environment(host)
- else:
- return proxy_bypass_registry(host)
-
-
-def dict_to_sequence(d):
- """Returns an internal sequence dictionary update."""
-
- if hasattr(d, "items"):
- d = d.items()
-
- return d
-
-
-def super_len(o):
- total_length = None
- current_position = 0
-
- if hasattr(o, "__len__"):
- total_length = len(o)
-
- elif hasattr(o, "len"):
- total_length = o.len
-
- elif hasattr(o, "fileno"):
- try:
- fileno = o.fileno()
- except (io.UnsupportedOperation, AttributeError):
- # AttributeError is a surprising exception, seeing as how we've just checked
- # that `hasattr(o, 'fileno')`. It happens for objects obtained via
- # `Tarfile.extractfile()`, per issue 5229.
- pass
- else:
- total_length = os.fstat(fileno).st_size
-
- # Having used fstat to determine the file length, we need to
- # confirm that this file was opened up in binary mode.
- if "b" not in o.mode:
- warnings.warn(
- (
- "Requests has determined the content-length for this "
- "request using the binary size of the file: however, the "
- "file has been opened in text mode (i.e. without the 'b' "
- "flag in the mode). This may lead to an incorrect "
- "content-length. In Requests 3.0, support will be removed "
- "for files in text mode."
- ),
- FileModeWarning,
- )
-
- if hasattr(o, "tell"):
- try:
- current_position = o.tell()
- except OSError:
- # This can happen in some weird situations, such as when the file
- # is actually a special file descriptor like stdin. In this
- # instance, we don't know what the length is, so set it to zero and
- # let requests chunk it instead.
- if total_length is not None:
- current_position = total_length
- else:
- if hasattr(o, "seek") and total_length is None:
- # StringIO and BytesIO have seek but no usable fileno
- try:
- # seek to end of file
- o.seek(0, 2)
- total_length = o.tell()
-
- # seek back to current position to support
- # partially read file-like objects
- o.seek(current_position or 0)
- except OSError:
- total_length = 0
-
- if total_length is None:
- total_length = 0
-
- return max(0, total_length - current_position)
-
-
-def get_netrc_auth(url, raise_errors=False):
- """Returns the Requests tuple auth for a given url from netrc."""
-
- netrc_file = os.environ.get("NETRC")
- if netrc_file is not None:
- netrc_locations = (netrc_file,)
- else:
- netrc_locations = (f"~/{f}" for f in NETRC_FILES)
-
- try:
- from netrc import NetrcParseError, netrc
-
- netrc_path = None
-
- for f in netrc_locations:
- try:
- loc = os.path.expanduser(f)
- except KeyError:
- # os.path.expanduser can fail when $HOME is undefined and
- # getpwuid fails. See https://bugs.python.org/issue20164 &
- # https://github.com/psf/requests/issues/1846
- return
-
- if os.path.exists(loc):
- netrc_path = loc
- break
-
- # Abort early if there isn't one.
- if netrc_path is None:
- return
-
- ri = urlparse(url)
-
- # Strip port numbers from netloc. This weird `if...encode`` dance is
- # used for Python 3.2, which doesn't support unicode literals.
- splitstr = b":"
- if isinstance(url, str):
- splitstr = splitstr.decode("ascii")
- host = ri.netloc.split(splitstr)[0]
-
- try:
- _netrc = netrc(netrc_path).authenticators(host)
- if _netrc:
- # Return with login / password
- login_i = 0 if _netrc[0] else 1
- return (_netrc[login_i], _netrc[2])
- except (NetrcParseError, OSError):
- # If there was a parsing error or a permissions issue reading the file,
- # we'll just skip netrc auth unless explicitly asked to raise errors.
- if raise_errors:
- raise
-
- # App Engine hackiness.
- except (ImportError, AttributeError):
- pass
-
-
-def guess_filename(obj):
- """Tries to guess the filename of the given object."""
- name = getattr(obj, "name", None)
- if name and isinstance(name, basestring) and name[0] != "<" and name[-1] != ">":
- return os.path.basename(name)
-
-
-def extract_zipped_paths(path):
- """Replace nonexistent paths that look like they refer to a member of a zip
- archive with the location of an extracted copy of the target, or else
- just return the provided path unchanged.
- """
- if os.path.exists(path):
- # this is already a valid path, no need to do anything further
- return path
-
- # find the first valid part of the provided path and treat that as a zip archive
- # assume the rest of the path is the name of a member in the archive
- archive, member = os.path.split(path)
- while archive and not os.path.exists(archive):
- archive, prefix = os.path.split(archive)
- if not prefix:
- # If we don't check for an empty prefix after the split (in other words, archive remains unchanged after the split),
- # we _can_ end up in an infinite loop on a rare corner case affecting a small number of users
- break
- member = "/".join([prefix, member])
-
- if not zipfile.is_zipfile(archive):
- return path
-
- zip_file = zipfile.ZipFile(archive)
- if member not in zip_file.namelist():
- return path
-
- # we have a valid zip archive and a valid member of that archive
- tmp = tempfile.gettempdir()
- extracted_path = os.path.join(tmp, member.split("/")[-1])
- if not os.path.exists(extracted_path):
- # use read + write to avoid the creating nested folders, we only want the file, avoids mkdir racing condition
- with atomic_open(extracted_path) as file_handler:
- file_handler.write(zip_file.read(member))
- return extracted_path
-
-
-@contextlib.contextmanager
-def atomic_open(filename):
- """Write a file to the disk in an atomic fashion"""
- tmp_descriptor, tmp_name = tempfile.mkstemp(dir=os.path.dirname(filename))
- try:
- with os.fdopen(tmp_descriptor, "wb") as tmp_handler:
- yield tmp_handler
- os.replace(tmp_name, filename)
- except BaseException:
- os.remove(tmp_name)
- raise
-
-
-def from_key_val_list(value):
- """Take an object and test to see if it can be represented as a
- dictionary. Unless it can not be represented as such, return an
- OrderedDict, e.g.,
-
- ::
-
- >>> from_key_val_list([('key', 'val')])
- OrderedDict([('key', 'val')])
- >>> from_key_val_list('string')
- Traceback (most recent call last):
- ...
- ValueError: cannot encode objects that are not 2-tuples
- >>> from_key_val_list({'key': 'val'})
- OrderedDict([('key', 'val')])
-
- :rtype: OrderedDict
- """
- if value is None:
- return None
-
- if isinstance(value, (str, bytes, bool, int)):
- raise ValueError("cannot encode objects that are not 2-tuples")
-
- return OrderedDict(value)
-
-
-def to_key_val_list(value):
- """Take an object and test to see if it can be represented as a
- dictionary. If it can be, return a list of tuples, e.g.,
-
- ::
-
- >>> to_key_val_list([('key', 'val')])
- [('key', 'val')]
- >>> to_key_val_list({'key': 'val'})
- [('key', 'val')]
- >>> to_key_val_list('string')
- Traceback (most recent call last):
- ...
- ValueError: cannot encode objects that are not 2-tuples
-
- :rtype: list
- """
- if value is None:
- return None
-
- if isinstance(value, (str, bytes, bool, int)):
- raise ValueError("cannot encode objects that are not 2-tuples")
-
- if isinstance(value, Mapping):
- value = value.items()
-
- return list(value)
-
-
-# From mitsuhiko/werkzeug (used with permission).
-def parse_list_header(value):
- """Parse lists as described by RFC 2068 Section 2.
-
- In particular, parse comma-separated lists where the elements of
- the list may include quoted-strings. A quoted-string could
- contain a comma. A non-quoted string could have quotes in the
- middle. Quotes are removed automatically after parsing.
-
- It basically works like :func:`parse_set_header` just that items
- may appear multiple times and case sensitivity is preserved.
-
- The return value is a standard :class:`list`:
-
- >>> parse_list_header('token, "quoted value"')
- ['token', 'quoted value']
-
- To create a header from the :class:`list` again, use the
- :func:`dump_header` function.
-
- :param value: a string with a list header.
- :return: :class:`list`
- :rtype: list
- """
- result = []
- for item in _parse_list_header(value):
- if item[:1] == item[-1:] == '"':
- item = unquote_header_value(item[1:-1])
- result.append(item)
- return result
-
-
-# From mitsuhiko/werkzeug (used with permission).
-def parse_dict_header(value):
- """Parse lists of key, value pairs as described by RFC 2068 Section 2 and
- convert them into a python dict:
-
- >>> d = parse_dict_header('foo="is a fish", bar="as well"')
- >>> type(d) is dict
- True
- >>> sorted(d.items())
- [('bar', 'as well'), ('foo', 'is a fish')]
-
- If there is no value for a key it will be `None`:
-
- >>> parse_dict_header('key_without_value')
- {'key_without_value': None}
-
- To create a header from the :class:`dict` again, use the
- :func:`dump_header` function.
-
- :param value: a string with a dict header.
- :return: :class:`dict`
- :rtype: dict
- """
- result = {}
- for item in _parse_list_header(value):
- if "=" not in item:
- result[item] = None
- continue
- name, value = item.split("=", 1)
- if value[:1] == value[-1:] == '"':
- value = unquote_header_value(value[1:-1])
- result[name] = value
- return result
-
-
-# From mitsuhiko/werkzeug (used with permission).
-def unquote_header_value(value, is_filename=False):
- r"""Unquotes a header value. (Reversal of :func:`quote_header_value`).
- This does not use the real unquoting but what browsers are actually
- using for quoting.
-
- :param value: the header value to unquote.
- :rtype: str
- """
- if value and value[0] == value[-1] == '"':
- # this is not the real unquoting, but fixing this so that the
- # RFC is met will result in bugs with internet explorer and
- # probably some other browsers as well. IE for example is
- # uploading files with "C:\foo\bar.txt" as filename
- value = value[1:-1]
-
- # if this is a filename and the starting characters look like
- # a UNC path, then just return the value without quotes. Using the
- # replace sequence below on a UNC path has the effect of turning
- # the leading double slash into a single slash and then
- # _fix_ie_filename() doesn't work correctly. See #458.
- if not is_filename or value[:2] != "\\\\":
- return value.replace("\\\\", "\\").replace('\\"', '"')
- return value
-
-
-def dict_from_cookiejar(cj):
- """Returns a key/value dictionary from a CookieJar.
-
- :param cj: CookieJar object to extract cookies from.
- :rtype: dict
- """
-
- cookie_dict = {}
-
- for cookie in cj:
- cookie_dict[cookie.name] = cookie.value
-
- return cookie_dict
-
-
-def add_dict_to_cookiejar(cj, cookie_dict):
- """Returns a CookieJar from a key/value dictionary.
-
- :param cj: CookieJar to insert cookies into.
- :param cookie_dict: Dict of key/values to insert into CookieJar.
- :rtype: CookieJar
- """
-
- return cookiejar_from_dict(cookie_dict, cj)
-
-
-def get_encodings_from_content(content):
- """Returns encodings from given content string.
-
- :param content: bytestring to extract encodings from.
- """
- warnings.warn(
- (
- "In requests 3.0, get_encodings_from_content will be removed. For "
- "more information, please see the discussion on issue #2266. (This"
- " warning should only appear once.)"
- ),
- DeprecationWarning,
- )
-
- charset_re = re.compile(r']', flags=re.I)
- pragma_re = re.compile(r']', flags=re.I)
- xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]')
-
- return (
- charset_re.findall(content)
- + pragma_re.findall(content)
- + xml_re.findall(content)
- )
-
-
-def _parse_content_type_header(header):
- """Returns content type and parameters from given header
-
- :param header: string
- :return: tuple containing content type and dictionary of
- parameters
- """
-
- tokens = header.split(";")
- content_type, params = tokens[0].strip(), tokens[1:]
- params_dict = {}
- items_to_strip = "\"' "
-
- for param in params:
- param = param.strip()
- if param:
- key, value = param, True
- index_of_equals = param.find("=")
- if index_of_equals != -1:
- key = param[:index_of_equals].strip(items_to_strip)
- value = param[index_of_equals + 1 :].strip(items_to_strip)
- params_dict[key.lower()] = value
- return content_type, params_dict
-
-
-def get_encoding_from_headers(headers):
- """Returns encodings from given HTTP Header Dict.
-
- :param headers: dictionary to extract encoding from.
- :rtype: str
- """
-
- content_type = headers.get("content-type")
-
- if not content_type:
- return None
-
- content_type, params = _parse_content_type_header(content_type)
-
- if "charset" in params:
- return params["charset"].strip("'\"")
-
- if "text" in content_type:
- return "ISO-8859-1"
-
- if "application/json" in content_type:
- # Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset
- return "utf-8"
-
-
-def stream_decode_response_unicode(iterator, r):
- """Stream decodes an iterator."""
-
- if r.encoding is None:
- yield from iterator
- return
-
- decoder = codecs.getincrementaldecoder(r.encoding)(errors="replace")
- for chunk in iterator:
- rv = decoder.decode(chunk)
- if rv:
- yield rv
- rv = decoder.decode(b"", final=True)
- if rv:
- yield rv
-
-
-def iter_slices(string, slice_length):
- """Iterate over slices of a string."""
- pos = 0
- if slice_length is None or slice_length <= 0:
- slice_length = len(string)
- while pos < len(string):
- yield string[pos : pos + slice_length]
- pos += slice_length
-
-
-def get_unicode_from_response(r):
- """Returns the requested content back in unicode.
-
- :param r: Response object to get unicode content from.
-
- Tried:
-
- 1. charset from content-type
- 2. fall back and replace all unicode characters
-
- :rtype: str
- """
- warnings.warn(
- (
- "In requests 3.0, get_unicode_from_response will be removed. For "
- "more information, please see the discussion on issue #2266. (This"
- " warning should only appear once.)"
- ),
- DeprecationWarning,
- )
-
- tried_encodings = []
-
- # Try charset from content-type
- encoding = get_encoding_from_headers(r.headers)
-
- if encoding:
- try:
- return str(r.content, encoding)
- except UnicodeError:
- tried_encodings.append(encoding)
-
- # Fall back:
- try:
- return str(r.content, encoding, errors="replace")
- except TypeError:
- return r.content
-
-
-# The unreserved URI characters (RFC 3986)
-UNRESERVED_SET = frozenset(
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~"
-)
-
-
-def unquote_unreserved(uri):
- """Un-escape any percent-escape sequences in a URI that are unreserved
- characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
-
- :rtype: str
- """
- parts = uri.split("%")
- for i in range(1, len(parts)):
- h = parts[i][0:2]
- if len(h) == 2 and h.isalnum():
- try:
- c = chr(int(h, 16))
- except ValueError:
- raise InvalidURL(f"Invalid percent-escape sequence: '{h}'")
-
- if c in UNRESERVED_SET:
- parts[i] = c + parts[i][2:]
- else:
- parts[i] = f"%{parts[i]}"
- else:
- parts[i] = f"%{parts[i]}"
- return "".join(parts)
-
-
-def requote_uri(uri):
- """Re-quote the given URI.
-
- This function passes the given URI through an unquote/quote cycle to
- ensure that it is fully and consistently quoted.
-
- :rtype: str
- """
- safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
- safe_without_percent = "!#$&'()*+,/:;=?@[]~"
- try:
- # Unquote only the unreserved characters
- # Then quote only illegal characters (do not quote reserved,
- # unreserved, or '%')
- return quote(unquote_unreserved(uri), safe=safe_with_percent)
- except InvalidURL:
- # We couldn't unquote the given URI, so let's try quoting it, but
- # there may be unquoted '%'s in the URI. We need to make sure they're
- # properly quoted so they do not cause issues elsewhere.
- return quote(uri, safe=safe_without_percent)
-
-
-def address_in_network(ip, net):
- """This function allows you to check if an IP belongs to a network subnet
-
- Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
- returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
-
- :rtype: bool
- """
- ipaddr = struct.unpack("=L", socket.inet_aton(ip))[0]
- netaddr, bits = net.split("/")
- netmask = struct.unpack("=L", socket.inet_aton(dotted_netmask(int(bits))))[0]
- network = struct.unpack("=L", socket.inet_aton(netaddr))[0] & netmask
- return (ipaddr & netmask) == (network & netmask)
-
-
-def dotted_netmask(mask):
- """Converts mask from /xx format to xxx.xxx.xxx.xxx
-
- Example: if mask is 24 function returns 255.255.255.0
-
- :rtype: str
- """
- bits = 0xFFFFFFFF ^ (1 << 32 - mask) - 1
- return socket.inet_ntoa(struct.pack(">I", bits))
-
-
-def is_ipv4_address(string_ip):
- """
- :rtype: bool
- """
- try:
- socket.inet_aton(string_ip)
- except OSError:
- return False
- return True
-
-
-def is_valid_cidr(string_network):
- """
- Very simple check of the cidr format in no_proxy variable.
-
- :rtype: bool
- """
- if string_network.count("/") == 1:
- try:
- mask = int(string_network.split("/")[1])
- except ValueError:
- return False
-
- if mask < 1 or mask > 32:
- return False
-
- try:
- socket.inet_aton(string_network.split("/")[0])
- except OSError:
- return False
- else:
- return False
- return True
-
-
-@contextlib.contextmanager
-def set_environ(env_name, value):
- """Set the environment variable 'env_name' to 'value'
-
- Save previous value, yield, and then restore the previous value stored in
- the environment variable 'env_name'.
-
- If 'value' is None, do nothing"""
- value_changed = value is not None
- if value_changed:
- old_value = os.environ.get(env_name)
- os.environ[env_name] = value
- try:
- yield
- finally:
- if value_changed:
- if old_value is None:
- del os.environ[env_name]
- else:
- os.environ[env_name] = old_value
-
-
-def should_bypass_proxies(url, no_proxy):
- """
- Returns whether we should bypass proxies or not.
-
- :rtype: bool
- """
- # Prioritize lowercase environment variables over uppercase
- # to keep a consistent behaviour with other http projects (curl, wget).
- def get_proxy(key):
- return os.environ.get(key) or os.environ.get(key.upper())
-
- # First check whether no_proxy is defined. If it is, check that the URL
- # we're getting isn't in the no_proxy list.
- no_proxy_arg = no_proxy
- if no_proxy is None:
- no_proxy = get_proxy("no_proxy")
- parsed = urlparse(url)
-
- if parsed.hostname is None:
- # URLs don't always have hostnames, e.g. file:/// urls.
- return True
-
- if no_proxy:
- # We need to check whether we match here. We need to see if we match
- # the end of the hostname, both with and without the port.
- no_proxy = (host for host in no_proxy.replace(" ", "").split(",") if host)
-
- if is_ipv4_address(parsed.hostname):
- for proxy_ip in no_proxy:
- if is_valid_cidr(proxy_ip):
- if address_in_network(parsed.hostname, proxy_ip):
- return True
- elif parsed.hostname == proxy_ip:
- # If no_proxy ip was defined in plain IP notation instead of cidr notation &
- # matches the IP of the index
- return True
- else:
- host_with_port = parsed.hostname
- if parsed.port:
- host_with_port += f":{parsed.port}"
-
- for host in no_proxy:
- if parsed.hostname.endswith(host) or host_with_port.endswith(host):
- # The URL does match something in no_proxy, so we don't want
- # to apply the proxies on this URL.
- return True
-
- with set_environ("no_proxy", no_proxy_arg):
- # parsed.hostname can be `None` in cases such as a file URI.
- try:
- bypass = proxy_bypass(parsed.hostname)
- except (TypeError, socket.gaierror):
- bypass = False
-
- if bypass:
- return True
-
- return False
-
-
-def get_environ_proxies(url, no_proxy=None):
- """
- Return a dict of environment proxies.
-
- :rtype: dict
- """
- if should_bypass_proxies(url, no_proxy=no_proxy):
- return {}
- else:
- return getproxies()
-
-
-def select_proxy(url, proxies):
- """Select a proxy for the url, if applicable.
-
- :param url: The url being for the request
- :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
- """
- proxies = proxies or {}
- urlparts = urlparse(url)
- if urlparts.hostname is None:
- return proxies.get(urlparts.scheme, proxies.get("all"))
-
- proxy_keys = [
- urlparts.scheme + "://" + urlparts.hostname,
- urlparts.scheme,
- "all://" + urlparts.hostname,
- "all",
- ]
- proxy = None
- for proxy_key in proxy_keys:
- if proxy_key in proxies:
- proxy = proxies[proxy_key]
- break
-
- return proxy
-
-
-def resolve_proxies(request, proxies, trust_env=True):
- """This method takes proxy information from a request and configuration
- input to resolve a mapping of target proxies. This will consider settings
- such a NO_PROXY to strip proxy configurations.
-
- :param request: Request or PreparedRequest
- :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
- :param trust_env: Boolean declaring whether to trust environment configs
-
- :rtype: dict
- """
- proxies = proxies if proxies is not None else {}
- url = request.url
- scheme = urlparse(url).scheme
- no_proxy = proxies.get("no_proxy")
- new_proxies = proxies.copy()
-
- if trust_env and not should_bypass_proxies(url, no_proxy=no_proxy):
- environ_proxies = get_environ_proxies(url, no_proxy=no_proxy)
-
- proxy = environ_proxies.get(scheme, environ_proxies.get("all"))
-
- if proxy:
- new_proxies.setdefault(scheme, proxy)
- return new_proxies
-
-
-def default_user_agent(name="python-requests"):
- """
- Return a string representing the default user agent.
-
- :rtype: str
- """
- return f"{name}/{__version__}"
-
-
-def default_headers():
- """
- :rtype: requests.structures.CaseInsensitiveDict
- """
- return CaseInsensitiveDict(
- {
- "User-Agent": default_user_agent(),
- "Accept-Encoding": DEFAULT_ACCEPT_ENCODING,
- "Accept": "*/*",
- "Connection": "keep-alive",
- }
- )
-
-
-def parse_header_links(value):
- """Return a list of parsed link headers proxies.
-
- i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg"
-
- :rtype: list
- """
-
- links = []
-
- replace_chars = " '\""
-
- value = value.strip(replace_chars)
- if not value:
- return links
-
- for val in re.split(", *<", value):
- try:
- url, params = val.split(";", 1)
- except ValueError:
- url, params = val, ""
-
- link = {"url": url.strip("<> '\"")}
-
- for param in params.split(";"):
- try:
- key, value = param.split("=")
- except ValueError:
- break
-
- link[key.strip(replace_chars)] = value.strip(replace_chars)
-
- links.append(link)
-
- return links
-
-
-# Null bytes; no need to recreate these on each call to guess_json_utf
-_null = "\x00".encode("ascii") # encoding to ASCII for Python 3
-_null2 = _null * 2
-_null3 = _null * 3
-
-
-def guess_json_utf(data):
- """
- :rtype: str
- """
- # JSON always starts with two ASCII characters, so detection is as
- # easy as counting the nulls and from their location and count
- # determine the encoding. Also detect a BOM, if present.
- sample = data[:4]
- if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
- return "utf-32" # BOM included
- if sample[:3] == codecs.BOM_UTF8:
- return "utf-8-sig" # BOM included, MS style (discouraged)
- if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
- return "utf-16" # BOM included
- nullcount = sample.count(_null)
- if nullcount == 0:
- return "utf-8"
- if nullcount == 2:
- if sample[::2] == _null2: # 1st and 3rd are null
- return "utf-16-be"
- if sample[1::2] == _null2: # 2nd and 4th are null
- return "utf-16-le"
- # Did not detect 2 valid UTF-16 ascii-range characters
- if nullcount == 3:
- if sample[:3] == _null3:
- return "utf-32-be"
- if sample[1:] == _null3:
- return "utf-32-le"
- # Did not detect a valid UTF-32 ascii-range character
- return None
-
-
-def prepend_scheme_if_needed(url, new_scheme):
- """Given a URL that may or may not have a scheme, prepend the given scheme.
- Does not replace a present scheme with the one provided as an argument.
-
- :rtype: str
- """
- parsed = parse_url(url)
- scheme, auth, host, port, path, query, fragment = parsed
-
- # A defect in urlparse determines that there isn't a netloc present in some
- # urls. We previously assumed parsing was overly cautious, and swapped the
- # netloc and path. Due to a lack of tests on the original defect, this is
- # maintained with parse_url for backwards compatibility.
- netloc = parsed.netloc
- if not netloc:
- netloc, path = path, netloc
-
- if auth:
- # parse_url doesn't provide the netloc with auth
- # so we'll add it ourselves.
- netloc = "@".join([auth, netloc])
- if scheme is None:
- scheme = new_scheme
- if path is None:
- path = ""
-
- return urlunparse((scheme, netloc, path, "", query, fragment))
-
-
-def get_auth_from_url(url):
- """Given a url with authentication components, extract them into a tuple of
- username,password.
-
- :rtype: (str,str)
- """
- parsed = urlparse(url)
-
- try:
- auth = (unquote(parsed.username), unquote(parsed.password))
- except (AttributeError, TypeError):
- auth = ("", "")
-
- return auth
-
-
-def check_header_validity(header):
- """Verifies that header parts don't contain leading whitespace
- reserved characters, or return characters.
-
- :param header: tuple, in the format (name, value).
- """
- name, value = header
- _validate_header_part(header, name, 0)
- _validate_header_part(header, value, 1)
-
-
-def _validate_header_part(header, header_part, header_validator_index):
- if isinstance(header_part, str):
- validator = _HEADER_VALIDATORS_STR[header_validator_index]
- elif isinstance(header_part, bytes):
- validator = _HEADER_VALIDATORS_BYTE[header_validator_index]
- else:
- raise InvalidHeader(
- f"Header part ({header_part!r}) from {header} "
- f"must be of type str or bytes, not {type(header_part)}"
- )
-
- if not validator.match(header_part):
- header_kind = "name" if header_validator_index == 0 else "value"
- raise InvalidHeader(
- f"Invalid leading whitespace, reserved character(s), or return"
- f"character(s) in header {header_kind}: {header_part!r}"
- )
-
-
-def urldefragauth(url):
- """
- Given a url remove the fragment and the authentication part.
-
- :rtype: str
- """
- scheme, netloc, path, params, query, fragment = urlparse(url)
-
- # see func:`prepend_scheme_if_needed`
- if not netloc:
- netloc, path = path, netloc
-
- netloc = netloc.rsplit("@", 1)[-1]
-
- return urlunparse((scheme, netloc, path, params, query, ""))
-
-
-def rewind_body(prepared_request):
- """Move file pointer back to its recorded starting position
- so it can be read again on redirect.
- """
- body_seek = getattr(prepared_request.body, "seek", None)
- if body_seek is not None and isinstance(
- prepared_request._body_position, integer_types
- ):
- try:
- body_seek(prepared_request._body_position)
- except OSError:
- raise UnrewindableBodyError(
- "An error occurred when rewinding request body for redirect."
- )
- else:
- raise UnrewindableBodyError("Unable to rewind request body for redirect.")
diff --git a/lib/requirements.txt b/lib/requirements.txt
new file mode 100644
index 0000000..288461f
--- /dev/null
+++ b/lib/requirements.txt
@@ -0,0 +1,2 @@
+splunk-sdk==2.1.1
+requests==2.32.3
diff --git a/lib/socks.py b/lib/socks.py
deleted file mode 100644
index 83b1435..0000000
--- a/lib/socks.py
+++ /dev/null
@@ -1,847 +0,0 @@
-from base64 import b64encode
-try:
- from collections.abc import Callable
-except ImportError:
- from collections import Callable
-from errno import EOPNOTSUPP, EINVAL, EAGAIN
-import functools
-from io import BytesIO
-import logging
-import os
-from os import SEEK_CUR
-import socket
-import struct
-import sys
-
-__version__ = "1.7.1"
-
-
-if os.name == "nt" and sys.version_info < (3, 0):
- try:
- import win_inet_pton
- except ImportError:
- raise ImportError(
- "To run PySocks on Windows you must install win_inet_pton")
-
-log = logging.getLogger(__name__)
-
-PROXY_TYPE_SOCKS4 = SOCKS4 = 1
-PROXY_TYPE_SOCKS5 = SOCKS5 = 2
-PROXY_TYPE_HTTP = HTTP = 3
-
-PROXY_TYPES = {"SOCKS4": SOCKS4, "SOCKS5": SOCKS5, "HTTP": HTTP}
-PRINTABLE_PROXY_TYPES = dict(zip(PROXY_TYPES.values(), PROXY_TYPES.keys()))
-
-_orgsocket = _orig_socket = socket.socket
-
-
-def set_self_blocking(function):
-
- @functools.wraps(function)
- def wrapper(*args, **kwargs):
- self = args[0]
- try:
- _is_blocking = self.gettimeout()
- if _is_blocking == 0:
- self.setblocking(True)
- return function(*args, **kwargs)
- except Exception as e:
- raise
- finally:
- # set orgin blocking
- if _is_blocking == 0:
- self.setblocking(False)
- return wrapper
-
-
-class ProxyError(IOError):
- """Socket_err contains original socket.error exception."""
- def __init__(self, msg, socket_err=None):
- self.msg = msg
- self.socket_err = socket_err
-
- if socket_err:
- self.msg += ": {}".format(socket_err)
-
- def __str__(self):
- return self.msg
-
-
-class GeneralProxyError(ProxyError):
- pass
-
-
-class ProxyConnectionError(ProxyError):
- pass
-
-
-class SOCKS5AuthError(ProxyError):
- pass
-
-
-class SOCKS5Error(ProxyError):
- pass
-
-
-class SOCKS4Error(ProxyError):
- pass
-
-
-class HTTPError(ProxyError):
- pass
-
-SOCKS4_ERRORS = {
- 0x5B: "Request rejected or failed",
- 0x5C: ("Request rejected because SOCKS server cannot connect to identd on"
- " the client"),
- 0x5D: ("Request rejected because the client program and identd report"
- " different user-ids")
-}
-
-SOCKS5_ERRORS = {
- 0x01: "General SOCKS server failure",
- 0x02: "Connection not allowed by ruleset",
- 0x03: "Network unreachable",
- 0x04: "Host unreachable",
- 0x05: "Connection refused",
- 0x06: "TTL expired",
- 0x07: "Command not supported, or protocol error",
- 0x08: "Address type not supported"
-}
-
-DEFAULT_PORTS = {SOCKS4: 1080, SOCKS5: 1080, HTTP: 8080}
-
-
-def set_default_proxy(proxy_type=None, addr=None, port=None, rdns=True,
- username=None, password=None):
- """Sets a default proxy.
-
- All further socksocket objects will use the default unless explicitly
- changed. All parameters are as for socket.set_proxy()."""
- socksocket.default_proxy = (proxy_type, addr, port, rdns,
- username.encode() if username else None,
- password.encode() if password else None)
-
-
-def setdefaultproxy(*args, **kwargs):
- if "proxytype" in kwargs:
- kwargs["proxy_type"] = kwargs.pop("proxytype")
- return set_default_proxy(*args, **kwargs)
-
-
-def get_default_proxy():
- """Returns the default proxy, set by set_default_proxy."""
- return socksocket.default_proxy
-
-getdefaultproxy = get_default_proxy
-
-
-def wrap_module(module):
- """Attempts to replace a module's socket library with a SOCKS socket.
-
- Must set a default proxy using set_default_proxy(...) first. This will
- only work on modules that import socket directly into the namespace;
- most of the Python Standard Library falls into this category."""
- if socksocket.default_proxy:
- module.socket.socket = socksocket
- else:
- raise GeneralProxyError("No default proxy specified")
-
-wrapmodule = wrap_module
-
-
-def create_connection(dest_pair,
- timeout=None, source_address=None,
- proxy_type=None, proxy_addr=None,
- proxy_port=None, proxy_rdns=True,
- proxy_username=None, proxy_password=None,
- socket_options=None):
- """create_connection(dest_pair, *[, timeout], **proxy_args) -> socket object
-
- Like socket.create_connection(), but connects to proxy
- before returning the socket object.
-
- dest_pair - 2-tuple of (IP/hostname, port).
- **proxy_args - Same args passed to socksocket.set_proxy() if present.
- timeout - Optional socket timeout value, in seconds.
- source_address - tuple (host, port) for the socket to bind to as its source
- address before connecting (only for compatibility)
- """
- # Remove IPv6 brackets on the remote address and proxy address.
- remote_host, remote_port = dest_pair
- if remote_host.startswith("["):
- remote_host = remote_host.strip("[]")
- if proxy_addr and proxy_addr.startswith("["):
- proxy_addr = proxy_addr.strip("[]")
-
- err = None
-
- # Allow the SOCKS proxy to be on IPv4 or IPv6 addresses.
- for r in socket.getaddrinfo(proxy_addr, proxy_port, 0, socket.SOCK_STREAM):
- family, socket_type, proto, canonname, sa = r
- sock = None
- try:
- sock = socksocket(family, socket_type, proto)
-
- if socket_options:
- for opt in socket_options:
- sock.setsockopt(*opt)
-
- if isinstance(timeout, (int, float)):
- sock.settimeout(timeout)
-
- if proxy_type:
- sock.set_proxy(proxy_type, proxy_addr, proxy_port, proxy_rdns,
- proxy_username, proxy_password)
- if source_address:
- sock.bind(source_address)
-
- sock.connect((remote_host, remote_port))
- return sock
-
- except (socket.error, ProxyError) as e:
- err = e
- if sock:
- sock.close()
- sock = None
-
- if err:
- raise err
-
- raise socket.error("gai returned empty list.")
-
-
-class _BaseSocket(socket.socket):
- """Allows Python 2 delegated methods such as send() to be overridden."""
- def __init__(self, *pos, **kw):
- _orig_socket.__init__(self, *pos, **kw)
-
- self._savedmethods = dict()
- for name in self._savenames:
- self._savedmethods[name] = getattr(self, name)
- delattr(self, name) # Allows normal overriding mechanism to work
-
- _savenames = list()
-
-
-def _makemethod(name):
- return lambda self, *pos, **kw: self._savedmethods[name](*pos, **kw)
-for name in ("sendto", "send", "recvfrom", "recv"):
- method = getattr(_BaseSocket, name, None)
-
- # Determine if the method is not defined the usual way
- # as a function in the class.
- # Python 2 uses __slots__, so there are descriptors for each method,
- # but they are not functions.
- if not isinstance(method, Callable):
- _BaseSocket._savenames.append(name)
- setattr(_BaseSocket, name, _makemethod(name))
-
-
-class socksocket(_BaseSocket):
- """socksocket([family[, type[, proto]]]) -> socket object
-
- Open a SOCKS enabled socket. The parameters are the same as
- those of the standard socket init. In order for SOCKS to work,
- you must specify family=AF_INET and proto=0.
- The "type" argument must be either SOCK_STREAM or SOCK_DGRAM.
- """
-
- default_proxy = None
-
- def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM,
- proto=0, *args, **kwargs):
- if type not in (socket.SOCK_STREAM, socket.SOCK_DGRAM):
- msg = "Socket type must be stream or datagram, not {!r}"
- raise ValueError(msg.format(type))
-
- super(socksocket, self).__init__(family, type, proto, *args, **kwargs)
- self._proxyconn = None # TCP connection to keep UDP relay alive
-
- if self.default_proxy:
- self.proxy = self.default_proxy
- else:
- self.proxy = (None, None, None, None, None, None)
- self.proxy_sockname = None
- self.proxy_peername = None
-
- self._timeout = None
-
- def _readall(self, file, count):
- """Receive EXACTLY the number of bytes requested from the file object.
-
- Blocks until the required number of bytes have been received."""
- data = b""
- while len(data) < count:
- d = file.read(count - len(data))
- if not d:
- raise GeneralProxyError("Connection closed unexpectedly")
- data += d
- return data
-
- def settimeout(self, timeout):
- self._timeout = timeout
- try:
- # test if we're connected, if so apply timeout
- peer = self.get_proxy_peername()
- super(socksocket, self).settimeout(self._timeout)
- except socket.error:
- pass
-
- def gettimeout(self):
- return self._timeout
-
- def setblocking(self, v):
- if v:
- self.settimeout(None)
- else:
- self.settimeout(0.0)
-
- def set_proxy(self, proxy_type=None, addr=None, port=None, rdns=True,
- username=None, password=None):
- """ Sets the proxy to be used.
-
- proxy_type - The type of the proxy to be used. Three types
- are supported: PROXY_TYPE_SOCKS4 (including socks4a),
- PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
- addr - The address of the server (IP or DNS).
- port - The port of the server. Defaults to 1080 for SOCKS
- servers and 8080 for HTTP proxy servers.
- rdns - Should DNS queries be performed on the remote side
- (rather than the local side). The default is True.
- Note: This has no effect with SOCKS4 servers.
- username - Username to authenticate with to the server.
- The default is no authentication.
- password - Password to authenticate with to the server.
- Only relevant when username is also provided."""
- self.proxy = (proxy_type, addr, port, rdns,
- username.encode() if username else None,
- password.encode() if password else None)
-
- def setproxy(self, *args, **kwargs):
- if "proxytype" in kwargs:
- kwargs["proxy_type"] = kwargs.pop("proxytype")
- return self.set_proxy(*args, **kwargs)
-
- def bind(self, *pos, **kw):
- """Implements proxy connection for UDP sockets.
-
- Happens during the bind() phase."""
- (proxy_type, proxy_addr, proxy_port, rdns, username,
- password) = self.proxy
- if not proxy_type or self.type != socket.SOCK_DGRAM:
- return _orig_socket.bind(self, *pos, **kw)
-
- if self._proxyconn:
- raise socket.error(EINVAL, "Socket already bound to an address")
- if proxy_type != SOCKS5:
- msg = "UDP only supported by SOCKS5 proxy type"
- raise socket.error(EOPNOTSUPP, msg)
- super(socksocket, self).bind(*pos, **kw)
-
- # Need to specify actual local port because
- # some relays drop packets if a port of zero is specified.
- # Avoid specifying host address in case of NAT though.
- _, port = self.getsockname()
- dst = ("0", port)
-
- self._proxyconn = _orig_socket()
- proxy = self._proxy_addr()
- self._proxyconn.connect(proxy)
-
- UDP_ASSOCIATE = b"\x03"
- _, relay = self._SOCKS5_request(self._proxyconn, UDP_ASSOCIATE, dst)
-
- # The relay is most likely on the same host as the SOCKS proxy,
- # but some proxies return a private IP address (10.x.y.z)
- host, _ = proxy
- _, port = relay
- super(socksocket, self).connect((host, port))
- super(socksocket, self).settimeout(self._timeout)
- self.proxy_sockname = ("0.0.0.0", 0) # Unknown
-
- def sendto(self, bytes, *args, **kwargs):
- if self.type != socket.SOCK_DGRAM:
- return super(socksocket, self).sendto(bytes, *args, **kwargs)
- if not self._proxyconn:
- self.bind(("", 0))
-
- address = args[-1]
- flags = args[:-1]
-
- header = BytesIO()
- RSV = b"\x00\x00"
- header.write(RSV)
- STANDALONE = b"\x00"
- header.write(STANDALONE)
- self._write_SOCKS5_address(address, header)
-
- sent = super(socksocket, self).send(header.getvalue() + bytes, *flags,
- **kwargs)
- return sent - header.tell()
-
- def send(self, bytes, flags=0, **kwargs):
- if self.type == socket.SOCK_DGRAM:
- return self.sendto(bytes, flags, self.proxy_peername, **kwargs)
- else:
- return super(socksocket, self).send(bytes, flags, **kwargs)
-
- def recvfrom(self, bufsize, flags=0):
- if self.type != socket.SOCK_DGRAM:
- return super(socksocket, self).recvfrom(bufsize, flags)
- if not self._proxyconn:
- self.bind(("", 0))
-
- buf = BytesIO(super(socksocket, self).recv(bufsize + 1024, flags))
- buf.seek(2, SEEK_CUR)
- frag = buf.read(1)
- if ord(frag):
- raise NotImplementedError("Received UDP packet fragment")
- fromhost, fromport = self._read_SOCKS5_address(buf)
-
- if self.proxy_peername:
- peerhost, peerport = self.proxy_peername
- if fromhost != peerhost or peerport not in (0, fromport):
- raise socket.error(EAGAIN, "Packet filtered")
-
- return (buf.read(bufsize), (fromhost, fromport))
-
- def recv(self, *pos, **kw):
- bytes, _ = self.recvfrom(*pos, **kw)
- return bytes
-
- def close(self):
- if self._proxyconn:
- self._proxyconn.close()
- return super(socksocket, self).close()
-
- def get_proxy_sockname(self):
- """Returns the bound IP address and port number at the proxy."""
- return self.proxy_sockname
-
- getproxysockname = get_proxy_sockname
-
- def get_proxy_peername(self):
- """
- Returns the IP and port number of the proxy.
- """
- return self.getpeername()
-
- getproxypeername = get_proxy_peername
-
- def get_peername(self):
- """Returns the IP address and port number of the destination machine.
-
- Note: get_proxy_peername returns the proxy."""
- return self.proxy_peername
-
- getpeername = get_peername
-
- def _negotiate_SOCKS5(self, *dest_addr):
- """Negotiates a stream connection through a SOCKS5 server."""
- CONNECT = b"\x01"
- self.proxy_peername, self.proxy_sockname = self._SOCKS5_request(
- self, CONNECT, dest_addr)
-
- def _SOCKS5_request(self, conn, cmd, dst):
- """
- Send SOCKS5 request with given command (CMD field) and
- address (DST field). Returns resolved DST address that was used.
- """
- proxy_type, addr, port, rdns, username, password = self.proxy
-
- writer = conn.makefile("wb")
- reader = conn.makefile("rb", 0) # buffering=0 renamed in Python 3
- try:
- # First we'll send the authentication packages we support.
- if username and password:
- # The username/password details were supplied to the
- # set_proxy method so we support the USERNAME/PASSWORD
- # authentication (in addition to the standard none).
- writer.write(b"\x05\x02\x00\x02")
- else:
- # No username/password were entered, therefore we
- # only support connections with no authentication.
- writer.write(b"\x05\x01\x00")
-
- # We'll receive the server's response to determine which
- # method was selected
- writer.flush()
- chosen_auth = self._readall(reader, 2)
-
- if chosen_auth[0:1] != b"\x05":
- # Note: string[i:i+1] is used because indexing of a bytestring
- # via bytestring[i] yields an integer in Python 3
- raise GeneralProxyError(
- "SOCKS5 proxy server sent invalid data")
-
- # Check the chosen authentication method
-
- if chosen_auth[1:2] == b"\x02":
- # Okay, we need to perform a basic username/password
- # authentication.
- if not (username and password):
- # Although we said we don't support authentication, the
- # server may still request basic username/password
- # authentication
- raise SOCKS5AuthError("No username/password supplied. "
- "Server requested username/password"
- " authentication")
-
- writer.write(b"\x01" + chr(len(username)).encode()
- + username
- + chr(len(password)).encode()
- + password)
- writer.flush()
- auth_status = self._readall(reader, 2)
- if auth_status[0:1] != b"\x01":
- # Bad response
- raise GeneralProxyError(
- "SOCKS5 proxy server sent invalid data")
- if auth_status[1:2] != b"\x00":
- # Authentication failed
- raise SOCKS5AuthError("SOCKS5 authentication failed")
-
- # Otherwise, authentication succeeded
-
- # No authentication is required if 0x00
- elif chosen_auth[1:2] != b"\x00":
- # Reaching here is always bad
- if chosen_auth[1:2] == b"\xFF":
- raise SOCKS5AuthError(
- "All offered SOCKS5 authentication methods were"
- " rejected")
- else:
- raise GeneralProxyError(
- "SOCKS5 proxy server sent invalid data")
-
- # Now we can request the actual connection
- writer.write(b"\x05" + cmd + b"\x00")
- resolved = self._write_SOCKS5_address(dst, writer)
- writer.flush()
-
- # Get the response
- resp = self._readall(reader, 3)
- if resp[0:1] != b"\x05":
- raise GeneralProxyError(
- "SOCKS5 proxy server sent invalid data")
-
- status = ord(resp[1:2])
- if status != 0x00:
- # Connection failed: server returned an error
- error = SOCKS5_ERRORS.get(status, "Unknown error")
- raise SOCKS5Error("{:#04x}: {}".format(status, error))
-
- # Get the bound address/port
- bnd = self._read_SOCKS5_address(reader)
-
- super(socksocket, self).settimeout(self._timeout)
- return (resolved, bnd)
- finally:
- reader.close()
- writer.close()
-
- def _write_SOCKS5_address(self, addr, file):
- """
- Return the host and port packed for the SOCKS5 protocol,
- and the resolved address as a tuple object.
- """
- host, port = addr
- proxy_type, _, _, rdns, username, password = self.proxy
- family_to_byte = {socket.AF_INET: b"\x01", socket.AF_INET6: b"\x04"}
-
- # If the given destination address is an IP address, we'll
- # use the IP address request even if remote resolving was specified.
- # Detect whether the address is IPv4/6 directly.
- for family in (socket.AF_INET, socket.AF_INET6):
- try:
- addr_bytes = socket.inet_pton(family, host)
- file.write(family_to_byte[family] + addr_bytes)
- host = socket.inet_ntop(family, addr_bytes)
- file.write(struct.pack(">H", port))
- return host, port
- except socket.error:
- continue
-
- # Well it's not an IP number, so it's probably a DNS name.
- if rdns:
- # Resolve remotely
- host_bytes = host.encode("idna")
- file.write(b"\x03" + chr(len(host_bytes)).encode() + host_bytes)
- else:
- # Resolve locally
- addresses = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
- socket.SOCK_STREAM,
- socket.IPPROTO_TCP,
- socket.AI_ADDRCONFIG)
- # We can't really work out what IP is reachable, so just pick the
- # first.
- target_addr = addresses[0]
- family = target_addr[0]
- host = target_addr[4][0]
-
- addr_bytes = socket.inet_pton(family, host)
- file.write(family_to_byte[family] + addr_bytes)
- host = socket.inet_ntop(family, addr_bytes)
- file.write(struct.pack(">H", port))
- return host, port
-
- def _read_SOCKS5_address(self, file):
- atyp = self._readall(file, 1)
- if atyp == b"\x01":
- addr = socket.inet_ntoa(self._readall(file, 4))
- elif atyp == b"\x03":
- length = self._readall(file, 1)
- addr = self._readall(file, ord(length))
- elif atyp == b"\x04":
- addr = socket.inet_ntop(socket.AF_INET6, self._readall(file, 16))
- else:
- raise GeneralProxyError("SOCKS5 proxy server sent invalid data")
-
- port = struct.unpack(">H", self._readall(file, 2))[0]
- return addr, port
-
- def _negotiate_SOCKS4(self, dest_addr, dest_port):
- """Negotiates a connection through a SOCKS4 server."""
- proxy_type, addr, port, rdns, username, password = self.proxy
-
- writer = self.makefile("wb")
- reader = self.makefile("rb", 0) # buffering=0 renamed in Python 3
- try:
- # Check if the destination address provided is an IP address
- remote_resolve = False
- try:
- addr_bytes = socket.inet_aton(dest_addr)
- except socket.error:
- # It's a DNS name. Check where it should be resolved.
- if rdns:
- addr_bytes = b"\x00\x00\x00\x01"
- remote_resolve = True
- else:
- addr_bytes = socket.inet_aton(
- socket.gethostbyname(dest_addr))
-
- # Construct the request packet
- writer.write(struct.pack(">BBH", 0x04, 0x01, dest_port))
- writer.write(addr_bytes)
-
- # The username parameter is considered userid for SOCKS4
- if username:
- writer.write(username)
- writer.write(b"\x00")
-
- # DNS name if remote resolving is required
- # NOTE: This is actually an extension to the SOCKS4 protocol
- # called SOCKS4A and may not be supported in all cases.
- if remote_resolve:
- writer.write(dest_addr.encode("idna") + b"\x00")
- writer.flush()
-
- # Get the response from the server
- resp = self._readall(reader, 8)
- if resp[0:1] != b"\x00":
- # Bad data
- raise GeneralProxyError(
- "SOCKS4 proxy server sent invalid data")
-
- status = ord(resp[1:2])
- if status != 0x5A:
- # Connection failed: server returned an error
- error = SOCKS4_ERRORS.get(status, "Unknown error")
- raise SOCKS4Error("{:#04x}: {}".format(status, error))
-
- # Get the bound address/port
- self.proxy_sockname = (socket.inet_ntoa(resp[4:]),
- struct.unpack(">H", resp[2:4])[0])
- if remote_resolve:
- self.proxy_peername = socket.inet_ntoa(addr_bytes), dest_port
- else:
- self.proxy_peername = dest_addr, dest_port
- finally:
- reader.close()
- writer.close()
-
- def _negotiate_HTTP(self, dest_addr, dest_port):
- """Negotiates a connection through an HTTP server.
-
- NOTE: This currently only supports HTTP CONNECT-style proxies."""
- proxy_type, addr, port, rdns, username, password = self.proxy
-
- # If we need to resolve locally, we do this now
- addr = dest_addr if rdns else socket.gethostbyname(dest_addr)
-
- http_headers = [
- (b"CONNECT " + addr.encode("idna") + b":"
- + str(dest_port).encode() + b" HTTP/1.1"),
- b"Host: " + dest_addr.encode("idna")
- ]
-
- if username and password:
- http_headers.append(b"Proxy-Authorization: basic "
- + b64encode(username + b":" + password))
-
- http_headers.append(b"\r\n")
-
- self.sendall(b"\r\n".join(http_headers))
-
- # We just need the first line to check if the connection was successful
- fobj = self.makefile()
- status_line = fobj.readline()
- fobj.close()
-
- if not status_line:
- raise GeneralProxyError("Connection closed unexpectedly")
-
- try:
- proto, status_code, status_msg = status_line.split(" ", 2)
- except ValueError:
- raise GeneralProxyError("HTTP proxy server sent invalid response")
-
- if not proto.startswith("HTTP/"):
- raise GeneralProxyError(
- "Proxy server does not appear to be an HTTP proxy")
-
- try:
- status_code = int(status_code)
- except ValueError:
- raise HTTPError(
- "HTTP proxy server did not return a valid HTTP status")
-
- if status_code != 200:
- error = "{}: {}".format(status_code, status_msg)
- if status_code in (400, 403, 405):
- # It's likely that the HTTP proxy server does not support the
- # CONNECT tunneling method
- error += ("\n[*] Note: The HTTP proxy server may not be"
- " supported by PySocks (must be a CONNECT tunnel"
- " proxy)")
- raise HTTPError(error)
-
- self.proxy_sockname = (b"0.0.0.0", 0)
- self.proxy_peername = addr, dest_port
-
- _proxy_negotiators = {
- SOCKS4: _negotiate_SOCKS4,
- SOCKS5: _negotiate_SOCKS5,
- HTTP: _negotiate_HTTP
- }
-
- @set_self_blocking
- def connect(self, dest_pair, catch_errors=None):
- """
- Connects to the specified destination through a proxy.
- Uses the same API as socket's connect().
- To select the proxy server, use set_proxy().
-
- dest_pair - 2-tuple of (IP/hostname, port).
- """
- if len(dest_pair) != 2 or dest_pair[0].startswith("["):
- # Probably IPv6, not supported -- raise an error, and hope
- # Happy Eyeballs (RFC6555) makes sure at least the IPv4
- # connection works...
- raise socket.error("PySocks doesn't support IPv6: %s"
- % str(dest_pair))
-
- dest_addr, dest_port = dest_pair
-
- if self.type == socket.SOCK_DGRAM:
- if not self._proxyconn:
- self.bind(("", 0))
- dest_addr = socket.gethostbyname(dest_addr)
-
- # If the host address is INADDR_ANY or similar, reset the peer
- # address so that packets are received from any peer
- if dest_addr == "0.0.0.0" and not dest_port:
- self.proxy_peername = None
- else:
- self.proxy_peername = (dest_addr, dest_port)
- return
-
- (proxy_type, proxy_addr, proxy_port, rdns, username,
- password) = self.proxy
-
- # Do a minimal input check first
- if (not isinstance(dest_pair, (list, tuple))
- or len(dest_pair) != 2
- or not dest_addr
- or not isinstance(dest_port, int)):
- # Inputs failed, raise an error
- raise GeneralProxyError(
- "Invalid destination-connection (host, port) pair")
-
- # We set the timeout here so that we don't hang in connection or during
- # negotiation.
- super(socksocket, self).settimeout(self._timeout)
-
- if proxy_type is None:
- # Treat like regular socket object
- self.proxy_peername = dest_pair
- super(socksocket, self).settimeout(self._timeout)
- super(socksocket, self).connect((dest_addr, dest_port))
- return
-
- proxy_addr = self._proxy_addr()
-
- try:
- # Initial connection to proxy server.
- super(socksocket, self).connect(proxy_addr)
-
- except socket.error as error:
- # Error while connecting to proxy
- self.close()
- if not catch_errors:
- proxy_addr, proxy_port = proxy_addr
- proxy_server = "{}:{}".format(proxy_addr, proxy_port)
- printable_type = PRINTABLE_PROXY_TYPES[proxy_type]
-
- msg = "Error connecting to {} proxy {}".format(printable_type,
- proxy_server)
- log.debug("%s due to: %s", msg, error)
- raise ProxyConnectionError(msg, error)
- else:
- raise error
-
- else:
- # Connected to proxy server, now negotiate
- try:
- # Calls negotiate_{SOCKS4, SOCKS5, HTTP}
- negotiate = self._proxy_negotiators[proxy_type]
- negotiate(self, dest_addr, dest_port)
- except socket.error as error:
- if not catch_errors:
- # Wrap socket errors
- self.close()
- raise GeneralProxyError("Socket error", error)
- else:
- raise error
- except ProxyError:
- # Protocol error while negotiating with proxy
- self.close()
- raise
-
- @set_self_blocking
- def connect_ex(self, dest_pair):
- """ https://docs.python.org/3/library/socket.html#socket.socket.connect_ex
- Like connect(address), but return an error indicator instead of raising an exception for errors returned by the C-level connect() call (other problems, such as "host not found" can still raise exceptions).
- """
- try:
- self.connect(dest_pair, catch_errors=True)
- return 0
- except OSError as e:
- # If the error is numeric (socket errors are numeric), then return number as
- # connect_ex expects. Otherwise raise the error again (socket timeout for example)
- if e.errno:
- return e.errno
- else:
- raise
-
- def _proxy_addr(self):
- """
- Return proxy address to connect to as tuple object
- """
- (proxy_type, proxy_addr, proxy_port, rdns, username,
- password) = self.proxy
- proxy_port = proxy_port or DEFAULT_PORTS.get(proxy_type)
- if not proxy_port:
- raise GeneralProxyError("Invalid proxy type")
- return proxy_addr, proxy_port
diff --git a/lib/sockshandler.py b/lib/sockshandler.py
deleted file mode 100644
index 6a2ed81..0000000
--- a/lib/sockshandler.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env python
-"""
-SocksiPy + urllib2 handler
-
-version: 0.3
-author: e
-
-This module provides a Handler which you can use with urllib2 to allow it to tunnel your connection through a socks.sockssocket socket, with out monkey patching the original socket...
-"""
-import socket
-import ssl
-
-try:
- import urllib2
- import httplib
-except ImportError: # Python 3
- import urllib.request as urllib2
- import http.client as httplib
-
-import socks # $ pip install PySocks
-
-def merge_dict(a, b):
- d = a.copy()
- d.update(b)
- return d
-
-def is_ip(s):
- try:
- if ':' in s:
- socket.inet_pton(socket.AF_INET6, s)
- elif '.' in s:
- socket.inet_aton(s)
- else:
- return False
- except:
- return False
- else:
- return True
-
-socks4_no_rdns = set()
-
-class SocksiPyConnection(httplib.HTTPConnection):
- def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
- self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
- httplib.HTTPConnection.__init__(self, *args, **kwargs)
-
- def connect(self):
- (proxytype, proxyaddr, proxyport, rdns, username, password) = self.proxyargs
- rdns = rdns and proxyaddr not in socks4_no_rdns
- while True:
- try:
- sock = socks.create_connection(
- (self.host, self.port), self.timeout, None,
- proxytype, proxyaddr, proxyport, rdns, username, password,
- ((socket.IPPROTO_TCP, socket.TCP_NODELAY, 1),))
- break
- except socks.SOCKS4Error as e:
- if rdns and "0x5b" in str(e) and not is_ip(self.host):
- # Maybe a SOCKS4 server that doesn't support remote resolving
- # Let's try again
- rdns = False
- socks4_no_rdns.add(proxyaddr)
- else:
- raise
- self.sock = sock
-
-class SocksiPyConnectionS(httplib.HTTPSConnection):
- def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
- self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
- httplib.HTTPSConnection.__init__(self, *args, **kwargs)
-
- def connect(self):
- SocksiPyConnection.connect(self)
- self.sock = self._context.wrap_socket(self.sock, server_hostname=self.host)
- if not self._context.check_hostname and self._check_hostname:
- try:
- ssl.match_hostname(self.sock.getpeercert(), self.host)
- except Exception:
- self.sock.shutdown(socket.SHUT_RDWR)
- self.sock.close()
- raise
-
-class SocksiPyHandler(urllib2.HTTPHandler, urllib2.HTTPSHandler):
- def __init__(self, *args, **kwargs):
- self.args = args
- self.kw = kwargs
- urllib2.HTTPHandler.__init__(self)
-
- def http_open(self, req):
- def build(host, port=None, timeout=0, **kwargs):
- kw = merge_dict(self.kw, kwargs)
- conn = SocksiPyConnection(*self.args, host=host, port=port, timeout=timeout, **kw)
- return conn
- return self.do_open(build, req)
-
- def https_open(self, req):
- def build(host, port=None, timeout=0, **kwargs):
- kw = merge_dict(self.kw, kwargs)
- conn = SocksiPyConnectionS(*self.args, host=host, port=port, timeout=timeout, **kw)
- return conn
- return self.do_open(build, req)
-
-if __name__ == "__main__":
- import sys
- try:
- port = int(sys.argv[1])
- except (ValueError, IndexError):
- port = 9050
- opener = urllib2.build_opener(SocksiPyHandler(socks.PROXY_TYPE_SOCKS5, "localhost", port))
- print("HTTP: " + opener.open("http://httpbin.org/ip").read().decode())
- print("HTTPS: " + opener.open("https://httpbin.org/ip").read().decode())
diff --git a/lib/splunk_sdk-2.1.0.dist-info/INSTALLER b/lib/splunk_sdk-2.1.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e..0000000
--- a/lib/splunk_sdk-2.1.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/lib/splunk_sdk-2.1.0.dist-info/METADATA b/lib/splunk_sdk-2.1.0.dist-info/METADATA
deleted file mode 100644
index 6bbf9d6..0000000
--- a/lib/splunk_sdk-2.1.0.dist-info/METADATA
+++ /dev/null
@@ -1,17 +0,0 @@
-Metadata-Version: 2.1
-Name: splunk-sdk
-Version: 2.1.0
-Summary: The Splunk Software Development Kit for Python.
-Home-page: http://github.com/splunk/splunk-sdk-python
-Author: Splunk, Inc.
-Author-email: devinfo@splunk.com
-License: http://www.apache.org/licenses/LICENSE-2.0
-Classifier: Programming Language :: Python
-Classifier: Development Status :: 6 - Mature
-Classifier: Environment :: Other Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Requires-Dist: deprecation
diff --git a/lib/splunk_sdk-2.1.0.dist-info/RECORD b/lib/splunk_sdk-2.1.0.dist-info/RECORD
deleted file mode 100644
index 937e97c..0000000
--- a/lib/splunk_sdk-2.1.0.dist-info/RECORD
+++ /dev/null
@@ -1,60 +0,0 @@
-splunk_sdk-2.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-splunk_sdk-2.1.0.dist-info/METADATA,sha256=4ziLuIcz5urWwla9tCp0pYVca1WNbt0_4O9CnWE2qN0,739
-splunk_sdk-2.1.0.dist-info/RECORD,,
-splunk_sdk-2.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-splunk_sdk-2.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-splunk_sdk-2.1.0.dist-info/top_level.txt,sha256=taq2YYfOB31tNefwW73s54xytiB_sy8bpbyBAfn0kr8,10
-splunklib/__init__.py,sha256=2jyQQZHmPEv0NB8qJgJe-pEEQZIKFG5C9w9KqBrrb-Y,1304
-splunklib/__pycache__/__init__.cpython-311.pyc,,
-splunklib/__pycache__/binding.cpython-311.pyc,,
-splunklib/__pycache__/client.cpython-311.pyc,,
-splunklib/__pycache__/data.cpython-311.pyc,,
-splunklib/__pycache__/results.cpython-311.pyc,,
-splunklib/__pycache__/six.cpython-311.pyc,,
-splunklib/__pycache__/utils.cpython-311.pyc,,
-splunklib/binding.py,sha256=Zh-VUSoks9FjLElV_ro_1KygU2LemTpsw_3BR_4jhfU,61070
-splunklib/client.py,sha256=LhNX0gBiJrm6-6a6Z0G4wdgkqXudXMaHrxgeCwBxiWI,152936
-splunklib/data.py,sha256=pPPx6ZN7B0mj233EDdIF65JTTZSVgIiajEYfrhPEXxo,8171
-splunklib/modularinput/__init__.py,sha256=bHyI0p3GtBoAjbFCEbuUibEFKwnHDyZzZOwS4Fvt0zs,400
-splunklib/modularinput/__pycache__/__init__.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/argument.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/event.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/event_writer.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/input_definition.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/scheme.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/script.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/utils.cpython-311.pyc,,
-splunklib/modularinput/__pycache__/validation_definition.cpython-311.pyc,,
-splunklib/modularinput/argument.py,sha256=Z7OrQ3Ip_vRs3IMG0uhLkgnoGuBDybUwAlphp4skcb8,4107
-splunklib/modularinput/event.py,sha256=KIrKk69BvxbD8zRQT8-Ua_bVN8GXNgG2f7HCAW7QYp4,4339
-splunklib/modularinput/event_writer.py,sha256=fHNjZJCYxJYQ16TEB_Mh-0HRiQMhFKeXBHrSdqo56ZI,3646
-splunklib/modularinput/input_definition.py,sha256=sM3TWTrN6FaORAcPzFKXn9vqWJxWlGPgexZ2EZSLAVE,1777
-splunklib/modularinput/scheme.py,sha256=l3rtHk4t7T8qRG9Pf2jrEXeuuRNvfLuVu8NPcJ89sNM,2962
-splunklib/modularinput/script.py,sha256=dvO79kYuUEjvBYws09w3119Z0SUIIWXxeUdQ71rrScY,6307
-splunklib/modularinput/utils.py,sha256=S5N9tk0TlmLU_YEoSKj61iVVFfUPd9J0Zj_5z1j7G_Y,2624
-splunklib/modularinput/validation_definition.py,sha256=O7C22l0lyECNwrlQpYsNKZJUcnoQn2HUcf2pHzixcWQ,2657
-splunklib/results.py,sha256=60aQc-wqWqB670M6XWctdaBTlPqn0Qlbymhiow-ol28,12801
-splunklib/searchcommands/__init__.py,sha256=sgIL7b84ywgDuyO_xYoDY2HsSFniUxsR7LWTTs9lpXQ,6244
-splunklib/searchcommands/__pycache__/__init__.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/decorators.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/environment.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/eventing_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/external_search_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/generating_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/internals.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/reporting_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/search_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/streaming_command.cpython-311.pyc,,
-splunklib/searchcommands/__pycache__/validators.cpython-311.pyc,,
-splunklib/searchcommands/decorators.py,sha256=em00H607sjd7ywtWoigYKlOpmJDzCprJL3zR0mLUIvI,15300
-splunklib/searchcommands/environment.py,sha256=RHGs0ed9gv9GCER31axLHl05PIo23sDNNjZxHBoyVww,4554
-splunklib/searchcommands/eventing_command.py,sha256=CmIDTiyR_zd9tuja4cQgK5k9zsaLxsywYrkjh7LqsqM,5250
-splunklib/searchcommands/external_search_command.py,sha256=vx-oyRhZx17ZXyhsZ-KXYRCFrnMgP-33Uyu5v41sNCk,7643
-splunklib/searchcommands/generating_command.py,sha256=e2LGGJp7F8U5tesgT64F6VBb_wzq1UlaBLKLDksVz4o,18661
-splunklib/searchcommands/internals.py,sha256=Z921cOakfEv_eR84TkZqkjTI421VmOwEObrlqADyirY,27394
-splunklib/searchcommands/reporting_command.py,sha256=xCKt1lLGxXL83mYa84t-2-1AxaOPz9j44tncxgg-5J4,9539
-splunklib/searchcommands/search_command.py,sha256=wkqYBZpye2hy-w94I1FMBDvWyCW02VQeI2yGisIrCC8,40132
-splunklib/searchcommands/streaming_command.py,sha256=-3ak5fIijbEWBhRQw8Wev3IJz62Ec5I0qNSNkzNmJcQ,6541
-splunklib/searchcommands/validators.py,sha256=uevUv2RcX3k6nLBlAEcyNfEGFWdOUi_TO2H26m5c7F8,12469
-splunklib/six.py,sha256=kZ-1CgvQf-HDGdmKqxzWn9UUCkPkK1Cgel5ckcj-xoc,34536
-splunklib/utils.py,sha256=HvonTTVDgrW_py6sjl3r74jeKYAcEYdZoXiTOkSjQ2c,1356
diff --git a/lib/splunk_sdk-2.1.0.dist-info/REQUESTED b/lib/splunk_sdk-2.1.0.dist-info/REQUESTED
deleted file mode 100644
index e69de29..0000000
diff --git a/lib/splunk_sdk-2.1.0.dist-info/WHEEL b/lib/splunk_sdk-2.1.0.dist-info/WHEEL
deleted file mode 100644
index ae527e7..0000000
--- a/lib/splunk_sdk-2.1.0.dist-info/WHEEL
+++ /dev/null
@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-
diff --git a/lib/splunk_sdk-2.1.0.dist-info/top_level.txt b/lib/splunk_sdk-2.1.0.dist-info/top_level.txt
deleted file mode 100644
index 7b93fb6..0000000
--- a/lib/splunk_sdk-2.1.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-splunklib
diff --git a/lib/splunklib/__init__.py b/lib/splunklib/__init__.py
deleted file mode 100644
index 5f83b2a..0000000
--- a/lib/splunklib/__init__.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-"""Python library for Splunk."""
-
-import logging
-
-DEFAULT_LOG_FORMAT = '%(asctime)s, Level=%(levelname)s, Pid=%(process)s, Logger=%(name)s, File=%(filename)s, ' \
- 'Line=%(lineno)s, %(message)s'
-DEFAULT_DATE_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
-
-
-# To set the logging level of splunklib
-# ex. To enable debug logs, call this method with parameter 'logging.DEBUG'
-# default logging level is set to 'WARNING'
-def setup_logging(level, log_format=DEFAULT_LOG_FORMAT, date_format=DEFAULT_DATE_FORMAT):
- logging.basicConfig(level=level,
- format=log_format,
- datefmt=date_format)
-
-
-__version_info__ = (2, 1, 0)
-__version__ = ".".join(map(str, __version_info__))
diff --git a/lib/splunklib/binding.py b/lib/splunklib/binding.py
deleted file mode 100644
index 25a0994..0000000
--- a/lib/splunklib/binding.py
+++ /dev/null
@@ -1,1504 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-"""The **splunklib.binding** module provides a low-level binding interface to the
-`Splunk REST API `_.
-
-This module handles the wire details of calling the REST API, such as
-authentication tokens, prefix paths, URL encoding, and so on. Actual path
-segments, ``GET`` and ``POST`` arguments, and the parsing of responses is left
-to the user.
-
-If you want a friendlier interface to the Splunk REST API, use the
-:mod:`splunklib.client` module.
-"""
-
-import io
-import json
-import logging
-import socket
-import ssl
-import time
-from base64 import b64encode
-from contextlib import contextmanager
-from datetime import datetime
-from functools import wraps
-from io import BytesIO
-from urllib import parse
-from http import client
-from http.cookies import SimpleCookie
-from xml.etree.ElementTree import XML, ParseError
-from splunklib.data import record
-from splunklib import __version__
-
-
-logger = logging.getLogger(__name__)
-
-__all__ = [
- "AuthenticationError",
- "connect",
- "Context",
- "handler",
- "HTTPError",
- "UrlEncoded",
- "_encode",
- "_make_cookie_header",
- "_NoAuthenticationToken",
- "namespace"
-]
-
-SENSITIVE_KEYS = ['Authorization', 'Cookie', 'action.email.auth_password', 'auth', 'auth_password', 'clear_password', 'clientId',
- 'crc-salt', 'encr_password', 'oldpassword', 'passAuth', 'password', 'session', 'suppressionKey',
- 'token']
-
-# If you change these, update the docstring
-# on _authority as well.
-DEFAULT_HOST = "localhost"
-DEFAULT_PORT = "8089"
-DEFAULT_SCHEME = "https"
-
-
-def _log_duration(f):
- @wraps(f)
- def new_f(*args, **kwargs):
- start_time = datetime.now()
- val = f(*args, **kwargs)
- end_time = datetime.now()
- logger.debug("Operation took %s", end_time - start_time)
- return val
-
- return new_f
-
-
-def mask_sensitive_data(data):
- '''
- Masked sensitive fields data for logging purpose
- '''
- if not isinstance(data, dict):
- try:
- data = json.loads(data)
- except Exception as ex:
- return data
-
- # json.loads will return "123"(str) as 123(int), so return the data if it's not 'dict' type
- if not isinstance(data, dict):
- return data
- mdata = {}
- for k, v in data.items():
- if k in SENSITIVE_KEYS:
- mdata[k] = "******"
- else:
- mdata[k] = mask_sensitive_data(v)
- return mdata
-
-
-def _parse_cookies(cookie_str, dictionary):
- """Tries to parse any key-value pairs of cookies in a string,
- then updates the the dictionary with any key-value pairs found.
-
- **Example**::
-
- dictionary = {}
- _parse_cookies('my=value', dictionary)
- # Now the following is True
- dictionary['my'] == 'value'
-
- :param cookie_str: A string containing "key=value" pairs from an HTTP "Set-Cookie" header.
- :type cookie_str: ``str``
- :param dictionary: A dictionary to update with any found key-value pairs.
- :type dictionary: ``dict``
- """
- parsed_cookie = SimpleCookie(cookie_str)
- for cookie in parsed_cookie.values():
- dictionary[cookie.key] = cookie.coded_value
-
-
-def _make_cookie_header(cookies):
- """
- Takes a list of 2-tuples of key-value pairs of
- cookies, and returns a valid HTTP ``Cookie``
- header.
-
- **Example**::
-
- header = _make_cookie_header([("key", "value"), ("key_2", "value_2")])
- # Now the following is True
- header == "key=value; key_2=value_2"
-
- :param cookies: A list of 2-tuples of cookie key-value pairs.
- :type cookies: ``list`` of 2-tuples
- :return: ``str` An HTTP header cookie string.
- :rtype: ``str``
- """
- return "; ".join(f"{key}={value}" for key, value in cookies)
-
-
-# Singleton values to eschew None
-class _NoAuthenticationToken:
- """The value stored in a :class:`Context` or :class:`splunklib.client.Service`
- class that is not logged in.
-
- If a ``Context`` or ``Service`` object is created without an authentication
- token, and there has not yet been a call to the ``login`` method, the token
- field of the ``Context`` or ``Service`` object is set to
- ``_NoAuthenticationToken``.
-
- Likewise, after a ``Context`` or ``Service`` object has been logged out, the
- token is set to this value again.
- """
-
-
-class UrlEncoded(str):
- """This class marks URL-encoded strings.
- It should be considered an SDK-private implementation detail.
-
- Manually tracking whether strings are URL encoded can be difficult. Avoid
- calling ``urllib.quote`` to replace special characters with escapes. When
- you receive a URL-encoded string, *do* use ``urllib.unquote`` to replace
- escapes with single characters. Then, wrap any string you want to use as a
- URL in ``UrlEncoded``. Note that because the ``UrlEncoded`` class is
- idempotent, making multiple calls to it is OK.
-
- ``UrlEncoded`` objects are identical to ``str`` objects (including being
- equal if their contents are equal) except when passed to ``UrlEncoded``
- again.
-
- ``UrlEncoded`` removes the ``str`` type support for interpolating values
- with ``%`` (doing that raises a ``TypeError``). There is no reliable way to
- encode values this way, so instead, interpolate into a string, quoting by
- hand, and call ``UrlEncode`` with ``skip_encode=True``.
-
- **Example**::
-
- import urllib
- UrlEncoded(f'{scheme}://{urllib.quote(host)}', skip_encode=True)
-
- If you append ``str`` strings and ``UrlEncoded`` strings, the result is also
- URL encoded.
-
- **Example**::
-
- UrlEncoded('ab c') + 'de f' == UrlEncoded('ab cde f')
- 'ab c' + UrlEncoded('de f') == UrlEncoded('ab cde f')
- """
-
- def __new__(self, val='', skip_encode=False, encode_slash=False):
- if isinstance(val, UrlEncoded):
- # Don't urllib.quote something already URL encoded.
- return val
- if skip_encode:
- return str.__new__(self, val)
- if encode_slash:
- return str.__new__(self, parse.quote_plus(val))
- # When subclassing str, just call str.__new__ method
- # with your class and the value you want to have in the
- # new string.
- return str.__new__(self, parse.quote(val))
-
- def __add__(self, other):
- """self + other
-
- If *other* is not a ``UrlEncoded``, URL encode it before
- adding it.
- """
- if isinstance(other, UrlEncoded):
- return UrlEncoded(str.__add__(self, other), skip_encode=True)
-
- return UrlEncoded(str.__add__(self, parse.quote(other)), skip_encode=True)
-
- def __radd__(self, other):
- """other + self
-
- If *other* is not a ``UrlEncoded``, URL _encode it before
- adding it.
- """
- if isinstance(other, UrlEncoded):
- return UrlEncoded(str.__radd__(self, other), skip_encode=True)
-
- return UrlEncoded(str.__add__(parse.quote(other), self), skip_encode=True)
-
- def __mod__(self, fields):
- """Interpolation into ``UrlEncoded``s is disabled.
-
- If you try to write ``UrlEncoded("%s") % "abc", will get a
- ``TypeError``.
- """
- raise TypeError("Cannot interpolate into a UrlEncoded object.")
-
- def __repr__(self):
- return f"UrlEncoded({repr(parse.unquote(str(self)))})"
-
-
-@contextmanager
-def _handle_auth_error(msg):
- """Handle re-raising HTTP authentication errors as something clearer.
-
- If an ``HTTPError`` is raised with status 401 (access denied) in
- the body of this context manager, re-raise it as an
- ``AuthenticationError`` instead, with *msg* as its message.
-
- This function adds no round trips to the server.
-
- :param msg: The message to be raised in ``AuthenticationError``.
- :type msg: ``str``
-
- **Example**::
-
- with _handle_auth_error("Your login failed."):
- ... # make an HTTP request
- """
- try:
- yield
- except HTTPError as he:
- if he.status == 401:
- raise AuthenticationError(msg, he)
- else:
- raise
-
-
-def _authentication(request_fun):
- """Decorator to handle autologin and authentication errors.
-
- *request_fun* is a function taking no arguments that needs to
- be run with this ``Context`` logged into Splunk.
-
- ``_authentication``'s behavior depends on whether the
- ``autologin`` field of ``Context`` is set to ``True`` or
- ``False``. If it's ``False``, then ``_authentication``
- aborts if the ``Context`` is not logged in, and raises an
- ``AuthenticationError`` if an ``HTTPError`` of status 401 is
- raised in *request_fun*. If it's ``True``, then
- ``_authentication`` will try at all sensible places to
- log in before issuing the request.
-
- If ``autologin`` is ``False``, ``_authentication`` makes
- one roundtrip to the server if the ``Context`` is logged in,
- or zero if it is not. If ``autologin`` is ``True``, it's less
- deterministic, and may make at most three roundtrips (though
- that would be a truly pathological case).
-
- :param request_fun: A function of no arguments encapsulating
- the request to make to the server.
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.connect(..., autologin=True)
- c.logout()
- def f():
- c.get("/services")
- return 42
- print(_authentication(f))
- """
-
- @wraps(request_fun)
- def wrapper(self, *args, **kwargs):
- if self.token is _NoAuthenticationToken and not self.has_cookies():
- # Not yet logged in.
- if self.autologin and self.username and self.password:
- # This will throw an uncaught
- # AuthenticationError if it fails.
- self.login()
- else:
- # Try the request anyway without authentication.
- # Most requests will fail. Some will succeed, such as
- # 'GET server/info'.
- with _handle_auth_error("Request aborted: not logged in."):
- return request_fun(self, *args, **kwargs)
- try:
- # Issue the request
- return request_fun(self, *args, **kwargs)
- except HTTPError as he:
- if he.status == 401 and self.autologin:
- # Authentication failed. Try logging in, and then
- # rerunning the request. If either step fails, throw
- # an AuthenticationError and give up.
- with _handle_auth_error("Autologin failed."):
- self.login()
- with _handle_auth_error("Authentication Failed! If session token is used, it seems to have been expired."):
- return request_fun(self, *args, **kwargs)
- elif he.status == 401 and not self.autologin:
- raise AuthenticationError(
- "Request failed: Session is not logged in.", he)
- else:
- raise
-
- return wrapper
-
-
-def _authority(scheme=DEFAULT_SCHEME, host=DEFAULT_HOST, port=DEFAULT_PORT):
- """Construct a URL authority from the given *scheme*, *host*, and *port*.
-
- Named in accordance with RFC2396_, which defines URLs as::
-
- ://?
-
- .. _RFC2396: http://www.ietf.org/rfc/rfc2396.txt
-
- So ``https://localhost:8000/a/b/b?boris=hilda`` would be parsed as::
-
- scheme := https
- authority := localhost:8000
- path := /a/b/c
- query := boris=hilda
-
- :param scheme: URL scheme (the default is "https")
- :type scheme: "http" or "https"
- :param host: The host name (the default is "localhost")
- :type host: string
- :param port: The port number (the default is 8089)
- :type port: integer
- :return: The URL authority.
- :rtype: UrlEncoded (subclass of ``str``)
-
- **Example**::
-
- _authority() == "https://localhost:8089"
-
- _authority(host="splunk.utopia.net") == "https://splunk.utopia.net:8089"
-
- _authority(host="2001:0db8:85a3:0000:0000:8a2e:0370:7334") == \
- "https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:8089"
-
- _authority(scheme="http", host="splunk.utopia.net", port="471") == \
- "http://splunk.utopia.net:471"
-
- """
- # check if host is an IPv6 address and not enclosed in [ ]
- if ':' in host and not (host.startswith('[') and host.endswith(']')):
- # IPv6 addresses must be enclosed in [ ] in order to be well
- # formed.
- host = '[' + host + ']'
- return UrlEncoded(f"{scheme}://{host}:{port}", skip_encode=True)
-
-
-# kwargs: sharing, owner, app
-def namespace(sharing=None, owner=None, app=None, **kwargs):
- """This function constructs a Splunk namespace.
-
- Every Splunk resource belongs to a namespace. The namespace is specified by
- the pair of values ``owner`` and ``app`` and is governed by a ``sharing`` mode.
- The possible values for ``sharing`` are: "user", "app", "global" and "system",
- which map to the following combinations of ``owner`` and ``app`` values:
-
- "user" => {owner}, {app}
-
- "app" => nobody, {app}
-
- "global" => nobody, {app}
-
- "system" => nobody, system
-
- "nobody" is a special user name that basically means no user, and "system"
- is the name reserved for system resources.
-
- "-" is a wildcard that can be used for both ``owner`` and ``app`` values and
- refers to all users and all apps, respectively.
-
- In general, when you specify a namespace you can specify any combination of
- these three values and the library will reconcile the triple, overriding the
- provided values as appropriate.
-
- Finally, if no namespacing is specified the library will make use of the
- ``/services`` branch of the REST API, which provides a namespaced view of
- Splunk resources equivelent to using ``owner={currentUser}`` and
- ``app={defaultApp}``.
-
- The ``namespace`` function returns a representation of the namespace from
- reconciling the values you provide. It ignores any keyword arguments other
- than ``owner``, ``app``, and ``sharing``, so you can provide ``dicts`` of
- configuration information without first having to extract individual keys.
-
- :param sharing: The sharing mode (the default is "user").
- :type sharing: "system", "global", "app", or "user"
- :param owner: The owner context (the default is "None").
- :type owner: ``string``
- :param app: The app context (the default is "None").
- :type app: ``string``
- :returns: A :class:`splunklib.data.Record` containing the reconciled
- namespace.
-
- **Example**::
-
- import splunklib.binding as binding
- n = binding.namespace(sharing="user", owner="boris", app="search")
- n = binding.namespace(sharing="global", app="search")
- """
- if sharing in ["system"]:
- return record({'sharing': sharing, 'owner': "nobody", 'app': "system"})
- if sharing in ["global", "app"]:
- return record({'sharing': sharing, 'owner': "nobody", 'app': app})
- if sharing in ["user", None]:
- return record({'sharing': sharing, 'owner': owner, 'app': app})
- raise ValueError("Invalid value for argument: 'sharing'")
-
-
-class Context:
- """This class represents a context that encapsulates a splunkd connection.
-
- The ``Context`` class encapsulates the details of HTTP requests,
- authentication, a default namespace, and URL prefixes to simplify access to
- the REST API.
-
- After creating a ``Context`` object, you must call its :meth:`login`
- method before you can issue requests to splunkd. Or, use the :func:`connect`
- function to create an already-authenticated ``Context`` object. You can
- provide a session token explicitly (the same token can be shared by multiple
- ``Context`` objects) to provide authentication.
-
- :param host: The host name (the default is "localhost").
- :type host: ``string``
- :param port: The port number (the default is 8089).
- :type port: ``integer``
- :param scheme: The scheme for accessing the service (the default is "https").
- :type scheme: "https" or "http"
- :param verify: Enable (True) or disable (False) SSL verification for https connections.
- :type verify: ``Boolean``
- :param self_signed_certificate: Specifies if self signed certificate is used
- :type self_signed_certificate: ``Boolean``
- :param sharing: The sharing mode for the namespace (the default is "user").
- :type sharing: "global", "system", "app", or "user"
- :param owner: The owner context of the namespace (optional, the default is "None").
- :type owner: ``string``
- :param app: The app context of the namespace (optional, the default is "None").
- :type app: ``string``
- :param token: A session token. When provided, you don't need to call :meth:`login`.
- :type token: ``string``
- :param cookie: A session cookie. When provided, you don't need to call :meth:`login`.
- This parameter is only supported for Splunk 6.2+.
- :type cookie: ``string``
- :param username: The Splunk account username, which is used to
- authenticate the Splunk instance.
- :type username: ``string``
- :param password: The password for the Splunk account.
- :type password: ``string``
- :param splunkToken: Splunk authentication token
- :type splunkToken: ``string``
- :param headers: List of extra HTTP headers to send (optional).
- :type headers: ``list`` of 2-tuples.
- :param retires: Number of retries for each HTTP connection (optional, the default is 0).
- NOTE THAT THIS MAY INCREASE THE NUMBER OF ROUND TRIP CONNECTIONS TO THE SPLUNK SERVER AND BLOCK THE
- CURRENT THREAD WHILE RETRYING.
- :type retries: ``int``
- :param retryDelay: How long to wait between connection attempts if `retries` > 0 (optional, defaults to 10s).
- :type retryDelay: ``int`` (in seconds)
- :param handler: The HTTP request handler (optional).
- :returns: A ``Context`` instance.
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.Context(username="boris", password="natasha", ...)
- c.login()
- # Or equivalently
- c = binding.connect(username="boris", password="natasha")
- # Or if you already have a session token
- c = binding.Context(token="atg232342aa34324a")
- # Or if you already have a valid cookie
- c = binding.Context(cookie="splunkd_8089=...")
- """
-
- def __init__(self, handler=None, **kwargs):
- self.http = HttpLib(handler, kwargs.get("verify", False), key_file=kwargs.get("key_file"),
- cert_file=kwargs.get("cert_file"), context=kwargs.get("context"),
- # Default to False for backward compat
- retries=kwargs.get("retries", 0), retryDelay=kwargs.get("retryDelay", 10))
- self.token = kwargs.get("token", _NoAuthenticationToken)
- if self.token is None: # In case someone explicitly passes token=None
- self.token = _NoAuthenticationToken
- self.scheme = kwargs.get("scheme", DEFAULT_SCHEME)
- self.host = kwargs.get("host", DEFAULT_HOST)
- self.port = int(kwargs.get("port", DEFAULT_PORT))
- self.authority = _authority(self.scheme, self.host, self.port)
- self.namespace = namespace(**kwargs)
- self.username = kwargs.get("username", "")
- self.password = kwargs.get("password", "")
- self.basic = kwargs.get("basic", False)
- self.bearerToken = kwargs.get("splunkToken", "")
- self.autologin = kwargs.get("autologin", False)
- self.additional_headers = kwargs.get("headers", [])
- self._self_signed_certificate = kwargs.get("self_signed_certificate", True)
-
- # Store any cookies in the self.http._cookies dict
- if "cookie" in kwargs and kwargs['cookie'] not in [None, _NoAuthenticationToken]:
- _parse_cookies(kwargs["cookie"], self.http._cookies)
-
- def get_cookies(self):
- """Gets the dictionary of cookies from the ``HttpLib`` member of this instance.
-
- :return: Dictionary of cookies stored on the ``self.http``.
- :rtype: ``dict``
- """
- return self.http._cookies
-
- def has_cookies(self):
- """Returns true if the ``HttpLib`` member of this instance has auth token stored.
-
- :return: ``True`` if there is auth token present, else ``False``
- :rtype: ``bool``
- """
- auth_token_key = "splunkd_"
- return any(auth_token_key in key for key in self.get_cookies().keys())
-
- # Shared per-context request headers
- @property
- def _auth_headers(self):
- """Headers required to authenticate a request.
-
- Assumes your ``Context`` already has a authentication token or
- cookie, either provided explicitly or obtained by logging
- into the Splunk instance.
-
- :returns: A list of 2-tuples containing key and value
- """
- header = []
- if self.has_cookies():
- return [("Cookie", _make_cookie_header(list(self.get_cookies().items())))]
- elif self.basic and (self.username and self.password):
- token = f'Basic {b64encode(("%s:%s" % (self.username, self.password)).encode("utf-8")).decode("ascii")}'
- elif self.bearerToken:
- token = f'Bearer {self.bearerToken}'
- elif self.token is _NoAuthenticationToken:
- token = []
- else:
- # Ensure the token is properly formatted
- if self.token.startswith('Splunk '):
- token = self.token
- else:
- token = f'Splunk {self.token}'
- if token:
- header.append(("Authorization", token))
- if self.get_cookies():
- header.append(("Cookie", _make_cookie_header(list(self.get_cookies().items()))))
-
- return header
-
- def connect(self):
- """Returns an open connection (socket) to the Splunk instance.
-
- This method is used for writing bulk events to an index or similar tasks
- where the overhead of opening a connection multiple times would be
- prohibitive.
-
- :returns: A socket.
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.connect(...)
- socket = c.connect()
- socket.write("POST %s HTTP/1.1\\r\\n" % "some/path/to/post/to")
- socket.write("Host: %s:%s\\r\\n" % (c.host, c.port))
- socket.write("Accept-Encoding: identity\\r\\n")
- socket.write("Authorization: %s\\r\\n" % c.token)
- socket.write("X-Splunk-Input-Mode: Streaming\\r\\n")
- socket.write("\\r\\n")
- """
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- if self.scheme == "https":
- context = ssl.create_default_context()
- context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
- context.check_hostname = not self._self_signed_certificate
- context.verify_mode = ssl.CERT_NONE if self._self_signed_certificate else ssl.CERT_REQUIRED
- sock = context.wrap_socket(sock, server_hostname=self.host)
- sock.connect((socket.gethostbyname(self.host), self.port))
- return sock
-
- @_authentication
- @_log_duration
- def delete(self, path_segment, owner=None, app=None, sharing=None, **query):
- """Performs a DELETE operation at the REST path segment with the given
- namespace and query.
-
- This method is named to match the HTTP method. ``delete`` makes at least
- one round trip to the server, one additional round trip for each 303
- status returned, and at most two additional round trips if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- If *owner*, *app*, and *sharing* are omitted, this method uses the
- default :class:`Context` namespace. All other keyword arguments are
- included in the URL as query parameters.
-
- :raises AuthenticationError: Raised when the ``Context`` object is not
- logged in.
- :raises HTTPError: Raised when an error occurred in a GET operation from
- *path_segment*.
- :param path_segment: A REST path segment.
- :type path_segment: ``string``
- :param owner: The owner context of the namespace (optional).
- :type owner: ``string``
- :param app: The app context of the namespace (optional).
- :type app: ``string``
- :param sharing: The sharing mode of the namespace (optional).
- :type sharing: ``string``
- :param query: All other keyword arguments, which are used as query
- parameters.
- :type query: ``string``
- :return: The response from the server.
- :rtype: ``dict`` with keys ``body``, ``headers``, ``reason``,
- and ``status``
-
- **Example**::
-
- c = binding.connect(...)
- c.delete('saved/searches/boris') == \\
- {'body': ...a response reader object...,
- 'headers': [('content-length', '1786'),
- ('expires', 'Fri, 30 Oct 1998 00:00:00 GMT'),
- ('server', 'Splunkd'),
- ('connection', 'close'),
- ('cache-control', 'no-store, max-age=0, must-revalidate, no-cache'),
- ('date', 'Fri, 11 May 2012 16:53:06 GMT'),
- ('content-type', 'text/xml; charset=utf-8')],
- 'reason': 'OK',
- 'status': 200}
- c.delete('nonexistant/path') # raises HTTPError
- c.logout()
- c.delete('apps/local') # raises AuthenticationError
- """
- path = self.authority + self._abspath(path_segment, owner=owner,
- app=app, sharing=sharing)
- logger.debug("DELETE request to %s (body: %s)", path, mask_sensitive_data(query))
- response = self.http.delete(path, self._auth_headers, **query)
- return response
-
- @_authentication
- @_log_duration
- def get(self, path_segment, owner=None, app=None, headers=None, sharing=None, **query):
- """Performs a GET operation from the REST path segment with the given
- namespace and query.
-
- This method is named to match the HTTP method. ``get`` makes at least
- one round trip to the server, one additional round trip for each 303
- status returned, and at most two additional round trips if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- If *owner*, *app*, and *sharing* are omitted, this method uses the
- default :class:`Context` namespace. All other keyword arguments are
- included in the URL as query parameters.
-
- :raises AuthenticationError: Raised when the ``Context`` object is not
- logged in.
- :raises HTTPError: Raised when an error occurred in a GET operation from
- *path_segment*.
- :param path_segment: A REST path segment.
- :type path_segment: ``string``
- :param owner: The owner context of the namespace (optional).
- :type owner: ``string``
- :param app: The app context of the namespace (optional).
- :type app: ``string``
- :param headers: List of extra HTTP headers to send (optional).
- :type headers: ``list`` of 2-tuples.
- :param sharing: The sharing mode of the namespace (optional).
- :type sharing: ``string``
- :param query: All other keyword arguments, which are used as query
- parameters.
- :type query: ``string``
- :return: The response from the server.
- :rtype: ``dict`` with keys ``body``, ``headers``, ``reason``,
- and ``status``
-
- **Example**::
-
- c = binding.connect(...)
- c.get('apps/local') == \\
- {'body': ...a response reader object...,
- 'headers': [('content-length', '26208'),
- ('expires', 'Fri, 30 Oct 1998 00:00:00 GMT'),
- ('server', 'Splunkd'),
- ('connection', 'close'),
- ('cache-control', 'no-store, max-age=0, must-revalidate, no-cache'),
- ('date', 'Fri, 11 May 2012 16:30:35 GMT'),
- ('content-type', 'text/xml; charset=utf-8')],
- 'reason': 'OK',
- 'status': 200}
- c.get('nonexistant/path') # raises HTTPError
- c.logout()
- c.get('apps/local') # raises AuthenticationError
- """
- if headers is None:
- headers = []
-
- path = self.authority + self._abspath(path_segment, owner=owner,
- app=app, sharing=sharing)
- logger.debug("GET request to %s (body: %s)", path, mask_sensitive_data(query))
- all_headers = headers + self.additional_headers + self._auth_headers
- response = self.http.get(path, all_headers, **query)
- return response
-
- @_authentication
- @_log_duration
- def post(self, path_segment, owner=None, app=None, sharing=None, headers=None, **query):
- """Performs a POST operation from the REST path segment with the given
- namespace and query.
-
- This method is named to match the HTTP method. ``post`` makes at least
- one round trip to the server, one additional round trip for each 303
- status returned, and at most two additional round trips if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- If *owner*, *app*, and *sharing* are omitted, this method uses the
- default :class:`Context` namespace. All other keyword arguments are
- included in the URL as query parameters.
-
- Some of Splunk's endpoints, such as ``receivers/simple`` and
- ``receivers/stream``, require unstructured data in the POST body
- and all metadata passed as GET-style arguments. If you provide
- a ``body`` argument to ``post``, it will be used as the POST
- body, and all other keyword arguments will be passed as
- GET-style arguments in the URL.
-
- :raises AuthenticationError: Raised when the ``Context`` object is not
- logged in.
- :raises HTTPError: Raised when an error occurred in a GET operation from
- *path_segment*.
- :param path_segment: A REST path segment.
- :type path_segment: ``string``
- :param owner: The owner context of the namespace (optional).
- :type owner: ``string``
- :param app: The app context of the namespace (optional).
- :type app: ``string``
- :param sharing: The sharing mode of the namespace (optional).
- :type sharing: ``string``
- :param headers: List of extra HTTP headers to send (optional).
- :type headers: ``list`` of 2-tuples.
- :param query: All other keyword arguments, which are used as query
- parameters.
- :param body: Parameters to be used in the post body. If specified,
- any parameters in the query will be applied to the URL instead of
- the body. If a dict is supplied, the key-value pairs will be form
- encoded. If a string is supplied, the body will be passed through
- in the request unchanged.
- :type body: ``dict`` or ``str``
- :return: The response from the server.
- :rtype: ``dict`` with keys ``body``, ``headers``, ``reason``,
- and ``status``
-
- **Example**::
-
- c = binding.connect(...)
- c.post('saved/searches', name='boris',
- search='search * earliest=-1m | head 1') == \\
- {'body': ...a response reader object...,
- 'headers': [('content-length', '10455'),
- ('expires', 'Fri, 30 Oct 1998 00:00:00 GMT'),
- ('server', 'Splunkd'),
- ('connection', 'close'),
- ('cache-control', 'no-store, max-age=0, must-revalidate, no-cache'),
- ('date', 'Fri, 11 May 2012 16:46:06 GMT'),
- ('content-type', 'text/xml; charset=utf-8')],
- 'reason': 'Created',
- 'status': 201}
- c.post('nonexistant/path') # raises HTTPError
- c.logout()
- # raises AuthenticationError:
- c.post('saved/searches', name='boris',
- search='search * earliest=-1m | head 1')
- """
- if headers is None:
- headers = []
-
- path = self.authority + self._abspath(path_segment, owner=owner, app=app, sharing=sharing)
-
- logger.debug("POST request to %s (body: %s)", path, mask_sensitive_data(query))
- all_headers = headers + self.additional_headers + self._auth_headers
- response = self.http.post(path, all_headers, **query)
- return response
-
- @_authentication
- @_log_duration
- def request(self, path_segment, method="GET", headers=None, body={},
- owner=None, app=None, sharing=None):
- """Issues an arbitrary HTTP request to the REST path segment.
-
- This method is named to match ``httplib.request``. This function
- makes a single round trip to the server.
-
- If *owner*, *app*, and *sharing* are omitted, this method uses the
- default :class:`Context` namespace. All other keyword arguments are
- included in the URL as query parameters.
-
- :raises AuthenticationError: Raised when the ``Context`` object is not
- logged in.
- :raises HTTPError: Raised when an error occurred in a GET operation from
- *path_segment*.
- :param path_segment: A REST path segment.
- :type path_segment: ``string``
- :param method: The HTTP method to use (optional).
- :type method: ``string``
- :param headers: List of extra HTTP headers to send (optional).
- :type headers: ``list`` of 2-tuples.
- :param body: Content of the HTTP request (optional).
- :type body: ``string``
- :param owner: The owner context of the namespace (optional).
- :type owner: ``string``
- :param app: The app context of the namespace (optional).
- :type app: ``string``
- :param sharing: The sharing mode of the namespace (optional).
- :type sharing: ``string``
- :return: The response from the server.
- :rtype: ``dict`` with keys ``body``, ``headers``, ``reason``,
- and ``status``
-
- **Example**::
-
- c = binding.connect(...)
- c.request('saved/searches', method='GET') == \\
- {'body': ...a response reader object...,
- 'headers': [('content-length', '46722'),
- ('expires', 'Fri, 30 Oct 1998 00:00:00 GMT'),
- ('server', 'Splunkd'),
- ('connection', 'close'),
- ('cache-control', 'no-store, max-age=0, must-revalidate, no-cache'),
- ('date', 'Fri, 11 May 2012 17:24:19 GMT'),
- ('content-type', 'text/xml; charset=utf-8')],
- 'reason': 'OK',
- 'status': 200}
- c.request('nonexistant/path', method='GET') # raises HTTPError
- c.logout()
- c.get('apps/local') # raises AuthenticationError
- """
- if headers is None:
- headers = []
-
- path = self.authority \
- + self._abspath(path_segment, owner=owner,
- app=app, sharing=sharing)
-
- all_headers = headers + self.additional_headers + self._auth_headers
- logger.debug("%s request to %s (headers: %s, body: %s)",
- method, path, str(mask_sensitive_data(dict(all_headers))), mask_sensitive_data(body))
- if body:
- body = _encode(**body)
-
- if method == "GET":
- path = path + UrlEncoded('?' + body, skip_encode=True)
- message = {'method': method,
- 'headers': all_headers}
- else:
- message = {'method': method,
- 'headers': all_headers,
- 'body': body}
- else:
- message = {'method': method,
- 'headers': all_headers}
-
- response = self.http.request(path, message)
-
- return response
-
- def login(self):
- """Logs into the Splunk instance referred to by the :class:`Context`
- object.
-
- Unless a ``Context`` is created with an explicit authentication token
- (probably obtained by logging in from a different ``Context`` object)
- you must call :meth:`login` before you can issue requests.
- The authentication token obtained from the server is stored in the
- ``token`` field of the ``Context`` object.
-
- :raises AuthenticationError: Raised when login fails.
- :returns: The ``Context`` object, so you can chain calls.
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.Context(...).login()
- # Then issue requests...
- """
-
- if self.has_cookies() and \
- (not self.username and not self.password):
- # If we were passed session cookie(s), but no username or
- # password, then login is a nop, since we're automatically
- # logged in.
- return
-
- if self.token is not _NoAuthenticationToken and \
- (not self.username and not self.password):
- # If we were passed a session token, but no username or
- # password, then login is a nop, since we're automatically
- # logged in.
- return
-
- if self.basic and (self.username and self.password):
- # Basic auth mode requested, so this method is a nop as long
- # as credentials were passed in.
- return
-
- if self.bearerToken:
- # Bearer auth mode requested, so this method is a nop as long
- # as authentication token was passed in.
- return
- # Only try to get a token and updated cookie if username & password are specified
- try:
- response = self.http.post(
- self.authority + self._abspath("/services/auth/login"),
- username=self.username,
- password=self.password,
- headers=self.additional_headers,
- cookie="1") # In Splunk 6.2+, passing "cookie=1" will return the "set-cookie" header
-
- body = response.body.read()
- session = XML(body).findtext("./sessionKey")
- self.token = f"Splunk {session}"
- return self
- except HTTPError as he:
- if he.status == 401:
- raise AuthenticationError("Login failed.", he)
- else:
- raise
-
- def logout(self):
- """Forgets the current session token, and cookies."""
- self.token = _NoAuthenticationToken
- self.http._cookies = {}
- return self
-
- def _abspath(self, path_segment,
- owner=None, app=None, sharing=None):
- """Qualifies *path_segment* into an absolute path for a URL.
-
- If *path_segment* is already absolute, returns it unchanged.
- If *path_segment* is relative, then qualifies it with either
- the provided namespace arguments or the ``Context``'s default
- namespace. Any forbidden characters in *path_segment* are URL
- encoded. This function has no network activity.
-
- Named to be consistent with RFC2396_.
-
- .. _RFC2396: http://www.ietf.org/rfc/rfc2396.txt
-
- :param path_segment: A relative or absolute URL path segment.
- :type path_segment: ``string``
- :param owner, app, sharing: Components of a namespace (defaults
- to the ``Context``'s namespace if all
- three are omitted)
- :type owner, app, sharing: ``string``
- :return: A ``UrlEncoded`` (a subclass of ``str``).
- :rtype: ``string``
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.connect(owner='boris', app='search', sharing='user')
- c._abspath('/a/b/c') == '/a/b/c'
- c._abspath('/a/b c/d') == '/a/b%20c/d'
- c._abspath('apps/local/search') == \
- '/servicesNS/boris/search/apps/local/search'
- c._abspath('apps/local/search', sharing='system') == \
- '/servicesNS/nobody/system/apps/local/search'
- url = c.authority + c._abspath('apps/local/sharing')
- """
- skip_encode = isinstance(path_segment, UrlEncoded)
- # If path_segment is absolute, escape all forbidden characters
- # in it and return it.
- if path_segment.startswith('/'):
- return UrlEncoded(path_segment, skip_encode=skip_encode)
-
- # path_segment is relative, so we need a namespace to build an
- # absolute path.
- if owner or app or sharing:
- ns = namespace(owner=owner, app=app, sharing=sharing)
- else:
- ns = self.namespace
-
- # If no app or owner are specified, then use the /services
- # endpoint. Otherwise, use /servicesNS with the specified
- # namespace. If only one of app and owner is specified, use
- # '-' for the other.
- if ns.app is None and ns.owner is None:
- return UrlEncoded(f"/services/{path_segment}", skip_encode=skip_encode)
-
- oname = "nobody" if ns.owner is None else ns.owner
- aname = "system" if ns.app is None else ns.app
- path = UrlEncoded(f"/servicesNS/{oname}/{aname}/{path_segment}", skip_encode=skip_encode)
- return path
-
-
-def connect(**kwargs):
- """This function returns an authenticated :class:`Context` object.
-
- This function is a shorthand for calling :meth:`Context.login`.
-
- This function makes one round trip to the server.
-
- :param host: The host name (the default is "localhost").
- :type host: ``string``
- :param port: The port number (the default is 8089).
- :type port: ``integer``
- :param scheme: The scheme for accessing the service (the default is "https").
- :type scheme: "https" or "http"
- :param owner: The owner context of the namespace (the default is "None").
- :type owner: ``string``
- :param app: The app context of the namespace (the default is "None").
- :type app: ``string``
- :param sharing: The sharing mode for the namespace (the default is "user").
- :type sharing: "global", "system", "app", or "user"
- :param token: The current session token (optional). Session tokens can be
- shared across multiple service instances.
- :type token: ``string``
- :param cookie: A session cookie. When provided, you don't need to call :meth:`login`.
- This parameter is only supported for Splunk 6.2+.
- :type cookie: ``string``
- :param username: The Splunk account username, which is used to
- authenticate the Splunk instance.
- :type username: ``string``
- :param password: The password for the Splunk account.
- :type password: ``string``
- :param headers: List of extra HTTP headers to send (optional).
- :type headers: ``list`` of 2-tuples.
- :param autologin: When ``True``, automatically tries to log in again if the
- session terminates.
- :type autologin: ``Boolean``
- :return: An initialized :class:`Context` instance.
-
- **Example**::
-
- import splunklib.binding as binding
- c = binding.connect(...)
- response = c.get("apps/local")
- """
- c = Context(**kwargs)
- c.login()
- return c
-
-
-# Note: the error response schema supports multiple messages but we only
-# return the first, although we do return the body so that an exception
-# handler that wants to read multiple messages can do so.
-class HTTPError(Exception):
- """This exception is raised for HTTP responses that return an error."""
-
- def __init__(self, response, _message=None):
- status = response.status
- reason = response.reason
- body = response.body.read()
- try:
- detail = XML(body).findtext("./messages/msg")
- except ParseError:
- detail = body
- detail_formatted = "" if detail is None else f" -- {detail}"
- message = f"HTTP {status} {reason}{detail_formatted}"
- Exception.__init__(self, _message or message)
- self.status = status
- self.reason = reason
- self.headers = response.headers
- self.body = body
- self._response = response
-
-
-class AuthenticationError(HTTPError):
- """Raised when a login request to Splunk fails.
-
- If your username was unknown or you provided an incorrect password
- in a call to :meth:`Context.login` or :meth:`splunklib.client.Service.login`,
- this exception is raised.
- """
-
- def __init__(self, message, cause):
- # Put the body back in the response so that HTTPError's constructor can
- # read it again.
- cause._response.body = BytesIO(cause.body)
-
- HTTPError.__init__(self, cause._response, message)
-
-
-#
-# The HTTP interface used by the Splunk binding layer abstracts the underlying
-# HTTP library using request & response 'messages' which are implemented as
-# dictionaries with the following structure:
-#
-# # HTTP request message (only method required)
-# request {
-# method : str,
-# headers? : [(str, str)*],
-# body? : str,
-# }
-#
-# # HTTP response message (all keys present)
-# response {
-# status : int,
-# reason : str,
-# headers : [(str, str)*],
-# body : file,
-# }
-#
-
-# Encode the given kwargs as a query string. This wrapper will also _encode
-# a list value as a sequence of assignments to the corresponding arg name,
-# for example an argument such as 'foo=[1,2,3]' will be encoded as
-# 'foo=1&foo=2&foo=3'.
-def _encode(**kwargs):
- items = []
- for key, value in kwargs.items():
- if isinstance(value, list):
- items.extend([(key, item) for item in value])
- else:
- items.append((key, value))
- return parse.urlencode(items)
-
-
-# Crack the given url into (scheme, host, port, path)
-def _spliturl(url):
- parsed_url = parse.urlparse(url)
- host = parsed_url.hostname
- port = parsed_url.port
- path = '?'.join((parsed_url.path, parsed_url.query)) if parsed_url.query else parsed_url.path
- # Strip brackets if its an IPv6 address
- if host.startswith('[') and host.endswith(']'): host = host[1:-1]
- if port is None: port = DEFAULT_PORT
- return parsed_url.scheme, host, port, path
-
-
-# Given an HTTP request handler, this wrapper objects provides a related
-# family of convenience methods built using that handler.
-class HttpLib:
- """A set of convenient methods for making HTTP calls.
-
- ``HttpLib`` provides a general :meth:`request` method, and :meth:`delete`,
- :meth:`post`, and :meth:`get` methods for the three HTTP methods that Splunk
- uses.
-
- By default, ``HttpLib`` uses Python's built-in ``httplib`` library,
- but you can replace it by passing your own handling function to the
- constructor for ``HttpLib``.
-
- The handling function should have the type:
-
- ``handler(`url`, `request_dict`) -> response_dict``
-
- where `url` is the URL to make the request to (including any query and
- fragment sections) as a dictionary with the following keys:
-
- - method: The method for the request, typically ``GET``, ``POST``, or ``DELETE``.
-
- - headers: A list of pairs specifying the HTTP headers (for example: ``[('key': value), ...]``).
-
- - body: A string containing the body to send with the request (this string
- should default to '').
-
- and ``response_dict`` is a dictionary with the following keys:
-
- - status: An integer containing the HTTP status code (such as 200 or 404).
-
- - reason: The reason phrase, if any, returned by the server.
-
- - headers: A list of pairs containing the response headers (for example, ``[('key': value), ...]``).
-
- - body: A stream-like object supporting ``read(size=None)`` and ``close()``
- methods to get the body of the response.
-
- The response dictionary is returned directly by ``HttpLib``'s methods with
- no further processing. By default, ``HttpLib`` calls the :func:`handler` function
- to get a handler function.
-
- If using the default handler, SSL verification can be disabled by passing verify=False.
- """
-
- def __init__(self, custom_handler=None, verify=False, key_file=None, cert_file=None, context=None, retries=0,
- retryDelay=10):
- if custom_handler is None:
- self.handler = handler(verify=verify, key_file=key_file, cert_file=cert_file, context=context)
- else:
- self.handler = custom_handler
- self._cookies = {}
- self.retries = retries
- self.retryDelay = retryDelay
-
- def delete(self, url, headers=None, **kwargs):
- """Sends a DELETE request to a URL.
-
- :param url: The URL.
- :type url: ``string``
- :param headers: A list of pairs specifying the headers for the HTTP
- response (for example, ``[('Content-Type': 'text/cthulhu'), ('Token': 'boris')]``).
- :type headers: ``list``
- :param kwargs: Additional keyword arguments (optional). These arguments
- are interpreted as the query part of the URL. The order of keyword
- arguments is not preserved in the request, but the keywords and
- their arguments will be URL encoded.
- :type kwargs: ``dict``
- :returns: A dictionary describing the response (see :class:`HttpLib` for
- its structure).
- :rtype: ``dict``
- """
- if headers is None: headers = []
- if kwargs:
- # url is already a UrlEncoded. We have to manually declare
- # the query to be encoded or it will get automatically URL
- # encoded by being appended to url.
- url = url + UrlEncoded('?' + _encode(**kwargs), skip_encode=True)
- message = {
- 'method': "DELETE",
- 'headers': headers,
- }
- return self.request(url, message)
-
- def get(self, url, headers=None, **kwargs):
- """Sends a GET request to a URL.
-
- :param url: The URL.
- :type url: ``string``
- :param headers: A list of pairs specifying the headers for the HTTP
- response (for example, ``[('Content-Type': 'text/cthulhu'), ('Token': 'boris')]``).
- :type headers: ``list``
- :param kwargs: Additional keyword arguments (optional). These arguments
- are interpreted as the query part of the URL. The order of keyword
- arguments is not preserved in the request, but the keywords and
- their arguments will be URL encoded.
- :type kwargs: ``dict``
- :returns: A dictionary describing the response (see :class:`HttpLib` for
- its structure).
- :rtype: ``dict``
- """
- if headers is None: headers = []
- if kwargs:
- # url is already a UrlEncoded. We have to manually declare
- # the query to be encoded or it will get automatically URL
- # encoded by being appended to url.
- url = url + UrlEncoded('?' + _encode(**kwargs), skip_encode=True)
- return self.request(url, {'method': "GET", 'headers': headers})
-
- def post(self, url, headers=None, **kwargs):
- """Sends a POST request to a URL.
-
- :param url: The URL.
- :type url: ``string``
- :param headers: A list of pairs specifying the headers for the HTTP
- response (for example, ``[('Content-Type': 'text/cthulhu'), ('Token': 'boris')]``).
- :type headers: ``list``
- :param kwargs: Additional keyword arguments (optional). If the argument
- is ``body``, the value is used as the body for the request, and the
- keywords and their arguments will be URL encoded. If there is no
- ``body`` keyword argument, all the keyword arguments are encoded
- into the body of the request in the format ``x-www-form-urlencoded``.
- :type kwargs: ``dict``
- :returns: A dictionary describing the response (see :class:`HttpLib` for
- its structure).
- :rtype: ``dict``
- """
- if headers is None: headers = []
-
- # We handle GET-style arguments and an unstructured body. This is here
- # to support the receivers/stream endpoint.
- if 'body' in kwargs:
- # We only use application/x-www-form-urlencoded if there is no other
- # Content-Type header present. This can happen in cases where we
- # send requests as application/json, e.g. for KV Store.
- if len([x for x in headers if x[0].lower() == "content-type"]) == 0:
- headers.append(("Content-Type", "application/x-www-form-urlencoded"))
-
- body = kwargs.pop('body')
- if isinstance(body, dict):
- body = _encode(**body).encode('utf-8')
- if len(kwargs) > 0:
- url = url + UrlEncoded('?' + _encode(**kwargs), skip_encode=True)
- else:
- body = _encode(**kwargs).encode('utf-8')
- message = {
- 'method': "POST",
- 'headers': headers,
- 'body': body
- }
- return self.request(url, message)
-
- def request(self, url, message, **kwargs):
- """Issues an HTTP request to a URL.
-
- :param url: The URL.
- :type url: ``string``
- :param message: A dictionary with the format as described in
- :class:`HttpLib`.
- :type message: ``dict``
- :param kwargs: Additional keyword arguments (optional). These arguments
- are passed unchanged to the handler.
- :type kwargs: ``dict``
- :returns: A dictionary describing the response (see :class:`HttpLib` for
- its structure).
- :rtype: ``dict``
- """
- while True:
- try:
- response = self.handler(url, message, **kwargs)
- break
- except Exception:
- if self.retries <= 0:
- raise
- else:
- time.sleep(self.retryDelay)
- self.retries -= 1
- response = record(response)
- if 400 <= response.status:
- raise HTTPError(response)
-
- # Update the cookie with any HTTP request
- # Initially, assume list of 2-tuples
- key_value_tuples = response.headers
- # If response.headers is a dict, get the key-value pairs as 2-tuples
- # this is the case when using urllib2
- if isinstance(response.headers, dict):
- key_value_tuples = list(response.headers.items())
- for key, value in key_value_tuples:
- if key.lower() == "set-cookie":
- _parse_cookies(value, self._cookies)
-
- return response
-
-
-# Converts an httplib response into a file-like object.
-class ResponseReader(io.RawIOBase):
- """This class provides a file-like interface for :class:`httplib` responses.
-
- The ``ResponseReader`` class is intended to be a layer to unify the different
- types of HTTP libraries used with this SDK. This class also provides a
- preview of the stream and a few useful predicates.
- """
-
- # For testing, you can use a StringIO as the argument to
- # ``ResponseReader`` instead of an ``httplib.HTTPResponse``. It
- # will work equally well.
- def __init__(self, response, connection=None):
- self._response = response
- self._connection = connection
- self._buffer = b''
-
- def __str__(self):
- return str(self.read(), 'UTF-8')
-
- @property
- def empty(self):
- """Indicates whether there is any more data in the response."""
- return self.peek(1) == b""
-
- def peek(self, size):
- """Nondestructively retrieves a given number of characters.
-
- The next :meth:`read` operation behaves as though this method was never
- called.
-
- :param size: The number of characters to retrieve.
- :type size: ``integer``
- """
- c = self.read(size)
- self._buffer = self._buffer + c
- return c
-
- def close(self):
- """Closes this response."""
- if self._connection:
- self._connection.close()
- self._response.close()
-
- def read(self, size=None):
- """Reads a given number of characters from the response.
-
- :param size: The number of characters to read, or "None" to read the
- entire response.
- :type size: ``integer`` or "None"
-
- """
- r = self._buffer
- self._buffer = b''
- if size is not None:
- size -= len(r)
- r = r + self._response.read(size)
- return r
-
- def readable(self):
- """ Indicates that the response reader is readable."""
- return True
-
- def readinto(self, byte_array):
- """ Read data into a byte array, upto the size of the byte array.
-
- :param byte_array: A byte array/memory view to pour bytes into.
- :type byte_array: ``bytearray`` or ``memoryview``
-
- """
- max_size = len(byte_array)
- data = self.read(max_size)
- bytes_read = len(data)
- byte_array[:bytes_read] = data
- return bytes_read
-
-
-def handler(key_file=None, cert_file=None, timeout=None, verify=False, context=None):
- """This class returns an instance of the default HTTP request handler using
- the values you provide.
-
- :param `key_file`: A path to a PEM (Privacy Enhanced Mail) formatted file containing your private key (optional).
- :type key_file: ``string``
- :param `cert_file`: A path to a PEM (Privacy Enhanced Mail) formatted file containing a certificate chain file (optional).
- :type cert_file: ``string``
- :param `timeout`: The request time-out period, in seconds (optional).
- :type timeout: ``integer`` or "None"
- :param `verify`: Set to False to disable SSL verification on https connections.
- :type verify: ``Boolean``
- :param `context`: The SSLContext that can is used with the HTTPSConnection when verify=True is enabled and context is specified
- :type context: ``SSLContext`
- """
-
- def connect(scheme, host, port):
- kwargs = {}
- if timeout is not None: kwargs['timeout'] = timeout
- if scheme == "http":
- return client.HTTPConnection(host, port, **kwargs)
- if scheme == "https":
- if key_file is not None: kwargs['key_file'] = key_file
- if cert_file is not None: kwargs['cert_file'] = cert_file
-
- if not verify:
- kwargs['context'] = ssl._create_unverified_context()
- elif context:
- # verify is True in elif branch and context is not None
- kwargs['context'] = context
-
- return client.HTTPSConnection(host, port, **kwargs)
- raise ValueError(f"unsupported scheme: {scheme}")
-
- def request(url, message, **kwargs):
- scheme, host, port, path = _spliturl(url)
- body = message.get("body", "")
- head = {
- "Content-Length": str(len(body)),
- "Host": host,
- "User-Agent": "splunk-sdk-python/%s" % __version__,
- "Accept": "*/*",
- "Connection": "Close",
- } # defaults
- for key, value in message["headers"]:
- head[key] = value
- method = message.get("method", "GET")
-
- connection = connect(scheme, host, port)
- is_keepalive = False
- try:
- connection.request(method, path, body, head)
- if timeout is not None:
- connection.sock.settimeout(timeout)
- response = connection.getresponse()
- is_keepalive = "keep-alive" in response.getheader("connection", default="close").lower()
- finally:
- if not is_keepalive:
- connection.close()
-
- return {
- "status": response.status,
- "reason": response.reason,
- "headers": response.getheaders(),
- "body": ResponseReader(response, connection if is_keepalive else None),
- }
-
- return request
diff --git a/lib/splunklib/client.py b/lib/splunklib/client.py
deleted file mode 100644
index ee390c9..0000000
--- a/lib/splunklib/client.py
+++ /dev/null
@@ -1,4002 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-#
-# The purpose of this module is to provide a friendlier domain interface to
-# various Splunk endpoints. The approach here is to leverage the binding
-# layer to capture endpoint context and provide objects and methods that
-# offer simplified access their corresponding endpoints. The design avoids
-# caching resource state. From the perspective of this module, the 'policy'
-# for caching resource state belongs in the application or a higher level
-# framework, and its the purpose of this module to provide simplified
-# access to that resource state.
-#
-# A side note, the objects below that provide helper methods for updating eg:
-# Entity state, are written so that they may be used in a fluent style.
-#
-
-"""The **splunklib.client** module provides a Pythonic interface to the
-`Splunk REST API `_,
-allowing you programmatically access Splunk's resources.
-
-**splunklib.client** wraps a Pythonic layer around the wire-level
-binding of the **splunklib.binding** module. The core of the library is the
-:class:`Service` class, which encapsulates a connection to the server, and
-provides access to the various aspects of Splunk's functionality, which are
-exposed via the REST API. Typically you connect to a running Splunk instance
-with the :func:`connect` function::
-
- import splunklib.client as client
- service = client.connect(host='localhost', port=8089,
- username='admin', password='...')
- assert isinstance(service, client.Service)
-
-:class:`Service` objects have fields for the various Splunk resources (such as apps,
-jobs, saved searches, inputs, and indexes). All of these fields are
-:class:`Collection` objects::
-
- appcollection = service.apps
- my_app = appcollection.create('my_app')
- my_app = appcollection['my_app']
- appcollection.delete('my_app')
-
-The individual elements of the collection, in this case *applications*,
-are subclasses of :class:`Entity`. An ``Entity`` object has fields for its
-attributes, and methods that are specific to each kind of entity. For example::
-
- print(my_app['author']) # Or: print(my_app.author)
- my_app.package() # Creates a compressed package of this application
-"""
-
-import contextlib
-import datetime
-import json
-import logging
-import re
-import socket
-from datetime import datetime, timedelta
-from time import sleep
-from urllib import parse
-
-from splunklib import data
-from splunklib.data import record
-from splunklib.binding import (AuthenticationError, Context, HTTPError, UrlEncoded,
- _encode, _make_cookie_header, _NoAuthenticationToken,
- namespace)
-
-logger = logging.getLogger(__name__)
-
-__all__ = [
- "connect",
- "NotSupportedError",
- "OperationError",
- "IncomparableException",
- "Service",
- "namespace",
- "AuthenticationError"
-]
-
-PATH_APPS = "apps/local/"
-PATH_CAPABILITIES = "authorization/capabilities/"
-PATH_CONF = "configs/conf-%s/"
-PATH_PROPERTIES = "properties/"
-PATH_DEPLOYMENT_CLIENTS = "deployment/client/"
-PATH_DEPLOYMENT_TENANTS = "deployment/tenants/"
-PATH_DEPLOYMENT_SERVERS = "deployment/server/"
-PATH_DEPLOYMENT_SERVERCLASSES = "deployment/serverclass/"
-PATH_EVENT_TYPES = "saved/eventtypes/"
-PATH_FIRED_ALERTS = "alerts/fired_alerts/"
-PATH_INDEXES = "data/indexes/"
-PATH_INPUTS = "data/inputs/"
-PATH_JOBS = "search/jobs/"
-PATH_JOBS_V2 = "search/v2/jobs/"
-PATH_LOGGER = "/services/server/logger/"
-PATH_MACROS = "configs/conf-macros/"
-PATH_MESSAGES = "messages/"
-PATH_MODULAR_INPUTS = "data/modular-inputs"
-PATH_ROLES = "authorization/roles/"
-PATH_SAVED_SEARCHES = "saved/searches/"
-PATH_STANZA = "configs/conf-%s/%s" # (file, stanza)
-PATH_USERS = "authentication/users/"
-PATH_RECEIVERS_STREAM = "/services/receivers/stream"
-PATH_RECEIVERS_SIMPLE = "/services/receivers/simple"
-PATH_STORAGE_PASSWORDS = "storage/passwords"
-
-XNAMEF_ATOM = "{http://www.w3.org/2005/Atom}%s"
-XNAME_ENTRY = XNAMEF_ATOM % "entry"
-XNAME_CONTENT = XNAMEF_ATOM % "content"
-
-MATCH_ENTRY_CONTENT = f"{XNAME_ENTRY}/{XNAME_CONTENT}/*"
-
-
-class IllegalOperationException(Exception):
- """Thrown when an operation is not possible on the Splunk instance that a
- :class:`Service` object is connected to."""
-
-
-class IncomparableException(Exception):
- """Thrown when trying to compare objects (using ``==``, ``<``, ``>``, and
- so on) of a type that doesn't support it."""
-
-
-class AmbiguousReferenceException(ValueError):
- """Thrown when the name used to fetch an entity matches more than one entity."""
-
-
-class InvalidNameException(Exception):
- """Thrown when the specified name contains characters that are not allowed
- in Splunk entity names."""
-
-
-class NoSuchCapability(Exception):
- """Thrown when the capability that has been referred to doesn't exist."""
-
-
-class OperationError(Exception):
- """Raised for a failed operation, such as a timeout."""
-
-
-class NotSupportedError(Exception):
- """Raised for operations that are not supported on a given object."""
-
-
-def _trailing(template, *targets):
- """Substring of *template* following all *targets*.
-
- **Example**::
-
- template = "this is a test of the bunnies."
- _trailing(template, "is", "est", "the") == " bunnies"
-
- Each target is matched successively in the string, and the string
- remaining after the last target is returned. If one of the targets
- fails to match, a ValueError is raised.
-
- :param template: Template to extract a trailing string from.
- :type template: ``string``
- :param targets: Strings to successively match in *template*.
- :type targets: list of ``string``s
- :return: Trailing string after all targets are matched.
- :rtype: ``string``
- :raises ValueError: Raised when one of the targets does not match.
- """
- s = template
- for t in targets:
- n = s.find(t)
- if n == -1:
- raise ValueError("Target " + t + " not found in template.")
- s = s[n + len(t):]
- return s
-
-
-# Filter the given state content record according to the given arg list.
-def _filter_content(content, *args):
- if len(args) > 0:
- return record((k, content[k]) for k in args)
- return record((k, v) for k, v in content.items()
- if k not in ['eai:acl', 'eai:attributes', 'type'])
-
-
-# Construct a resource path from the given base path + resource name
-def _path(base, name):
- if not base.endswith('/'): base = base + '/'
- return base + name
-
-
-# Load an atom record from the body of the given response
-# this will ultimately be sent to an xml ElementTree so we
-# should use the xmlcharrefreplace option
-def _load_atom(response, match=None):
- return data.load(response.body.read()
- .decode('utf-8', 'xmlcharrefreplace'), match)
-
-
-# Load an array of atom entries from the body of the given response
-def _load_atom_entries(response):
- r = _load_atom(response)
- if 'feed' in r:
- # Need this to handle a random case in the REST API
- if r.feed.get('totalResults') in [0, '0']:
- return []
- entries = r.feed.get('entry', None)
- if entries is None: return None
- return entries if isinstance(entries, list) else [entries]
- # Unlike most other endpoints, the jobs endpoint does not return
- # its state wrapped in another element, but at the top level.
- # For example, in XML, it returns ... instead of
- # ... ``,
- and within that element one or more ```` elements.
- """
- # Some subclasses of Collection have to override this because
- # splunkd returns something that doesn't match
- # .
- entries = _load_atom_entries(response)
- if entries is None: return []
- entities = []
- for entry in entries:
- state = _parse_atom_entry(entry)
- entity = self.item(
- self.service,
- self._entity_path(state),
- state=state)
- entities.append(entity)
-
- return entities
-
- def itemmeta(self):
- """Returns metadata for members of the collection.
-
- Makes a single roundtrip to the server, plus two more at most if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :return: A :class:`splunklib.data.Record` object containing the metadata.
-
- **Example**::
-
- import splunklib.client as client
- import pprint
- s = client.connect(...)
- pprint.pprint(s.apps.itemmeta())
- {'access': {'app': 'search',
- 'can_change_perms': '1',
- 'can_list': '1',
- 'can_share_app': '1',
- 'can_share_global': '1',
- 'can_share_user': '1',
- 'can_write': '1',
- 'modifiable': '1',
- 'owner': 'admin',
- 'perms': {'read': ['*'], 'write': ['admin']},
- 'removable': '0',
- 'sharing': 'user'},
- 'fields': {'optional': ['author',
- 'configured',
- 'description',
- 'label',
- 'manageable',
- 'template',
- 'visible'],
- 'required': ['name'], 'wildcard': []}}
- """
- response = self.get("_new")
- content = _load_atom(response, MATCH_ENTRY_CONTENT)
- return _parse_atom_metadata(content)
-
- def iter(self, offset=0, count=None, pagesize=None, **kwargs):
- """Iterates over the collection.
-
- This method is equivalent to the :meth:`list` method, but
- it returns an iterator and can load a certain number of entities at a
- time from the server.
-
- :param offset: The index of the first entity to return (optional).
- :type offset: ``integer``
- :param count: The maximum number of entities to return (optional).
- :type count: ``integer``
- :param pagesize: The number of entities to load (optional).
- :type pagesize: ``integer``
- :param kwargs: Additional arguments (optional):
-
- - "search" (``string``): The search query to filter responses.
-
- - "sort_dir" (``string``): The direction to sort returned items:
- "asc" or "desc".
-
- - "sort_key" (``string``): The field to use for sorting (optional).
-
- - "sort_mode" (``string``): The collating sequence for sorting
- returned items: "auto", "alpha", "alpha_case", or "num".
-
- :type kwargs: ``dict``
-
- **Example**::
-
- import splunklib.client as client
- s = client.connect(...)
- for saved_search in s.saved_searches.iter(pagesize=10):
- # Loads 10 saved searches at a time from the
- # server.
- ...
- """
- assert pagesize is None or pagesize > 0
- if count is None:
- count = self.null_count
- fetched = 0
- while count == self.null_count or fetched < count:
- response = self.get(count=pagesize or count, offset=offset, **kwargs)
- items = self._load_list(response)
- N = len(items)
- fetched += N
- for item in items:
- yield item
- if pagesize is None or N < pagesize:
- break
- offset += N
- logger.debug("pagesize=%d, fetched=%d, offset=%d, N=%d, kwargs=%s", pagesize, fetched, offset, N, kwargs)
-
- # kwargs: count, offset, search, sort_dir, sort_key, sort_mode
- def list(self, count=None, **kwargs):
- """Retrieves a list of entities in this collection.
-
- The entire collection is loaded at once and is returned as a list. This
- function makes a single roundtrip to the server, plus at most two more if
- the ``autologin`` field of :func:`connect` is set to ``True``.
- There is no caching--every call makes at least one round trip.
-
- :param count: The maximum number of entities to return (optional).
- :type count: ``integer``
- :param kwargs: Additional arguments (optional):
-
- - "offset" (``integer``): The offset of the first item to return.
-
- - "search" (``string``): The search query to filter responses.
-
- - "sort_dir" (``string``): The direction to sort returned items:
- "asc" or "desc".
-
- - "sort_key" (``string``): The field to use for sorting (optional).
-
- - "sort_mode" (``string``): The collating sequence for sorting
- returned items: "auto", "alpha", "alpha_case", or "num".
-
- :type kwargs: ``dict``
- :return: A ``list`` of entities.
- """
- # response = self.get(count=count, **kwargs)
- # return self._load_list(response)
- return list(self.iter(count=count, **kwargs))
-
-
-class Collection(ReadOnlyCollection):
- """A collection of entities.
-
- Splunk provides a number of different collections of distinct
- entity types: applications, saved searches, fired alerts, and a
- number of others. Each particular type is available separately
- from the Splunk instance, and the entities of that type are
- returned in a :class:`Collection`.
-
- The interface for :class:`Collection` does not quite match either
- ``list`` or ``dict`` in Python, because there are enough semantic
- mismatches with either to make its behavior surprising. A unique
- element in a :class:`Collection` is defined by a string giving its
- name plus namespace (although the namespace is optional if the name is
- unique).
-
- **Example**::
-
- import splunklib.client as client
- service = client.connect(...)
- mycollection = service.saved_searches
- mysearch = mycollection['my_search', client.namespace(owner='boris', app='natasha', sharing='user')]
- # Or if there is only one search visible named 'my_search'
- mysearch = mycollection['my_search']
-
- Similarly, ``name`` in ``mycollection`` works as you might expect (though
- you cannot currently pass a namespace to the ``in`` operator), as does
- ``len(mycollection)``.
-
- However, as an aggregate, :class:`Collection` behaves more like a
- list. If you iterate over a :class:`Collection`, you get an
- iterator over the entities, not the names and namespaces.
-
- **Example**::
-
- for entity in mycollection:
- assert isinstance(entity, client.Entity)
-
- Use the :meth:`create` and :meth:`delete` methods to create and delete
- entities in this collection. To view the access control list and other
- metadata of the collection, use the :meth:`ReadOnlyCollection.itemmeta` method.
-
- :class:`Collection` does no caching. Each call makes at least one
- round trip to the server to fetch data.
- """
-
- def create(self, name, **params):
- """Creates a new entity in this collection.
-
- This function makes either one or two roundtrips to the
- server, depending on the type of entities in this
- collection, plus at most two more if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :param name: The name of the entity to create.
- :type name: ``string``
- :param namespace: A namespace, as created by the :func:`splunklib.binding.namespace`
- function (optional). You can also set ``owner``, ``app``, and
- ``sharing`` in ``params``.
- :type namespace: A :class:`splunklib.data.Record` object with keys ``owner``, ``app``,
- and ``sharing``.
- :param params: Additional entity-specific arguments (optional).
- :type params: ``dict``
- :return: The new entity.
- :rtype: A subclass of :class:`Entity`, chosen by :meth:`Collection.self.item`.
-
- **Example**::
-
- import splunklib.client as client
- s = client.connect(...)
- applications = s.apps
- new_app = applications.create("my_fake_app")
- """
- if not isinstance(name, str):
- raise InvalidNameException(f"{name} is not a valid name for an entity.")
- if 'namespace' in params:
- namespace = params.pop('namespace')
- params['owner'] = namespace.owner
- params['app'] = namespace.app
- params['sharing'] = namespace.sharing
- response = self.post(name=name, **params)
- atom = _load_atom(response, XNAME_ENTRY)
- if atom is None:
- # This endpoint doesn't return the content of the new
- # item. We have to go fetch it ourselves.
- return self[name]
- entry = atom.entry
- state = _parse_atom_entry(entry)
- entity = self.item(
- self.service,
- self._entity_path(state),
- state=state)
- return entity
-
- def delete(self, name, **params):
- """Deletes a specified entity from the collection.
-
- :param name: The name of the entity to delete.
- :type name: ``string``
- :return: The collection.
- :rtype: ``self``
-
- This method is implemented for consistency with the REST API's DELETE
- method.
-
- If there is no *name* entity on the server, a ``KeyError`` is
- thrown. This function always makes a roundtrip to the server.
-
- **Example**::
-
- import splunklib.client as client
- c = client.connect(...)
- saved_searches = c.saved_searches
- saved_searches.create('my_saved_search',
- 'search * | head 1')
- assert 'my_saved_search' in saved_searches
- saved_searches.delete('my_saved_search')
- assert 'my_saved_search' not in saved_searches
- """
- name = UrlEncoded(name, encode_slash=True)
- if 'namespace' in params:
- namespace = params.pop('namespace')
- params['owner'] = namespace.owner
- params['app'] = namespace.app
- params['sharing'] = namespace.sharing
- try:
- self.service.delete(_path(self.path, name), **params)
- except HTTPError as he:
- # An HTTPError with status code 404 means that the entity
- # has already been deleted, and we reraise it as a
- # KeyError.
- if he.status == 404:
- raise KeyError(f"No such entity {name}")
- else:
- raise
- return self
-
- def get(self, name="", owner=None, app=None, sharing=None, **query):
- """Performs a GET request to the server on the collection.
-
- If *owner*, *app*, and *sharing* are omitted, this method takes a
- default namespace from the :class:`Service` object for this :class:`Endpoint`.
- All other keyword arguments are included in the URL as query parameters.
-
- :raises AuthenticationError: Raised when the ``Service`` is not logged in.
- :raises HTTPError: Raised when an error in the request occurs.
- :param path_segment: A path segment relative to this endpoint.
- :type path_segment: ``string``
- :param owner: The owner context of the namespace (optional).
- :type owner: ``string``
- :param app: The app context of the namespace (optional).
- :type app: ``string``
- :param sharing: The sharing mode for the namespace (optional).
- :type sharing: "global", "system", "app", or "user"
- :param query: All other keyword arguments, which are used as query
- parameters.
- :type query: ``string``
- :return: The response from the server.
- :rtype: ``dict`` with keys ``body``, ``headers``, ``reason``,
- and ``status``
-
- **Example**::
-
- import splunklib.client
- s = client.service(...)
- saved_searches = s.saved_searches
- saved_searches.get("my/saved/search") == \\
- {'body': ...a response reader object...,
- 'headers': [('content-length', '26208'),
- ('expires', 'Fri, 30 Oct 1998 00:00:00 GMT'),
- ('server', 'Splunkd'),
- ('connection', 'close'),
- ('cache-control', 'no-store, max-age=0, must-revalidate, no-cache'),
- ('date', 'Fri, 11 May 2012 16:30:35 GMT'),
- ('content-type', 'text/xml; charset=utf-8')],
- 'reason': 'OK',
- 'status': 200}
- saved_searches.get('nonexistant/search') # raises HTTPError
- s.logout()
- saved_searches.get() # raises AuthenticationError
-
- """
- name = UrlEncoded(name, encode_slash=True)
- return super().get(name, owner, app, sharing, **query)
-
-
-class ConfigurationFile(Collection):
- """This class contains all of the stanzas from one configuration file.
- """
-
- # __init__'s arguments must match those of an Entity, not a
- # Collection, since it is being created as the elements of a
- # Configurations, which is a Collection subclass.
- def __init__(self, service, path, **kwargs):
- Collection.__init__(self, service, path, item=Stanza)
- self.name = kwargs['state']['title']
-
-
-class Configurations(Collection):
- """This class provides access to the configuration files from this Splunk
- instance. Retrieve this collection using :meth:`Service.confs`.
-
- Splunk's configuration is divided into files, and each file into
- stanzas. This collection is unusual in that the values in it are
- themselves collections of :class:`ConfigurationFile` objects.
- """
-
- def __init__(self, service):
- Collection.__init__(self, service, PATH_PROPERTIES, item=ConfigurationFile)
- if self.service.namespace.owner == '-' or self.service.namespace.app == '-':
- raise ValueError("Configurations cannot have wildcards in namespace.")
-
- def __getitem__(self, key):
- # The superclass implementation is designed for collections that contain
- # entities. This collection (Configurations) contains collections
- # (ConfigurationFile).
- #
- # The configurations endpoint returns multiple entities when we ask for a single file.
- # This screws up the default implementation of __getitem__ from Collection, which thinks
- # that multiple entities means a name collision, so we have to override it here.
- try:
- self.get(key)
- return ConfigurationFile(self.service, PATH_CONF % key, state={'title': key})
- except HTTPError as he:
- if he.status == 404: # No entity matching key
- raise KeyError(key)
- else:
- raise
-
- def __contains__(self, key):
- # configs/conf-{name} never returns a 404. We have to post to properties/{name}
- # in order to find out if a configuration exists.
- try:
- self.get(key)
- return True
- except HTTPError as he:
- if he.status == 404: # No entity matching key
- return False
- raise
-
- def create(self, name):
- """ Creates a configuration file named *name*.
-
- If there is already a configuration file with that name,
- the existing file is returned.
-
- :param name: The name of the configuration file.
- :type name: ``string``
-
- :return: The :class:`ConfigurationFile` object.
- """
- # This has to be overridden to handle the plumbing of creating
- # a ConfigurationFile (which is a Collection) instead of some
- # Entity.
- if not isinstance(name, str):
- raise ValueError(f"Invalid name: {repr(name)}")
- response = self.post(__conf=name)
- if response.status == 303:
- return self[name]
- if response.status == 201:
- return ConfigurationFile(self.service, PATH_CONF % name, item=Stanza, state={'title': name})
- raise ValueError(f"Unexpected status code {response.status} returned from creating a stanza")
-
- def delete(self, key):
- """Raises `IllegalOperationException`."""
- raise IllegalOperationException("Cannot delete configuration files from the REST API.")
-
- def _entity_path(self, state):
- # Overridden to make all the ConfigurationFile objects
- # returned refer to the configs/ path instead of the
- # properties/ path used by Configrations.
- return PATH_CONF % state['title']
-
-
-class Stanza(Entity):
- """This class contains a single configuration stanza."""
-
- def submit(self, stanza):
- """Adds keys to the current configuration stanza as a
- dictionary of key-value pairs.
-
- :param stanza: A dictionary of key-value pairs for the stanza.
- :type stanza: ``dict``
- :return: The :class:`Stanza` object.
- """
- body = _encode(**stanza)
- self.service.post(self.path, body=body)
- return self
-
- def __len__(self):
- # The stanza endpoint returns all the keys at the same level in the XML as the eai information
- # and 'disabled', so to get an accurate length, we have to filter those out and have just
- # the stanza keys.
- return len([x for x in self._state.content.keys()
- if not x.startswith('eai') and x != 'disabled'])
-
-
-class StoragePassword(Entity):
- """This class contains a storage password.
- """
-
- def __init__(self, service, path, **kwargs):
- state = kwargs.get('state', None)
- kwargs['skip_refresh'] = kwargs.get('skip_refresh', state is not None)
- super().__init__(service, path, **kwargs)
- self._state = state
-
- @property
- def clear_password(self):
- return self.content.get('clear_password')
-
- @property
- def encrypted_password(self):
- return self.content.get('encr_password')
-
- @property
- def realm(self):
- return self.content.get('realm')
-
- @property
- def username(self):
- return self.content.get('username')
-
-
-class StoragePasswords(Collection):
- """This class provides access to the storage passwords from this Splunk
- instance. Retrieve this collection using :meth:`Service.storage_passwords`.
- """
-
- def __init__(self, service):
- if service.namespace.owner == '-' or service.namespace.app == '-':
- raise ValueError("StoragePasswords cannot have wildcards in namespace.")
- super().__init__(service, PATH_STORAGE_PASSWORDS, item=StoragePassword)
-
- def create(self, password, username, realm=None):
- """ Creates a storage password.
-
- A `StoragePassword` can be identified by , or by : if the
- optional realm parameter is also provided.
-
- :param password: The password for the credentials - this is the only part of the credentials that will be stored securely.
- :type name: ``string``
- :param username: The username for the credentials.
- :type name: ``string``
- :param realm: The credential realm. (optional)
- :type name: ``string``
-
- :return: The :class:`StoragePassword` object created.
- """
- if not isinstance(username, str):
- raise ValueError(f"Invalid name: {repr(username)}")
-
- if realm is None:
- response = self.post(password=password, name=username)
- else:
- response = self.post(password=password, realm=realm, name=username)
-
- if response.status != 201:
- raise ValueError(f"Unexpected status code {response.status} returned from creating a stanza")
-
- entries = _load_atom_entries(response)
- state = _parse_atom_entry(entries[0])
- storage_password = StoragePassword(self.service, self._entity_path(state), state=state, skip_refresh=True)
-
- return storage_password
-
- def delete(self, username, realm=None):
- """Delete a storage password by username and/or realm.
-
- The identifier can be passed in through the username parameter as
- or :, but the preferred way is by
- passing in the username and realm parameters.
-
- :param username: The username for the credentials, or : if the realm parameter is omitted.
- :type name: ``string``
- :param realm: The credential realm. (optional)
- :type name: ``string``
- :return: The `StoragePassword` collection.
- :rtype: ``self``
- """
- if realm is None:
- # This case makes the username optional, so
- # the full name can be passed in as realm.
- # Assume it's already encoded.
- name = username
- else:
- # Encode each component separately
- name = UrlEncoded(realm, encode_slash=True) + ":" + UrlEncoded(username, encode_slash=True)
-
- # Append the : expected at the end of the name
- if name[-1] != ":":
- name = name + ":"
- return Collection.delete(self, name)
-
-
-class AlertGroup(Entity):
- """This class represents a group of fired alerts for a saved search. Access
- it using the :meth:`alerts` property."""
-
- def __init__(self, service, path, **kwargs):
- Entity.__init__(self, service, path, **kwargs)
-
- def __len__(self):
- return self.count
-
- @property
- def alerts(self):
- """Returns a collection of triggered alerts.
-
- :return: A :class:`Collection` of triggered alerts.
- """
- return Collection(self.service, self.path)
-
- @property
- def count(self):
- """Returns the count of triggered alerts.
-
- :return: The triggered alert count.
- :rtype: ``integer``
- """
- return int(self.content.get('triggered_alert_count', 0))
-
-
-class Indexes(Collection):
- """This class contains the collection of indexes in this Splunk instance.
- Retrieve this collection using :meth:`Service.indexes`.
- """
-
- def get_default(self):
- """ Returns the name of the default index.
-
- :return: The name of the default index.
-
- """
- index = self['_audit']
- return index['defaultDatabase']
-
- def delete(self, name):
- """ Deletes a given index.
-
- **Note**: This method is only supported in Splunk 5.0 and later.
-
- :param name: The name of the index to delete.
- :type name: ``string``
- """
- if self.service.splunk_version >= (5,):
- Collection.delete(self, name)
- else:
- raise IllegalOperationException("Deleting indexes via the REST API is "
- "not supported before Splunk version 5.")
-
-
-class Index(Entity):
- """This class represents an index and provides different operations, such as
- cleaning the index, writing to the index, and so forth."""
-
- def __init__(self, service, path, **kwargs):
- Entity.__init__(self, service, path, **kwargs)
-
- def attach(self, host=None, source=None, sourcetype=None):
- """Opens a stream (a writable socket) for writing events to the index.
-
- :param host: The host value for events written to the stream.
- :type host: ``string``
- :param source: The source value for events written to the stream.
- :type source: ``string``
- :param sourcetype: The sourcetype value for events written to the
- stream.
- :type sourcetype: ``string``
-
- :return: A writable socket.
- """
- args = {'index': self.name}
- if host is not None: args['host'] = host
- if source is not None: args['source'] = source
- if sourcetype is not None: args['sourcetype'] = sourcetype
- path = UrlEncoded(PATH_RECEIVERS_STREAM + "?" + parse.urlencode(args), skip_encode=True)
-
- cookie_header = self.service.token if self.service.token is _NoAuthenticationToken else self.service.token.replace("Splunk ", "")
- cookie_or_auth_header = f"Authorization: Splunk {cookie_header}\r\n"
-
- # If we have cookie(s), use them instead of "Authorization: ..."
- if self.service.has_cookies():
- cookie_header = _make_cookie_header(self.service.get_cookies().items())
- cookie_or_auth_header = f"Cookie: {cookie_header}\r\n"
-
- # Since we need to stream to the index connection, we have to keep
- # the connection open and use the Splunk extension headers to note
- # the input mode
- sock = self.service.connect()
- headers = [f"POST {str(self.service._abspath(path))} HTTP/1.1\r\n".encode('utf-8'),
- f"Host: {self.service.host}:{int(self.service.port)}\r\n".encode('utf-8'),
- b"Accept-Encoding: identity\r\n",
- cookie_or_auth_header.encode('utf-8'),
- b"X-Splunk-Input-Mode: Streaming\r\n",
- b"\r\n"]
-
- for h in headers:
- sock.write(h)
- return sock
-
- @contextlib.contextmanager
- def attached_socket(self, *args, **kwargs):
- """Opens a raw socket in a ``with`` block to write data to Splunk.
-
- The arguments are identical to those for :meth:`attach`. The socket is
- automatically closed at the end of the ``with`` block, even if an
- exception is raised in the block.
-
- :param host: The host value for events written to the stream.
- :type host: ``string``
- :param source: The source value for events written to the stream.
- :type source: ``string``
- :param sourcetype: The sourcetype value for events written to the
- stream.
- :type sourcetype: ``string``
-
- :returns: Nothing.
-
- **Example**::
-
- import splunklib.client as client
- s = client.connect(...)
- index = s.indexes['some_index']
- with index.attached_socket(sourcetype='test') as sock:
- sock.send('Test event\\r\\n')
-
- """
- try:
- sock = self.attach(*args, **kwargs)
- yield sock
- finally:
- sock.shutdown(socket.SHUT_RDWR)
- sock.close()
-
- def clean(self, timeout=60):
- """Deletes the contents of the index.
-
- This method blocks until the index is empty, because it needs to restore
- values at the end of the operation.
-
- :param timeout: The time-out period for the operation, in seconds (the
- default is 60).
- :type timeout: ``integer``
-
- :return: The :class:`Index`.
- """
- self.refresh()
-
- tds = self['maxTotalDataSizeMB']
- ftp = self['frozenTimePeriodInSecs']
- was_disabled_initially = self.disabled
- try:
- if not was_disabled_initially and self.service.splunk_version < (5,):
- # Need to disable the index first on Splunk 4.x,
- # but it doesn't work to disable it on 5.0.
- self.disable()
- self.update(maxTotalDataSizeMB=1, frozenTimePeriodInSecs=1)
- self.roll_hot_buckets()
-
- # Wait until event count goes to 0.
- start = datetime.now()
- diff = timedelta(seconds=timeout)
- while self.content.totalEventCount != '0' and datetime.now() < start + diff:
- sleep(1)
- self.refresh()
-
- if self.content.totalEventCount != '0':
- raise OperationError(
- f"Cleaning index {self.name} took longer than {timeout} seconds; timing out.")
- finally:
- # Restore original values
- self.update(maxTotalDataSizeMB=tds, frozenTimePeriodInSecs=ftp)
- if not was_disabled_initially and self.service.splunk_version < (5,):
- # Re-enable the index if it was originally enabled and we messed with it.
- self.enable()
-
- return self
-
- def roll_hot_buckets(self):
- """Performs rolling hot buckets for this index.
-
- :return: The :class:`Index`.
- """
- self.post("roll-hot-buckets")
- return self
-
- def submit(self, event, host=None, source=None, sourcetype=None):
- """Submits a single event to the index using ``HTTP POST``.
-
- :param event: The event to submit.
- :type event: ``string``
- :param `host`: The host value of the event.
- :type host: ``string``
- :param `source`: The source value of the event.
- :type source: ``string``
- :param `sourcetype`: The sourcetype value of the event.
- :type sourcetype: ``string``
-
- :return: The :class:`Index`.
- """
- args = {'index': self.name}
- if host is not None: args['host'] = host
- if source is not None: args['source'] = source
- if sourcetype is not None: args['sourcetype'] = sourcetype
-
- self.service.post(PATH_RECEIVERS_SIMPLE, body=event, **args)
- return self
-
- # kwargs: host, host_regex, host_segment, rename-source, sourcetype
- def upload(self, filename, **kwargs):
- """Uploads a file for immediate indexing.
-
- **Note**: The file must be locally accessible from the server.
-
- :param filename: The name of the file to upload. The file can be a
- plain, compressed, or archived file.
- :type filename: ``string``
- :param kwargs: Additional arguments (optional). For more about the
- available parameters, see `Index parameters `_ on Splunk Developer Portal.
- :type kwargs: ``dict``
-
- :return: The :class:`Index`.
- """
- kwargs['index'] = self.name
- path = 'data/inputs/oneshot'
- self.service.post(path, name=filename, **kwargs)
- return self
-
-
-class Input(Entity):
- """This class represents a Splunk input. This class is the base for all
- typed input classes and is also used when the client does not recognize an
- input kind.
- """
-
- def __init__(self, service, path, kind=None, **kwargs):
- # kind can be omitted (in which case it is inferred from the path)
- # Otherwise, valid values are the paths from data/inputs ("udp",
- # "monitor", "tcp/raw"), or two special cases: "tcp" (which is "tcp/raw")
- # and "splunktcp" (which is "tcp/cooked").
- Entity.__init__(self, service, path, **kwargs)
- if kind is None:
- path_segments = path.split('/')
- i = path_segments.index('inputs') + 1
- if path_segments[i] == 'tcp':
- self.kind = path_segments[i] + '/' + path_segments[i + 1]
- else:
- self.kind = path_segments[i]
- else:
- self.kind = kind
-
- # Handle old input kind names.
- if self.kind == 'tcp':
- self.kind = 'tcp/raw'
- if self.kind == 'splunktcp':
- self.kind = 'tcp/cooked'
-
- def update(self, **kwargs):
- """Updates the server with any changes you've made to the current input
- along with any additional arguments you specify.
-
- :param kwargs: Additional arguments (optional). For more about the
- available parameters, see `Input parameters `_ on Splunk Developer Portal.
- :type kwargs: ``dict``
-
- :return: The input this method was called on.
- :rtype: class:`Input`
- """
- # UDP and TCP inputs require special handling due to their restrictToHost
- # field. For all other inputs kinds, we can dispatch to the superclass method.
- if self.kind not in ['tcp', 'splunktcp', 'tcp/raw', 'tcp/cooked', 'udp']:
- return super().update(**kwargs)
- else:
- # The behavior of restrictToHost is inconsistent across input kinds and versions of Splunk.
- # In Splunk 4.x, the name of the entity is only the port, independent of the value of
- # restrictToHost. In Splunk 5.0 this changed so the name will be of the form :.
- # In 5.0 and 5.0.1, if you don't supply the restrictToHost value on every update, it will
- # remove the host restriction from the input. As of 5.0.2 you simply can't change restrictToHost
- # on an existing input.
-
- # The logic to handle all these cases:
- # - Throw an exception if the user tries to set restrictToHost on an existing input
- # for *any* version of Splunk.
- # - Set the existing restrictToHost value on the update args internally so we don't
- # cause it to change in Splunk 5.0 and 5.0.1.
- to_update = kwargs.copy()
-
- if 'restrictToHost' in kwargs:
- raise IllegalOperationException("Cannot set restrictToHost on an existing input with the SDK.")
- if 'restrictToHost' in self._state.content and self.kind != 'udp':
- to_update['restrictToHost'] = self._state.content['restrictToHost']
-
- # Do the actual update operation.
- return super().update(**to_update)
-
-
-# Inputs is a "kinded" collection, which is a heterogenous collection where
-# each item is tagged with a kind, that provides a single merged view of all
-# input kinds.
-class Inputs(Collection):
- """This class represents a collection of inputs. The collection is
- heterogeneous and each member of the collection contains a *kind* property
- that indicates the specific type of input.
- Retrieve this collection using :meth:`Service.inputs`."""
-
- def __init__(self, service, kindmap=None):
- Collection.__init__(self, service, PATH_INPUTS, item=Input)
-
- def __getitem__(self, key):
- # The key needed to retrieve the input needs it's parenthesis to be URL encoded
- # based on the REST API for input
- #
- if isinstance(key, tuple) and len(key) == 2:
- # Fetch a single kind
- key, kind = key
- key = UrlEncoded(key, encode_slash=True)
- try:
- response = self.get(self.kindpath(kind) + "/" + key)
- entries = self._load_list(response)
- if len(entries) > 1:
- raise AmbiguousReferenceException(f"Found multiple inputs of kind {kind} named {key}.")
- if len(entries) == 0:
- raise KeyError((key, kind))
- return entries[0]
- except HTTPError as he:
- if he.status == 404: # No entity matching kind and key
- raise KeyError((key, kind))
- else:
- raise
- else:
- # Iterate over all the kinds looking for matches.
- kind = None
- candidate = None
- key = UrlEncoded(key, encode_slash=True)
- for kind in self.kinds:
- try:
- response = self.get(kind + "/" + key)
- entries = self._load_list(response)
- if len(entries) > 1:
- raise AmbiguousReferenceException(f"Found multiple inputs of kind {kind} named {key}.")
- if len(entries) == 0:
- pass
- else:
- if candidate is not None: # Already found at least one candidate
- raise AmbiguousReferenceException(
- f"Found multiple inputs named {key}, please specify a kind")
- candidate = entries[0]
- except HTTPError as he:
- if he.status == 404:
- pass # Just carry on to the next kind.
- else:
- raise
- if candidate is None:
- raise KeyError(key) # Never found a match.
- return candidate
-
- def __contains__(self, key):
- if isinstance(key, tuple) and len(key) == 2:
- # If we specify a kind, this will shortcut properly
- try:
- self.__getitem__(key)
- return True
- except KeyError:
- return False
- else:
- # Without a kind, we want to minimize the number of round trips to the server, so we
- # reimplement some of the behavior of __getitem__ in order to be able to stop searching
- # on the first hit.
- for kind in self.kinds:
- try:
- response = self.get(self.kindpath(kind) + "/" + key)
- entries = self._load_list(response)
- if len(entries) > 0:
- return True
- except HTTPError as he:
- if he.status == 404:
- pass # Just carry on to the next kind.
- else:
- raise
- return False
-
- def create(self, name, kind, **kwargs):
- """Creates an input of a specific kind in this collection, with any
- arguments you specify.
-
- :param `name`: The input name.
- :type name: ``string``
- :param `kind`: The kind of input:
-
- - "ad": Active Directory
-
- - "monitor": Files and directories
-
- - "registry": Windows Registry
-
- - "script": Scripts
-
- - "splunktcp": TCP, processed
-
- - "tcp": TCP, unprocessed
-
- - "udp": UDP
-
- - "win-event-log-collections": Windows event log
-
- - "win-perfmon": Performance monitoring
-
- - "win-wmi-collections": WMI
-
- :type kind: ``string``
- :param `kwargs`: Additional arguments (optional). For more about the
- available parameters, see `Input parameters `_ on Splunk Developer Portal.
-
- :type kwargs: ``dict``
-
- :return: The new :class:`Input`.
- """
- kindpath = self.kindpath(kind)
- self.post(kindpath, name=name, **kwargs)
-
- # If we created an input with restrictToHost set, then
- # its path will be :, not just ,
- # and we have to adjust accordingly.
-
- # Url encodes the name of the entity.
- name = UrlEncoded(name, encode_slash=True)
- path = _path(
- self.path + kindpath,
- f"{kwargs['restrictToHost']}:{name}" if 'restrictToHost' in kwargs else name
- )
- return Input(self.service, path, kind)
-
- def delete(self, name, kind=None):
- """Removes an input from the collection.
-
- :param `kind`: The kind of input:
-
- - "ad": Active Directory
-
- - "monitor": Files and directories
-
- - "registry": Windows Registry
-
- - "script": Scripts
-
- - "splunktcp": TCP, processed
-
- - "tcp": TCP, unprocessed
-
- - "udp": UDP
-
- - "win-event-log-collections": Windows event log
-
- - "win-perfmon": Performance monitoring
-
- - "win-wmi-collections": WMI
-
- :type kind: ``string``
- :param name: The name of the input to remove.
- :type name: ``string``
-
- :return: The :class:`Inputs` collection.
- """
- if kind is None:
- self.service.delete(self[name].path)
- else:
- self.service.delete(self[name, kind].path)
- return self
-
- def itemmeta(self, kind):
- """Returns metadata for the members of a given kind.
-
- :param `kind`: The kind of input:
-
- - "ad": Active Directory
-
- - "monitor": Files and directories
-
- - "registry": Windows Registry
-
- - "script": Scripts
-
- - "splunktcp": TCP, processed
-
- - "tcp": TCP, unprocessed
-
- - "udp": UDP
-
- - "win-event-log-collections": Windows event log
-
- - "win-perfmon": Performance monitoring
-
- - "win-wmi-collections": WMI
-
- :type kind: ``string``
-
- :return: The metadata.
- :rtype: class:``splunklib.data.Record``
- """
- response = self.get(f"{self._kindmap[kind]}/_new")
- content = _load_atom(response, MATCH_ENTRY_CONTENT)
- return _parse_atom_metadata(content)
-
- def _get_kind_list(self, subpath=None):
- if subpath is None:
- subpath = []
-
- kinds = []
- response = self.get('/'.join(subpath))
- content = _load_atom_entries(response)
- for entry in content:
- this_subpath = subpath + [entry.title]
- # The "all" endpoint doesn't work yet.
- # The "tcp/ssl" endpoint is not a real input collection.
- if entry.title == 'all' or this_subpath == ['tcp', 'ssl']:
- continue
- if 'create' in [x.rel for x in entry.link]:
- path = '/'.join(subpath + [entry.title])
- kinds.append(path)
- else:
- subkinds = self._get_kind_list(subpath + [entry.title])
- kinds.extend(subkinds)
- return kinds
-
- @property
- def kinds(self):
- """Returns the input kinds on this Splunk instance.
-
- :return: The list of input kinds.
- :rtype: ``list``
- """
- return self._get_kind_list()
-
- def kindpath(self, kind):
- """Returns a path to the resources for a given input kind.
-
- :param `kind`: The kind of input:
-
- - "ad": Active Directory
-
- - "monitor": Files and directories
-
- - "registry": Windows Registry
-
- - "script": Scripts
-
- - "splunktcp": TCP, processed
-
- - "tcp": TCP, unprocessed
-
- - "udp": UDP
-
- - "win-event-log-collections": Windows event log
-
- - "win-perfmon": Performance monitoring
-
- - "win-wmi-collections": WMI
-
- :type kind: ``string``
-
- :return: The relative endpoint path.
- :rtype: ``string``
- """
- if kind == 'tcp':
- return UrlEncoded('tcp/raw', skip_encode=True)
- if kind == 'splunktcp':
- return UrlEncoded('tcp/cooked', skip_encode=True)
- return UrlEncoded(kind, skip_encode=True)
-
- def list(self, *kinds, **kwargs):
- """Returns a list of inputs that are in the :class:`Inputs` collection.
- You can also filter by one or more input kinds.
-
- This function iterates over all possible inputs, regardless of any arguments you
- specify. Because the :class:`Inputs` collection is the union of all the inputs of each
- kind, this method implements parameters such as "count", "search", and so
- on at the Python level once all the data has been fetched. The exception
- is when you specify a single input kind, and then this method makes a single request
- with the usual semantics for parameters.
-
- :param kinds: The input kinds to return (optional).
-
- - "ad": Active Directory
-
- - "monitor": Files and directories
-
- - "registry": Windows Registry
-
- - "script": Scripts
-
- - "splunktcp": TCP, processed
-
- - "tcp": TCP, unprocessed
-
- - "udp": UDP
-
- - "win-event-log-collections": Windows event log
-
- - "win-perfmon": Performance monitoring
-
- - "win-wmi-collections": WMI
-
- :type kinds: ``string``
- :param kwargs: Additional arguments (optional):
-
- - "count" (``integer``): The maximum number of items to return.
-
- - "offset" (``integer``): The offset of the first item to return.
-
- - "search" (``string``): The search query to filter responses.
-
- - "sort_dir" (``string``): The direction to sort returned items:
- "asc" or "desc".
-
- - "sort_key" (``string``): The field to use for sorting (optional).
-
- - "sort_mode" (``string``): The collating sequence for sorting
- returned items: "auto", "alpha", "alpha_case", or "num".
-
- :type kwargs: ``dict``
-
- :return: A list of input kinds.
- :rtype: ``list``
- """
- if len(kinds) == 0:
- kinds = self.kinds
- if len(kinds) == 1:
- kind = kinds[0]
- logger.debug("Inputs.list taking short circuit branch for single kind.")
- path = self.kindpath(kind)
- logger.debug("Path for inputs: %s", path)
- try:
- path = UrlEncoded(path, skip_encode=True)
- response = self.get(path, **kwargs)
- except HTTPError as he:
- if he.status == 404: # No inputs of this kind
- return []
- entities = []
- entries = _load_atom_entries(response)
- if entries is None:
- return [] # No inputs in a collection comes back with no feed or entry in the XML
- for entry in entries:
- state = _parse_atom_entry(entry)
- # Unquote the URL, since all URL encoded in the SDK
- # should be of type UrlEncoded, and all str should not
- # be URL encoded.
- path = parse.unquote(state.links.alternate)
- entity = Input(self.service, path, kind, state=state)
- entities.append(entity)
- return entities
-
- search = kwargs.get('search', '*')
-
- entities = []
- for kind in kinds:
- response = None
- try:
- kind = UrlEncoded(kind, skip_encode=True)
- response = self.get(self.kindpath(kind), search=search)
- except HTTPError as e:
- if e.status == 404:
- continue # No inputs of this kind
- else:
- raise
-
- entries = _load_atom_entries(response)
- if entries is None: continue # No inputs to process
- for entry in entries:
- state = _parse_atom_entry(entry)
- # Unquote the URL, since all URL encoded in the SDK
- # should be of type UrlEncoded, and all str should not
- # be URL encoded.
- path = parse.unquote(state.links.alternate)
- entity = Input(self.service, path, kind, state=state)
- entities.append(entity)
- if 'offset' in kwargs:
- entities = entities[kwargs['offset']:]
- if 'count' in kwargs:
- entities = entities[:kwargs['count']]
- if kwargs.get('sort_mode', None) == 'alpha':
- sort_field = kwargs.get('sort_field', 'name')
- if sort_field == 'name':
- f = lambda x: x.name.lower()
- else:
- f = lambda x: x[sort_field].lower()
- entities = sorted(entities, key=f)
- if kwargs.get('sort_mode', None) == 'alpha_case':
- sort_field = kwargs.get('sort_field', 'name')
- if sort_field == 'name':
- f = lambda x: x.name
- else:
- f = lambda x: x[sort_field]
- entities = sorted(entities, key=f)
- if kwargs.get('sort_dir', 'asc') == 'desc':
- entities = list(reversed(entities))
- return entities
-
- def __iter__(self, **kwargs):
- for item in self.iter(**kwargs):
- yield item
-
- def iter(self, **kwargs):
- """ Iterates over the collection of inputs.
-
- :param kwargs: Additional arguments (optional):
-
- - "count" (``integer``): The maximum number of items to return.
-
- - "offset" (``integer``): The offset of the first item to return.
-
- - "search" (``string``): The search query to filter responses.
-
- - "sort_dir" (``string``): The direction to sort returned items:
- "asc" or "desc".
-
- - "sort_key" (``string``): The field to use for sorting (optional).
-
- - "sort_mode" (``string``): The collating sequence for sorting
- returned items: "auto", "alpha", "alpha_case", or "num".
-
- :type kwargs: ``dict``
- """
- for item in self.list(**kwargs):
- yield item
-
- def oneshot(self, path, **kwargs):
- """ Creates a oneshot data input, which is an upload of a single file
- for one-time indexing.
-
- :param path: The path and filename.
- :type path: ``string``
- :param kwargs: Additional arguments (optional). For more about the
- available parameters, see `Input parameters `_ on Splunk Developer Portal.
- :type kwargs: ``dict``
- """
- self.post('oneshot', name=path, **kwargs)
-
-
-class Job(Entity):
- """This class represents a search job."""
-
- def __init__(self, service, sid, **kwargs):
- # Default to v2 in Splunk Version 9+
- path = "{path}{sid}"
- # Formatting path based on the Splunk Version
- if service.disable_v2_api:
- path = path.format(path=PATH_JOBS, sid=sid)
- else:
- path = path.format(path=PATH_JOBS_V2, sid=sid)
-
- Entity.__init__(self, service, path, skip_refresh=True, **kwargs)
- self.sid = sid
-
- # The Job entry record is returned at the root of the response
- def _load_atom_entry(self, response):
- return _load_atom(response).entry
-
- def cancel(self):
- """Stops the current search and deletes the results cache.
-
- :return: The :class:`Job`.
- """
- try:
- self.post("control", action="cancel")
- except HTTPError as he:
- if he.status == 404:
- # The job has already been cancelled, so
- # cancelling it twice is a nop.
- pass
- else:
- raise
- return self
-
- def disable_preview(self):
- """Disables preview for this job.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="disablepreview")
- return self
-
- def enable_preview(self):
- """Enables preview for this job.
-
- **Note**: Enabling preview might slow search considerably.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="enablepreview")
- return self
-
- def events(self, **kwargs):
- """Returns a streaming handle to this job's events.
-
- :param kwargs: Additional parameters (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/events
- `_
- in the REST API documentation.
- :type kwargs: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's events.
- """
- kwargs['segmentation'] = kwargs.get('segmentation', 'none')
-
- # Search API v1(GET) and v2(POST)
- if self.service.disable_v2_api:
- return self.get("events", **kwargs).body
- return self.post("events", **kwargs).body
-
- def finalize(self):
- """Stops the job and provides intermediate results for retrieval.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="finalize")
- return self
-
- def is_done(self):
- """Indicates whether this job finished running.
-
- :return: ``True`` if the job is done, ``False`` if not.
- :rtype: ``boolean``
- """
- if not self.is_ready():
- return False
- done = (self._state.content['isDone'] == '1')
- return done
-
- def is_ready(self):
- """Indicates whether this job is ready for querying.
-
- :return: ``True`` if the job is ready, ``False`` if not.
- :rtype: ``boolean``
-
- """
- response = self.get()
- if response.status == 204:
- return False
- self._state = self.read(response)
- ready = self._state.content['dispatchState'] not in ['QUEUED', 'PARSING']
- return ready
-
- @property
- def name(self):
- """Returns the name of the search job, which is the search ID (SID).
-
- :return: The search ID.
- :rtype: ``string``
- """
- return self.sid
-
- def pause(self):
- """Suspends the current search.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="pause")
- return self
-
- def results(self, **query_params):
- """Returns a streaming handle to this job's search results. To get a nice, Pythonic iterator, pass the handle
- to :class:`splunklib.results.JSONResultsReader` along with the query param "output_mode='json'", as in::
-
- import splunklib.client as client
- import splunklib.results as results
- from time import sleep
- service = client.connect(...)
- job = service.jobs.create("search * | head 5")
- while not job.is_done():
- sleep(.2)
- rr = results.JSONResultsReader(job.results(output_mode='json'))
- for result in rr:
- if isinstance(result, results.Message):
- # Diagnostic messages may be returned in the results
- print(f'{result.type}: {result.message}')
- elif isinstance(result, dict):
- # Normal events are returned as dicts
- print(result)
- assert rr.is_preview == False
-
- Results are not available until the job has finished. If called on
- an unfinished job, the result is an empty event set.
-
- This method makes a single roundtrip
- to the server, plus at most two additional round trips if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :param query_params: Additional parameters (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/results
- `_.
- :type query_params: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's results.
- """
- query_params['segmentation'] = query_params.get('segmentation', 'none')
-
- # Search API v1(GET) and v2(POST)
- if self.service.disable_v2_api:
- return self.get("results", **query_params).body
- return self.post("results", **query_params).body
-
- def preview(self, **query_params):
- """Returns a streaming handle to this job's preview search results.
-
- Unlike :class:`splunklib.results.JSONResultsReader`along with the query param "output_mode='json'",
- which requires a job to be finished to return any results, the ``preview`` method returns any results that
- have been generated so far, whether the job is running or not. The returned search results are the raw data
- from the server. Pass the handle returned to :class:`splunklib.results.JSONResultsReader` to get a nice,
- Pythonic iterator over objects, as in::
-
- import splunklib.client as client
- import splunklib.results as results
- service = client.connect(...)
- job = service.jobs.create("search * | head 5")
- rr = results.JSONResultsReader(job.preview(output_mode='json'))
- for result in rr:
- if isinstance(result, results.Message):
- # Diagnostic messages may be returned in the results
- print(f'{result.type}: {result.message}')
- elif isinstance(result, dict):
- # Normal events are returned as dicts
- print(result)
- if rr.is_preview:
- print("Preview of a running search job.")
- else:
- print("Job is finished. Results are final.")
-
- This method makes one roundtrip to the server, plus at most
- two more if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :param query_params: Additional parameters (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/results_preview
- `_
- in the REST API documentation.
- :type query_params: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's preview results.
- """
- query_params['segmentation'] = query_params.get('segmentation', 'none')
-
- # Search API v1(GET) and v2(POST)
- if self.service.disable_v2_api:
- return self.get("results_preview", **query_params).body
- return self.post("results_preview", **query_params).body
-
- def searchlog(self, **kwargs):
- """Returns a streaming handle to this job's search log.
-
- :param `kwargs`: Additional parameters (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/search.log
- `_
- in the REST API documentation.
- :type kwargs: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's search log.
- """
- return self.get("search.log", **kwargs).body
-
- def set_priority(self, value):
- """Sets this job's search priority in the range of 0-10.
-
- Higher numbers indicate higher priority. Unless splunkd is
- running as *root*, you can only decrease the priority of a running job.
-
- :param `value`: The search priority.
- :type value: ``integer``
-
- :return: The :class:`Job`.
- """
- self.post('control', action="setpriority", priority=value)
- return self
-
- def summary(self, **kwargs):
- """Returns a streaming handle to this job's summary.
-
- :param `kwargs`: Additional parameters (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/summary
- `_
- in the REST API documentation.
- :type kwargs: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's summary.
- """
- return self.get("summary", **kwargs).body
-
- def timeline(self, **kwargs):
- """Returns a streaming handle to this job's timeline results.
-
- :param `kwargs`: Additional timeline arguments (optional). For a list of valid
- parameters, see `GET search/jobs/{search_id}/timeline
- `_
- in the REST API documentation.
- :type kwargs: ``dict``
-
- :return: The ``InputStream`` IO handle to this job's timeline.
- """
- return self.get("timeline", **kwargs).body
-
- def touch(self):
- """Extends the expiration time of the search to the current time (now) plus
- the time-to-live (ttl) value.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="touch")
- return self
-
- def set_ttl(self, value):
- """Set the job's time-to-live (ttl) value, which is the time before the
- search job expires and is still available.
-
- :param `value`: The ttl value, in seconds.
- :type value: ``integer``
-
- :return: The :class:`Job`.
- """
- self.post("control", action="setttl", ttl=value)
- return self
-
- def unpause(self):
- """Resumes the current search, if paused.
-
- :return: The :class:`Job`.
- """
- self.post("control", action="unpause")
- return self
-
-
-class Jobs(Collection):
- """This class represents a collection of search jobs. Retrieve this
- collection using :meth:`Service.jobs`."""
-
- def __init__(self, service):
- # Splunk 9 introduces the v2 endpoint
- if not service.disable_v2_api:
- path = PATH_JOBS_V2
- else:
- path = PATH_JOBS
- Collection.__init__(self, service, path, item=Job)
- # The count value to say list all the contents of this
- # Collection is 0, not -1 as it is on most.
- self.null_count = 0
-
- def _load_list(self, response):
- # Overridden because Job takes a sid instead of a path.
- entries = _load_atom_entries(response)
- if entries is None: return []
- entities = []
- for entry in entries:
- state = _parse_atom_entry(entry)
- entity = self.item(
- self.service,
- entry['content']['sid'],
- state=state)
- entities.append(entity)
- return entities
-
- def create(self, query, **kwargs):
- """ Creates a search using a search query and any additional parameters
- you provide.
-
- :param query: The search query.
- :type query: ``string``
- :param kwargs: Additiona parameters (optional). For a list of available
- parameters, see `Search job parameters
- `_
- on Splunk Developer Portal.
- :type kwargs: ``dict``
-
- :return: The :class:`Job`.
- """
- if kwargs.get("exec_mode", None) == "oneshot":
- raise TypeError("Cannot specify exec_mode=oneshot; use the oneshot method instead.")
- response = self.post(search=query, **kwargs)
- sid = _load_sid(response, kwargs.get("output_mode", None))
- return Job(self.service, sid)
-
- def export(self, query, **params):
- """Runs a search and immediately starts streaming preview events. This method returns a streaming handle to
- this job's events as an XML document from the server. To parse this stream into usable Python objects,
- pass the handle to :class:`splunklib.results.JSONResultsReader` along with the query param
- "output_mode='json'"::
-
- import splunklib.client as client
- import splunklib.results as results
- service = client.connect(...)
- rr = results.JSONResultsReader(service.jobs.export("search * | head 5",output_mode='json'))
- for result in rr:
- if isinstance(result, results.Message):
- # Diagnostic messages may be returned in the results
- print(f'{result.type}: {result.message}')
- elif isinstance(result, dict):
- # Normal events are returned as dicts
- print(result)
- assert rr.is_preview == False
-
- Running an export search is more efficient as it streams the results
- directly to you, rather than having to write them out to disk and make
- them available later. As soon as results are ready, you will receive
- them.
-
- The ``export`` method makes a single roundtrip to the server (as opposed
- to two for :meth:`create` followed by :meth:`preview`), plus at most two
- more if the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :raises `ValueError`: Raised for invalid queries.
- :param query: The search query.
- :type query: ``string``
- :param params: Additional arguments (optional). For a list of valid
- parameters, see `GET search/jobs/export
- `_
- in the REST API documentation.
- :type params: ``dict``
-
- :return: The ``InputStream`` IO handle to raw XML returned from the server.
- """
- if "exec_mode" in params:
- raise TypeError("Cannot specify an exec_mode to export.")
- params['segmentation'] = params.get('segmentation', 'none')
- return self.post(path_segment="export",
- search=query,
- **params).body
-
- def itemmeta(self):
- """There is no metadata available for class:``Jobs``.
-
- Any call to this method raises a class:``NotSupportedError``.
-
- :raises: class:``NotSupportedError``
- """
- raise NotSupportedError()
-
- def oneshot(self, query, **params):
- """Run a oneshot search and returns a streaming handle to the results.
-
- The ``InputStream`` object streams fragments from the server. To parse this stream into usable Python
- objects, pass the handle to :class:`splunklib.results.JSONResultsReader` along with the query param
- "output_mode='json'" ::
-
- import splunklib.client as client
- import splunklib.results as results
- service = client.connect(...)
- rr = results.JSONResultsReader(service.jobs.oneshot("search * | head 5",output_mode='json'))
- for result in rr:
- if isinstance(result, results.Message):
- # Diagnostic messages may be returned in the results
- print(f'{result.type}: {result.message}')
- elif isinstance(result, dict):
- # Normal events are returned as dicts
- print(result)
- assert rr.is_preview == False
-
- The ``oneshot`` method makes a single roundtrip to the server (as opposed
- to two for :meth:`create` followed by :meth:`results`), plus at most two more
- if the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :raises ValueError: Raised for invalid queries.
-
- :param query: The search query.
- :type query: ``string``
- :param params: Additional arguments (optional):
-
- - "output_mode": Specifies the output format of the results (XML,
- JSON, or CSV).
-
- - "earliest_time": Specifies the earliest time in the time range to
- search. The time string can be a UTC time (with fractional seconds),
- a relative time specifier (to now), or a formatted time string.
-
- - "latest_time": Specifies the latest time in the time range to
- search. The time string can be a UTC time (with fractional seconds),
- a relative time specifier (to now), or a formatted time string.
-
- - "rf": Specifies one or more fields to add to the search.
-
- :type params: ``dict``
-
- :return: The ``InputStream`` IO handle to raw XML returned from the server.
- """
- if "exec_mode" in params:
- raise TypeError("Cannot specify an exec_mode to oneshot.")
- params['segmentation'] = params.get('segmentation', 'none')
- return self.post(search=query,
- exec_mode="oneshot",
- **params).body
-
-
-class Loggers(Collection):
- """This class represents a collection of service logging categories.
- Retrieve this collection using :meth:`Service.loggers`."""
-
- def __init__(self, service):
- Collection.__init__(self, service, PATH_LOGGER)
-
- def itemmeta(self):
- """There is no metadata available for class:``Loggers``.
-
- Any call to this method raises a class:``NotSupportedError``.
-
- :raises: class:``NotSupportedError``
- """
- raise NotSupportedError()
-
-
-class Message(Entity):
- def __init__(self, service, path, **kwargs):
- Entity.__init__(self, service, path, **kwargs)
-
- @property
- def value(self):
- """Returns the message value.
-
- :return: The message value.
- :rtype: ``string``
- """
- return self[self.name]
-
-
-class ModularInputKind(Entity):
- """This class contains the different types of modular inputs. Retrieve this
- collection using :meth:`Service.modular_input_kinds`.
- """
-
- def __contains__(self, name):
- args = self.state.content['endpoints']['args']
- if name in args:
- return True
- return Entity.__contains__(self, name)
-
- def __getitem__(self, name):
- args = self.state.content['endpoint']['args']
- if name in args:
- return args['item']
- return Entity.__getitem__(self, name)
-
- @property
- def arguments(self):
- """A dictionary of all the arguments supported by this modular input kind.
-
- The keys in the dictionary are the names of the arguments. The values are
- another dictionary giving the metadata about that argument. The possible
- keys in that dictionary are ``"title"``, ``"description"``, ``"required_on_create``",
- ``"required_on_edit"``, ``"data_type"``. Each value is a string. It should be one
- of ``"true"`` or ``"false"`` for ``"required_on_create"`` and ``"required_on_edit"``,
- and one of ``"boolean"``, ``"string"``, or ``"number``" for ``"data_type"``.
-
- :return: A dictionary describing the arguments this modular input kind takes.
- :rtype: ``dict``
- """
- return self.state.content['endpoint']['args']
-
- def update(self, **kwargs):
- """Raises an error. Modular input kinds are read only."""
- raise IllegalOperationException("Modular input kinds cannot be updated via the REST API.")
-
-
-class SavedSearch(Entity):
- """This class represents a saved search."""
-
- def __init__(self, service, path, **kwargs):
- Entity.__init__(self, service, path, **kwargs)
-
- def acknowledge(self):
- """Acknowledges the suppression of alerts from this saved search and
- resumes alerting.
-
- :return: The :class:`SavedSearch`.
- """
- self.post("acknowledge")
- return self
-
- @property
- def alert_count(self):
- """Returns the number of alerts fired by this saved search.
-
- :return: The number of alerts fired by this saved search.
- :rtype: ``integer``
- """
- return int(self._state.content.get('triggered_alert_count', 0))
-
- def dispatch(self, **kwargs):
- """Runs the saved search and returns the resulting search job.
-
- :param `kwargs`: Additional dispatch arguments (optional). For details,
- see the `POST saved/searches/{name}/dispatch
- `_
- endpoint in the REST API documentation.
- :type kwargs: ``dict``
- :return: The :class:`Job`.
- """
- response = self.post("dispatch", **kwargs)
- sid = _load_sid(response, kwargs.get("output_mode", None))
- return Job(self.service, sid)
-
- @property
- def fired_alerts(self):
- """Returns the collection of fired alerts (a fired alert group)
- corresponding to this saved search's alerts.
-
- :raises IllegalOperationException: Raised when the search is not scheduled.
-
- :return: A collection of fired alerts.
- :rtype: :class:`AlertGroup`
- """
- if self['is_scheduled'] == '0':
- raise IllegalOperationException('Unscheduled saved searches have no alerts.')
- c = Collection(
- self.service,
- self.service._abspath(PATH_FIRED_ALERTS + self.name,
- owner=self._state.access.owner,
- app=self._state.access.app,
- sharing=self._state.access.sharing),
- item=AlertGroup)
- return c
-
- def history(self, **kwargs):
- """Returns a list of search jobs corresponding to this saved search.
-
- :param `kwargs`: Additional arguments (optional).
- :type kwargs: ``dict``
-
- :return: A list of :class:`Job` objects.
- """
- response = self.get("history", **kwargs)
- entries = _load_atom_entries(response)
- if entries is None: return []
- jobs = []
- for entry in entries:
- job = Job(self.service, entry.title)
- jobs.append(job)
- return jobs
-
- def update(self, search=None, **kwargs):
- """Updates the server with any changes you've made to the current saved
- search along with any additional arguments you specify.
-
- :param `search`: The search query (optional).
- :type search: ``string``
- :param `kwargs`: Additional arguments (optional). For a list of available
- parameters, see `Saved search parameters
- `_
- on Splunk Developer Portal.
- :type kwargs: ``dict``
-
- :return: The :class:`SavedSearch`.
- """
- # Updates to a saved search *require* that the search string be
- # passed, so we pass the current search string if a value wasn't
- # provided by the caller.
- if search is None: search = self.content.search
- Entity.update(self, search=search, **kwargs)
- return self
-
- def scheduled_times(self, earliest_time='now', latest_time='+1h'):
- """Returns the times when this search is scheduled to run.
-
- By default this method returns the times in the next hour. For different
- time ranges, set *earliest_time* and *latest_time*. For example,
- for all times in the last day use "earliest_time=-1d" and
- "latest_time=now".
-
- :param earliest_time: The earliest time.
- :type earliest_time: ``string``
- :param latest_time: The latest time.
- :type latest_time: ``string``
-
- :return: The list of search times.
- """
- response = self.get("scheduled_times",
- earliest_time=earliest_time,
- latest_time=latest_time)
- data = self._load_atom_entry(response)
- rec = _parse_atom_entry(data)
- times = [datetime.fromtimestamp(int(t))
- for t in rec.content.scheduled_times]
- return times
-
- def suppress(self, expiration):
- """Skips any scheduled runs of this search in the next *expiration*
- number of seconds.
-
- :param expiration: The expiration period, in seconds.
- :type expiration: ``integer``
-
- :return: The :class:`SavedSearch`.
- """
- self.post("suppress", expiration=expiration)
- return self
-
- @property
- def suppressed(self):
- """Returns the number of seconds that this search is blocked from running
- (possibly 0).
-
- :return: The number of seconds.
- :rtype: ``integer``
- """
- r = self._run_action("suppress")
- if r.suppressed == "1":
- return int(r.expiration)
- return 0
-
- def unsuppress(self):
- """Cancels suppression and makes this search run as scheduled.
-
- :return: The :class:`SavedSearch`.
- """
- self.post("suppress", expiration="0")
- return self
-
-
-class SavedSearches(Collection):
- """This class represents a collection of saved searches. Retrieve this
- collection using :meth:`Service.saved_searches`."""
-
- def __init__(self, service):
- Collection.__init__(
- self, service, PATH_SAVED_SEARCHES, item=SavedSearch)
-
- def create(self, name, search, **kwargs):
- """ Creates a saved search.
-
- :param name: The name for the saved search.
- :type name: ``string``
- :param search: The search query.
- :type search: ``string``
- :param kwargs: Additional arguments (optional). For a list of available
- parameters, see `Saved search parameters
- `_
- on Splunk Developer Portal.
- :type kwargs: ``dict``
- :return: The :class:`SavedSearches` collection.
- """
- return Collection.create(self, name, search=search, **kwargs)
-
-
-class Macro(Entity):
- """This class represents a search macro."""
- def __init__(self, service, path, **kwargs):
- Entity.__init__(self, service, path, **kwargs)
-
- @property
- def args(self):
- """Returns the macro arguments.
- :return: The macro arguments.
- :rtype: ``string``
- """
- return self._state.content.get('args', '')
-
- @property
- def definition(self):
- """Returns the macro definition.
- :return: The macro definition.
- :rtype: ``string``
- """
- return self._state.content.get('definition', '')
-
- @property
- def errormsg(self):
- """Returns the validation error message for the macro.
- :return: The validation error message for the macro.
- :rtype: ``string``
- """
- return self._state.content.get('errormsg', '')
-
- @property
- def iseval(self):
- """Returns the eval-based definition status of the macro.
- :return: The iseval value for the macro.
- :rtype: ``string``
- """
- return self._state.content.get('iseval', '0')
-
- def update(self, definition=None, **kwargs):
- """Updates the server with any changes you've made to the current macro
- along with any additional arguments you specify.
- :param `definition`: The macro definition (optional).
- :type definition: ``string``
- :param `kwargs`: Additional arguments (optional). Available parameters are:
- 'disabled', 'iseval', 'validation', and 'errormsg'.
- :type kwargs: ``dict``
- :return: The :class:`Macro`.
- """
- # Updates to a macro *require* that the definition be
- # passed, so we pass the current definition if a value wasn't
- # provided by the caller.
- if definition is None: definition = self.content.definition
- Entity.update(self, definition=definition, **kwargs)
- return self
-
- @property
- def validation(self):
- """Returns the validation expression for the macro.
- :return: The validation expression for the macro.
- :rtype: ``string``
- """
- return self._state.content.get('validation', '')
-
-
-class Macros(Collection):
- """This class represents a collection of macros. Retrieve this
- collection using :meth:`Service.macros`."""
- def __init__(self, service):
- Collection.__init__(
- self, service, PATH_MACROS, item=Macro)
-
- def create(self, name, definition, **kwargs):
- """ Creates a macro.
- :param name: The name for the macro.
- :type name: ``string``
- :param definition: The macro definition.
- :type definition: ``string``
- :param kwargs: Additional arguments (optional). Available parameters are:
- 'disabled', 'iseval', 'validation', and 'errormsg'.
- :type kwargs: ``dict``
- :return: The :class:`Macros` collection.
- """
- return Collection.create(self, name, definition=definition, **kwargs)
-
-
-class Settings(Entity):
- """This class represents configuration settings for a Splunk service.
- Retrieve this collection using :meth:`Service.settings`."""
-
- def __init__(self, service, **kwargs):
- Entity.__init__(self, service, "/services/server/settings", **kwargs)
-
- # Updates on the settings endpoint are POSTed to server/settings/settings.
- def update(self, **kwargs):
- """Updates the settings on the server using the arguments you provide.
-
- :param kwargs: Additional arguments. For a list of valid arguments, see
- `POST server/settings/{name}
- `_
- in the REST API documentation.
- :type kwargs: ``dict``
- :return: The :class:`Settings` collection.
- """
- self.service.post("/services/server/settings/settings", **kwargs)
- return self
-
-
-class User(Entity):
- """This class represents a Splunk user.
- """
-
- @property
- def role_entities(self):
- """Returns a list of roles assigned to this user.
-
- :return: The list of roles.
- :rtype: ``list``
- """
- all_role_names = [r.name for r in self.service.roles.list()]
- return [self.service.roles[name] for name in self.content.roles if name in all_role_names]
-
-
-# Splunk automatically lowercases new user names so we need to match that
-# behavior here to ensure that the subsequent member lookup works correctly.
-class Users(Collection):
- """This class represents the collection of Splunk users for this instance of
- Splunk. Retrieve this collection using :meth:`Service.users`.
- """
-
- def __init__(self, service):
- Collection.__init__(self, service, PATH_USERS, item=User)
-
- def __getitem__(self, key):
- return Collection.__getitem__(self, key.lower())
-
- def __contains__(self, name):
- return Collection.__contains__(self, name.lower())
-
- def create(self, username, password, roles, **params):
- """Creates a new user.
-
- This function makes two roundtrips to the server, plus at most
- two more if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :param username: The username.
- :type username: ``string``
- :param password: The password.
- :type password: ``string``
- :param roles: A single role or list of roles for the user.
- :type roles: ``string`` or ``list``
- :param params: Additional arguments (optional). For a list of available
- parameters, see `User authentication parameters
- `_
- on Splunk Developer Portal.
- :type params: ``dict``
-
- :return: The new user.
- :rtype: :class:`User`
-
- **Example**::
-
- import splunklib.client as client
- c = client.connect(...)
- users = c.users
- boris = users.create("boris", "securepassword", roles="user")
- hilda = users.create("hilda", "anotherpassword", roles=["user","power"])
- """
- if not isinstance(username, str):
- raise ValueError(f"Invalid username: {str(username)}")
- username = username.lower()
- self.post(name=username, password=password, roles=roles, **params)
- # splunkd doesn't return the user in the POST response body,
- # so we have to make a second round trip to fetch it.
- response = self.get(username)
- entry = _load_atom(response, XNAME_ENTRY).entry
- state = _parse_atom_entry(entry)
- entity = self.item(
- self.service,
- parse.unquote(state.links.alternate),
- state=state)
- return entity
-
- def delete(self, name):
- """ Deletes the user and returns the resulting collection of users.
-
- :param name: The name of the user to delete.
- :type name: ``string``
-
- :return:
- :rtype: :class:`Users`
- """
- return Collection.delete(self, name.lower())
-
-
-class Role(Entity):
- """This class represents a user role.
- """
-
- def grant(self, *capabilities_to_grant):
- """Grants additional capabilities to this role.
-
- :param capabilities_to_grant: Zero or more capabilities to grant this
- role. For a list of capabilities, see
- `Capabilities `_
- on Splunk Developer Portal.
- :type capabilities_to_grant: ``string`` or ``list``
- :return: The :class:`Role`.
-
- **Example**::
-
- service = client.connect(...)
- role = service.roles['somerole']
- role.grant('change_own_password', 'search')
- """
- possible_capabilities = self.service.capabilities
- for capability in capabilities_to_grant:
- if capability not in possible_capabilities:
- raise NoSuchCapability(capability)
- new_capabilities = self['capabilities'] + list(capabilities_to_grant)
- self.post(capabilities=new_capabilities)
- return self
-
- def revoke(self, *capabilities_to_revoke):
- """Revokes zero or more capabilities from this role.
-
- :param capabilities_to_revoke: Zero or more capabilities to grant this
- role. For a list of capabilities, see
- `Capabilities `_
- on Splunk Developer Portal.
- :type capabilities_to_revoke: ``string`` or ``list``
-
- :return: The :class:`Role`.
-
- **Example**::
-
- service = client.connect(...)
- role = service.roles['somerole']
- role.revoke('change_own_password', 'search')
- """
- possible_capabilities = self.service.capabilities
- for capability in capabilities_to_revoke:
- if capability not in possible_capabilities:
- raise NoSuchCapability(capability)
- old_capabilities = self['capabilities']
- new_capabilities = []
- for c in old_capabilities:
- if c not in capabilities_to_revoke:
- new_capabilities.append(c)
- if not new_capabilities:
- new_capabilities = '' # Empty lists don't get passed in the body, so we have to force an empty argument.
- self.post(capabilities=new_capabilities)
- return self
-
-
-class Roles(Collection):
- """This class represents the collection of roles in the Splunk instance.
- Retrieve this collection using :meth:`Service.roles`."""
-
- def __init__(self, service):
- Collection.__init__(self, service, PATH_ROLES, item=Role)
-
- def __getitem__(self, key):
- return Collection.__getitem__(self, key.lower())
-
- def __contains__(self, name):
- return Collection.__contains__(self, name.lower())
-
- def create(self, name, **params):
- """Creates a new role.
-
- This function makes two roundtrips to the server, plus at most
- two more if
- the ``autologin`` field of :func:`connect` is set to ``True``.
-
- :param name: Name for the role.
- :type name: ``string``
- :param params: Additional arguments (optional). For a list of available
- parameters, see `Roles parameters
- `_
- on Splunk Developer Portal.
- :type params: ``dict``
-
- :return: The new role.
- :rtype: :class:`Role`
-
- **Example**::
-
- import splunklib.client as client
- c = client.connect(...)
- roles = c.roles
- paltry = roles.create("paltry", imported_roles="user", defaultApp="search")
- """
- if not isinstance(name, str):
- raise ValueError(f"Invalid role name: {str(name)}")
- name = name.lower()
- self.post(name=name, **params)
- # splunkd doesn't return the user in the POST response body,
- # so we have to make a second round trip to fetch it.
- response = self.get(name)
- entry = _load_atom(response, XNAME_ENTRY).entry
- state = _parse_atom_entry(entry)
- entity = self.item(
- self.service,
- parse.unquote(state.links.alternate),
- state=state)
- return entity
-
- def delete(self, name):
- """ Deletes the role and returns the resulting collection of roles.
-
- :param name: The name of the role to delete.
- :type name: ``string``
-
- :rtype: The :class:`Roles`
- """
- return Collection.delete(self, name.lower())
-
-
-class Application(Entity):
- """Represents a locally-installed Splunk app."""
-
- @property
- def setupInfo(self):
- """Returns the setup information for the app.
-
- :return: The setup information.
- """
- return self.content.get('eai:setup', None)
-
- def package(self):
- """ Creates a compressed package of the app for archiving."""
- return self._run_action("package")
-
- def updateInfo(self):
- """Returns any update information that is available for the app."""
- return self._run_action("update")
-
-
-class KVStoreCollections(Collection):
- def __init__(self, service):
- Collection.__init__(self, service, 'storage/collections/config', item=KVStoreCollection)
-
- def __getitem__(self, item):
- res = Collection.__getitem__(self, item)
- for k, v in res.content.items():
- if "accelerated_fields" in k:
- res.content[k] = json.loads(v)
- return res
-
- def create(self, name, accelerated_fields={}, fields={}, **kwargs):
- """Creates a KV Store Collection.
-
- :param name: name of collection to create
- :type name: ``string``
- :param accelerated_fields: dictionary of accelerated_fields definitions
- :type accelerated_fields: ``dict``
- :param fields: dictionary of field definitions
- :type fields: ``dict``
- :param kwargs: a dictionary of additional parameters specifying indexes and field definitions
- :type kwargs: ``dict``
-
- :return: Result of POST request
- """
- for k, v in accelerated_fields.items():
- if isinstance(v, dict):
- v = json.dumps(v)
- kwargs['accelerated_fields.' + k] = v
- for k, v in fields.items():
- kwargs['field.' + k] = v
- return self.post(name=name, **kwargs)
-
-
-class KVStoreCollection(Entity):
- @property
- def data(self):
- """Returns data object for this Collection.
-
- :rtype: :class:`KVStoreCollectionData`
- """
- return KVStoreCollectionData(self)
-
- def update_accelerated_field(self, name, value):
- """Changes the definition of a KV Store accelerated_field.
-
- :param name: name of accelerated_fields to change
- :type name: ``string``
- :param value: new accelerated_fields definition
- :type value: ``dict``
-
- :return: Result of POST request
- """
- kwargs = {}
- kwargs['accelerated_fields.' + name] = json.dumps(value) if isinstance(value, dict) else value
- return self.post(**kwargs)
-
- def update_field(self, name, value):
- """Changes the definition of a KV Store field.
-
- :param name: name of field to change
- :type name: ``string``
- :param value: new field definition
- :type value: ``string``
-
- :return: Result of POST request
- """
- kwargs = {}
- kwargs['field.' + name] = value
- return self.post(**kwargs)
-
-
-class KVStoreCollectionData:
- """This class represents the data endpoint for a KVStoreCollection.
-
- Retrieve using :meth:`KVStoreCollection.data`
- """
- JSON_HEADER = [('Content-Type', 'application/json')]
-
- def __init__(self, collection):
- self.service = collection.service
- self.collection = collection
- self.owner, self.app, self.sharing = collection._proper_namespace()
- self.path = 'storage/collections/data/' + UrlEncoded(self.collection.name, encode_slash=True) + '/'
-
- def _get(self, url, **kwargs):
- return self.service.get(self.path + url, owner=self.owner, app=self.app, sharing=self.sharing, **kwargs)
-
- def _post(self, url, **kwargs):
- return self.service.post(self.path + url, owner=self.owner, app=self.app, sharing=self.sharing, **kwargs)
-
- def _delete(self, url, **kwargs):
- return self.service.delete(self.path + url, owner=self.owner, app=self.app, sharing=self.sharing, **kwargs)
-
- def query(self, **query):
- """
- Gets the results of query, with optional parameters sort, limit, skip, and fields.
-
- :param query: Optional parameters. Valid options are sort, limit, skip, and fields
- :type query: ``dict``
-
- :return: Array of documents retrieved by query.
- :rtype: ``array``
- """
-
- for key, value in query.items():
- if isinstance(query[key], dict):
- query[key] = json.dumps(value)
-
- return json.loads(self._get('', **query).body.read().decode('utf-8'))
-
- def query_by_id(self, id):
- """
- Returns object with _id = id.
-
- :param id: Value for ID. If not a string will be coerced to string.
- :type id: ``string``
-
- :return: Document with id
- :rtype: ``dict``
- """
- return json.loads(self._get(UrlEncoded(str(id), encode_slash=True)).body.read().decode('utf-8'))
-
- def insert(self, data):
- """
- Inserts item into this collection. An _id field will be generated if not assigned in the data.
-
- :param data: Document to insert
- :type data: ``string``
-
- :return: _id of inserted object
- :rtype: ``dict``
- """
- if isinstance(data, dict):
- data = json.dumps(data)
- return json.loads(
- self._post('', headers=KVStoreCollectionData.JSON_HEADER, body=data).body.read().decode('utf-8'))
-
- def delete(self, query=None):
- """
- Deletes all data in collection if query is absent. Otherwise, deletes all data matched by query.
-
- :param query: Query to select documents to delete
- :type query: ``string``
-
- :return: Result of DELETE request
- """
- return self._delete('', **({'query': query}) if query else {})
-
- def delete_by_id(self, id):
- """
- Deletes document that has _id = id.
-
- :param id: id of document to delete
- :type id: ``string``
-
- :return: Result of DELETE request
- """
- return self._delete(UrlEncoded(str(id), encode_slash=True))
-
- def update(self, id, data):
- """
- Replaces document with _id = id with data.
-
- :param id: _id of document to update
- :type id: ``string``
- :param data: the new document to insert
- :type data: ``string``
-
- :return: id of replaced document
- :rtype: ``dict``
- """
- if isinstance(data, dict):
- data = json.dumps(data)
- return json.loads(self._post(UrlEncoded(str(id), encode_slash=True), headers=KVStoreCollectionData.JSON_HEADER,
- body=data).body.read().decode('utf-8'))
-
- def batch_find(self, *dbqueries):
- """
- Returns array of results from queries dbqueries.
-
- :param dbqueries: Array of individual queries as dictionaries
- :type dbqueries: ``array`` of ``dict``
-
- :return: Results of each query
- :rtype: ``array`` of ``array``
- """
- if len(dbqueries) < 1:
- raise Exception('Must have at least one query.')
-
- data = json.dumps(dbqueries)
-
- return json.loads(
- self._post('batch_find', headers=KVStoreCollectionData.JSON_HEADER, body=data).body.read().decode('utf-8'))
-
- def batch_save(self, *documents):
- """
- Inserts or updates every document specified in documents.
-
- :param documents: Array of documents to save as dictionaries
- :type documents: ``array`` of ``dict``
-
- :return: Results of update operation as overall stats
- :rtype: ``dict``
- """
- if len(documents) < 1:
- raise Exception('Must have at least one document.')
-
- data = json.dumps(documents)
-
- return json.loads(
- self._post('batch_save', headers=KVStoreCollectionData.JSON_HEADER, body=data).body.read().decode('utf-8'))
\ No newline at end of file
diff --git a/lib/splunklib/data.py b/lib/splunklib/data.py
deleted file mode 100644
index 34f3ffa..0000000
--- a/lib/splunklib/data.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-"""The **splunklib.data** module reads the responses from splunkd in Atom Feed
-format, which is the format used by most of the REST API.
-"""
-
-from xml.etree.ElementTree import XML
-
-__all__ = ["load", "record"]
-
-# LNAME refers to element names without namespaces; XNAME is the same
-# name, but with an XML namespace.
-LNAME_DICT = "dict"
-LNAME_ITEM = "item"
-LNAME_KEY = "key"
-LNAME_LIST = "list"
-
-XNAMEF_REST = "{http://dev.splunk.com/ns/rest}%s"
-XNAME_DICT = XNAMEF_REST % LNAME_DICT
-XNAME_ITEM = XNAMEF_REST % LNAME_ITEM
-XNAME_KEY = XNAMEF_REST % LNAME_KEY
-XNAME_LIST = XNAMEF_REST % LNAME_LIST
-
-
-# Some responses don't use namespaces (eg: search/parse) so we look for
-# both the extended and local versions of the following names.
-
-
-def isdict(name):
- return name in (XNAME_DICT, LNAME_DICT)
-
-
-def isitem(name):
- return name in (XNAME_ITEM, LNAME_ITEM)
-
-
-def iskey(name):
- return name in (XNAME_KEY, LNAME_KEY)
-
-
-def islist(name):
- return name in (XNAME_LIST, LNAME_LIST)
-
-
-def hasattrs(element):
- return len(element.attrib) > 0
-
-
-def localname(xname):
- rcurly = xname.find('}')
- return xname if rcurly == -1 else xname[rcurly + 1:]
-
-
-def load(text, match=None):
- """This function reads a string that contains the XML of an Atom Feed, then
- returns the
- data in a native Python structure (a ``dict`` or ``list``). If you also
- provide a tag name or path to match, only the matching sub-elements are
- loaded.
-
- :param text: The XML text to load.
- :type text: ``string``
- :param match: A tag name or path to match (optional).
- :type match: ``string``
- """
- if text is None: return None
- text = text.strip()
- if len(text) == 0: return None
- nametable = {
- 'namespaces': [],
- 'names': {}
- }
-
- root = XML(text)
- items = [root] if match is None else root.findall(match)
- count = len(items)
- if count == 0:
- return None
- if count == 1:
- return load_root(items[0], nametable)
- return [load_root(item, nametable) for item in items]
-
-
-# Load the attributes of the given element.
-def load_attrs(element):
- if not hasattrs(element): return None
- attrs = record()
- for key, value in element.attrib.items():
- attrs[key] = value
- return attrs
-
-
-# Parse a element and return a Python dict
-def load_dict(element, nametable=None):
- value = record()
- children = list(element)
- for child in children:
- assert iskey(child.tag)
- name = child.attrib["name"]
- value[name] = load_value(child, nametable)
- return value
-
-
-# Loads the given elements attrs & value into single merged dict.
-def load_elem(element, nametable=None):
- name = localname(element.tag)
- attrs = load_attrs(element)
- value = load_value(element, nametable)
- if attrs is None: return name, value
- if value is None: return name, attrs
- # If value is simple, merge into attrs dict using special key
- if isinstance(value, str):
- attrs["$text"] = value
- return name, attrs
- # Both attrs & value are complex, so merge the two dicts, resolving collisions.
- collision_keys = []
- for key, val in attrs.items():
- if key in value and key in collision_keys:
- value[key].append(val)
- elif key in value and key not in collision_keys:
- value[key] = [value[key], val]
- collision_keys.append(key)
- else:
- value[key] = val
- return name, value
-
-
-# Parse a element and return a Python list
-def load_list(element, nametable=None):
- assert islist(element.tag)
- value = []
- children = list(element)
- for child in children:
- assert isitem(child.tag)
- value.append(load_value(child, nametable))
- return value
-
-
-# Load the given root element.
-def load_root(element, nametable=None):
- tag = element.tag
- if isdict(tag): return load_dict(element, nametable)
- if islist(tag): return load_list(element, nametable)
- k, v = load_elem(element, nametable)
- return Record.fromkv(k, v)
-
-
-# Load the children of the given element.
-def load_value(element, nametable=None):
- children = list(element)
- count = len(children)
-
- # No children, assume a simple text value
- if count == 0:
- text = element.text
- if text is None:
- return None
-
- if len(text.strip()) == 0:
- return None
- return text
-
- # Look for the special case of a single well-known structure
- if count == 1:
- child = children[0]
- tag = child.tag
- if isdict(tag): return load_dict(child, nametable)
- if islist(tag): return load_list(child, nametable)
-
- value = record()
- for child in children:
- name, item = load_elem(child, nametable)
- # If we have seen this name before, promote the value to a list
- if name in value:
- current = value[name]
- if not isinstance(current, list):
- value[name] = [current]
- value[name].append(item)
- else:
- value[name] = item
-
- return value
-
-
-# A generic utility that enables "dot" access to dicts
-class Record(dict):
- """This generic utility class enables dot access to members of a Python
- dictionary.
-
- Any key that is also a valid Python identifier can be retrieved as a field.
- So, for an instance of ``Record`` called ``r``, ``r.key`` is equivalent to
- ``r['key']``. A key such as ``invalid-key`` or ``invalid.key`` cannot be
- retrieved as a field, because ``-`` and ``.`` are not allowed in
- identifiers.
-
- Keys of the form ``a.b.c`` are very natural to write in Python as fields. If
- a group of keys shares a prefix ending in ``.``, you can retrieve keys as a
- nested dictionary by calling only the prefix. For example, if ``r`` contains
- keys ``'foo'``, ``'bar.baz'``, and ``'bar.qux'``, ``r.bar`` returns a record
- with the keys ``baz`` and ``qux``. If a key contains multiple ``.``, each
- one is placed into a nested dictionary, so you can write ``r.bar.qux`` or
- ``r['bar.qux']`` interchangeably.
- """
- sep = '.'
-
- def __call__(self, *args):
- if len(args) == 0: return self
- return Record((key, self[key]) for key in args)
-
- def __getattr__(self, name):
- try:
- return self[name]
- except KeyError:
- raise AttributeError(name)
-
- def __delattr__(self, name):
- del self[name]
-
- def __setattr__(self, name, value):
- self[name] = value
-
- @staticmethod
- def fromkv(k, v):
- result = record()
- result[k] = v
- return result
-
- def __getitem__(self, key):
- if key in self:
- return dict.__getitem__(self, key)
- key += self.sep
- result = record()
- for k, v in self.items():
- if not k.startswith(key):
- continue
- suffix = k[len(key):]
- if '.' in suffix:
- ks = suffix.split(self.sep)
- z = result
- for x in ks[:-1]:
- if x not in z:
- z[x] = record()
- z = z[x]
- z[ks[-1]] = v
- else:
- result[suffix] = v
- if len(result) == 0:
- raise KeyError(f"No key or prefix: {key}")
- return result
-
-
-def record(value=None):
- """This function returns a :class:`Record` instance constructed with an
- initial value that you provide.
-
- :param value: An initial record value.
- :type value: ``dict``
- """
- if value is None: value = {}
- return Record(value)
diff --git a/lib/splunklib/modularinput/__init__.py b/lib/splunklib/modularinput/__init__.py
deleted file mode 100644
index ace954a..0000000
--- a/lib/splunklib/modularinput/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""The following imports allow these classes to be imported via
-the splunklib.modularinput package like so:
-
-from splunklib.modularinput import *
-"""
-from .argument import Argument
-from .event import Event
-from .event_writer import EventWriter
-from .input_definition import InputDefinition
-from .scheme import Scheme
-from .script import Script
-from .validation_definition import ValidationDefinition
diff --git a/lib/splunklib/modularinput/argument.py b/lib/splunklib/modularinput/argument.py
deleted file mode 100644
index ec64387..0000000
--- a/lib/splunklib/modularinput/argument.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 xml.etree.ElementTree as ET
-
-class Argument:
-
- """Class representing an argument to a modular input kind.
-
- ``Argument`` is meant to be used with ``Scheme`` to generate an XML
- definition of the modular input kind that Splunk understands.
-
- ``name`` is the only required parameter for the constructor.
-
- **Example with least parameters**::
-
- arg1 = Argument(name="arg1")
-
- **Example with all parameters**::
-
- arg2 = Argument(
- name="arg2",
- description="This is an argument with lots of parameters",
- validation="is_pos_int('some_name')",
- data_type=Argument.data_type_number,
- required_on_edit=True,
- required_on_create=True
- )
- """
-
- # Constant values, do not change.
- # These should be used for setting the value of an Argument object's data_type field.
- data_type_boolean = "BOOLEAN"
- data_type_number = "NUMBER"
- data_type_string = "STRING"
-
- def __init__(self, name, description=None, validation=None,
- data_type=data_type_string, required_on_edit=False, required_on_create=False, title=None):
- """
- :param name: ``string``, identifier for this argument in Splunk.
- :param description: ``string``, human-readable description of the argument.
- :param validation: ``string`` specifying how the argument should be validated, if using internal validation.
- If using external validation, this will be ignored.
- :param data_type: ``string``, data type of this field; use the class constants.
- "data_type_boolean", "data_type_number", or "data_type_string".
- :param required_on_edit: ``Boolean``, whether this arg is required when editing an existing modular input of this kind.
- :param required_on_create: ``Boolean``, whether this arg is required when creating a modular input of this kind.
- :param title: ``String``, a human-readable title for the argument.
- """
- self.name = name
- self.description = description
- self.validation = validation
- self.data_type = data_type
- self.required_on_edit = required_on_edit
- self.required_on_create = required_on_create
- self.title = title
-
- def add_to_document(self, parent):
- """Adds an ``Argument`` object to this ElementTree document.
-
- Adds an subelement to the parent element, typically
- and sets up its subelements with their respective text.
-
- :param parent: An ``ET.Element`` to be the parent of a new subelement
- :returns: An ``ET.Element`` object representing this argument.
- """
- arg = ET.SubElement(parent, "arg")
- arg.set("name", self.name)
-
- if self.title is not None:
- ET.SubElement(arg, "title").text = self.title
-
- if self.description is not None:
- ET.SubElement(arg, "description").text = self.description
-
- if self.validation is not None:
- ET.SubElement(arg, "validation").text = self.validation
-
- # add all other subelements to this Argument, represented by (tag, text)
- subelements = [
- ("data_type", self.data_type),
- ("required_on_edit", self.required_on_edit),
- ("required_on_create", self.required_on_create)
- ]
-
- for name, value in subelements:
- ET.SubElement(arg, name).text = str(value).lower()
-
- return arg
diff --git a/lib/splunklib/modularinput/event.py b/lib/splunklib/modularinput/event.py
deleted file mode 100644
index 7ee7266..0000000
--- a/lib/splunklib/modularinput/event.py
+++ /dev/null
@@ -1,111 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 io import TextIOBase
-import xml.etree.ElementTree as ET
-
-from splunklib.utils import ensure_str
-
-
-class Event:
- """Represents an event or fragment of an event to be written by this modular input to Splunk.
-
- To write an input to a stream, call the ``write_to`` function, passing in a stream.
- """
- def __init__(self, data=None, stanza=None, time=None, host=None, index=None, source=None,
- sourcetype=None, done=True, unbroken=True):
- """There are no required parameters for constructing an Event
-
- **Example with minimal configuration**::
-
- my_event = Event(
- data="This is a test of my new event.",
- stanza="myStanzaName",
- time="%.3f" % 1372187084.000
- )
-
- **Example with full configuration**::
-
- excellent_event = Event(
- data="This is a test of my excellent event.",
- stanza="excellenceOnly",
- time="%.3f" % 1372274622.493,
- host="localhost",
- index="main",
- source="Splunk",
- sourcetype="misc",
- done=True,
- unbroken=True
- )
-
- :param data: ``string``, the event's text.
- :param stanza: ``string``, name of the input this event should be sent to.
- :param time: ``float``, time in seconds, including up to 3 decimal places to represent milliseconds.
- :param host: ``string``, the event's host, ex: localhost.
- :param index: ``string``, the index this event is specified to write to, or None if default index.
- :param source: ``string``, the source of this event, or None to have Splunk guess.
- :param sourcetype: ``string``, source type currently set on this event, or None to have Splunk guess.
- :param done: ``boolean``, is this a complete ``Event``? False if an ``Event`` fragment.
- :param unbroken: ``boolean``, Is this event completely encapsulated in this ``Event`` object?
- """
- self.data = data
- self.done = done
- self.host = host
- self.index = index
- self.source = source
- self.sourceType = sourcetype
- self.stanza = stanza
- self.time = time
- self.unbroken = unbroken
-
- def write_to(self, stream):
- """Write an XML representation of self, an ``Event`` object, to the given stream.
-
- The ``Event`` object will only be written if its data field is defined,
- otherwise a ``ValueError`` is raised.
-
- :param stream: stream to write XML to.
- """
- if self.data is None:
- raise ValueError("Events must have at least the data field set to be written to XML.")
-
- event = ET.Element("event")
- if self.stanza is not None:
- event.set("stanza", self.stanza)
- event.set("unbroken", str(int(self.unbroken)))
-
- # if a time isn't set, let Splunk guess by not creating a element
- if self.time is not None:
- ET.SubElement(event, "time").text = str(self.time)
-
- # add all other subelements to this Event, represented by (tag, text)
- subelements = [
- ("source", self.source),
- ("sourcetype", self.sourceType),
- ("index", self.index),
- ("host", self.host),
- ("data", self.data)
- ]
- for node, value in subelements:
- if value is not None:
- ET.SubElement(event, node).text = value
-
- if self.done:
- ET.SubElement(event, "done")
-
- if isinstance(stream, TextIOBase):
- stream.write(ensure_str(ET.tostring(event)))
- else:
- stream.write(ET.tostring(event))
- stream.flush()
diff --git a/lib/splunklib/modularinput/event_writer.py b/lib/splunklib/modularinput/event_writer.py
deleted file mode 100644
index 7be3845..0000000
--- a/lib/splunklib/modularinput/event_writer.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 sys
-import traceback
-
-from splunklib.utils import ensure_str
-from .event import ET
-
-
-class EventWriter:
- """``EventWriter`` writes events and error messages to Splunk from a modular input.
- Its two important methods are ``writeEvent``, which takes an ``Event`` object,
- and ``log``, which takes a severity and an error message.
- """
-
- # Severities that Splunk understands for log messages from modular inputs.
- # Do not change these
- DEBUG = "DEBUG"
- INFO = "INFO"
- WARN = "WARN"
- ERROR = "ERROR"
- FATAL = "FATAL"
-
- def __init__(self, output = sys.stdout, error = sys.stderr):
- """
- :param output: Where to write the output; defaults to sys.stdout.
- :param error: Where to write any errors; defaults to sys.stderr.
- """
- self._out = output
- self._err = error
-
- # has the opening tag been written yet?
- self.header_written = False
-
- def write_event(self, event):
- """Writes an ``Event`` object to Splunk.
-
- :param event: An ``Event`` object.
- """
-
- if not self.header_written:
- self._out.write("")
- self.header_written = True
-
- event.write_to(self._out)
-
- def log(self, severity, message):
- """Logs messages about the state of this modular input to Splunk.
- These messages will show up in Splunk's internal logs.
-
- :param severity: ``string``, severity of message, see severities defined as class constants.
- :param message: ``string``, message to log.
- """
-
- self._err.write(f"{severity} {message}\n")
- self._err.flush()
-
- def log_exception(self, message, exception=None, severity=None):
- """Logs messages about the exception thrown by this modular input to Splunk.
- These messages will show up in Splunk's internal logs.
-
- :param message: ``string``, message to log.
- :param exception: ``Exception``, exception thrown by this modular input; if none, sys.exc_info() is used
- :param severity: ``string``, severity of message, see severities defined as class constants. Default severity: ERROR
- """
- if exception is not None:
- tb_str = traceback.format_exception(type(exception), exception, exception.__traceback__)
- else:
- tb_str = traceback.format_exc()
-
- if severity is None:
- severity = EventWriter.ERROR
-
- self._err.write(("%s %s - %s" % (severity, message, tb_str)).replace("\n", " "))
- self._err.flush()
-
- def write_xml_document(self, document):
- """Writes a string representation of an
- ``ElementTree`` object to the output stream.
-
- :param document: An ``ElementTree`` object.
- """
- self._out.write(ensure_str(ET.tostring(document), errors="replace"))
- self._out.flush()
-
- def close(self):
- """Write the closing tag to make this XML well formed."""
- if self.header_written:
- self._out.write(" ")
- self._out.flush()
diff --git a/lib/splunklib/modularinput/input_definition.py b/lib/splunklib/modularinput/input_definition.py
deleted file mode 100644
index 190192f..0000000
--- a/lib/splunklib/modularinput/input_definition.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 xml.etree.ElementTree as ET
-from .utils import parse_xml_data
-
-class InputDefinition:
- """``InputDefinition`` encodes the XML defining inputs that Splunk passes to
- a modular input script.
-
- **Example**::
-
- i = InputDefinition()
-
- """
- def __init__ (self):
- self.metadata = {}
- self.inputs = {}
-
- def __eq__(self, other):
- if not isinstance(other, InputDefinition):
- return False
- return self.metadata == other.metadata and self.inputs == other.inputs
-
- @staticmethod
- def parse(stream):
- """Parse a stream containing XML into an ``InputDefinition``.
-
- :param stream: stream containing XML to parse.
- :return: definition: an ``InputDefinition`` object.
- """
- definition = InputDefinition()
-
- # parse XML from the stream, then get the root node
- root = ET.parse(stream).getroot()
-
- for node in root:
- if node.tag == "configuration":
- # get config for each stanza
- definition.inputs = parse_xml_data(node, "stanza")
- else:
- definition.metadata[node.tag] = node.text
-
- return definition
diff --git a/lib/splunklib/modularinput/scheme.py b/lib/splunklib/modularinput/scheme.py
deleted file mode 100644
index a3b0868..0000000
--- a/lib/splunklib/modularinput/scheme.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 xml.etree.ElementTree as ET
-
-
-class Scheme:
- """Class representing the metadata for a modular input kind.
-
- A ``Scheme`` specifies a title, description, several options of how Splunk should run modular inputs of this
- kind, and a set of arguments which define a particular modular input's properties.
-
- The primary use of ``Scheme`` is to abstract away the construction of XML to feed to Splunk.
- """
-
- # Constant values, do not change
- # These should be used for setting the value of a Scheme object's streaming_mode field.
- streaming_mode_simple = "SIMPLE"
- streaming_mode_xml = "XML"
-
- def __init__(self, title):
- """
- :param title: ``string`` identifier for this Scheme in Splunk.
- """
- self.title = title
- self.description = None
- self.use_external_validation = True
- self.use_single_instance = False
- self.streaming_mode = Scheme.streaming_mode_xml
-
- # list of Argument objects, each to be represented by an tag
- self.arguments = []
-
- def add_argument(self, arg):
- """Add the provided argument, ``arg``, to the ``self.arguments`` list.
-
- :param arg: An ``Argument`` object to add to ``self.arguments``.
- """
- self.arguments.append(arg)
-
- def to_xml(self):
- """Creates an ``ET.Element`` representing self, then returns it.
-
- :returns: an ``ET.Element`` representing this scheme.
- """
- root = ET.Element("scheme")
-
- ET.SubElement(root, "title").text = self.title
-
- # add a description subelement if it's defined
- if self.description is not None:
- ET.SubElement(root, "description").text = self.description
-
- # add all other subelements to this Scheme, represented by (tag, text)
- subelements = [
- ("use_external_validation", self.use_external_validation),
- ("use_single_instance", self.use_single_instance),
- ("streaming_mode", self.streaming_mode)
- ]
- for name, value in subelements:
- ET.SubElement(root, name).text = str(value).lower()
-
- endpoint = ET.SubElement(root, "endpoint")
-
- args = ET.SubElement(endpoint, "args")
-
- # add arguments as subelements to the element
- for arg in self.arguments:
- arg.add_to_document(args)
-
- return root
diff --git a/lib/splunklib/modularinput/script.py b/lib/splunklib/modularinput/script.py
deleted file mode 100644
index a6c9619..0000000
--- a/lib/splunklib/modularinput/script.py
+++ /dev/null
@@ -1,167 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 abc import ABCMeta, abstractmethod
-import sys
-import xml.etree.ElementTree as ET
-from urllib.parse import urlsplit
-
-from ..client import Service
-from .event_writer import EventWriter
-from .input_definition import InputDefinition
-from .validation_definition import ValidationDefinition
-
-
-class Script(metaclass=ABCMeta):
- """An abstract base class for implementing modular inputs.
-
- Subclasses should override ``get_scheme``, ``stream_events``,
- and optionally ``validate_input`` if the modular input uses
- external validation.
-
- The ``run`` function is used to run modular inputs; it typically should
- not be overridden.
- """
-
- def __init__(self):
- self._input_definition = None
- self._service = None
-
- def run(self, args):
- """Runs this modular input
-
- :param args: List of command line arguments passed to this script.
- :returns: An integer to be used as the exit value of this program.
- """
-
- # call the run_script function, which handles the specifics of running
- # a modular input
- return self.run_script(args, EventWriter(), sys.stdin)
-
- def run_script(self, args, event_writer, input_stream):
- """Handles all the specifics of running a modular input
-
- :param args: List of command line arguments passed to this script.
- :param event_writer: An ``EventWriter`` object for writing events.
- :param input_stream: An input stream for reading inputs.
- :returns: An integer to be used as the exit value of this program.
- """
-
- try:
- if len(args) == 1:
- # This script is running as an input. Input definitions will be
- # passed on stdin as XML, and the script will write events on
- # stdout and log entries on stderr.
- self._input_definition = InputDefinition.parse(input_stream)
- self.stream_events(self._input_definition, event_writer)
- event_writer.close()
- return 0
-
- if str(args[1]).lower() == "--scheme":
- # Splunk has requested XML specifying the scheme for this
- # modular input Return it and exit.
- scheme = self.get_scheme()
- if scheme is None:
- event_writer.log(
- EventWriter.FATAL,
- "Modular input script returned a null scheme.")
- return 1
- event_writer.write_xml_document(scheme.to_xml())
- return 0
-
- if args[1].lower() == "--validate-arguments":
- validation_definition = ValidationDefinition.parse(input_stream)
- try:
- self.validate_input(validation_definition)
- return 0
- except Exception as e:
- root = ET.Element("error")
- ET.SubElement(root, "message").text = str(e)
- event_writer.write_xml_document(root)
-
- return 1
- event_writer.log(EventWriter.ERROR, "Invalid arguments to modular input script:" + ' '.join(
- args))
- return 1
-
- except Exception as e:
- event_writer.log_exception(str(e))
- return 1
-
- @property
- def service(self):
- """ Returns a Splunk service object for this script invocation.
-
- The service object is created from the Splunkd URI and session key
- passed to the command invocation on the modular input stream. It is
- available as soon as the :code:`Script.stream_events` method is
- called.
-
- :return: :class:`splunklib.client.Service`. A value of None is returned,
- if you call this method before the :code:`Script.stream_events` method
- is called.
-
- """
- if self._service is not None:
- return self._service
-
- if self._input_definition is None:
- return None
-
- splunkd_uri = self._input_definition.metadata["server_uri"]
- session_key = self._input_definition.metadata["session_key"]
-
- splunkd = urlsplit(splunkd_uri, allow_fragments=False)
-
- self._service = Service(
- scheme=splunkd.scheme,
- host=splunkd.hostname,
- port=splunkd.port,
- token=session_key,
- )
-
- return self._service
-
- @abstractmethod
- def get_scheme(self):
- """The scheme defines the parameters understood by this modular input.
-
- :return: a ``Scheme`` object representing the parameters for this modular input.
- """
-
- def validate_input(self, definition):
- """Handles external validation for modular input kinds.
-
- When Splunk calls a modular input script in validation mode, it will
- pass in an XML document giving information about the Splunk instance (so
- you can call back into it if needed) and the name and parameters of the
- proposed input.
-
- If this function does not throw an exception, the validation is assumed
- to succeed. Otherwise any errors thrown will be turned into a string and
- logged back to Splunk.
-
- The default implementation always passes.
-
- :param definition: The parameters for the proposed input passed by splunkd.
- """
-
- @abstractmethod
- def stream_events(self, inputs, ew):
- """The method called to stream events into Splunk. It should do all of its output via
- EventWriter rather than assuming that there is a console attached.
-
- :param inputs: An ``InputDefinition`` object.
- :param ew: An object with methods to write events and log messages to Splunk.
- """
diff --git a/lib/splunklib/modularinput/utils.py b/lib/splunklib/modularinput/utils.py
deleted file mode 100644
index dad73dd..0000000
--- a/lib/splunklib/modularinput/utils.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-# File for utility functions
-
-
-def xml_compare(expected, found):
- """Checks equality of two ``ElementTree`` objects.
-
- :param expected: An ``ElementTree`` object.
- :param found: An ``ElementTree`` object.
- :return: ``Boolean``, whether the two objects are equal.
- """
-
- # if comparing the same ET object
- if expected == found:
- return True
-
- # compare element attributes, ignoring order
- if set(expected.items()) != set(found.items()):
- return False
-
- # check for equal number of children
- expected_children = list(expected)
- found_children = list(found)
- if len(expected_children) != len(found_children):
- return False
-
- # compare children
- if not all(xml_compare(a, b) for a, b in zip(expected_children, found_children)):
- return False
-
- # compare elements, if there is no text node, return True
- if (expected.text is None or expected.text.strip() == "") \
- and (found.text is None or found.text.strip() == ""):
- return True
- return expected.tag == found.tag and expected.text == found.text \
- and expected.attrib == found.attrib
-
-def parse_parameters(param_node):
- if param_node.tag == "param":
- return param_node.text
- if param_node.tag == "param_list":
- parameters = []
- for mvp in param_node:
- parameters.append(mvp.text)
- return parameters
- raise ValueError(f"Invalid configuration scheme, {param_node.tag} tag unexpected.")
-
-def parse_xml_data(parent_node, child_node_tag):
- data = {}
- for child in parent_node:
- child_name = child.get("name")
- if child.tag == child_node_tag:
- if child_node_tag == "stanza":
- data[child_name] = {
- "__app": child.get("app", None)
- }
- for param in child:
- data[child_name][param.get("name")] = parse_parameters(param)
- elif "item" == parent_node.tag:
- data[child_name] = parse_parameters(child)
- return data
diff --git a/lib/splunklib/modularinput/validation_definition.py b/lib/splunklib/modularinput/validation_definition.py
deleted file mode 100644
index b71e1e7..0000000
--- a/lib/splunklib/modularinput/validation_definition.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 xml.etree.ElementTree as ET
-
-from .utils import parse_xml_data
-
-
-class ValidationDefinition:
- """This class represents the XML sent by Splunk for external validation of a
- new modular input.
-
- **Example**::
-
- v = ValidationDefinition()
-
- """
- def __init__(self):
- self.metadata = {}
- self.parameters = {}
-
- def __eq__(self, other):
- if not isinstance(other, ValidationDefinition):
- return False
- return self.metadata == other.metadata and self.parameters == other.parameters
-
- @staticmethod
- def parse(stream):
- """Creates a ``ValidationDefinition`` from a provided stream containing XML.
-
- The XML typically will look like this:
-
- .. code-block:: xml
-
-
- myHost
- https://127.0.0.1:8089
- 123102983109283019283
- /opt/splunk/var/lib/splunk/modinputs
- -
-
- value2
- value3
- value4
-
-
-
-
- :param stream: ``Stream`` containing XML to parse.
- :return: A ``ValidationDefinition`` object.
-
- """
-
- definition = ValidationDefinition()
-
- # parse XML from the stream, then get the root node
- root = ET.parse(stream).getroot()
-
- for node in root:
- # lone item node
- if node.tag == "item":
- # name from item node
- definition.metadata["name"] = node.get("name")
- definition.parameters = parse_xml_data(node, "")
- else:
- # Store anything else in metadata
- definition.metadata[node.tag] = node.text
-
- return definition
diff --git a/lib/splunklib/results.py b/lib/splunklib/results.py
deleted file mode 100644
index 30476c8..0000000
--- a/lib/splunklib/results.py
+++ /dev/null
@@ -1,343 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-"""The **splunklib.results** module provides a streaming XML reader for Splunk
-search results.
-
-Splunk search results can be returned in a variety of formats including XML,
-JSON, and CSV. To make it easier to stream search results in XML format, they
-are returned as a stream of XML *fragments*, not as a single XML document. This
-module supports incrementally reading one result record at a time from such a
-result stream. This module also provides a friendly iterator-based interface for
-accessing search results while avoiding buffering the result set, which can be
-very large.
-
-To use the reader, instantiate :class:`JSONResultsReader` on a search result stream
-as follows:::
-
- reader = ResultsReader(result_stream)
- for item in reader:
- print(item)
- print(f"Results are a preview: {reader.is_preview}")
-"""
-
-from io import BufferedReader, BytesIO
-
-
-import xml.etree.ElementTree as et
-
-from collections import OrderedDict
-from json import loads as json_loads
-
-__all__ = [
- "ResultsReader",
- "Message",
- "JSONResultsReader"
-]
-
-import deprecation
-
-
-class Message:
- """This class represents informational messages that Splunk interleaves in the results stream.
-
- ``Message`` takes two arguments: a string giving the message type (e.g., "DEBUG"), and
- a string giving the message itself.
-
- **Example**::
-
- m = Message("DEBUG", "There's something in that variable...")
- """
-
- def __init__(self, type_, message):
- self.type = type_
- self.message = message
-
- def __repr__(self):
- return f"{self.type}: {self.message}"
-
- def __eq__(self, other):
- return (self.type, self.message) == (other.type, other.message)
-
- def __hash__(self):
- return hash((self.type, self.message))
-
-
-class _ConcatenatedStream:
- """Lazily concatenate zero or more streams into a stream.
-
- As you read from the concatenated stream, you get characters from
- each stream passed to ``_ConcatenatedStream``, in order.
-
- **Example**::
-
- from StringIO import StringIO
- s = _ConcatenatedStream(StringIO("abc"), StringIO("def"))
- assert s.read() == "abcdef"
- """
-
- def __init__(self, *streams):
- self.streams = list(streams)
-
- def read(self, n=None):
- """Read at most *n* characters from this stream.
-
- If *n* is ``None``, return all available characters.
- """
- response = b""
- while len(self.streams) > 0 and (n is None or n > 0):
- txt = self.streams[0].read(n)
- response += txt
- if n is not None:
- n -= len(txt)
- if n is None or n > 0:
- del self.streams[0]
- return response
-
-
-class _XMLDTDFilter:
- """Lazily remove all XML DTDs from a stream.
-
- All substrings matching the regular expression ]*> are
- removed in their entirety from the stream. No regular expressions
- are used, however, so everything still streams properly.
-
- **Example**::
-
- from StringIO import StringIO
- s = _XMLDTDFilter(" element to make the parser happy.
- stream = _XMLDTDFilter(stream)
- stream = _ConcatenatedStream(BytesIO(b""), stream, BytesIO(b" "))
- self.is_preview = None
- self._gen = self._parse_results(stream)
-
- def __iter__(self):
- return self
-
- def __next__(self):
- return next(self._gen)
-
-
- def _parse_results(self, stream):
- """Parse results and messages out of *stream*."""
- result = None
- values = None
- try:
- for event, elem in et.iterparse(stream, events=('start', 'end')):
- if elem.tag == 'results' and event == 'start':
- # The wrapper element is a . We
- # don't care about it except to tell is whether these
- # are preview results, or the final results from the
- # search.
- is_preview = elem.attrib['preview'] == '1'
- self.is_preview = is_preview
- if elem.tag == 'result':
- if event == 'start':
- result = OrderedDict()
- elif event == 'end':
- yield result
- result = None
- elem.clear()
-
- elif elem.tag == 'field' and result is not None:
- # We need the 'result is not None' check because
- # 'field' is also the element name in the `__
-
- 2. `Create Custom Search Commands with commands.conf.spec `_
-
- 3. `Configure seach assistant with searchbnf.conf `_
-
- 4. `Control search distribution with distsearch.conf `_
-
-"""
-
-from .environment import *
-from .decorators import *
-from .validators import *
-
-from .generating_command import GeneratingCommand
-from .streaming_command import StreamingCommand
-from .eventing_command import EventingCommand
-from .reporting_command import ReportingCommand
-
-from .external_search_command import execute, ExternalSearchCommand
-from .search_command import dispatch, SearchMetric
diff --git a/lib/splunklib/searchcommands/decorators.py b/lib/splunklib/searchcommands/decorators.py
deleted file mode 100644
index 1393d78..0000000
--- a/lib/splunklib/searchcommands/decorators.py
+++ /dev/null
@@ -1,442 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 collections import OrderedDict
-from inspect import getmembers, isclass, isfunction
-
-
-from .internals import ConfigurationSettingsType, json_encode_string
-from .validators import OptionName
-
-
-class Configuration:
- """ Defines the configuration settings for a search command.
-
- Documents, validates, and ensures that only relevant configuration settings are applied. Adds a :code:`name` class
- variable to search command classes that don't have one. The :code:`name` is derived from the name of the class.
- By convention command class names end with the word "Command". To derive :code:`name` the word "Command" is removed
- from the end of the class name and then converted to lower case for conformance with the `Search command style guide
- `__
-
- """
- def __init__(self, o=None, **kwargs):
- #
- # The o argument enables the configuration decorator to be used with or without parentheses. For example, it
- # enables you to write code that looks like this:
- #
- # @Configuration
- # class Foo(SearchCommand):
- # ...
- #
- # @Configuration()
- # class Bar(SearchCommand):
- # ...
- #
- # Without the o argument, the Python compiler will complain about the first form. With the o argument, both
- # forms work. The first form provides a value for o: Foo. The second form does does not provide a value for o.
- # The class or method decorated is not passed to the constructor. A value of None is passed instead.
- #
- self.settings = kwargs
-
- def __call__(self, o):
-
- if isfunction(o):
- # We must wait to finalize configuration as the class containing this function is under construction
- # at the time this call to decorate a member function. This will be handled in the call to
- # o.ConfigurationSettings.fix_up(o) in the elif clause of this code block.
- o._settings = self.settings
- elif isclass(o):
-
- # Set command name
-
- name = o.__name__
- if name.endswith('Command'):
- name = name[:-len('Command')]
- o.name = str(name.lower())
-
- # Construct ConfigurationSettings instance for the command class
-
- o.ConfigurationSettings = ConfigurationSettingsType(
- module=o.__module__ + '.' + o.__name__,
- name='ConfigurationSettings',
- bases=(o.ConfigurationSettings,))
-
- ConfigurationSetting.fix_up(o.ConfigurationSettings, self.settings)
- o.ConfigurationSettings.fix_up(o)
- Option.fix_up(o)
- else:
- raise TypeError(f'Incorrect usage: Configuration decorator applied to {type(o)}')
-
- return o
-
-
-class ConfigurationSetting(property):
- """ Generates a :class:`property` representing the named configuration setting
-
- This is a convenience function designed to reduce the amount of boiler-plate code you must write; most notably for
- property setters.
-
- :param name: Configuration setting name.
- :type name: str or unicode
-
- :param doc: A documentation string.
- :type doc: bytes, unicode or NoneType
-
- :param readonly: If true, specifies that the configuration setting is fixed.
- :type name: bool or NoneType
-
- :param value: Configuration setting value.
-
- :return: A :class:`property` instance representing the configuration setting.
- :rtype: property
-
- """
- def __init__(self, fget=None, fset=None, fdel=None, doc=None, name=None, readonly=None, value=None):
- property.__init__(self, fget=fget, fset=fset, fdel=fdel, doc=doc)
- self._readonly = readonly
- self._value = value
- self._name = name
-
- def __call__(self, function):
- return self.getter(function)
-
- def deleter(self, function):
- return self._copy_extra_attributes(property.deleter(self, function))
-
- def getter(self, function):
- return self._copy_extra_attributes(property.getter(self, function))
-
- def setter(self, function):
- return self._copy_extra_attributes(property.setter(self, function))
-
- @staticmethod
- def fix_up(cls, values):
-
- is_configuration_setting = lambda attribute: isinstance(attribute, ConfigurationSetting)
- definitions = getmembers(cls, is_configuration_setting)
- i = 0
-
- for name, setting in definitions:
-
- if setting._name is None:
- setting._name = name = str(name)
- else:
- name = setting._name
-
- validate, specification = setting._get_specification()
- backing_field_name = '_' + name
-
- if setting.fget is None and setting.fset is None and setting.fdel is None:
-
- value = setting._value
-
- if setting._readonly or value is not None:
- validate(specification, name, value)
-
- def fget(bfn, value):
- return lambda this: getattr(this, bfn, value)
-
- setting = setting.getter(fget(backing_field_name, value))
-
- if not setting._readonly:
-
- def fset(bfn, validate, specification, name):
- return lambda this, value: setattr(this, bfn, validate(specification, name, value))
-
- setting = setting.setter(fset(backing_field_name, validate, specification, name))
-
- setattr(cls, name, setting)
-
- def is_supported_by_protocol(supporting_protocols):
-
- def is_supported_by_protocol(version):
- return version in supporting_protocols
-
- return is_supported_by_protocol
-
- del setting._name, setting._value, setting._readonly
-
- setting.is_supported_by_protocol = is_supported_by_protocol(specification.supporting_protocols)
- setting.supporting_protocols = specification.supporting_protocols
- setting.backing_field_name = backing_field_name
- definitions[i] = setting
- setting.name = name
-
- i += 1
-
- try:
- value = values[name]
- except KeyError:
- continue
-
- if setting.fset is None:
- raise ValueError(f'The value of configuration setting {name} is fixed')
-
- setattr(cls, backing_field_name, validate(specification, name, value))
- del values[name]
-
- if len(values) > 0:
- settings = sorted(list(values.items()))
- settings = [f'{n_v[0]}={n_v[1]}' for n_v in settings]
- raise AttributeError('Inapplicable configuration settings: ' + ', '.join(settings))
-
- cls.configuration_setting_definitions = definitions
-
- def _copy_extra_attributes(self, other):
- other._readonly = self._readonly
- other._value = self._value
- other._name = self._name
- return other
-
- def _get_specification(self):
-
- name = self._name
-
- try:
- specification = ConfigurationSettingsType.specification_matrix[name]
- except KeyError:
- raise AttributeError(f'Unknown configuration setting: {name}={repr(self._value)}')
-
- return ConfigurationSettingsType.validate_configuration_setting, specification
-
-
-class Option(property):
- """ Represents a search command option.
-
- Required options must be specified on the search command line.
-
- **Example:**
-
- Short form (recommended). When you are satisfied with built-in or custom validation behaviors.
-
- .. code-block:: python
- :linenos:
-
- from splunklib.searchcommands.decorators import Option
- from splunklib.searchcommands.validators import Fieldname
-
- total = Option(
- doc=''' **Syntax:** **total=****
- **Description:** Name of the field that will hold the computed
- sum''',
- require=True, validate=Fieldname())
-
- **Example:**
-
- Long form. Useful when you wish to manage the option value and its deleter/getter/setter side-effects yourself. You
- must provide a getter and a setter. If your :code:`Option` requires `destruction `_ you must
- also provide a deleter. You must be prepared to accept a value of :const:`None` which indicates that your
- :code:`Option` is unset.
-
- .. code-block:: python
- :linenos:
-
- from splunklib.searchcommands import Option
-
- @Option()
- def logging_configuration(self):
- \""" **Syntax:** logging_configuration=
- **Description:** Loads an alternative logging configuration file for a command invocation. The logging
- configuration file must be in Python ConfigParser-format. The ** name and all path names specified in
- configuration are relative to the app root directory.
-
- \"""
- return self._logging_configuration
-
- @logging_configuration.setter
- def logging_configuration(self, value):
- if value is not None
- logging.configure(value)
- self._logging_configuration = value
-
- def __init__(self)
- self._logging_configuration = None
-
- """
- def __init__(self, fget=None, fset=None, fdel=None, doc=None, name=None, default=None, require=None, validate=None):
- property.__init__(self, fget, fset, fdel, doc)
- self.name = name
- self.default = default
- self.validate = validate
- self.require = bool(require)
-
- def __call__(self, function):
- return self.getter(function)
-
- # region Methods
-
- def deleter(self, function):
- return self._copy_extra_attributes(property.deleter(self, function))
-
- def getter(self, function):
- return self._copy_extra_attributes(property.getter(self, function))
-
- def setter(self, function):
- return self._copy_extra_attributes(property.setter(self, function))
-
- @classmethod
- def fix_up(cls, command_class):
-
- is_option = lambda attribute: isinstance(attribute, Option)
- definitions = getmembers(command_class, is_option)
- validate_option_name = OptionName()
- i = 0
-
- for name, option in definitions:
-
- if option.name is None:
- option.name = name # no validation required
- else:
- validate_option_name(option.name)
-
- if option.fget is None and option.fset is None and option.fdel is None:
- backing_field_name = '_' + name
-
- def fget(bfn):
- return lambda this: getattr(this, bfn, None)
-
- option = option.getter(fget(backing_field_name))
-
- def fset(bfn, validate):
- if validate is None:
- return lambda this, value: setattr(this, bfn, value)
- return lambda this, value: setattr(this, bfn, validate(value))
-
- option = option.setter(fset(backing_field_name, option.validate))
- setattr(command_class, name, option)
-
- elif option.validate is not None:
-
- def fset(function, validate):
- return lambda this, value: function(this, validate(value))
-
- option = option.setter(fset(option.fset, option.validate))
- setattr(command_class, name, option)
-
- definitions[i] = name, option
- i += 1
-
- command_class.option_definitions = definitions
-
- def _copy_extra_attributes(self, other):
- other.name = self.name
- other.default = self.default
- other.require = self.require
- other.validate = self.validate
- return other
-
- # endregion
-
- # region Types
-
- class Item:
- """ Presents an instance/class view over a search command `Option`.
-
- This class is used by SearchCommand.process to parse and report on option values.
-
- """
- def __init__(self, command, option):
- self._command = command
- self._option = option
- self._is_set = False
- validator = self.validator
- self._format = str if validator is None else validator.format
-
- def __repr__(self):
- return '(' + repr(self.name) + ', ' + repr(self._format(self.value)) + ')'
-
- def __str__(self):
- value = self.value
- value = 'None' if value is None else json_encode_string(self._format(value))
- return self.name + '=' + value
-
- # region Properties
-
- @property
- def is_required(self):
- return bool(self._option.require)
-
- @property
- def is_set(self):
- """ Indicates whether an option value was provided as argument.
-
- """
- return self._is_set
-
- @property
- def name(self):
- return self._option.name
-
- @property
- def validator(self):
- return self._option.validate
-
- @property
- def value(self):
- return self._option.__get__(self._command)
-
- @value.setter
- def value(self, value):
- self._option.__set__(self._command, value)
- self._is_set = True
-
- # endregion
-
- # region Methods
-
- def reset(self):
- self._option.__set__(self._command, self._option.default)
- self._is_set = False
-
- # endregion
-
- class View(OrderedDict):
- """ Presents an ordered dictionary view of the set of :class:`Option` arguments to a search command.
-
- This class is used by SearchCommand.process to parse and report on option values.
-
- """
- def __init__(self, command):
- definitions = type(command).option_definitions
- item_class = Option.Item
- OrderedDict.__init__(self, ((option.name, item_class(command, option)) for (name, option) in definitions))
-
- def __repr__(self):
- text = 'Option.View([' + ','.join([repr(item) for item in self.values()]) + '])'
- return text
-
- def __str__(self):
- text = ' '.join([str(item) for item in self.values() if item.is_set])
- return text
-
- # region Methods
-
- def get_missing(self):
- missing = [item.name for item in self.values() if item.is_required and not item.is_set]
- return missing if len(missing) > 0 else None
-
- def reset(self):
- for value in self.values():
- value.reset()
-
- # endregion
-
-
- # endregion
-
-
-__all__ = ['Configuration', 'Option']
diff --git a/lib/splunklib/searchcommands/environment.py b/lib/splunklib/searchcommands/environment.py
deleted file mode 100644
index 35f1dea..0000000
--- a/lib/splunklib/searchcommands/environment.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 logging import getLogger, root, StreamHandler
-from logging.config import fileConfig
-from os import chdir, environ, path, getcwd
-import sys
-
-
-
-def configure_logging(logger_name, filename=None):
- """ Configure logging and return the named logger and the location of the logging configuration file loaded.
-
- This function expects a Splunk app directory structure::
-
-
- bin
- ...
- default
- ...
- local
- ...
-
- This function looks for a logging configuration file at each of these locations, loading the first, if any,
- logging configuration file that it finds::
-
- local/{name}.logging.conf
- default/{name}.logging.conf
- local/logging.conf
- default/logging.conf
-
- The current working directory is set to ** before the logging configuration file is loaded. Hence, paths
- in the logging configuration file are relative to **. The current directory is reset before return.
-
- You may short circuit the search for a logging configuration file by providing an alternative file location in
- `path`. Logging configuration files must be in `ConfigParser format`_.
-
- #Arguments:
-
- :param logger_name: Logger name
- :type logger_name: bytes, unicode
-
- :param filename: Location of an alternative logging configuration file or `None`.
- :type filename: bytes, unicode or NoneType
-
- :returns: The named logger and the location of the logging configuration file loaded.
- :rtype: tuple
-
- .. _ConfigParser format: https://docs.python.org/2/library/logging.config.html#configuration-file-format
-
- """
- if filename is None:
- if logger_name is None:
- probing_paths = [path.join('local', 'logging.conf'), path.join('default', 'logging.conf')]
- else:
- probing_paths = [
- path.join('local', logger_name + '.logging.conf'),
- path.join('default', logger_name + '.logging.conf'),
- path.join('local', 'logging.conf'),
- path.join('default', 'logging.conf')]
- for relative_path in probing_paths:
- configuration_file = path.join(app_root, relative_path)
- if path.exists(configuration_file):
- filename = configuration_file
- break
- elif not path.isabs(filename):
- found = False
- for conf in 'local', 'default':
- configuration_file = path.join(app_root, conf, filename)
- if path.exists(configuration_file):
- filename = configuration_file
- found = True
- break
- if not found:
- raise ValueError(f'Logging configuration file "{filename}" not found in local or default directory')
- elif not path.exists(filename):
- raise ValueError(f'Logging configuration file "{filename}" not found')
-
- if filename is not None:
- global _current_logging_configuration_file
- filename = path.realpath(filename)
-
- if filename != _current_logging_configuration_file:
- working_directory = getcwd()
- chdir(app_root)
- try:
- fileConfig(filename, {'SPLUNK_HOME': splunk_home})
- finally:
- chdir(working_directory)
- _current_logging_configuration_file = filename
-
- if len(root.handlers) == 0:
- root.addHandler(StreamHandler())
-
- return None if logger_name is None else getLogger(logger_name), filename
-
-
-_current_logging_configuration_file = None
-
-splunk_home = path.abspath(path.join(getcwd(), environ.get('SPLUNK_HOME', '')))
-app_file = getattr(sys.modules['__main__'], '__file__', sys.executable)
-app_root = path.dirname(path.abspath(path.dirname(app_file)))
-
-splunklib_logger, logging_configuration = configure_logging('splunklib')
-
-
-__all__ = ['app_file', 'app_root', 'logging_configuration', 'splunk_home', 'splunklib_logger']
diff --git a/lib/splunklib/searchcommands/eventing_command.py b/lib/splunklib/searchcommands/eventing_command.py
deleted file mode 100644
index d42d056..0000000
--- a/lib/splunklib/searchcommands/eventing_command.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 .decorators import ConfigurationSetting
-from .search_command import SearchCommand
-
-
-class EventingCommand(SearchCommand):
- """ Applies a transformation to search results as they travel through the events pipeline.
-
- Eventing commands typically filter, group, order, and/or or augment event records. Examples of eventing commands
- from Splunk's built-in command set include sort_, dedup_, and cluster_. Each execution of an eventing command
- should produce a set of event records that is independently usable by downstream processors.
-
- .. _sort: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Sort
- .. _dedup: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Dedup
- .. _cluster: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Cluster
-
- EventingCommand configuration
- ==============================
-
- You can configure your command for operation under Search Command Protocol (SCP) version 1 or 2. SCP 2 requires
- Splunk 6.3 or later.
-
- """
- # region Methods
-
- def transform(self, records):
- """ Generator function that processes and yields event records to the Splunk events pipeline.
-
- You must override this method.
-
- """
- raise NotImplementedError('EventingCommand.transform(self, records)')
-
- def _execute(self, ifile, process):
- SearchCommand._execute(self, ifile, self.transform)
-
- # endregion
-
- class ConfigurationSettings(SearchCommand.ConfigurationSettings):
- """ Represents the configuration settings that apply to a :class:`EventingCommand`.
-
- """
- # region SCP v1/v2 properties
-
- required_fields = ConfigurationSetting(doc='''
- List of required fields for this search which back-propagates to the generating search.
-
- Setting this value enables selected fields mode under SCP 2. Under SCP 1 you must also specify
- :code:`clear_required_fields=True` to enable selected fields mode. To explicitly select all fields,
- specify a value of :const:`['*']`. No error is generated if a specified field is missing.
-
- Default: :const:`None`, which implicitly selects all fields.
-
- ''')
-
- # endregion
-
- # region SCP v1 properties
-
- clear_required_fields = ConfigurationSetting(doc='''
- :const:`True`, if required_fields represent the *only* fields required.
-
- If :const:`False`, required_fields are additive to any fields that may be required by subsequent commands.
- In most cases, :const:`False` is appropriate for eventing commands.
-
- Default: :const:`False`
-
- ''')
-
- retainsevents = ConfigurationSetting(readonly=True, value=True, doc='''
- :const:`True`, if the command retains events the way the sort/dedup/cluster commands do.
-
- If :const:`False`, the command transforms events the way the stats command does.
-
- Fixed: :const:`True`
-
- ''')
-
- # endregion
-
- # region SCP v2 properties
-
- maxinputs = ConfigurationSetting(doc='''
- Specifies the maximum number of events that can be passed to the command for each invocation.
-
- This limit cannot exceed the value of `maxresultrows` as defined in limits.conf_. Under SCP 1 you must
- specify this value in commands.conf_.
-
- Default: The value of `maxresultrows`.
-
- Supported by: SCP 2
-
- .. _limits.conf: http://docs.splunk.com/Documentation/Splunk/latest/admin/Limitsconf
-
- ''')
-
- type = ConfigurationSetting(readonly=True, value='events', doc='''
- Command type
-
- Fixed: :const:`'events'`.
-
- Supported by: SCP 2
-
- ''')
-
- # endregion
-
- # region Methods
-
- @classmethod
- def fix_up(cls, command):
- """ Verifies :code:`command` class structure.
-
- """
- if command.transform == EventingCommand.transform:
- raise AttributeError('No EventingCommand.transform override')
- SearchCommand.ConfigurationSettings.fix_up(command)
-
- # TODO: Stop looking like a dictionary because we don't obey the semantics
- # N.B.: Does not use Python 2 dict copy semantics
- def iteritems(self):
- iteritems = SearchCommand.ConfigurationSettings.iteritems(self)
- return [(name_value[0], 'events' if name_value[0] == 'type' else name_value[1]) for name_value in iteritems]
-
- # N.B.: Does not use Python 3 dict view semantics
-
- items = iteritems
-
- # endregion
diff --git a/lib/splunklib/searchcommands/external_search_command.py b/lib/splunklib/searchcommands/external_search_command.py
deleted file mode 100644
index a8929f8..0000000
--- a/lib/splunklib/searchcommands/external_search_command.py
+++ /dev/null
@@ -1,224 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 logging import getLogger
-import os
-import sys
-import traceback
-from . import splunklib_logger as logger
-
-
-if sys.platform == 'win32':
- from signal import signal, CTRL_BREAK_EVENT, SIGBREAK, SIGINT, SIGTERM
- from subprocess import Popen
- import atexit
-
-
-
-# P1 [ ] TODO: Add ExternalSearchCommand class documentation
-
-
-class ExternalSearchCommand:
- def __init__(self, path, argv=None, environ=None):
-
- if not isinstance(path, (bytes,str)):
- raise ValueError(f'Expected a string value for path, not {repr(path)}')
-
- self._logger = getLogger(self.__class__.__name__)
- self._path = str(path)
- self._argv = None
- self._environ = None
-
- self.argv = argv
- self.environ = environ
-
- # region Properties
-
- @property
- def argv(self):
- return getattr(self, '_argv')
-
- @argv.setter
- def argv(self, value):
- if not (value is None or isinstance(value, (list, tuple))):
- raise ValueError(f'Expected a list, tuple or value of None for argv, not {repr(value)}')
- self._argv = value
-
- @property
- def environ(self):
- return getattr(self, '_environ')
-
- @environ.setter
- def environ(self, value):
- if not (value is None or isinstance(value, dict)):
- raise ValueError(f'Expected a dictionary value for environ, not {repr(value)}')
- self._environ = value
-
- @property
- def logger(self):
- return self._logger
-
- @property
- def path(self):
- return self._path
-
- # endregion
-
- # region Methods
-
- def execute(self):
- # noinspection PyBroadException
- try:
- if self._argv is None:
- self._argv = os.path.splitext(os.path.basename(self._path))[0]
- self._execute(self._path, self._argv, self._environ)
- except:
- error_type, error, tb = sys.exc_info()
- message = f'Command execution failed: {str(error)}'
- self._logger.error(message + '\nTraceback:\n' + ''.join(traceback.format_tb(tb)))
- sys.exit(1)
-
- if sys.platform == 'win32':
-
- @staticmethod
- def _execute(path, argv=None, environ=None):
- """ Executes an external search command.
-
- :param path: Path to the external search command.
- :type path: unicode
-
- :param argv: Argument list.
- :type argv: list or tuple
- The arguments to the child process should start with the name of the command being run, but this is not
- enforced. A value of :const:`None` specifies that the base name of path name :param:`path` should be used.
-
- :param environ: A mapping which is used to define the environment variables for the new process.
- :type environ: dict or None.
- This mapping is used instead of the current process’s environment. A value of :const:`None` specifies that
- the :data:`os.environ` mapping should be used.
-
- :return: None
-
- """
- search_path = os.getenv('PATH') if environ is None else environ.get('PATH')
- found = ExternalSearchCommand._search_path(path, search_path)
-
- if found is None:
- raise ValueError(f'Cannot find command on path: {path}')
-
- path = found
- logger.debug(f'starting command="{path}", arguments={argv}')
-
- def terminate(signal_number):
- sys.exit(f'External search command is terminating on receipt of signal={signal_number}.')
-
- def terminate_child():
- if p.pid is not None and p.returncode is None:
- logger.debug('terminating command="%s", arguments=%d, pid=%d', path, argv, p.pid)
- os.kill(p.pid, CTRL_BREAK_EVENT)
-
- p = Popen(argv, executable=path, env=environ, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
- atexit.register(terminate_child)
- signal(SIGBREAK, terminate)
- signal(SIGINT, terminate)
- signal(SIGTERM, terminate)
-
- logger.debug('started command="%s", arguments=%s, pid=%d', path, argv, p.pid)
- p.wait()
-
- logger.debug('finished command="%s", arguments=%s, pid=%d, returncode=%d', path, argv, p.pid, p.returncode)
-
- if p.returncode != 0:
- sys.exit(p.returncode)
-
- @staticmethod
- def _search_path(executable, paths):
- """ Locates an executable program file.
-
- :param executable: The name of the executable program to locate.
- :type executable: unicode
-
- :param paths: A list of one or more directory paths where executable programs are located.
- :type paths: unicode
-
- :return:
- :rtype: Path to the executable program located or :const:`None`.
-
- """
- directory, filename = os.path.split(executable)
- extension = os.path.splitext(filename)[1].upper()
- executable_extensions = ExternalSearchCommand._executable_extensions
-
- if directory:
- if len(extension) and extension in executable_extensions:
- return None
- for extension in executable_extensions:
- path = executable + extension
- if os.path.isfile(path):
- return path
- return None
-
- if not paths:
- return None
-
- directories = [directory for directory in paths.split(';') if len(directory)]
-
- if len(directories) == 0:
- return None
-
- if len(extension) and extension in executable_extensions:
- for directory in directories:
- path = os.path.join(directory, executable)
- if os.path.isfile(path):
- return path
- return None
-
- for directory in directories:
- path_without_extension = os.path.join(directory, executable)
- for extension in executable_extensions:
- path = path_without_extension + extension
- if os.path.isfile(path):
- return path
-
- return None
-
- _executable_extensions = ('.COM', '.EXE')
- else:
- @staticmethod
- def _execute(path, argv, environ):
- if environ is None:
- os.execvp(path, argv)
- else:
- os.execvpe(path, argv, environ)
-
- # endregion
-
-
-def execute(path, argv=None, environ=None, command_class=ExternalSearchCommand):
- """
- :param path:
- :type path: basestring
- :param argv:
- :type: argv: list, tuple, or None
- :param environ:
- :type environ: dict
- :param command_class: External search command class to instantiate and execute.
- :type command_class: type
- :return:
- :rtype: None
- """
- assert issubclass(command_class, ExternalSearchCommand)
- command_class(path, argv, environ).execute()
diff --git a/lib/splunklib/searchcommands/generating_command.py b/lib/splunklib/searchcommands/generating_command.py
deleted file mode 100644
index 36b014c..0000000
--- a/lib/splunklib/searchcommands/generating_command.py
+++ /dev/null
@@ -1,379 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 sys
-
-from .decorators import ConfigurationSetting
-from .search_command import SearchCommand
-
-
-# P1 [O] TODO: Discuss generates_timeorder in the class-level documentation for GeneratingCommand
-
-
-class GeneratingCommand(SearchCommand):
- """ Generates events based on command arguments.
-
- Generating commands receive no input and must be the first command on a pipeline. There are three pipelines:
- streams, events, and reports. The streams pipeline generates or processes time-ordered event records on an
- indexer or search head.
-
- Streaming commands filter, modify, or augment event records and can be applied to subsets of index data in a
- parallel manner. An example of a streaming command from Splunk's built-in command set is rex_ which extracts and
- adds fields to event records at search time. Records that pass through the streams pipeline move on to the events
- pipeline.
-
- The events pipeline generates or processes records on a search head. Eventing commands typically filter, group,
- order, or augment event records. Examples of eventing commands from Splunk's built-in command set include sort_,
- dedup_, and cluster_. Each execution of an eventing command should produce a set of event records that is
- independently usable by downstream processors. Records that pass through the events pipeline move on to the reports
- pipeline.
-
- The reports pipeline also runs on a search head, but yields data structures for presentation, not event records.
- Examples of streaming from Splunk's built-in command set include chart_, stats_, and contingency_.
-
- GeneratingCommand configuration
- ===============================
-
- Configure your generating command based on the pipeline that it targets. How you configure your command depends on
- the Search Command Protocol (SCP) version.
-
- +----------+-------------------------------------+--------------------------------------------+
- | Pipeline | SCP 1 | SCP 2 |
- +==========+=====================================+============================================+
- | streams | streaming=True[,local=[True|False]] | type='streaming'[,distributed=[true|false] |
- +----------+-------------------------------------+--------------------------------------------+
- | events | retainsevents=True, streaming=False | type='events' |
- +----------+-------------------------------------+--------------------------------------------+
- | reports | streaming=False | type='reporting' |
- +----------+-------------------------------------+--------------------------------------------+
-
- Only streaming commands may be distributed to indexers. By default generating commands are configured to run
- locally in the streams pipeline and will run under either SCP 1 or SCP 2.
-
- .. code-block:: python
-
- @Configuration()
- class StreamingGeneratingCommand(GeneratingCommand)
- ...
-
- How you configure your command to run on a different pipeline or in a distributed fashion depends on what SCP
- protocol versions you wish to support. You must be sure to configure your command consistently for each protocol,
- if you wish to support both protocol versions correctly.
-
- .. _chart: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Chart
- .. _cluster: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Cluster
- .. _contingency: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Contingency
- .. _dedup: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Dedup
- .. _rex: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Rex
- .. _sort: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Sort
- .. _stats: http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Stats
-
- Distributed Generating command
- ==============================
-
- Commands configured like this will run as the first command on search heads and/or indexers on the streams pipeline.
-
- +----------+---------------------------------------------------+---------------------------------------------------+
- | Pipeline | SCP 1 | SCP 2 |
- +==========+===================================================+===================================================+
- | streams | 1. Add this line to your command's stanza in | 1. Add this configuration setting to your code: |
- | | | |
- | | default/commands.conf:: | .. code-block:: python |
- | | | |
- | | local = false | @Configuration(distributed=True) |
- | | | class SomeCommand(GeneratingCommand) |
- | | | ... |
- | | 2. Restart splunk | |
- | | | 2. You are good to go; no need to restart Splunk |
- +----------+---------------------------------------------------+---------------------------------------------------+
-
- Eventing Generating command
- ===========================
-
- Generating commands configured like this will run as the first command on a search head on the events pipeline.
-
- +----------+---------------------------------------------------+---------------------------------------------------+
- | Pipeline | SCP 1 | SCP 2 |
- +==========+===================================================+===================================================+
- | events | You have a choice. Add these configuration | Add this configuration setting to your command |
- | | settings to your command class: | setting to your command class: |
- | | | |
- | | .. code-block:: python | .. code-block:: python |
- | | | |
- | | @Configuration( | @Configuration(type='events') |
- | | retainsevents=True, streaming=False) | class SomeCommand(GeneratingCommand) |
- | | class SomeCommand(GeneratingCommand) | ... |
- | | ... | |
- | | | |
- | | Or add these lines to default/commands.conf: | |
- | | | |
- | | .. code-block:: text | |
- | | | |
- | | retainsevents = true | |
- | | streaming = false | |
- +----------+---------------------------------------------------+---------------------------------------------------+
-
- Configure your command class like this, if you wish to support both protocols:
-
- .. code-block:: python
-
- @Configuration(type='events', retainsevents=True, streaming=False)
- class SomeCommand(GeneratingCommand)
- ...
-
- You might also consider adding these lines to commands.conf instead of adding them to your command class:
-
- .. code-block:: python
-
- retainsevents = false
- streaming = false
-
- Reporting Generating command
- ============================
-
- Commands configured like this will run as the first command on a search head on the reports pipeline.
-
- +----------+---------------------------------------------------+---------------------------------------------------+
- | Pipeline | SCP 1 | SCP 2 |
- +==========+===================================================+===================================================+
- | events | You have a choice. Add these configuration | Add this configuration setting to your command |
- | | settings to your command class: | setting to your command class: |
- | | | |
- | | .. code-block:: python | .. code-block:: python |
- | | | |
- | | @Configuration(retainsevents=False) | @Configuration(type='reporting') |
- | | class SomeCommand(GeneratingCommand) | class SomeCommand(GeneratingCommand) |
- | | ... | ... |
- | | | |
- | | Or add this lines to default/commands.conf: | |
- | | | |
- | | .. code-block:: text | |
- | | | |
- | | retainsevents = false | |
- | | streaming = false | |
- +----------+---------------------------------------------------+---------------------------------------------------+
-
- Configure your command class like this, if you wish to support both protocols:
-
- .. code-block:: python
-
- @Configuration(type='reporting', streaming=False)
- class SomeCommand(GeneratingCommand)
- ...
-
- You might also consider adding these lines to commands.conf instead of adding them to your command class:
-
- .. code-block:: text
-
- retainsevents = false
- streaming = false
-
- """
- # region Methods
-
- def generate(self):
- """ A generator that yields records to the Splunk processing pipeline
-
- You must override this method.
-
- """
- raise NotImplementedError('GeneratingCommand.generate(self)')
-
- def _execute(self, ifile, process):
- """ Execution loop
-
- :param ifile: Input file object. Unused.
- :type ifile: file
-
- :return: `None`.
-
- """
- if self._protocol_version == 2:
- self._execute_v2(ifile, self.generate())
- else:
- assert self._protocol_version == 1
- self._record_writer.write_records(self.generate())
- self.finish()
-
- def _execute_chunk_v2(self, process, chunk):
- count = 0
- records = []
- for row in process:
- records.append(row)
- count += 1
- if count == self._record_writer._maxresultrows:
- break
-
- for row in records:
- self._record_writer.write_record(row)
-
- if count == self._record_writer._maxresultrows:
- self._finished = False
- else:
- self._finished = True
-
- def process(self, argv=sys.argv, ifile=sys.stdin, ofile=sys.stdout, allow_empty_input=True):
- """ Process data.
-
- :param argv: Command line arguments.
- :type argv: list or tuple
-
- :param ifile: Input data file.
- :type ifile: file
-
- :param ofile: Output data file.
- :type ofile: file
-
- :param allow_empty_input: For generating commands, it must be true. Doing otherwise will cause an error.
- :type allow_empty_input: bool
-
- :return: :const:`None`
- :rtype: NoneType
-
- """
-
- # Generating commands are expected to run on an empty set of inputs as the first command being run in a search,
- # also this class implements its own separate _execute_chunk_v2 method which does not respect allow_empty_input
- # so ensure that allow_empty_input is always True
-
- if not allow_empty_input:
- raise ValueError("allow_empty_input cannot be False for Generating Commands")
- return super().process(argv=argv, ifile=ifile, ofile=ofile, allow_empty_input=True)
-
- # endregion
-
- # region Types
-
- class ConfigurationSettings(SearchCommand.ConfigurationSettings):
- """ Represents the configuration settings for a :code:`GeneratingCommand` class.
-
- """
- # region SCP v1/v2 Properties
-
- generating = ConfigurationSetting(readonly=True, value=True, doc='''
- Tells Splunk that this command generates events, but does not process inputs.
-
- Generating commands must appear at the front of the search pipeline identified by :meth:`type`.
-
- Fixed: :const:`True`
-
- Supported by: SCP 1, SCP 2
-
- ''')
-
- # endregion
-
- # region SCP v1 Properties
-
- generates_timeorder = ConfigurationSetting(doc='''
- :const:`True`, if the command generates new events.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- local = ConfigurationSetting(doc='''
- :const:`True`, if the command should run locally on the search head.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- retainsevents = ConfigurationSetting(doc='''
- :const:`True`, if the command retains events the way the sort, dedup, and cluster commands do, or whether it
- transforms them the way the stats command does.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- streaming = ConfigurationSetting(doc='''
- :const:`True`, if the command is streamable.
-
- Default: :const:`True`
-
- Supported by: SCP 1
-
- ''')
-
- # endregion
-
- # region SCP v2 Properties
-
- distributed = ConfigurationSetting(value=False, doc='''
- True, if this command should be distributed to indexers.
-
- This value is ignored unless :meth:`type` is equal to :const:`streaming`. It is only this command type that
- may be distributed.
-
- Default: :const:`False`
-
- Supported by: SCP 2
-
- ''')
-
- type = ConfigurationSetting(value='streaming', doc='''
- A command type name.
-
- ==================== ======================================================================================
- Value Description
- -------------------- --------------------------------------------------------------------------------------
- :const:`'events'` Runs as the first command in the Splunk events pipeline. Cannot be distributed.
- :const:`'reporting'` Runs as the first command in the Splunk reports pipeline. Cannot be distributed.
- :const:`'streaming'` Runs as the first command in the Splunk streams pipeline. May be distributed.
- ==================== ======================================================================================
-
- Default: :const:`'streaming'`
-
- Supported by: SCP 2
-
- ''')
-
- # endregion
-
- # region Methods
-
- @classmethod
- def fix_up(cls, command):
- """ Verifies :code:`command` class structure.
-
- """
- if command.generate == GeneratingCommand.generate:
- raise AttributeError('No GeneratingCommand.generate override')
-
- # TODO: Stop looking like a dictionary because we don't obey the semantics
- # N.B.: Does not use Python 2 dict copy semantics
- def iteritems(self):
- iteritems = SearchCommand.ConfigurationSettings.iteritems(self)
- version = self.command.protocol_version
- if version == 2:
- iteritems = [name_value1 for name_value1 in iteritems if name_value1[0] != 'distributed']
- if not self.distributed and self.type == 'streaming':
- iteritems = [(name_value[0], 'stateful') if name_value[0] == 'type' else (name_value[0], name_value[1]) for name_value in iteritems]
- return iteritems
-
- # N.B.: Does not use Python 3 dict view semantics
- items = iteritems
-
- # endregion
-
- # endregion
diff --git a/lib/splunklib/searchcommands/internals.py b/lib/splunklib/searchcommands/internals.py
deleted file mode 100644
index abceac3..0000000
--- a/lib/splunklib/searchcommands/internals.py
+++ /dev/null
@@ -1,825 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 csv
-import gzip
-import os
-import re
-import sys
-import warnings
-import urllib.parse
-from io import TextIOWrapper, StringIO
-from collections import deque, namedtuple
-from collections import OrderedDict
-from itertools import chain
-from json import JSONDecoder, JSONEncoder
-from json.encoder import encode_basestring_ascii as json_encode_string
-
-
-
-
-from . import environment
-
-csv.field_size_limit(10485760) # The default value is 128KB; upping to 10MB. See SPL-12117 for background on this issue
-
-
-def set_binary_mode(fh):
- """ Helper method to set up binary mode for file handles.
- Emphasis being sys.stdin, sys.stdout, sys.stderr.
- For python3, we want to return .buffer
- """
- typefile = TextIOWrapper
- # check for file handle
- if not isinstance(fh, typefile):
- return fh
-
- # check for buffer
- if hasattr(fh, 'buffer'):
- return fh.buffer
- return fh
-
-
-class CommandLineParser:
- r""" Parses the arguments to a search command.
-
- A search command line is described by the following syntax.
-
- **Syntax**::
-
- command = command-name *[wsp option] *[wsp [dquote] field-name [dquote]]
- command-name = alpha *( alpha / digit )
- option = option-name [wsp] "=" [wsp] option-value
- option-name = alpha *( alpha / digit / "_" )
- option-value = word / quoted-string
- word = 1*( %01-%08 / %0B / %0C / %0E-1F / %21 / %23-%FF ) ; Any character but DQUOTE and WSP
- quoted-string = dquote *( word / wsp / "\" dquote / dquote dquote ) dquote
- field-name = ( "_" / alpha ) *( alpha / digit / "_" / "." / "-" )
-
- **Note:**
-
- This syntax is constrained to an 8-bit character set.
-
- **Note:**
-
- This syntax does not show that `field-name` values may be comma-separated when in fact they can be. This is
- because Splunk strips commas from the command line. A custom search command will never see them.
-
- **Example:**
-
- countmatches fieldname = word_count pattern = \w+ some_text_field
-
- Option names are mapped to properties in the targeted ``SearchCommand``. It is the responsibility of the property
- setters to validate the values they receive. Property setters may also produce side effects. For example,
- setting the built-in `log_level` immediately changes the `log_level`.
-
- """
- @classmethod
- def parse(cls, command, argv):
- """ Splits an argument list into an options dictionary and a fieldname
- list.
-
- The argument list, `argv`, must be of the form::
-
- *[option]... *[]
-
- Options are validated and assigned to items in `command.options`. Field names are validated and stored in the
- list of `command.fieldnames`.
-
- #Arguments:
-
- :param command: Search command instance.
- :type command: ``SearchCommand``
- :param argv: List of search command arguments.
- :type argv: ``list``
- :return: ``None``
-
- #Exceptions:
-
- ``SyntaxError``: Argument list is incorrectly formed.
- ``ValueError``: Unrecognized option/field name, or an illegal field value.
-
- """
- debug = environment.splunklib_logger.debug
- command_class = type(command).__name__
-
- # Prepare
-
- debug('Parsing %s command line: %r', command_class, argv)
- command.fieldnames = None
- command.options.reset()
- argv = ' '.join(argv)
-
- command_args = cls._arguments_re.match(argv)
-
- if command_args is None:
- raise SyntaxError(f'Syntax error: {argv}')
-
- # Parse options
-
- for option in cls._options_re.finditer(command_args.group('options')):
- name, value = option.group('name'), option.group('value')
- if name not in command.options:
- raise ValueError(
- f'Unrecognized {command.name} command option: {name}={json_encode_string(value)}')
- command.options[name].value = cls.unquote(value)
-
- missing = command.options.get_missing()
-
- if missing is not None:
- if len(missing) > 1:
- raise ValueError(
- f'Values for these {command.name} command options are required: {", ".join(missing)}')
- raise ValueError(f'A value for {command.name} command option {missing[0]} is required')
-
- # Parse field names
-
- fieldnames = command_args.group('fieldnames')
-
- if fieldnames is None:
- command.fieldnames = []
- else:
- command.fieldnames = [cls.unquote(value.group(0)) for value in cls._fieldnames_re.finditer(fieldnames)]
-
- debug(' %s: %s', command_class, command)
-
- @classmethod
- def unquote(cls, string):
- """ Removes quotes from a quoted string.
-
- Splunk search command quote rules are applied. The enclosing double-quotes, if present, are removed. Escaped
- double-quotes ('\"' or '""') are replaced by a single double-quote ('"').
-
- **NOTE**
-
- We are not using a json.JSONDecoder because Splunk quote rules are different than JSON quote rules. A
- json.JSONDecoder does not recognize a pair of double-quotes ('""') as an escaped quote ('"') and will
- decode single-quoted strings ("'") in addition to double-quoted ('"') strings.
-
- """
- if len(string) == 0:
- return ''
-
- if string[0] == '"':
- if len(string) == 1 or string[-1] != '"':
- raise SyntaxError('Poorly formed string literal: ' + string)
- string = string[1:-1]
-
- if len(string) == 0:
- return ''
-
- def replace(match):
- value = match.group(0)
- if value == '""':
- return '"'
- if len(value) < 2:
- raise SyntaxError('Poorly formed string literal: ' + string)
- return value[1]
-
- result = re.sub(cls._escaped_character_re, replace, string)
- return result
-
- # region Class variables
-
- _arguments_re = re.compile(r"""
- ^\s*
- (?P # Match a leading set of name/value pairs
- (?:
- (?:(?=\w)[^\d]\w*) # name
- \s*=\s* # =
- (?:"(?:\\.|""|[^"])*"|(?:\\.|[^\s"])+)\s* # value
- )*
- )\s*
- (?P # Match a trailing set of field names
- (?:
- (?:"(?:\\.|""|[^"])*"|(?:\\.|[^\s"])+)\s*
- )*
- )\s*$
- """, re.VERBOSE | re.UNICODE)
-
- _escaped_character_re = re.compile(r'(\\.|""|[\\"])')
-
- _fieldnames_re = re.compile(r"""("(?:\\.|""|[^"\\])+"|(?:\\.|[^\s"])+)""")
-
- _options_re = re.compile(r"""
- # Captures a set of name/value pairs when used with re.finditer
- (?P(?:(?=\w)[^\d]\w*)) # name
- \s*=\s* # =
- (?P"(?:\\.|""|[^"])*"|(?:\\.|[^\s"])+) # value
- """, re.VERBOSE | re.UNICODE)
-
- # endregion
-
-
-class ConfigurationSettingsType(type):
- """ Metaclass for constructing ConfigurationSettings classes.
-
- Instances of :class:`ConfigurationSettingsType` construct :class:`ConfigurationSettings` classes from classes from
- a base :class:`ConfigurationSettings` class and a dictionary of configuration settings. The settings in the
- dictionary are validated against the settings in the base class. You cannot add settings, you can only change their
- backing-field values and you cannot modify settings without backing-field values. These are considered fixed
- configuration setting values.
-
- This is an internal class used in two places:
-
- + :meth:`decorators.Configuration.__call__`
-
- Adds a ConfigurationSettings attribute to a :class:`SearchCommand` class.
-
- + :meth:`reporting_command.ReportingCommand.fix_up`
-
- Adds a ConfigurationSettings attribute to a :meth:`ReportingCommand.map` method, if there is one.
-
- """
- def __new__(mcs, module, name, bases):
- mcs = super(ConfigurationSettingsType, mcs).__new__(mcs, str(name), bases, {})
- return mcs
-
- def __init__(cls, module, name, bases):
-
- super(ConfigurationSettingsType, cls).__init__(name, bases, None)
- cls.__module__ = module
-
- @staticmethod
- def validate_configuration_setting(specification, name, value):
- if not isinstance(value, specification.type):
- if isinstance(specification.type, type):
- type_names = specification.type.__name__
- else:
- type_names = ', '.join(map(lambda t: t.__name__, specification.type))
- raise ValueError(f'Expected {type_names} value, not {name}={repr(value)}')
- if specification.constraint and not specification.constraint(value):
- raise ValueError(f'Illegal value: {name}={ repr(value)}')
- return value
-
- specification = namedtuple(
- 'ConfigurationSettingSpecification', (
- 'type',
- 'constraint',
- 'supporting_protocols'))
-
- # P1 [ ] TODO: Review ConfigurationSettingsType.specification_matrix for completeness and correctness
-
- specification_matrix = {
- 'clear_required_fields': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'distributed': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[2]),
- 'generates_timeorder': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'generating': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1, 2]),
- 'local': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'maxinputs': specification(
- type=int,
- constraint=lambda value: 0 <= value <= sys.maxsize,
- supporting_protocols=[2]),
- 'overrides_timeorder': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'required_fields': specification(
- type=(list, set, tuple),
- constraint=None,
- supporting_protocols=[1, 2]),
- 'requires_preop': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'retainsevents': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'run_in_preview': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[2]),
- 'streaming': specification(
- type=bool,
- constraint=None,
- supporting_protocols=[1]),
- 'streaming_preop': specification(
- type=(bytes, str),
- constraint=None,
- supporting_protocols=[1, 2]),
- 'type': specification(
- type=(bytes, str),
- constraint=lambda value: value in ('events', 'reporting', 'streaming'),
- supporting_protocols=[2])}
-
-
-class CsvDialect(csv.Dialect):
- """ Describes the properties of Splunk CSV streams """
- delimiter = ','
- quotechar = '"'
- doublequote = True
- skipinitialspace = False
- lineterminator = '\r\n'
- if sys.version_info >= (3, 0) and sys.platform == 'win32':
- lineterminator = '\n'
- quoting = csv.QUOTE_MINIMAL
-
-
-class InputHeader(dict):
- """ Represents a Splunk input header as a collection of name/value pairs.
-
- """
-
- def __str__(self):
- return '\n'.join([name + ':' + value for name, value in self.items()])
-
- def read(self, ifile):
- """ Reads an input header from an input file.
-
- The input header is read as a sequence of ****:**** pairs separated by a newline. The end of the
- input header is signalled by an empty line or an end-of-file.
-
- :param ifile: File-like object that supports iteration over lines.
-
- """
- name, value = None, None
-
- for line in ifile:
- if line == '\n':
- break
- item = line.split(':', 1)
- if len(item) == 2:
- # start of a new item
- if name is not None:
- self[name] = value[:-1] # value sans trailing newline
- name, value = item[0], urllib.parse.unquote(item[1])
- elif name is not None:
- # continuation of the current item
- value += urllib.parse.unquote(line)
-
- if name is not None:
- self[name] = value[:-1] if value[-1] == '\n' else value
-
-
-Message = namedtuple('Message', ('type', 'text'))
-
-
-class MetadataDecoder(JSONDecoder):
-
- def __init__(self):
- JSONDecoder.__init__(self, object_hook=self._object_hook)
-
- @staticmethod
- def _object_hook(dictionary):
-
- object_view = ObjectView(dictionary)
- stack = deque()
- stack.append((None, None, dictionary))
-
- while len(stack):
- instance, member_name, dictionary = stack.popleft()
-
- for name, value in dictionary.items():
- if isinstance(value, dict):
- stack.append((dictionary, name, value))
-
- if instance is not None:
- instance[member_name] = ObjectView(dictionary)
-
- return object_view
-
-
-class MetadataEncoder(JSONEncoder):
-
- def __init__(self):
- JSONEncoder.__init__(self, separators=MetadataEncoder._separators)
-
- def default(self, o):
- return o.__dict__ if isinstance(o, ObjectView) else JSONEncoder.default(self, o)
-
- _separators = (',', ':')
-
-
-class ObjectView:
-
- def __init__(self, dictionary):
- self.__dict__ = dictionary
-
- def update(self, obj):
- self.__dict__.update(obj.__dict__)
-
- def __repr__(self):
- return repr(self.__dict__)
-
- def __str__(self):
- return str(self.__dict__)
-
-
-class Recorder:
-
- def __init__(self, path, f):
- self._recording = gzip.open(path + '.gz', 'wb')
- self._file = f
-
- def __getattr__(self, name):
- return getattr(self._file, name)
-
- def __iter__(self):
- for line in self._file:
- self._recording.write(line)
- self._recording.flush()
- yield line
-
- def read(self, size=None):
- value = self._file.read() if size is None else self._file.read(size)
- self._recording.write(value)
- self._recording.flush()
- return value
-
- def readline(self, size=None):
- value = self._file.readline() if size is None else self._file.readline(size)
- if len(value) > 0:
- self._recording.write(value)
- self._recording.flush()
- return value
-
- def record(self, *args):
- for arg in args:
- self._recording.write(arg)
-
- def write(self, text):
- self._recording.write(text)
- self._file.write(text)
- self._recording.flush()
-
-
-class RecordWriter:
-
- def __init__(self, ofile, maxresultrows=None):
- self._maxresultrows = 50000 if maxresultrows is None else maxresultrows
-
- self._ofile = set_binary_mode(ofile)
- self._fieldnames = None
- self._buffer = StringIO()
-
- self._writer = csv.writer(self._buffer, dialect=CsvDialect)
- self._writerow = self._writer.writerow
- self._finished = False
- self._flushed = False
-
- self._inspector = OrderedDict()
- self._chunk_count = 0
- self._pending_record_count = 0
- self._committed_record_count = 0
- self.custom_fields = set()
-
- @property
- def is_flushed(self):
- return self._flushed
-
- @is_flushed.setter
- def is_flushed(self, value):
- self._flushed = bool(value)
-
- @property
- def ofile(self):
- return self._ofile
-
- @ofile.setter
- def ofile(self, value):
- self._ofile = set_binary_mode(value)
-
- @property
- def pending_record_count(self):
- return self._pending_record_count
-
- @property
- def _record_count(self):
- warnings.warn(
- "_record_count will be deprecated soon. Use pending_record_count instead.",
- PendingDeprecationWarning
- )
- return self.pending_record_count
-
- @property
- def committed_record_count(self):
- return self._committed_record_count
-
- @property
- def _total_record_count(self):
- warnings.warn(
- "_total_record_count will be deprecated soon. Use committed_record_count instead.",
- PendingDeprecationWarning
- )
- return self.committed_record_count
-
- def write(self, data):
- bytes_type = bytes if sys.version_info >= (3, 0) else str
- if not isinstance(data, bytes_type):
- data = data.encode('utf-8')
- self.ofile.write(data)
-
- def flush(self, finished=None, partial=None):
- assert finished is None or isinstance(finished, bool)
- assert partial is None or isinstance(partial, bool)
- assert not (finished is None and partial is None)
- assert finished is None or partial is None
- self._ensure_validity()
-
- def write_message(self, message_type, message_text, *args, **kwargs):
- self._ensure_validity()
- self._inspector.setdefault('messages', []).append((message_type, message_text.format(*args, **kwargs)))
-
- def write_record(self, record):
- self._ensure_validity()
- self._write_record(record)
-
- def write_records(self, records):
- self._ensure_validity()
- records = list(records)
- write_record = self._write_record
- for record in records:
- write_record(record)
-
- def _clear(self):
- self._buffer.seek(0)
- self._buffer.truncate()
- self._inspector.clear()
- self._pending_record_count = 0
-
- def _ensure_validity(self):
- if self._finished is True:
- assert self._record_count == 0 and len(self._inspector) == 0
- raise RuntimeError('I/O operation on closed record writer')
-
- def _write_record(self, record):
-
- fieldnames = self._fieldnames
-
- if fieldnames is None:
- self._fieldnames = fieldnames = list(record.keys())
- self._fieldnames.extend([i for i in self.custom_fields if i not in self._fieldnames])
- value_list = map(lambda fn: (str(fn), str('__mv_') + str(fn)), fieldnames)
- self._writerow(list(chain.from_iterable(value_list)))
-
- get_value = record.get
- values = []
-
- for fieldname in fieldnames:
- value = get_value(fieldname, None)
-
- if value is None:
- values += (None, None)
- continue
-
- value_t = type(value)
-
- if issubclass(value_t, (list, tuple)):
-
- if len(value) == 0:
- values += (None, None)
- continue
-
- if len(value) > 1:
- value_list = value
- sv = ''
- mv = '$'
-
- for value in value_list:
-
- if value is None:
- sv += '\n'
- mv += '$;$'
- continue
-
- value_t = type(value)
-
- if value_t is not bytes:
-
- if value_t is bool:
- value = str(value.real)
- elif value_t is str:
- value = value
- elif isinstance(value, int) or value_t is float or value_t is complex:
- value = str(value)
- elif issubclass(value_t, (dict, list, tuple)):
- value = str(''.join(RecordWriter._iterencode_json(value, 0)))
- else:
- value = repr(value).encode('utf-8', errors='backslashreplace')
-
- sv += value + '\n'
- mv += value.replace('$', '$$') + '$;$'
-
- values += (sv[:-1], mv[:-2])
- continue
-
- value = value[0]
- value_t = type(value)
-
- if value_t is bool:
- values += (str(value.real), None)
- continue
-
- if value_t is bytes:
- values += (value, None)
- continue
-
- if value_t is str:
- values += (value, None)
- continue
-
- if isinstance(value, int) or value_t is float or value_t is complex:
- values += (str(value), None)
- continue
-
- if issubclass(value_t, dict):
- values += (str(''.join(RecordWriter._iterencode_json(value, 0))), None)
- continue
-
- values += (repr(value), None)
-
- self._writerow(values)
- self._pending_record_count += 1
-
- if self.pending_record_count >= self._maxresultrows:
- self.flush(partial=True)
-
- try:
- # noinspection PyUnresolvedReferences
- from _json import make_encoder
- except ImportError:
- # We may be running under PyPy 2.5 which does not include the _json module
- _iterencode_json = JSONEncoder(separators=(',', ':')).iterencode
- else:
- # Creating _iterencode_json this way yields a two-fold performance improvement on Python 2.7.9 and 2.7.10
- from json.encoder import encode_basestring_ascii
-
- @staticmethod
- def _default(o):
- raise TypeError(repr(o) + ' is not JSON serializable')
-
- _iterencode_json = make_encoder(
- {}, # markers (for detecting circular references)
- _default, # object_encoder
- encode_basestring_ascii, # string_encoder
- None, # indent
- ':', ',', # separators
- False, # sort_keys
- False, # skip_keys
- True # allow_nan
- )
-
- del make_encoder
-
-
-class RecordWriterV1(RecordWriter):
-
- def flush(self, finished=None, partial=None):
-
- RecordWriter.flush(self, finished, partial) # validates arguments and the state of this instance
-
- if self.pending_record_count > 0 or (self._chunk_count == 0 and 'messages' in self._inspector):
-
- messages = self._inspector.get('messages')
-
- if self._chunk_count == 0:
-
- # Messages are written to the messages header when we write the first chunk of data
- # Guarantee: These messages are displayed by splunkweb and the job inspector
-
- if messages is not None:
-
- message_level = RecordWriterV1._message_level.get
-
- for level, text in messages:
- self.write(message_level(level, level))
- self.write('=')
- self.write(text)
- self.write('\r\n')
-
- self.write('\r\n')
-
- elif messages is not None:
-
- # Messages are written to the messages header when we write subsequent chunks of data
- # Guarantee: These messages are displayed by splunkweb and the job inspector, if and only if the
- # command is configured with
- #
- # stderr_dest = message
- #
- # stderr_dest is a static configuration setting. This means that it can only be set in commands.conf.
- # It cannot be set in code.
-
- stderr = sys.stderr
-
- for level, text in messages:
- print(level, text, file=stderr)
-
- self.write(self._buffer.getvalue())
- self._chunk_count += 1
- self._committed_record_count += self.pending_record_count
- self._clear()
-
- self._finished = finished is True
-
- _message_level = {
- 'DEBUG': 'debug_message',
- 'ERROR': 'error_message',
- 'FATAL': 'error_message',
- 'INFO': 'info_message',
- 'WARN': 'warn_message'
- }
-
-
-class RecordWriterV2(RecordWriter):
-
- def flush(self, finished=None, partial=None):
-
- RecordWriter.flush(self, finished, partial) # validates arguments and the state of this instance
-
- if partial or not finished:
- # Don't flush partial chunks, since the SCP v2 protocol does not
- # provide a way to send partial chunks yet.
- return
-
- if not self.is_flushed:
- self.write_chunk(finished=True)
-
- def write_chunk(self, finished=None):
- inspector = self._inspector
- self._committed_record_count += self.pending_record_count
- self._chunk_count += 1
-
- # TODO: DVPL-6448: splunklib.searchcommands | Add support for partial: true when it is implemented in
- # ChunkedExternProcessor (See SPL-103525)
- #
- # We will need to replace the following block of code with this block:
- #
- # metadata = [item for item in (('inspector', inspector), ('finished', finished), ('partial', partial))]
- #
- # if partial is True:
- # finished = False
-
- if len(inspector) == 0:
- inspector = None
-
- metadata = [('inspector', inspector), ('finished', finished)]
- self._write_chunk(metadata, self._buffer.getvalue())
- self._clear()
-
- def write_metadata(self, configuration):
- self._ensure_validity()
-
- metadata = chain(configuration.items(), (('inspector', self._inspector if self._inspector else None),))
- self._write_chunk(metadata, '')
- self._clear()
-
- def write_metric(self, name, value):
- self._ensure_validity()
- self._inspector['metric.' + name] = value
-
- def _clear(self):
- super()._clear()
- self._fieldnames = None
-
- def _write_chunk(self, metadata, body):
-
- if metadata:
- metadata = str(''.join(self._iterencode_json(dict((n, v) for n, v in metadata if v is not None), 0)))
- if sys.version_info >= (3, 0):
- metadata = metadata.encode('utf-8')
- metadata_length = len(metadata)
- else:
- metadata_length = 0
-
- if sys.version_info >= (3, 0):
- body = body.encode('utf-8')
- body_length = len(body)
-
- if not (metadata_length > 0 or body_length > 0):
- return
-
- start_line = f'chunked 1.0,{metadata_length},{body_length}\n'
- self.write(start_line)
- self.write(metadata)
- self.write(body)
- self._ofile.flush()
- self._flushed = True
diff --git a/lib/splunklib/searchcommands/reporting_command.py b/lib/splunklib/searchcommands/reporting_command.py
deleted file mode 100644
index 5df3dc7..0000000
--- a/lib/splunklib/searchcommands/reporting_command.py
+++ /dev/null
@@ -1,277 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 itertools import chain
-
-from .internals import ConfigurationSettingsType, json_encode_string
-from .decorators import ConfigurationSetting, Option
-from .streaming_command import StreamingCommand
-from .search_command import SearchCommand
-from .validators import Set
-
-
-class ReportingCommand(SearchCommand):
- """ Processes search result records and generates a reporting data structure.
-
- Reporting search commands run as either reduce or map/reduce operations. The reduce part runs on a search head and
- is responsible for processing a single chunk of search results to produce the command's reporting data structure.
- The map part is called a streaming preop. It feeds the reduce part with partial results and by default runs on the
- search head and/or one or more indexers.
-
- You must implement a :meth:`reduce` method as a generator function that iterates over a set of event records and
- yields a reporting data structure. You may implement a :meth:`map` method as a generator function that iterates
- over a set of event records and yields :class:`dict` or :class:`list(dict)` instances.
-
- ReportingCommand configuration
- ==============================
-
- Configure the :meth:`map` operation using a Configuration decorator on your :meth:`map` method. Configure it like
- you would a :class:`StreamingCommand`. Configure the :meth:`reduce` operation using a Configuration decorator on
- your :meth:`ReportingCommand` class.
-
- You can configure your command for operation under Search Command Protocol (SCP) version 1 or 2. SCP 2 requires
- Splunk 6.3 or later.
-
- """
- # region Special methods
-
- def __init__(self):
- SearchCommand.__init__(self)
-
- # endregion
-
- # region Options
-
- phase = Option(doc='''
- **Syntax:** phase=[map|reduce]
-
- **Description:** Identifies the phase of the current map-reduce operation.
-
- ''', default='reduce', validate=Set('map', 'reduce'))
-
- # endregion
-
- # region Methods
-
- def map(self, records):
- """ Override this method to compute partial results.
-
- :param records:
- :type records:
-
- You must override this method, if :code:`requires_preop=True`.
-
- """
- return NotImplemented
-
- def prepare(self):
-
- phase = self.phase
-
- if phase == 'map':
- # noinspection PyUnresolvedReferences
- self._configuration = self.map.ConfigurationSettings(self)
- return
-
- if phase == 'reduce':
- streaming_preop = chain((self.name, 'phase="map"', str(self._options)), self.fieldnames)
- self._configuration.streaming_preop = ' '.join(streaming_preop)
- return
-
- raise RuntimeError(f'Unrecognized reporting command phase: {json_encode_string(str(phase))}')
-
- def reduce(self, records):
- """ Override this method to produce a reporting data structure.
-
- You must override this method.
-
- """
- raise NotImplementedError('reduce(self, records)')
-
- def _execute(self, ifile, process):
- SearchCommand._execute(self, ifile, getattr(self, self.phase))
-
- # endregion
-
- # region Types
-
- class ConfigurationSettings(SearchCommand.ConfigurationSettings):
- """ Represents the configuration settings for a :code:`ReportingCommand`.
-
- """
- # region SCP v1/v2 Properties
-
- required_fields = ConfigurationSetting(doc='''
- List of required fields for this search which back-propagates to the generating search.
-
- Setting this value enables selected fields mode under SCP 2. Under SCP 1 you must also specify
- :code:`clear_required_fields=True` to enable selected fields mode. To explicitly select all fields,
- specify a value of :const:`['*']`. No error is generated if a specified field is missing.
-
- Default: :const:`None`, which implicitly selects all fields.
-
- Supported by: SCP 1, SCP 2
-
- ''')
-
- requires_preop = ConfigurationSetting(doc='''
- Indicates whether :meth:`ReportingCommand.map` is required for proper command execution.
-
- If :const:`True`, :meth:`ReportingCommand.map` is guaranteed to be called. If :const:`False`, Splunk
- considers it to be an optimization that may be skipped.
-
- Default: :const:`False`
-
- Supported by: SCP 1, SCP 2
-
- ''')
-
- streaming_preop = ConfigurationSetting(doc='''
- Denotes the requested streaming preop search string.
-
- Computed.
-
- Supported by: SCP 1, SCP 2
-
- ''')
-
- # endregion
-
- # region SCP v1 Properties
-
- clear_required_fields = ConfigurationSetting(doc='''
- :const:`True`, if required_fields represent the *only* fields required.
-
- If :const:`False`, required_fields are additive to any fields that may be required by subsequent commands.
- In most cases, :const:`True` is appropriate for reporting commands.
-
- Default: :const:`True`
-
- Supported by: SCP 1
-
- ''')
-
- retainsevents = ConfigurationSetting(readonly=True, value=False, doc='''
- Signals that :meth:`ReportingCommand.reduce` transforms _raw events to produce a reporting data structure.
-
- Fixed: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- streaming = ConfigurationSetting(readonly=True, value=False, doc='''
- Signals that :meth:`ReportingCommand.reduce` runs on the search head.
-
- Fixed: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- # endregion
-
- # region SCP v2 Properties
-
- maxinputs = ConfigurationSetting(doc='''
- Specifies the maximum number of events that can be passed to the command for each invocation.
-
- This limit cannot exceed the value of `maxresultrows` in limits.conf_. Under SCP 1 you must specify this
- value in commands.conf_.
-
- Default: The value of `maxresultrows`.
-
- Supported by: SCP 2
-
- .. _limits.conf: http://docs.splunk.com/Documentation/Splunk/latest/admin/Limitsconf
-
- ''')
-
- run_in_preview = ConfigurationSetting(doc='''
- :const:`True`, if this command should be run to generate results for preview; not wait for final output.
-
- This may be important for commands that have side effects (e.g., outputlookup).
-
- Default: :const:`True`
-
- Supported by: SCP 2
-
- ''')
-
- type = ConfigurationSetting(readonly=True, value='reporting', doc='''
- Command type name.
-
- Fixed: :const:`'reporting'`.
-
- Supported by: SCP 2
-
- ''')
-
- # endregion
-
- # region Methods
-
- @classmethod
- def fix_up(cls, command):
- """ Verifies :code:`command` class structure and configures the :code:`command.map` method.
-
- Verifies that :code:`command` derives from :class:`ReportingCommand` and overrides
- :code:`ReportingCommand.reduce`. It then configures :code:`command.reduce`, if an overriding implementation
- of :code:`ReportingCommand.reduce` has been provided.
-
- :param command: :code:`ReportingCommand` class
-
- Exceptions:
-
- :code:`TypeError` :code:`command` class is not derived from :code:`ReportingCommand`
- :code:`AttributeError` No :code:`ReportingCommand.reduce` override
-
- """
- if not issubclass(command, ReportingCommand):
- raise TypeError(f'{command} is not a ReportingCommand')
-
- if command.reduce == ReportingCommand.reduce:
- raise AttributeError('No ReportingCommand.reduce override')
-
- if command.map == ReportingCommand.map:
- cls._requires_preop = False
- return
-
- f = vars(command)['map'] # Function backing the map method
-
- # EXPLANATION OF PREVIOUS STATEMENT: There is no way to add custom attributes to methods. See [Why does
- # setattr fail on a method](http://stackoverflow.com/questions/7891277/why-does-setattr-fail-on-a-bound-method) for a discussion of this issue.
-
- try:
- settings = f._settings
- except AttributeError:
- f.ConfigurationSettings = StreamingCommand.ConfigurationSettings
- return
-
- # Create new StreamingCommand.ConfigurationSettings class
-
- module = command.__module__ + '.' + command.__name__ + '.map'
- name = b'ConfigurationSettings'
- bases = (StreamingCommand.ConfigurationSettings,)
-
- f.ConfigurationSettings = ConfigurationSettingsType(module, name, bases)
- ConfigurationSetting.fix_up(f.ConfigurationSettings, settings)
- del f._settings
-
-
- # endregion
-
- # endregion
diff --git a/lib/splunklib/searchcommands/search_command.py b/lib/splunklib/searchcommands/search_command.py
deleted file mode 100644
index 7e8f771..0000000
--- a/lib/splunklib/searchcommands/search_command.py
+++ /dev/null
@@ -1,1143 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-# Absolute imports
-
-import csv
-import io
-import os
-import re
-import sys
-import tempfile
-import traceback
-from collections import namedtuple, OrderedDict
-from copy import deepcopy
-from io import StringIO
-from itertools import chain, islice
-from logging import _nameToLevel as _levelNames, getLevelName, getLogger
-from shutil import make_archive
-from time import time
-from urllib.parse import unquote
-from urllib.parse import urlsplit
-from warnings import warn
-from xml.etree import ElementTree
-from splunklib.utils import ensure_str
-
-
-# Relative imports
-import splunklib
-from . import Boolean, Option, environment
-from .internals import (
- CommandLineParser,
- CsvDialect,
- InputHeader,
- Message,
- MetadataDecoder,
- MetadataEncoder,
- ObjectView,
- Recorder,
- RecordWriterV1,
- RecordWriterV2,
- json_encode_string)
-from ..client import Service
-
-
-# ----------------------------------------------------------------------------------------------------------------------
-
-# P1 [ ] TODO: Log these issues against ChunkedExternProcessor
-#
-# 1. Implement requires_preop configuration setting.
-# This configuration setting is currently rejected by ChunkedExternProcessor.
-#
-# 2. Rename type=events as type=eventing for symmetry with type=reporting and type=streaming
-# Eventing commands process records on the events pipeline. This change effects ChunkedExternProcessor.cpp,
-# eventing_command.py, and generating_command.py.
-#
-# 3. For consistency with SCPV1, commands.conf should not require filename setting when chunked = true
-# The SCPV1 processor uses .py as the default filename. The ChunkedExternProcessor should do the same.
-
-# P1 [ ] TODO: Verify that ChunkedExternProcessor complains if a streaming_preop has a type other than 'streaming'
-# It once looked like sending type='reporting' for the streaming_preop was accepted.
-
-# ----------------------------------------------------------------------------------------------------------------------
-
-# P2 [ ] TODO: Consider bumping None formatting up to Option.Item.__str__
-
-
-class SearchCommand:
- """ Represents a custom search command.
-
- """
-
- def __init__(self):
-
- # Variables that may be used, but not altered by derived classes
-
- class_name = self.__class__.__name__
-
- self._logger, self._logging_configuration = getLogger(class_name), environment.logging_configuration
-
- # Variables backing option/property values
-
- self._configuration = self.ConfigurationSettings(self)
- self._input_header = InputHeader()
- self._fieldnames = None
- self._finished = None
- self._metadata = None
- self._options = None
- self._protocol_version = None
- self._search_results_info = None
- self._service = None
-
- # Internal variables
-
- self._default_logging_level = self._logger.level
- self._record_writer = None
- self._records = None
- self._allow_empty_input = True
-
- def __str__(self):
- text = ' '.join(chain((type(self).name, str(self.options)), [] if self.fieldnames is None else self.fieldnames))
- return text
-
- # region Options
-
- @Option
- def logging_configuration(self):
- """ **Syntax:** logging_configuration=
-
- **Description:** Loads an alternative logging configuration file for
- a command invocation. The logging configuration file must be in Python
- ConfigParser-format. Path names are relative to the app root directory.
-
- """
- return self._logging_configuration
-
- @logging_configuration.setter
- def logging_configuration(self, value):
- self._logger, self._logging_configuration = environment.configure_logging(self.__class__.__name__, value)
-
- @Option
- def logging_level(self):
- """ **Syntax:** logging_level=[CRITICAL|ERROR|WARNING|INFO|DEBUG|NOTSET]
-
- **Description:** Sets the threshold for the logger of this command invocation. Logging messages less severe than
- `logging_level` will be ignored.
-
- """
- return getLevelName(self._logger.getEffectiveLevel())
-
- @logging_level.setter
- def logging_level(self, value):
- if value is None:
- value = self._default_logging_level
- if isinstance(value, (bytes, str)):
- try:
- level = _levelNames[value.upper()]
- except KeyError:
- raise ValueError(f'Unrecognized logging level: {value}')
- else:
- try:
- level = int(value)
- except ValueError:
- raise ValueError(f'Unrecognized logging level: {value}')
- self._logger.setLevel(level)
-
- def add_field(self, current_record, field_name, field_value):
- self._record_writer.custom_fields.add(field_name)
- current_record[field_name] = field_value
-
- def gen_record(self, **record):
- self._record_writer.custom_fields |= set(record.keys())
- return record
-
- record = Option(doc='''
- **Syntax: record=
-
- **Description:** When `true`, records the interaction between the command and splunkd. Defaults to `false`.
-
- ''', default=False, validate=Boolean())
-
- show_configuration = Option(doc='''
- **Syntax:** show_configuration=
-
- **Description:** When `true`, reports command configuration as an informational message. Defaults to `false`.
-
- ''', default=False, validate=Boolean())
-
- # endregion
-
- # region Properties
-
- @property
- def configuration(self):
- """ Returns the configuration settings for this command.
-
- """
- return self._configuration
-
- @property
- def fieldnames(self):
- """ Returns the fieldnames specified as argument to this command.
-
- """
- return self._fieldnames
-
- @fieldnames.setter
- def fieldnames(self, value):
- self._fieldnames = value
-
- @property
- def input_header(self):
- """ Returns the input header for this command.
-
- :return: The input header for this command.
- :rtype: InputHeader
-
- """
- warn(
- 'SearchCommand.input_header is deprecated and will be removed in a future release. '
- 'Please use SearchCommand.metadata instead.', DeprecationWarning, 2)
- return self._input_header
-
- @property
- def logger(self):
- """ Returns the logger for this command.
-
- :return: The logger for this command.
- :rtype:
-
- """
- return self._logger
-
- @property
- def metadata(self):
- return self._metadata
-
- @property
- def options(self):
- """ Returns the options specified as argument to this command.
-
- """
- if self._options is None:
- self._options = Option.View(self)
- return self._options
-
- @property
- def protocol_version(self):
- return self._protocol_version
-
- @property
- def search_results_info(self):
- """ Returns the search results info for this command invocation.
-
- The search results info object is created from the search results info file associated with the command
- invocation.
-
- :return: Search results info:const:`None`, if the search results info file associated with the command
- invocation is inaccessible.
- :rtype: SearchResultsInfo or NoneType
-
- """
- if self._search_results_info is not None:
- return self._search_results_info
-
- if self._protocol_version == 1:
- try:
- path = self._input_header['infoPath']
- except KeyError:
- return None
- else:
- assert self._protocol_version == 2
-
- try:
- dispatch_dir = self._metadata.searchinfo.dispatch_dir
- except AttributeError:
- return None
-
- path = os.path.join(dispatch_dir, 'info.csv')
-
- try:
- with io.open(path, 'r') as f:
- reader = csv.reader(f, dialect=CsvDialect)
- fields = next(reader)
- values = next(reader)
- except IOError as error:
- if error.errno == 2:
- self.logger.error(f'Search results info file {json_encode_string(path)} does not exist.')
- return
- raise
-
- def convert_field(field):
- return (field[1:] if field[0] == '_' else field).replace('.', '_')
-
- decode = MetadataDecoder().decode
-
- def convert_value(value):
- try:
- return decode(value) if len(value) > 0 else value
- except ValueError:
- return value
-
- info = ObjectView(dict((convert_field(f_v[0]), convert_value(f_v[1])) for f_v in zip(fields, values)))
-
- try:
- count_map = info.countMap
- except AttributeError:
- pass
- else:
- count_map = count_map.split(';')
- n = len(count_map)
- info.countMap = dict(list(zip(islice(count_map, 0, n, 2), islice(count_map, 1, n, 2))))
-
- try:
- msg_type = info.msgType
- msg_text = info.msg
- except AttributeError:
- pass
- else:
- messages = [t_m for t_m in zip(msg_type.split('\n'), msg_text.split('\n')) if t_m[0] or t_m[1]]
- info.msg = [Message(message) for message in messages]
- del info.msgType
-
- try:
- info.vix_families = ElementTree.fromstring(info.vix_families)
- except AttributeError:
- pass
-
- self._search_results_info = info
- return info
-
- @property
- def service(self):
- """ Returns a Splunk service object for this command invocation or None.
-
- The service object is created from the Splunkd URI and authentication token passed to the command invocation in
- the search results info file. This data is not passed to a command invocation by default. You must request it by
- specifying this pair of configuration settings in commands.conf:
-
- .. code-block:: python
-
- enableheader = true
- requires_srinfo = true
-
- The :code:`enableheader` setting is :code:`true` by default. Hence, you need not set it. The
- :code:`requires_srinfo` setting is false by default. Hence, you must set it.
-
- :return: :class:`splunklib.client.Service`, if :code:`enableheader` and :code:`requires_srinfo` are both
- :code:`true`. Otherwise, if either :code:`enableheader` or :code:`requires_srinfo` are :code:`false`, a value
- of :code:`None` is returned.
-
- """
- if self._service is not None:
- return self._service
-
- metadata = self._metadata
-
- if metadata is None:
- return None
-
- try:
- searchinfo = self._metadata.searchinfo
- except AttributeError:
- return None
-
- splunkd_uri = searchinfo.splunkd_uri
-
- if splunkd_uri is None:
- return None
-
- uri = urlsplit(splunkd_uri, allow_fragments=False)
-
- self._service = Service(
- scheme=uri.scheme, host=uri.hostname, port=uri.port, app=searchinfo.app, token=searchinfo.session_key)
-
- return self._service
-
- # endregion
-
- # region Methods
-
- def error_exit(self, error, message=None):
- self.write_error(error.message if message is None else message)
- self.logger.error('Abnormal exit: %s', error)
- exit(1)
-
- def finish(self):
- """ Flushes the output buffer and signals that this command has finished processing data.
-
- :return: :const:`None`
-
- """
- self._record_writer.flush(finished=True)
-
- def flush(self):
- """ Flushes the output buffer.
-
- :return: :const:`None`
-
- """
- self._record_writer.flush(finished=False)
-
- def prepare(self):
- """ Prepare for execution.
-
- This method should be overridden in search command classes that wish to examine and update their configuration
- or option settings prior to execution. It is called during the getinfo exchange before command metadata is sent
- to splunkd.
-
- :return: :const:`None`
- :rtype: NoneType
-
- """
-
- def process(self, argv=sys.argv, ifile=sys.stdin, ofile=sys.stdout, allow_empty_input=True):
- """ Process data.
-
- :param argv: Command line arguments.
- :type argv: list or tuple
-
- :param ifile: Input data file.
- :type ifile: file
-
- :param ofile: Output data file.
- :type ofile: file
-
- :param allow_empty_input: Allow empty input records for the command, if False an Error will be returned if empty chunk body is encountered when read
- :type allow_empty_input: bool
-
- :return: :const:`None`
- :rtype: NoneType
-
- """
-
- self._allow_empty_input = allow_empty_input
-
- if len(argv) > 1:
- self._process_protocol_v1(argv, ifile, ofile)
- else:
- self._process_protocol_v2(argv, ifile, ofile)
-
- def _map_input_header(self):
- metadata = self._metadata
- searchinfo = metadata.searchinfo
- self._input_header.update(
- allowStream=None,
- infoPath=os.path.join(searchinfo.dispatch_dir, 'info.csv'),
- keywords=None,
- preview=metadata.preview,
- realtime=searchinfo.earliest_time != 0 and searchinfo.latest_time != 0,
- search=searchinfo.search,
- sid=searchinfo.sid,
- splunkVersion=searchinfo.splunk_version,
- truncated=None)
-
- def _map_metadata(self, argv):
- source = SearchCommand._MetadataSource(argv, self._input_header, self.search_results_info)
-
- def _map(metadata_map):
- metadata = {}
-
- for name, value in metadata_map.items():
- if isinstance(value, dict):
- value = _map(value)
- else:
- transform, extract = value
- if extract is None:
- value = None
- else:
- value = extract(source)
- if not (value is None or transform is None):
- value = transform(value)
- metadata[name] = value
-
- return ObjectView(metadata)
-
- self._metadata = _map(SearchCommand._metadata_map)
-
- _metadata_map = {
- 'action':
- (lambda v: 'getinfo' if v == '__GETINFO__' else 'execute' if v == '__EXECUTE__' else None,
- lambda s: s.argv[1]),
- 'preview':
- (bool, lambda s: s.input_header.get('preview')),
- 'searchinfo': {
- 'app':
- (lambda v: v.ppc_app, lambda s: s.search_results_info),
- 'args':
- (None, lambda s: s.argv),
- 'dispatch_dir':
- (os.path.dirname, lambda s: s.input_header.get('infoPath')),
- 'earliest_time':
- (lambda v: float(v.rt_earliest) if len(v.rt_earliest) > 0 else 0.0, lambda s: s.search_results_info),
- 'latest_time':
- (lambda v: float(v.rt_latest) if len(v.rt_latest) > 0 else 0.0, lambda s: s.search_results_info),
- 'owner':
- (None, None),
- 'raw_args':
- (None, lambda s: s.argv),
- 'search':
- (unquote, lambda s: s.input_header.get('search')),
- 'session_key':
- (lambda v: v.auth_token, lambda s: s.search_results_info),
- 'sid':
- (None, lambda s: s.input_header.get('sid')),
- 'splunk_version':
- (None, lambda s: s.input_header.get('splunkVersion')),
- 'splunkd_uri':
- (lambda v: v.splunkd_uri, lambda s: s.search_results_info),
- 'username':
- (lambda v: v.ppc_user, lambda s: s.search_results_info)}}
-
- _MetadataSource = namedtuple('Source', ('argv', 'input_header', 'search_results_info'))
-
- def _prepare_protocol_v1(self, argv, ifile, ofile):
-
- debug = environment.splunklib_logger.debug
-
- # Provide as much context as possible in advance of parsing the command line and preparing for execution
-
- self._input_header.read(ifile)
- self._protocol_version = 1
- self._map_metadata(argv)
-
- debug(' metadata=%r, input_header=%r', self._metadata, self._input_header)
-
- try:
- tempfile.tempdir = self._metadata.searchinfo.dispatch_dir
- except AttributeError:
- raise RuntimeError(f'{self.__class__.__name__}.metadata.searchinfo.dispatch_dir is undefined')
-
- debug(' tempfile.tempdir=%r', tempfile.tempdir)
-
- CommandLineParser.parse(self, argv[2:])
- self.prepare()
-
- if self.record:
- self.record = False
-
- record_argv = [argv[0], argv[1], str(self._options), ' '.join(self.fieldnames)]
- ifile, ofile = self._prepare_recording(record_argv, ifile, ofile)
- self._record_writer.ofile = ofile
- ifile.record(str(self._input_header), '\n\n')
-
- if self.show_configuration:
- self.write_info(self.name + ' command configuration: ' + str(self._configuration))
-
- return ifile # wrapped, if self.record is True
-
- def _prepare_recording(self, argv, ifile, ofile):
-
- # Create the recordings directory, if it doesn't already exist
-
- recordings = os.path.join(environment.splunk_home, 'var', 'run', 'splunklib.searchcommands', 'recordings')
-
- if not os.path.isdir(recordings):
- os.makedirs(recordings)
-
- # Create input/output recorders from ifile and ofile
-
- recording = os.path.join(recordings, self.__class__.__name__ + '-' + repr(time()) + '.' + self._metadata.action)
- ifile = Recorder(recording + '.input', ifile)
- ofile = Recorder(recording + '.output', ofile)
-
- # Archive the dispatch directory--if it exists--so that it can be used as a baseline in mocks)
-
- dispatch_dir = self._metadata.searchinfo.dispatch_dir
-
- if dispatch_dir is not None: # __GETINFO__ action does not include a dispatch_dir
- root_dir, base_dir = os.path.split(dispatch_dir)
- make_archive(recording + '.dispatch_dir', 'gztar', root_dir, base_dir, logger=self.logger)
-
- # Save a splunk command line because it is useful for developing tests
-
- with open(recording + '.splunk_cmd', 'wb') as f:
- f.write('splunk cmd python '.encode())
- f.write(os.path.basename(argv[0]).encode())
- for arg in islice(argv, 1, len(argv)):
- f.write(' '.encode())
- f.write(arg.encode())
-
- return ifile, ofile
-
- def _process_protocol_v1(self, argv, ifile, ofile):
-
- debug = environment.splunklib_logger.debug
- class_name = self.__class__.__name__
-
- debug('%s.process started under protocol_version=1', class_name)
- self._record_writer = RecordWriterV1(ofile)
-
- # noinspection PyBroadException
- try:
- if argv[1] == '__GETINFO__':
-
- debug('Writing configuration settings')
-
- ifile = self._prepare_protocol_v1(argv, ifile, ofile)
- self._record_writer.write_record(dict(
- (n, ','.join(v) if isinstance(v, (list, tuple)) else v) for n, v in
- self._configuration.items()))
- self.finish()
-
- elif argv[1] == '__EXECUTE__':
-
- debug('Executing')
-
- ifile = self._prepare_protocol_v1(argv, ifile, ofile)
- self._records = self._records_protocol_v1
- self._metadata.action = 'execute'
- self._execute(ifile, None)
-
- else:
- message = (
- f'Command {self.name} appears to be statically configured for search command protocol version 1 and static '
- 'configuration is unsupported by splunklib.searchcommands. Please ensure that '
- 'default/commands.conf contains this stanza:\n'
- f'[{self.name}]\n'
- f'filename = {os.path.basename(argv[0])}\n'
- 'enableheader = true\n'
- 'outputheader = true\n'
- 'requires_srinfo = true\n'
- 'supports_getinfo = true\n'
- 'supports_multivalues = true\n'
- 'supports_rawargs = true')
- raise RuntimeError(message)
-
- except (SyntaxError, ValueError) as error:
- self.write_error(str(error))
- self.flush()
- exit(0)
-
- except SystemExit:
- self.flush()
- raise
-
- except:
- self._report_unexpected_error()
- self.flush()
- exit(1)
-
- debug('%s.process finished under protocol_version=1', class_name)
-
- def _protocol_v2_option_parser(self, arg):
- """ Determines if an argument is an Option/Value pair, or just a Positional Argument.
- Method so different search commands can handle parsing of arguments differently.
-
- :param arg: A single argument provided to the command from SPL
- :type arg: str
-
- :return: [OptionName, OptionValue] OR [PositionalArgument]
- :rtype: List[str]
-
- """
- return arg.split('=', 1)
-
- def _process_protocol_v2(self, argv, ifile, ofile):
- """ Processes records on the `input stream optionally writing records to the output stream.
-
- :param ifile: Input file object.
- :type ifile: file or InputType
-
- :param ofile: Output file object.
- :type ofile: file or OutputType
-
- :return: :const:`None`
-
- """
- debug = environment.splunklib_logger.debug
- class_name = self.__class__.__name__
-
- debug('%s.process started under protocol_version=2', class_name)
- self._protocol_version = 2
-
- # Read search command metadata from splunkd
- # noinspection PyBroadException
- try:
- debug('Reading metadata')
- metadata, body = self._read_chunk(self._as_binary_stream(ifile))
-
- action = getattr(metadata, 'action', None)
-
- if action != 'getinfo':
- raise RuntimeError(f'Expected getinfo action, not {action}')
-
- if len(body) > 0:
- raise RuntimeError('Did not expect data for getinfo action')
-
- self._metadata = deepcopy(metadata)
-
- searchinfo = self._metadata.searchinfo
-
- searchinfo.earliest_time = float(searchinfo.earliest_time)
- searchinfo.latest_time = float(searchinfo.latest_time)
- searchinfo.search = unquote(searchinfo.search)
-
- self._map_input_header()
-
- debug(' metadata=%r, input_header=%r', self._metadata, self._input_header)
-
- try:
- tempfile.tempdir = self._metadata.searchinfo.dispatch_dir
- except AttributeError:
- raise RuntimeError(f'{class_name}.metadata.searchinfo.dispatch_dir is undefined')
-
- debug(' tempfile.tempdir=%r', tempfile.tempdir)
- except:
- self._record_writer = RecordWriterV2(ofile)
- self._report_unexpected_error()
- self.finish()
- exit(1)
-
- # Write search command configuration for consumption by splunkd
- # noinspection PyBroadException
- try:
- self._record_writer = RecordWriterV2(ofile, getattr(self._metadata.searchinfo, 'maxresultrows', None))
- self.fieldnames = []
- self.options.reset()
-
- args = self.metadata.searchinfo.args
- error_count = 0
-
- debug('Parsing arguments')
-
- if args and isinstance(args, list):
- for arg in args:
- result = self._protocol_v2_option_parser(arg)
- if len(result) == 1:
- self.fieldnames.append(str(result[0]))
- else:
- name, value = result
- name = str(name)
- try:
- option = self.options[name]
- except KeyError:
- self.write_error(f'Unrecognized option: {name}={value}')
- error_count += 1
- continue
- try:
- option.value = value
- except ValueError:
- self.write_error(f'Illegal value: {name}={value}')
- error_count += 1
- continue
-
- missing = self.options.get_missing()
-
- if missing is not None:
- if len(missing) == 1:
- self.write_error(f'A value for "{missing[0]}" is required')
- else:
- self.write_error(f'Values for these required options are missing: {", ".join(missing)}')
- error_count += 1
-
- if error_count > 0:
- exit(1)
-
- debug(' command: %s', str(self))
-
- debug('Preparing for execution')
- self.prepare()
-
- if self.record:
-
- ifile, ofile = self._prepare_recording(argv, ifile, ofile)
- self._record_writer.ofile = ofile
-
- # Record the metadata that initiated this command after removing the record option from args/raw_args
-
- info = self._metadata.searchinfo
-
- for attr in 'args', 'raw_args':
- setattr(info, attr, [arg for arg in getattr(info, attr) if not arg.startswith('record=')])
-
- metadata = MetadataEncoder().encode(self._metadata)
- ifile.record('chunked 1.0,', str(len(metadata)), ',0\n', metadata)
-
- if self.show_configuration:
- self.write_info(self.name + ' command configuration: ' + str(self._configuration))
-
- debug(' command configuration: %s', self._configuration)
-
- except SystemExit:
- self._record_writer.write_metadata(self._configuration)
- self.finish()
- raise
- except:
- self._record_writer.write_metadata(self._configuration)
- self._report_unexpected_error()
- self.finish()
- exit(1)
-
- self._record_writer.write_metadata(self._configuration)
-
- # Execute search command on data passing through the pipeline
- # noinspection PyBroadException
- try:
- debug('Executing under protocol_version=2')
- self._metadata.action = 'execute'
- self._execute(ifile, None)
- except SystemExit:
- self.finish()
- raise
- except:
- self._report_unexpected_error()
- self.finish()
- exit(1)
-
- debug('%s.process completed', class_name)
-
- def write_debug(self, message, *args):
- self._record_writer.write_message('DEBUG', message, *args)
-
- def write_error(self, message, *args):
- self._record_writer.write_message('ERROR', message, *args)
-
- def write_fatal(self, message, *args):
- self._record_writer.write_message('FATAL', message, *args)
-
- def write_info(self, message, *args):
- self._record_writer.write_message('INFO', message, *args)
-
- def write_warning(self, message, *args):
- self._record_writer.write_message('WARN', message, *args)
-
- def write_metric(self, name, value):
- """ Writes a metric that will be added to the search inspector.
-
- :param name: Name of the metric.
- :type name: basestring
-
- :param value: A 4-tuple containing the value of metric ``name`` where
-
- value[0] = Elapsed seconds or :const:`None`.
- value[1] = Number of invocations or :const:`None`.
- value[2] = Input count or :const:`None`.
- value[3] = Output count or :const:`None`.
-
- The :data:`SearchMetric` type provides a convenient encapsulation of ``value``.
- The :data:`SearchMetric` type provides a convenient encapsulation of ``value``.
-
- :return: :const:`None`.
-
- """
- self._record_writer.write_metric(name, value)
-
- # P2 [ ] TODO: Support custom inspector values
-
- @staticmethod
- def _decode_list(mv):
- return [match.replace('$$', '$') for match in SearchCommand._encoded_value.findall(mv)]
-
- _encoded_value = re.compile(r'\$(?P- (?:\$\$|[^$])*)\$(?:;|$)') # matches a single value in an encoded list
-
- # Note: Subclasses must override this method so that it can be called
- # called as self._execute(ifile, None)
- def _execute(self, ifile, process):
- """ Default processing loop
-
- :param ifile: Input file object.
- :type ifile: file
-
- :param process: Bound method to call in processing loop.
- :type process: instancemethod
-
- :return: :const:`None`.
- :rtype: NoneType
-
- """
- if self.protocol_version == 1:
- self._record_writer.write_records(process(self._records(ifile)))
- self.finish()
- else:
- assert self._protocol_version == 2
- self._execute_v2(ifile, process)
-
- @staticmethod
- def _as_binary_stream(ifile):
- naught = ifile.read(0)
- if isinstance(naught, bytes):
- return ifile
-
- try:
- return ifile.buffer
- except AttributeError as error:
- raise RuntimeError(f'Failed to get underlying buffer: {error}')
-
- @staticmethod
- def _read_chunk(istream):
- # noinspection PyBroadException
- assert isinstance(istream.read(0), bytes), 'Stream must be binary'
-
- try:
- header = istream.readline()
- except Exception as error:
- raise RuntimeError(f'Failed to read transport header: {error}')
-
- if not header:
- return None
-
- match = SearchCommand._header.match(ensure_str(header))
-
- if match is None:
- raise RuntimeError(f'Failed to parse transport header: {header}')
-
- metadata_length, body_length = match.groups()
- metadata_length = int(metadata_length)
- body_length = int(body_length)
-
- try:
- metadata = istream.read(metadata_length)
- except Exception as error:
- raise RuntimeError(f'Failed to read metadata of length {metadata_length}: {error}')
-
- decoder = MetadataDecoder()
-
- try:
- metadata = decoder.decode(ensure_str(metadata))
- except Exception as error:
- raise RuntimeError(f'Failed to parse metadata of length {metadata_length}: {error}')
-
- # if body_length <= 0:
- # return metadata, ''
-
- body = ""
- try:
- if body_length > 0:
- body = istream.read(body_length)
- except Exception as error:
- raise RuntimeError(f'Failed to read body of length {body_length}: {error}')
-
- return metadata, ensure_str(body,errors="replace")
-
- _header = re.compile(r'chunked\s+1.0\s*,\s*(\d+)\s*,\s*(\d+)\s*\n')
-
- def _records_protocol_v1(self, ifile):
- return self._read_csv_records(ifile)
-
- def _read_csv_records(self, ifile):
- reader = csv.reader(ifile, dialect=CsvDialect)
-
- try:
- fieldnames = next(reader)
- except StopIteration:
- return
-
- mv_fieldnames = dict((name, name[len('__mv_'):]) for name in fieldnames if name.startswith('__mv_'))
-
- if len(mv_fieldnames) == 0:
- for values in reader:
- yield OrderedDict(list(zip(fieldnames, values)))
- return
-
- for values in reader:
- record = OrderedDict()
- for fieldname, value in zip(fieldnames, values):
- if fieldname.startswith('__mv_'):
- if len(value) > 0:
- record[mv_fieldnames[fieldname]] = self._decode_list(value)
- elif fieldname not in record:
- record[fieldname] = value
- yield record
-
- def _execute_v2(self, ifile, process):
- istream = self._as_binary_stream(ifile)
-
- while True:
- result = self._read_chunk(istream)
-
- if not result:
- return
-
- metadata, body = result
- action = getattr(metadata, 'action', None)
- if action != 'execute':
- raise RuntimeError(f'Expected execute action, not {action}')
-
- self._finished = getattr(metadata, 'finished', False)
- self._record_writer.is_flushed = False
- self._metadata.update(metadata)
- self._execute_chunk_v2(process, result)
-
- self._record_writer.write_chunk(finished=self._finished)
-
- def _execute_chunk_v2(self, process, chunk):
- metadata, body = chunk
-
- if len(body) <= 0 and not self._allow_empty_input:
- raise ValueError(
- "No records found to process. Set allow_empty_input=True in dispatch function to move forward "
- "with empty records.")
-
- records = self._read_csv_records(StringIO(body))
- self._record_writer.write_records(process(records))
-
- def _report_unexpected_error(self):
-
- error_type, error, tb = sys.exc_info()
- origin = tb
-
- while origin.tb_next is not None:
- origin = origin.tb_next
-
- filename = origin.tb_frame.f_code.co_filename
- lineno = origin.tb_lineno
- message = f'{error_type.__name__} at "{filename}", line {str(lineno)} : {error}'
-
- environment.splunklib_logger.error(message + '\nTraceback:\n' + ''.join(traceback.format_tb(tb)))
- self.write_error(message)
-
- # endregion
-
- # region Types
-
- class ConfigurationSettings:
- """ Represents the configuration settings common to all :class:`SearchCommand` classes.
-
- """
-
- def __init__(self, command):
- self.command = command
-
- def __repr__(self):
- """ Converts the value of this instance to its string representation.
-
- The value of this ConfigurationSettings instance is represented as a string of comma-separated
- :code:`(name, value)` pairs.
-
- :return: String representation of this instance
-
- """
- definitions = type(self).configuration_setting_definitions
- settings = [repr((setting.name, setting.__get__(self), setting.supporting_protocols)) for setting in
- definitions]
- return '[' + ', '.join(settings) + ']'
-
- def __str__(self):
- """ Converts the value of this instance to its string representation.
-
- The value of this ConfigurationSettings instance is represented as a string of comma-separated
- :code:`name=value` pairs. Items with values of :const:`None` are filtered from the list.
-
- :return: String representation of this instance
-
- """
- # text = ', '.join(imap(lambda (name, value): name + '=' + json_encode_string(unicode(value)), self.iteritems()))
- text = ', '.join([f'{name}={json_encode_string(str(value))}' for (name, value) in self.items()])
- return text
-
- # region Methods
-
- @classmethod
- def fix_up(cls, command_class):
- """ Adjusts and checks this class and its search command class.
-
- Derived classes typically override this method. It is used by the :decorator:`Configuration` decorator to
- fix up the :class:`SearchCommand` class it adorns. This method is overridden by :class:`EventingCommand`,
- :class:`GeneratingCommand`, :class:`ReportingCommand`, and :class:`StreamingCommand`, the base types for
- all other search commands.
-
- :param command_class: Command class targeted by this class
-
- """
- return
-
- # TODO: Stop looking like a dictionary because we don't obey the semantics
- # N.B.: Does not use Python 2 dict copy semantics
- def iteritems(self):
- definitions = type(self).configuration_setting_definitions
- version = self.command.protocol_version
- return [name_value1 for name_value1 in [(setting.name, setting.__get__(self)) for setting in
- [setting for setting in definitions if
- setting.is_supported_by_protocol(version)]] if
- name_value1[1] is not None]
-
- # N.B.: Does not use Python 3 dict view semantics
-
- items = iteritems
-
- # endregion
-
- # endregion
-
-
-SearchMetric = namedtuple('SearchMetric', ('elapsed_seconds', 'invocation_count', 'input_count', 'output_count'))
-
-
-def dispatch(command_class, argv=sys.argv, input_file=sys.stdin, output_file=sys.stdout, module_name=None,
- allow_empty_input=True):
- """ Instantiates and executes a search command class
-
- This function implements a `conditional script stanza
`_ based on the value of
- :code:`module_name`::
-
- if module_name is None or module_name == '__main__':
- # execute command
-
- Call this function at module scope with :code:`module_name=__name__`, if you would like your module to act as either
- a reusable module or a standalone program. Otherwise, if you wish this function to unconditionally instantiate and
- execute :code:`command_class`, pass :const:`None` as the value of :code:`module_name`.
-
- :param command_class: Search command class to instantiate and execute.
- :type command_class: type
- :param argv: List of arguments to the command.
- :type argv: list or tuple
- :param input_file: File from which the command will read data.
- :type input_file: :code:`file`
- :param output_file: File to which the command will write data.
- :type output_file: :code:`file`
- :param module_name: Name of the module calling :code:`dispatch` or :const:`None`.
- :type module_name: :code:`basestring`
- :param allow_empty_input: Allow empty input records for the command, if False an Error will be returned if empty chunk body is encountered when read
- :type allow_empty_input: bool
- :returns: :const:`None`
-
- **Example**
-
- .. code-block:: python
- :linenos:
-
- #!/usr/bin/env python
- from splunklib.searchcommands import dispatch, StreamingCommand, Configuration, Option, validators
- @Configuration()
- class SomeStreamingCommand(StreamingCommand):
- ...
- def stream(records):
- ...
- dispatch(SomeStreamingCommand, module_name=__name__)
-
- Dispatches the :code:`SomeStreamingCommand`, if and only if :code:`__name__` is equal to :code:`'__main__'`.
-
- **Example**
-
- .. code-block:: python
- :linenos:
-
- from splunklib.searchcommands import dispatch, StreamingCommand, Configuration, Option, validators
- @Configuration()
- class SomeStreamingCommand(StreamingCommand):
- ...
- def stream(records):
- ...
- dispatch(SomeStreamingCommand)
-
- Unconditionally dispatches :code:`SomeStreamingCommand`.
-
- """
- assert issubclass(command_class, SearchCommand)
-
- if module_name is None or module_name == '__main__':
- command_class().process(argv, input_file, output_file, allow_empty_input)
diff --git a/lib/splunklib/searchcommands/streaming_command.py b/lib/splunklib/searchcommands/streaming_command.py
deleted file mode 100644
index e2a3a40..0000000
--- a/lib/splunklib/searchcommands/streaming_command.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 .decorators import ConfigurationSetting
-from .search_command import SearchCommand
-
-
-class StreamingCommand(SearchCommand):
- """ Applies a transformation to search results as they travel through the streams pipeline.
-
- Streaming commands typically filter, augment, or update, search result records. Splunk will send them in batches of
- up to 50,000 records. Hence, a search command must be prepared to be invoked many times during the course of
- pipeline processing. Each invocation should produce a set of results independently usable by downstream processors.
-
- By default Splunk may choose to run a streaming command locally on a search head and/or remotely on one or more
- indexers concurrently. The size and frequency of the search result batches sent to the command will vary based
- on scheduling considerations.
-
- StreamingCommand configuration
- ==============================
-
- You can configure your command for operation under Search Command Protocol (SCP) version 1 or 2. SCP 2 requires
- Splunk 6.3 or later.
-
- """
- # region Methods
-
- def stream(self, records):
- """ Generator function that processes and yields event records to the Splunk stream pipeline.
-
- You must override this method.
-
- """
- raise NotImplementedError('StreamingCommand.stream(self, records)')
-
- def _execute(self, ifile, process):
- SearchCommand._execute(self, ifile, self.stream)
-
- # endregion
-
- class ConfigurationSettings(SearchCommand.ConfigurationSettings):
- """ Represents the configuration settings that apply to a :class:`StreamingCommand`.
-
- """
- # region SCP v1/v2 properties
-
- required_fields = ConfigurationSetting(doc='''
- List of required fields for this search which back-propagates to the generating search.
-
- Setting this value enables selected fields mode under SCP 2. Under SCP 1 you must also specify
- :code:`clear_required_fields=True` to enable selected fields mode. To explicitly select all fields,
- specify a value of :const:`['*']`. No error is generated if a specified field is missing.
-
- Default: :const:`None`, which implicitly selects all fields.
-
- Supported by: SCP 1, SCP 2
-
- ''')
-
- # endregion
-
- # region SCP v1 properties
-
- clear_required_fields = ConfigurationSetting(doc='''
- :const:`True`, if required_fields represent the *only* fields required.
-
- If :const:`False`, required_fields are additive to any fields that may be required by subsequent commands.
- In most cases, :const:`False` is appropriate for streaming commands.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- local = ConfigurationSetting(doc='''
- :const:`True`, if the command should run locally on the search head.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- overrides_timeorder = ConfigurationSetting(doc='''
- :const:`True`, if the command changes the order of events with respect to time.
-
- Default: :const:`False`
-
- Supported by: SCP 1
-
- ''')
-
- streaming = ConfigurationSetting(readonly=True, value=True, doc='''
- Specifies that the command is streamable.
-
- Fixed: :const:`True`
-
- Supported by: SCP 1
-
- ''')
-
- # endregion
-
- # region SCP v2 Properties
-
- distributed = ConfigurationSetting(value=True, doc='''
- :const:`True`, if this command should be distributed to indexers.
-
- Under SCP 1 you must either specify `local = False` or include this line in commands.conf_, if this command
- should be distributed to indexers.
-
- ..code:
- local = true
-
- Default: :const:`True`
-
- Supported by: SCP 2
-
- .. commands.conf_: http://docs.splunk.com/Documentation/Splunk/latest/Admin/Commandsconf
-
- ''')
-
- maxinputs = ConfigurationSetting(doc='''
- Specifies the maximum number of events that can be passed to the command for each invocation.
-
- This limit cannot exceed the value of `maxresultrows` in limits.conf. Under SCP 1 you must specify this
- value in commands.conf_.
-
- Default: The value of `maxresultrows`.
-
- Supported by: SCP 2
-
- ''')
-
- type = ConfigurationSetting(readonly=True, value='streaming', doc='''
- Command type name.
-
- Fixed: :const:`'streaming'`
-
- Supported by: SCP 2
-
- ''')
-
- # endregion
-
- # region Methods
-
- @classmethod
- def fix_up(cls, command):
- """ Verifies :code:`command` class structure.
-
- """
- if command.stream == StreamingCommand.stream:
- raise AttributeError('No StreamingCommand.stream override')
-
- # TODO: Stop looking like a dictionary because we don't obey the semantics
- # N.B.: Does not use Python 2 dict copy semantics
- def iteritems(self):
- iteritems = SearchCommand.ConfigurationSettings.iteritems(self)
- version = self.command.protocol_version
- if version == 1:
- if self.required_fields is None:
- iteritems = [name_value for name_value in iteritems if name_value[0] != 'clear_required_fields']
- else:
- iteritems = [name_value2 for name_value2 in iteritems if name_value2[0] != 'distributed']
- if not self.distributed:
- iteritems = [(name_value1[0], 'stateful') if name_value1[0] == 'type' else (name_value1[0], name_value1[1]) for name_value1 in iteritems]
- return iteritems
-
- # N.B.: Does not use Python 3 dict view semantics
- items = iteritems
-
- # endregion
diff --git a/lib/splunklib/searchcommands/validators.py b/lib/splunklib/searchcommands/validators.py
deleted file mode 100644
index ccaebca..0000000
--- a/lib/splunklib/searchcommands/validators.py
+++ /dev/null
@@ -1,423 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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 csv
-import os
-import re
-from io import open, StringIO
-from os import getcwd
-from json.encoder import encode_basestring_ascii as json_encode_string
-from collections import namedtuple
-
-
-
-class Validator:
- """ Base class for validators that check and format search command options.
-
- You must inherit from this class and override :code:`Validator.__call__` and
- :code:`Validator.format`. :code:`Validator.__call__` should convert the
- value it receives as argument and then return it or raise a
- :code:`ValueError`, if the value will not convert.
-
- :code:`Validator.format` should return a human readable version of the value
- it receives as argument the same way :code:`str` does.
-
- """
- def __call__(self, value):
- raise NotImplementedError()
-
- def format(self, value):
- raise NotImplementedError()
-
-
-class Boolean(Validator):
- """ Validates Boolean option values.
-
- """
- truth_values = {
- '1': True, '0': False,
- 't': True, 'f': False,
- 'true': True, 'false': False,
- 'y': True, 'n': False,
- 'yes': True, 'no': False
- }
-
- def __call__(self, value):
- if not (value is None or isinstance(value, bool)):
- value = str(value).lower()
- if value not in Boolean.truth_values:
- raise ValueError(f'Unrecognized truth value: {value}')
- value = Boolean.truth_values[value]
- return value
-
- def format(self, value):
- if value is None:
- return None
- return 't' if value else 'f'
-
-
-class Code(Validator):
- """ Validates code option values.
-
- This validator compiles an option value into a Python code object that can be executed by :func:`exec` or evaluated
- by :func:`eval`. The value returned is a :func:`namedtuple` with two members: object, the result of compilation, and
- source, the original option value.
-
- """
- def __init__(self, mode='eval'):
- """
- :param mode: Specifies what kind of code must be compiled; it can be :const:`'exec'`, if source consists of a
- sequence of statements, :const:`'eval'`, if it consists of a single expression, or :const:`'single'` if it
- consists of a single interactive statement. In the latter case, expression statements that evaluate to
- something other than :const:`None` will be printed.
- :type mode: unicode or bytes
-
- """
- self._mode = mode
-
- def __call__(self, value):
- if value is None:
- return None
- try:
- return Code.object(compile(value, 'string', self._mode), str(value))
- except (SyntaxError, TypeError) as error:
- message = str(error)
-
- raise ValueError(message) from error
-
- def format(self, value):
- return None if value is None else value.source
-
- object = namedtuple('Code', ('object', 'source'))
-
-
-class Fieldname(Validator):
- """ Validates field name option values.
-
- """
- pattern = re.compile(r'''[_.a-zA-Z-][_.a-zA-Z0-9-]*$''')
-
- def __call__(self, value):
- if value is not None:
- value = str(value)
- if Fieldname.pattern.match(value) is None:
- raise ValueError(f'Illegal characters in fieldname: {value}')
- return value
-
- def format(self, value):
- return value
-
-
-class File(Validator):
- """ Validates file option values.
-
- """
- def __init__(self, mode='rt', buffering=None, directory=None):
- self.mode = mode
- self.buffering = buffering
- self.directory = File._var_run_splunk if directory is None else directory
-
- def __call__(self, value):
-
- if value is None:
- return value
-
- path = str(value)
-
- if not os.path.isabs(path):
- path = os.path.join(self.directory, path)
-
- try:
- value = open(path, self.mode) if self.buffering is None else open(path, self.mode, self.buffering)
- except IOError as error:
- raise ValueError(f'Cannot open {value} with mode={self.mode} and buffering={self.buffering}: {error}')
-
- return value
-
- def format(self, value):
- return None if value is None else value.name
-
- _var_run_splunk = os.path.join(
- os.environ['SPLUNK_HOME'] if 'SPLUNK_HOME' in os.environ else getcwd(), 'var', 'run', 'splunk')
-
-
-class Integer(Validator):
- """ Validates integer option values.
-
- """
- def __init__(self, minimum=None, maximum=None):
- if minimum is not None and maximum is not None:
- def check_range(value):
- if not minimum <= value <= maximum:
- raise ValueError(f'Expected integer in the range [{minimum},{maximum}], not {value}')
-
- elif minimum is not None:
- def check_range(value):
- if value < minimum:
- raise ValueError(f'Expected integer in the range [{minimum},+∞], not {value}')
- elif maximum is not None:
- def check_range(value):
- if value > maximum:
- raise ValueError(f'Expected integer in the range [-∞,{maximum}], not {value}')
-
- else:
- def check_range(value):
- return
-
- self.check_range = check_range
-
-
- def __call__(self, value):
- if value is None:
- return None
- try:
- value = int(value)
- except ValueError:
- raise ValueError(f'Expected integer value, not {json_encode_string(value)}')
-
- self.check_range(value)
- return value
-
- def format(self, value):
- return None if value is None else str(int(value))
-
-
-class Float(Validator):
- """ Validates float option values.
-
- """
- def __init__(self, minimum=None, maximum=None):
- if minimum is not None and maximum is not None:
- def check_range(value):
- if not minimum <= value <= maximum:
- raise ValueError(f'Expected float in the range [{minimum},{maximum}], not {value}')
- elif minimum is not None:
- def check_range(value):
- if value < minimum:
- raise ValueError(f'Expected float in the range [{minimum},+∞], not {value}')
- elif maximum is not None:
- def check_range(value):
- if value > maximum:
- raise ValueError(f'Expected float in the range [-∞,{maximum}], not {value}')
- else:
- def check_range(value):
- return
- self.check_range = check_range
-
-
- def __call__(self, value):
- if value is None:
- return None
- try:
- value = float(value)
- except ValueError:
- raise ValueError(f'Expected float value, not {json_encode_string(value)}')
-
- self.check_range(value)
- return value
-
- def format(self, value):
- return None if value is None else str(float(value))
-
-
-class Duration(Validator):
- """ Validates duration option values.
-
- """
- def __call__(self, value):
-
- if value is None:
- return None
-
- p = value.split(':', 2)
- result = None
- _60 = Duration._60
- _unsigned = Duration._unsigned
-
- try:
- if len(p) == 1:
- result = _unsigned(p[0])
- if len(p) == 2:
- result = 60 * _unsigned(p[0]) + _60(p[1])
- if len(p) == 3:
- result = 3600 * _unsigned(p[0]) + 60 * _60(p[1]) + _60(p[2])
- except ValueError:
- raise ValueError(f'Invalid duration value: {value}')
-
- return result
-
- def format(self, value):
-
- if value is None:
- return None
-
- value = int(value)
-
- s = value % 60
- m = value // 60 % 60
- h = value // (60 * 60)
-
- return '{0:02d}:{1:02d}:{2:02d}'.format(h, m, s)
-
- _60 = Integer(0, 59)
- _unsigned = Integer(0)
-
-
-class List(Validator):
- """ Validates a list of strings
-
- """
- class Dialect(csv.Dialect):
- """ Describes the properties of list option values. """
- strict = True
- delimiter = str(',')
- quotechar = str('"')
- doublequote = True
- lineterminator = str('\n')
- skipinitialspace = True
- quoting = csv.QUOTE_MINIMAL
-
- def __init__(self, validator=None):
- if not (validator is None or isinstance(validator, Validator)):
- raise ValueError(f'Expected a Validator instance or None for validator, not {repr(validator)}')
- self._validator = validator
-
- def __call__(self, value):
-
- if value is None or isinstance(value, list):
- return value
-
- try:
- value = next(csv.reader([value], self.Dialect))
- except csv.Error as error:
- raise ValueError(error)
-
- if self._validator is None:
- return value
-
- try:
- for index, item in enumerate(value):
- value[index] = self._validator(item)
- except ValueError as error:
- raise ValueError(f'Could not convert item {index}: {error}')
-
- return value
-
- def format(self, value):
- output = StringIO()
- writer = csv.writer(output, List.Dialect)
- writer.writerow(value)
- value = output.getvalue()
- return value[:-1]
-
-
-class Map(Validator):
- """ Validates map option values.
-
- """
- def __init__(self, **kwargs):
- self.membership = kwargs
-
- def __call__(self, value):
-
- if value is None:
- return None
-
- value = str(value)
-
- if value not in self.membership:
- raise ValueError(f'Unrecognized value: {value}')
-
- return self.membership[value]
-
- def format(self, value):
- return None if value is None else list(self.membership.keys())[list(self.membership.values()).index(value)]
-
-
-class Match(Validator):
- """ Validates that a value matches a regular expression pattern.
-
- """
- def __init__(self, name, pattern, flags=0):
- self.name = str(name)
- self.pattern = re.compile(pattern, flags)
-
- def __call__(self, value):
- if value is None:
- return None
- value = str(value)
- if self.pattern.match(value) is None:
- raise ValueError(f'Expected {self.name}, not {json_encode_string(value)}')
- return value
-
- def format(self, value):
- return None if value is None else str(value)
-
-
-class OptionName(Validator):
- """ Validates option names.
-
- """
- pattern = re.compile(r'''(?=\w)[^\d]\w*$''', re.UNICODE)
-
- def __call__(self, value):
- if value is not None:
- value = str(value)
- if OptionName.pattern.match(value) is None:
- raise ValueError(f'Illegal characters in option name: {value}')
- return value
-
- def format(self, value):
- return None if value is None else str(value)
-
-
-class RegularExpression(Validator):
- """ Validates regular expression option values.
-
- """
- def __call__(self, value):
- if value is None:
- return None
- try:
- value = re.compile(str(value))
- except re.error as error:
- raise ValueError(f'{str(error).capitalize()}: {value}')
- return value
-
- def format(self, value):
- return None if value is None else value.pattern
-
-
-class Set(Validator):
- """ Validates set option values.
-
- """
- def __init__(self, *args):
- self.membership = set(args)
-
- def __call__(self, value):
- if value is None:
- return None
- value = str(value)
- if value not in self.membership:
- raise ValueError(f'Unrecognized value: {value}')
- return value
-
- def format(self, value):
- return self.__call__(value)
-
-
-__all__ = ['Boolean', 'Code', 'Duration', 'File', 'Integer', 'Float', 'List', 'Map', 'RegularExpression', 'Set']
diff --git a/lib/splunklib/six.py b/lib/splunklib/six.py
deleted file mode 100644
index d13e50c..0000000
--- a/lib/splunklib/six.py
+++ /dev/null
@@ -1,993 +0,0 @@
-# Copyright (c) 2010-2020 Benjamin Peterson
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-"""Utilities for writing code that runs on Python 2 and 3"""
-
-from __future__ import absolute_import
-
-import functools
-import itertools
-import operator
-import sys
-import types
-
-__author__ = "Benjamin Peterson "
-__version__ = "1.14.0"
-
-
-# Useful for very coarse version differentiation.
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-PY34 = sys.version_info[0:2] >= (3, 4)
-
-if PY3:
- string_types = str,
- integer_types = int,
- class_types = type,
- text_type = str
- binary_type = bytes
-
- MAXSIZE = sys.maxsize
-else:
- string_types = basestring,
- integer_types = (int, long)
- class_types = (type, types.ClassType)
- text_type = unicode
- binary_type = str
-
- if sys.platform.startswith("java"):
- # Jython always uses 32 bits.
- MAXSIZE = int((1 << 31) - 1)
- else:
- # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
- class X(object):
-
- def __len__(self):
- return 1 << 31
- try:
- len(X())
- except OverflowError:
- # 32-bit
- MAXSIZE = int((1 << 31) - 1)
- else:
- # 64-bit
- MAXSIZE = int((1 << 63) - 1)
- del X
-
-
-def _add_doc(func, doc):
- """Add documentation to a function."""
- func.__doc__ = doc
-
-
-def _import_module(name):
- """Import module, returning the module after the last dot."""
- __import__(name)
- return sys.modules[name]
-
-
-class _LazyDescr(object):
-
- def __init__(self, name):
- self.name = name
-
- def __get__(self, obj, tp):
- result = self._resolve()
- setattr(obj, self.name, result) # Invokes __set__.
- try:
- # This is a bit ugly, but it avoids running this again by
- # removing this descriptor.
- delattr(obj.__class__, self.name)
- except AttributeError:
- pass
- return result
-
-
-class MovedModule(_LazyDescr):
-
- def __init__(self, name, old, new=None):
- super(MovedModule, self).__init__(name)
- if PY3:
- if new is None:
- new = name
- self.mod = new
- else:
- self.mod = old
-
- def _resolve(self):
- return _import_module(self.mod)
-
- def __getattr__(self, attr):
- _module = self._resolve()
- value = getattr(_module, attr)
- setattr(self, attr, value)
- return value
-
-
-class _LazyModule(types.ModuleType):
-
- def __init__(self, name):
- super(_LazyModule, self).__init__(name)
- self.__doc__ = self.__class__.__doc__
-
- def __dir__(self):
- attrs = ["__doc__", "__name__"]
- attrs += [attr.name for attr in self._moved_attributes]
- return attrs
-
- # Subclasses should override this
- _moved_attributes = []
-
-
-class MovedAttribute(_LazyDescr):
-
- def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
- super(MovedAttribute, self).__init__(name)
- if PY3:
- if new_mod is None:
- new_mod = name
- self.mod = new_mod
- if new_attr is None:
- if old_attr is None:
- new_attr = name
- else:
- new_attr = old_attr
- self.attr = new_attr
- else:
- self.mod = old_mod
- if old_attr is None:
- old_attr = name
- self.attr = old_attr
-
- def _resolve(self):
- module = _import_module(self.mod)
- return getattr(module, self.attr)
-
-
-class _SixMetaPathImporter(object):
-
- """
- A meta path importer to import six.moves and its submodules.
-
- This class implements a PEP302 finder and loader. It should be compatible
- with Python 2.5 and all existing versions of Python3
- """
-
- def __init__(self, six_module_name):
- self.name = six_module_name
- self.known_modules = {}
-
- def _add_module(self, mod, *fullnames):
- for fullname in fullnames:
- self.known_modules[self.name + "." + fullname] = mod
-
- def _get_module(self, fullname):
- return self.known_modules[self.name + "." + fullname]
-
- def find_module(self, fullname, path=None):
- if fullname in self.known_modules:
- return self
- return None
-
- def __get_module(self, fullname):
- try:
- return self.known_modules[fullname]
- except KeyError:
- raise ImportError("This loader does not know module " + fullname)
-
- def load_module(self, fullname):
- try:
- # in case of a reload
- return sys.modules[fullname]
- except KeyError:
- pass
- mod = self.__get_module(fullname)
- if isinstance(mod, MovedModule):
- mod = mod._resolve()
- else:
- mod.__loader__ = self
- sys.modules[fullname] = mod
- return mod
-
- def is_package(self, fullname):
- """
- Return true, if the named module is a package.
-
- We need this method to get correct spec objects with
- Python 3.4 (see PEP451)
- """
- return hasattr(self.__get_module(fullname), "__path__")
-
- def get_code(self, fullname):
- """Return None
-
- Required, if is_package is implemented"""
- self.__get_module(fullname) # eventually raises ImportError
- return None
- get_source = get_code # same as get_code
-
-_importer = _SixMetaPathImporter(__name__)
-
-
-class _MovedItems(_LazyModule):
-
- """Lazy loading of moved objects"""
- __path__ = [] # mark as package
-
-
-_moved_attributes = [
- MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
- MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
- MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
- MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
- MovedAttribute("intern", "__builtin__", "sys"),
- MovedAttribute("map", "itertools", "builtins", "imap", "map"),
- MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
- MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
- MovedAttribute("getoutput", "commands", "subprocess"),
- MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
- MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
- MovedAttribute("reduce", "__builtin__", "functools"),
- MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
- MovedAttribute("StringIO", "StringIO", "io"),
- MovedAttribute("UserDict", "UserDict", "collections"),
- MovedAttribute("UserList", "UserList", "collections"),
- MovedAttribute("UserString", "UserString", "collections"),
- MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
- MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
- MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
- MovedModule("builtins", "__builtin__"),
- MovedModule("configparser", "ConfigParser"),
- MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
- MovedModule("copyreg", "copy_reg"),
- MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
- MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
- MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
- MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
- MovedModule("http_cookies", "Cookie", "http.cookies"),
- MovedModule("html_entities", "htmlentitydefs", "html.entities"),
- MovedModule("html_parser", "HTMLParser", "html.parser"),
- MovedModule("http_client", "httplib", "http.client"),
- MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
- MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
- MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
- MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
- MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
- MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
- MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
- MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
- MovedModule("cPickle", "cPickle", "pickle"),
- MovedModule("queue", "Queue"),
- MovedModule("reprlib", "repr"),
- MovedModule("socketserver", "SocketServer"),
- MovedModule("_thread", "thread", "_thread"),
- MovedModule("tkinter", "Tkinter"),
- MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
- MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
- MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
- MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
- MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
- MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
- MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
- MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
- MovedModule("tkinter_colorchooser", "tkColorChooser",
- "tkinter.colorchooser"),
- MovedModule("tkinter_commondialog", "tkCommonDialog",
- "tkinter.commondialog"),
- MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
- MovedModule("tkinter_font", "tkFont", "tkinter.font"),
- MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
- MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
- "tkinter.simpledialog"),
- MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
- MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
- MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
- MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
- MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
- MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
-]
-# Add windows specific modules.
-if sys.platform == "win32":
- _moved_attributes += [
- MovedModule("winreg", "_winreg"),
- ]
-
-for attr in _moved_attributes:
- setattr(_MovedItems, attr.name, attr)
- if isinstance(attr, MovedModule):
- _importer._add_module(attr, "moves." + attr.name)
-del attr
-
-_MovedItems._moved_attributes = _moved_attributes
-
-moves = _MovedItems(__name__ + ".moves")
-_importer._add_module(moves, "moves")
-
-
-class Module_six_moves_urllib_parse(_LazyModule):
-
- """Lazy loading of moved objects in six.moves.urllib_parse"""
-
-
-_urllib_parse_moved_attributes = [
- MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
- MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
- MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
- MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
- MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
- MovedAttribute("urljoin", "urlparse", "urllib.parse"),
- MovedAttribute("urlparse", "urlparse", "urllib.parse"),
- MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
- MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
- MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
- MovedAttribute("quote", "urllib", "urllib.parse"),
- MovedAttribute("quote_plus", "urllib", "urllib.parse"),
- MovedAttribute("unquote", "urllib", "urllib.parse"),
- MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
- MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
- MovedAttribute("urlencode", "urllib", "urllib.parse"),
- MovedAttribute("splitquery", "urllib", "urllib.parse"),
- MovedAttribute("splittag", "urllib", "urllib.parse"),
- MovedAttribute("splituser", "urllib", "urllib.parse"),
- MovedAttribute("splitvalue", "urllib", "urllib.parse"),
- MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
- MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
- MovedAttribute("uses_params", "urlparse", "urllib.parse"),
- MovedAttribute("uses_query", "urlparse", "urllib.parse"),
- MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
-]
-for attr in _urllib_parse_moved_attributes:
- setattr(Module_six_moves_urllib_parse, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
- "moves.urllib_parse", "moves.urllib.parse")
-
-
-class Module_six_moves_urllib_error(_LazyModule):
-
- """Lazy loading of moved objects in six.moves.urllib_error"""
-
-
-_urllib_error_moved_attributes = [
- MovedAttribute("URLError", "urllib2", "urllib.error"),
- MovedAttribute("HTTPError", "urllib2", "urllib.error"),
- MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
-]
-for attr in _urllib_error_moved_attributes:
- setattr(Module_six_moves_urllib_error, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
- "moves.urllib_error", "moves.urllib.error")
-
-
-class Module_six_moves_urllib_request(_LazyModule):
-
- """Lazy loading of moved objects in six.moves.urllib_request"""
-
-
-_urllib_request_moved_attributes = [
- MovedAttribute("urlopen", "urllib2", "urllib.request"),
- MovedAttribute("install_opener", "urllib2", "urllib.request"),
- MovedAttribute("build_opener", "urllib2", "urllib.request"),
- MovedAttribute("pathname2url", "urllib", "urllib.request"),
- MovedAttribute("url2pathname", "urllib", "urllib.request"),
- MovedAttribute("getproxies", "urllib", "urllib.request"),
- MovedAttribute("Request", "urllib2", "urllib.request"),
- MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
- MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
- MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
- MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
- MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
- MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
- MovedAttribute("FileHandler", "urllib2", "urllib.request"),
- MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
- MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
- MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
- MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
- MovedAttribute("urlretrieve", "urllib", "urllib.request"),
- MovedAttribute("urlcleanup", "urllib", "urllib.request"),
- MovedAttribute("URLopener", "urllib", "urllib.request"),
- MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
- MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
- MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
- MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
-]
-for attr in _urllib_request_moved_attributes:
- setattr(Module_six_moves_urllib_request, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
- "moves.urllib_request", "moves.urllib.request")
-
-
-class Module_six_moves_urllib_response(_LazyModule):
-
- """Lazy loading of moved objects in six.moves.urllib_response"""
-
-
-_urllib_response_moved_attributes = [
- MovedAttribute("addbase", "urllib", "urllib.response"),
- MovedAttribute("addclosehook", "urllib", "urllib.response"),
- MovedAttribute("addinfo", "urllib", "urllib.response"),
- MovedAttribute("addinfourl", "urllib", "urllib.response"),
-]
-for attr in _urllib_response_moved_attributes:
- setattr(Module_six_moves_urllib_response, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
- "moves.urllib_response", "moves.urllib.response")
-
-
-class Module_six_moves_urllib_robotparser(_LazyModule):
-
- """Lazy loading of moved objects in six.moves.urllib_robotparser"""
-
-
-_urllib_robotparser_moved_attributes = [
- MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
-]
-for attr in _urllib_robotparser_moved_attributes:
- setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
- "moves.urllib_robotparser", "moves.urllib.robotparser")
-
-
-class Module_six_moves_urllib(types.ModuleType):
-
- """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
- __path__ = [] # mark as package
- parse = _importer._get_module("moves.urllib_parse")
- error = _importer._get_module("moves.urllib_error")
- request = _importer._get_module("moves.urllib_request")
- response = _importer._get_module("moves.urllib_response")
- robotparser = _importer._get_module("moves.urllib_robotparser")
-
- def __dir__(self):
- return ['parse', 'error', 'request', 'response', 'robotparser']
-
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
- "moves.urllib")
-
-
-def add_move(move):
- """Add an item to six.moves."""
- setattr(_MovedItems, move.name, move)
-
-
-def remove_move(name):
- """Remove item from six.moves."""
- try:
- delattr(_MovedItems, name)
- except AttributeError:
- try:
- del moves.__dict__[name]
- except KeyError:
- raise AttributeError("no such move, %r" % (name,))
-
-
-if PY3:
- _meth_func = "__func__"
- _meth_self = "__self__"
-
- _func_closure = "__closure__"
- _func_code = "__code__"
- _func_defaults = "__defaults__"
- _func_globals = "__globals__"
-else:
- _meth_func = "im_func"
- _meth_self = "im_self"
-
- _func_closure = "func_closure"
- _func_code = "func_code"
- _func_defaults = "func_defaults"
- _func_globals = "func_globals"
-
-
-try:
- advance_iterator = next
-except NameError:
- def advance_iterator(it):
- return it.next()
-next = advance_iterator
-
-
-try:
- callable = callable
-except NameError:
- def callable(obj):
- return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-if PY3:
- def get_unbound_function(unbound):
- return unbound
-
- create_bound_method = types.MethodType
-
- def create_unbound_method(func, cls):
- return func
-
- Iterator = object
-else:
- def get_unbound_function(unbound):
- return unbound.im_func
-
- def create_bound_method(func, obj):
- return types.MethodType(func, obj, obj.__class__)
-
- def create_unbound_method(func, cls):
- return types.MethodType(func, None, cls)
-
- class Iterator(object):
-
- def next(self):
- return type(self).__next__(self)
-
- callable = callable
-_add_doc(get_unbound_function,
- """Get the function out of a possibly unbound function""")
-
-
-get_method_function = operator.attrgetter(_meth_func)
-get_method_self = operator.attrgetter(_meth_self)
-get_function_closure = operator.attrgetter(_func_closure)
-get_function_code = operator.attrgetter(_func_code)
-get_function_defaults = operator.attrgetter(_func_defaults)
-get_function_globals = operator.attrgetter(_func_globals)
-
-
-if PY3:
- def iterkeys(d, **kw):
- return iter(d.keys(**kw))
-
- def itervalues(d, **kw):
- return iter(d.values(**kw))
-
- def iteritems(d, **kw):
- return iter(d.items(**kw))
-
- def iterlists(d, **kw):
- return iter(d.lists(**kw))
-
- viewkeys = operator.methodcaller("keys")
-
- viewvalues = operator.methodcaller("values")
-
- viewitems = operator.methodcaller("items")
-else:
- def iterkeys(d, **kw):
- return d.iterkeys(**kw)
-
- def itervalues(d, **kw):
- return d.itervalues(**kw)
-
- def iteritems(d, **kw):
- return d.iteritems(**kw)
-
- def iterlists(d, **kw):
- return d.iterlists(**kw)
-
- viewkeys = operator.methodcaller("viewkeys")
-
- viewvalues = operator.methodcaller("viewvalues")
-
- viewitems = operator.methodcaller("viewitems")
-
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
-_add_doc(iteritems,
- "Return an iterator over the (key, value) pairs of a dictionary.")
-_add_doc(iterlists,
- "Return an iterator over the (key, [values]) pairs of a dictionary.")
-
-
-if PY3:
- def b(s):
- return s.encode("latin-1")
-
- def u(s):
- return s
- unichr = chr
- import struct
- int2byte = struct.Struct(">B").pack
- del struct
- byte2int = operator.itemgetter(0)
- indexbytes = operator.getitem
- iterbytes = iter
- import io
- StringIO = io.StringIO
- BytesIO = io.BytesIO
- del io
- _assertCountEqual = "assertCountEqual"
- if sys.version_info[1] <= 1:
- _assertRaisesRegex = "assertRaisesRegexp"
- _assertRegex = "assertRegexpMatches"
- _assertNotRegex = "assertNotRegexpMatches"
- else:
- _assertRaisesRegex = "assertRaisesRegex"
- _assertRegex = "assertRegex"
- _assertNotRegex = "assertNotRegex"
-else:
- def b(s):
- return s
- # Workaround for standalone backslash
-
- def u(s):
- return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
- unichr = unichr
- int2byte = chr
-
- def byte2int(bs):
- return ord(bs[0])
-
- def indexbytes(buf, i):
- return ord(buf[i])
- iterbytes = functools.partial(itertools.imap, ord)
- import StringIO
- StringIO = BytesIO = StringIO.StringIO
- _assertCountEqual = "assertItemsEqual"
- _assertRaisesRegex = "assertRaisesRegexp"
- _assertRegex = "assertRegexpMatches"
- _assertNotRegex = "assertNotRegexpMatches"
-_add_doc(b, """Byte literal""")
-_add_doc(u, """Text literal""")
-
-
-def assertCountEqual(self, *args, **kwargs):
- return getattr(self, _assertCountEqual)(*args, **kwargs)
-
-
-def assertRaisesRegex(self, *args, **kwargs):
- return getattr(self, _assertRaisesRegex)(*args, **kwargs)
-
-
-def assertRegex(self, *args, **kwargs):
- return getattr(self, _assertRegex)(*args, **kwargs)
-
-
-def assertNotRegex(self, *args, **kwargs):
- return getattr(self, _assertNotRegex)(*args, **kwargs)
-
-
-if PY3:
- exec_ = getattr(moves.builtins, "exec")
-
- def reraise(tp, value, tb=None):
- try:
- if value is None:
- value = tp()
- if value.__traceback__ is not tb:
- raise value.with_traceback(tb)
- raise value
- finally:
- value = None
- tb = None
-
-else:
- def exec_(_code_, _globs_=None, _locs_=None):
- """Execute code in a namespace."""
- if _globs_ is None:
- frame = sys._getframe(1)
- _globs_ = frame.f_globals
- if _locs_ is None:
- _locs_ = frame.f_locals
- del frame
- elif _locs_ is None:
- _locs_ = _globs_
- exec("""exec _code_ in _globs_, _locs_""")
-
- exec_("""def reraise(tp, value, tb=None):
- try:
- raise tp, value, tb
- finally:
- tb = None
-""")
-
-
-if sys.version_info[:2] > (3,):
- exec_("""def raise_from(value, from_value):
- try:
- raise value from from_value
- finally:
- value = None
-""")
-else:
- def raise_from(value, from_value):
- raise value
-
-
-print_ = getattr(moves.builtins, "print", None)
-if print_ is None:
- def print_(*args, **kwargs):
- """The new-style print function for Python 2.4 and 2.5."""
- fp = kwargs.pop("file", sys.stdout)
- if fp is None:
- return
-
- def write(data):
- if not isinstance(data, basestring):
- data = str(data)
- # If the file has an encoding, encode unicode with it.
- if (isinstance(fp, file) and
- isinstance(data, unicode) and
- fp.encoding is not None):
- errors = getattr(fp, "errors", None)
- if errors is None:
- errors = "strict"
- data = data.encode(fp.encoding, errors)
- fp.write(data)
- want_unicode = False
- sep = kwargs.pop("sep", None)
- if sep is not None:
- if isinstance(sep, unicode):
- want_unicode = True
- elif not isinstance(sep, str):
- raise TypeError("sep must be None or a string")
- end = kwargs.pop("end", None)
- if end is not None:
- if isinstance(end, unicode):
- want_unicode = True
- elif not isinstance(end, str):
- raise TypeError("end must be None or a string")
- if kwargs:
- raise TypeError("invalid keyword arguments to print()")
- if not want_unicode:
- for arg in args:
- if isinstance(arg, unicode):
- want_unicode = True
- break
- if want_unicode:
- newline = unicode("\n")
- space = unicode(" ")
- else:
- newline = "\n"
- space = " "
- if sep is None:
- sep = space
- if end is None:
- end = newline
- for i, arg in enumerate(args):
- if i:
- write(sep)
- write(arg)
- write(end)
-if sys.version_info[:2] < (3, 3):
- _print = print_
-
- def print_(*args, **kwargs):
- fp = kwargs.get("file", sys.stdout)
- flush = kwargs.pop("flush", False)
- _print(*args, **kwargs)
- if flush and fp is not None:
- fp.flush()
-
-_add_doc(reraise, """Reraise an exception.""")
-
-if sys.version_info[0:2] < (3, 4):
- # This does exactly the same what the :func:`py3:functools.update_wrapper`
- # function does on Python versions after 3.2. It sets the ``__wrapped__``
- # attribute on ``wrapper`` object and it doesn't raise an error if any of
- # the attributes mentioned in ``assigned`` and ``updated`` are missing on
- # ``wrapped`` object.
- def _update_wrapper(wrapper, wrapped,
- assigned=functools.WRAPPER_ASSIGNMENTS,
- updated=functools.WRAPPER_UPDATES):
- for attr in assigned:
- try:
- value = getattr(wrapped, attr)
- except AttributeError:
- continue
- else:
- setattr(wrapper, attr, value)
- for attr in updated:
- getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
- wrapper.__wrapped__ = wrapped
- return wrapper
- _update_wrapper.__doc__ = functools.update_wrapper.__doc__
-
- def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
- updated=functools.WRAPPER_UPDATES):
- return functools.partial(_update_wrapper, wrapped=wrapped,
- assigned=assigned, updated=updated)
- wraps.__doc__ = functools.wraps.__doc__
-
-else:
- wraps = functools.wraps
-
-
-def with_metaclass(meta, *bases):
- """Create a base class with a metaclass."""
- # This requires a bit of explanation: the basic idea is to make a dummy
- # metaclass for one level of class instantiation that replaces itself with
- # the actual metaclass.
- class metaclass(type):
-
- def __new__(cls, name, this_bases, d):
- if sys.version_info[:2] >= (3, 7):
- # This version introduced PEP 560 that requires a bit
- # of extra care (we mimic what is done by __build_class__).
- resolved_bases = types.resolve_bases(bases)
- if resolved_bases is not bases:
- d['__orig_bases__'] = bases
- else:
- resolved_bases = bases
- return meta(name, resolved_bases, d)
-
- @classmethod
- def __prepare__(cls, name, this_bases):
- return meta.__prepare__(name, bases)
- return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-def add_metaclass(metaclass):
- """Class decorator for creating a class with a metaclass."""
- def wrapper(cls):
- orig_vars = cls.__dict__.copy()
- slots = orig_vars.get('__slots__')
- if slots is not None:
- if isinstance(slots, str):
- slots = [slots]
- for slots_var in slots:
- orig_vars.pop(slots_var)
- orig_vars.pop('__dict__', None)
- orig_vars.pop('__weakref__', None)
- if hasattr(cls, '__qualname__'):
- orig_vars['__qualname__'] = cls.__qualname__
- return metaclass(cls.__name__, cls.__bases__, orig_vars)
- return wrapper
-
-
-def ensure_binary(s, encoding='utf-8', errors='strict'):
- """Coerce **s** to six.binary_type.
-
- For Python 2:
- - `unicode` -> encoded to `str`
- - `str` -> `str`
-
- For Python 3:
- - `str` -> encoded to `bytes`
- - `bytes` -> `bytes`
- """
- if isinstance(s, text_type):
- return s.encode(encoding, errors)
- elif isinstance(s, binary_type):
- return s
- else:
- raise TypeError("not expecting type '%s'" % type(s))
-
-
-def ensure_str(s, encoding='utf-8', errors='strict'):
- """Coerce *s* to `str`.
-
- For Python 2:
- - `unicode` -> encoded to `str`
- - `str` -> `str`
-
- For Python 3:
- - `str` -> `str`
- - `bytes` -> decoded to `str`
- """
- if not isinstance(s, (text_type, binary_type)):
- raise TypeError("not expecting type '%s'" % type(s))
- if PY2 and isinstance(s, text_type):
- s = s.encode(encoding, errors)
- elif PY3 and isinstance(s, binary_type):
- s = s.decode(encoding, errors)
- return s
-
-
-def ensure_text(s, encoding='utf-8', errors='strict'):
- """Coerce *s* to six.text_type.
-
- For Python 2:
- - `unicode` -> `unicode`
- - `str` -> `unicode`
-
- For Python 3:
- - `str` -> `str`
- - `bytes` -> decoded to `str`
- """
- if isinstance(s, binary_type):
- return s.decode(encoding, errors)
- elif isinstance(s, text_type):
- return s
- else:
- raise TypeError("not expecting type '%s'" % type(s))
-
-
-def python_2_unicode_compatible(klass):
- """
- A class decorator that defines __unicode__ and __str__ methods under Python 2.
- Under Python 3 it does nothing.
-
- To support Python 2 and 3 with a single code base, define a __str__ method
- returning text and apply this decorator to the class.
- """
- if PY2:
- if '__str__' not in klass.__dict__:
- raise ValueError("@python_2_unicode_compatible cannot be applied "
- "to %s because it doesn't define __str__()." %
- klass.__name__)
- klass.__unicode__ = klass.__str__
- klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
- return klass
-
-
-# Complete the moves implementation.
-# This code is at the end of this module to speed up module loading.
-# Turn this module into a package.
-__path__ = [] # required for PEP 302 and PEP 451
-__package__ = __name__ # see PEP 366 @ReservedAssignment
-if globals().get("__spec__") is not None:
- __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable
-# Remove other six meta path importers, since they cause problems. This can
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does
-# this for some reason.)
-if sys.meta_path:
- for i, importer in enumerate(sys.meta_path):
- # Here's some real nastiness: Another "instance" of the six module might
- # be floating around. Therefore, we can't use isinstance() to check for
- # the six meta path importer, since the other six instance will have
- # inserted an importer with different class.
- if (type(importer).__name__ == "_SixMetaPathImporter" and
- importer.name == __name__):
- del sys.meta_path[i]
- break
- del i, importer
-# Finally, add the importer to the meta path import hook.
-sys.meta_path.append(_importer)
-
-import warnings
-
-def deprecated(message):
- def deprecated_decorator(func):
- def deprecated_func(*args, **kwargs):
- warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
- category=DeprecationWarning,
- stacklevel=2)
- warnings.simplefilter('default', DeprecationWarning)
- return func(*args, **kwargs)
- return deprecated_func
- return deprecated_decorator
\ No newline at end of file
diff --git a/lib/splunklib/utils.py b/lib/splunklib/utils.py
deleted file mode 100644
index db9c312..0000000
--- a/lib/splunklib/utils.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# Copyright © 2011-2024 Splunk, Inc.
-#
-# 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.
-
-"""The **splunklib.utils** File for utility functions.
-"""
-
-
-def ensure_binary(s, encoding='utf-8', errors='strict'):
- """
- - `str` -> encoded to `bytes`
- - `bytes` -> `bytes`
- """
- if isinstance(s, str):
- return s.encode(encoding, errors)
-
- if isinstance(s, bytes):
- return s
-
- raise TypeError(f"not expecting type '{type(s)}'")
-
-
-def ensure_str(s, encoding='utf-8', errors='strict'):
- """
- - `str` -> `str`
- - `bytes` -> decoded to `str`
- """
- if isinstance(s, bytes):
- return s.decode(encoding, errors)
-
- if isinstance(s, str):
- return s
-
- raise TypeError(f"not expecting type '{type(s)}'")
-
-
-def assertRegex(self, *args, **kwargs):
- return getattr(self, "assertRegex")(*args, **kwargs)
-
-
- 
-
-
- 
-