diff --git a/python/user_packages/Python313/site-packages/importlib_resources-7.1.0.dist-info/licenses/LICENSE b/python/user_packages/Python313/site-packages/importlib_resources-7.1.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7b25cfb85f10bb21140ba18e5df5087d75406dd5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources-7.1.0.dist-info/licenses/LICENSE @@ -0,0 +1,73 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. + +Copyright 2026 [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_adapters.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_adapters.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..252a6ed37cbe897046b925747da5bdf847a184cd Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_adapters.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_common.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_common.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22586a6fd57a0bf0b6c69d8997c42e96275d1506 Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_common.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_functional.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_functional.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b20362494253a42cff12a69a181351300217016 Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_functional.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_itertools.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_itertools.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03aa1e53e7be7e479e8fb71e3ef392c702db21ff Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/_itertools.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/abc.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/abc.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ac5c5cd06fddda3a579cfc7dff665a2efdec0f5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/abc.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/readers.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/readers.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16f9d03888da1cc6a02d69af8d32fd370c3ff631 Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/readers.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/simple.cpython-313.pyc b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/simple.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84e512389c4a287d8c3d28ae5177309ba80d6461 Binary files /dev/null and b/python/user_packages/Python313/site-packages/importlib_resources/__pycache__/simple.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/importlib_resources/compat/__init__.py b/python/user_packages/Python313/site-packages/importlib_resources/compat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/importlib_resources/compat/py39.py b/python/user_packages/Python313/site-packages/importlib_resources/compat/py39.py new file mode 100644 index 0000000000000000000000000000000000000000..684d3c638311527c24350f29c9bcc93c142b210a --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/compat/py39.py @@ -0,0 +1,9 @@ +import sys + +__all__ = ['ZipPath'] + + +if sys.version_info >= (3, 10): + from zipfile import Path as ZipPath +else: + from zipp import Path as ZipPath diff --git a/python/user_packages/Python313/site-packages/importlib_resources/future/__init__.py b/python/user_packages/Python313/site-packages/importlib_resources/future/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/importlib_resources/future/adapters.py b/python/user_packages/Python313/site-packages/importlib_resources/future/adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..239e52b795fc45ae614d0f7f641b5b4c3f272740 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/future/adapters.py @@ -0,0 +1,102 @@ +import functools +import pathlib +from contextlib import suppress +from types import SimpleNamespace + +from .. import _adapters, readers + + +def _block_standard(reader_getter): + """ + Wrap _adapters.TraversableResourcesLoader.get_resource_reader + and intercept any standard library readers. + """ + + @functools.wraps(reader_getter) + def wrapper(*args, **kwargs): + """ + If the reader is from the standard library, return None to allow + allow likely newer implementations in this library to take precedence. + """ + try: + reader = reader_getter(*args, **kwargs) + except NotADirectoryError: + # MultiplexedPath may fail on zip subdirectory + return + except ValueError as exc: + # NamespaceReader in stdlib may fail for editable installs + # (python/importlib_resources#311, python/importlib_resources#318) + # Remove after bugfix applied to Python 3.13. + if "not enough values to unpack" not in str(exc): + raise + return + # Python 3.10+ + mod_name = reader.__class__.__module__ + if mod_name.startswith('importlib.') and mod_name.endswith('readers'): + return + # Python 3.8, 3.9 + if isinstance(reader, _adapters.CompatibilityFiles) and ( + reader.spec.loader.__class__.__module__.startswith('zipimport') + or reader.spec.loader.__class__.__module__.startswith( + '_frozen_importlib_external' + ) + ): + return + return reader + + return wrapper + + +def _skip_degenerate(reader): + """ + Mask any degenerate reader. Ref #298. + """ + is_degenerate = ( + isinstance(reader, _adapters.CompatibilityFiles) and not reader._reader + ) + return reader if not is_degenerate else None + + +class TraversableResourcesLoader(_adapters.TraversableResourcesLoader): + """ + Adapt loaders to provide TraversableResources and other + compatibility. + + Ensures the readers from importlib_resources are preferred + over stdlib readers. + """ + + def get_resource_reader(self, name): + return ( + _skip_degenerate(_block_standard(super().get_resource_reader)(name)) + or self._standard_reader() + or super().get_resource_reader(name) + ) + + def _standard_reader(self): + return self._zip_reader() or self._namespace_reader() or self._file_reader() + + def _zip_reader(self): + with suppress(AttributeError): + return readers.ZipReader(self.spec.loader, self.spec.name) + + def _namespace_reader(self): + with suppress(AttributeError, ValueError): + return readers.NamespaceReader(self.spec.submodule_search_locations) + + def _file_reader(self): + try: + path = pathlib.Path(self.spec.origin) + except TypeError: + return None + if path.exists(): + return readers.FileReader(SimpleNamespace(path=path)) + + +def wrap_spec(package): + """ + Override _adapters.wrap_spec to use TraversableResourcesLoader + from above. Ensures that future behavior is always available on older + Pythons. + """ + return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader) diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/__init__.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/_path.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/_path.py new file mode 100644 index 0000000000000000000000000000000000000000..3720af7c5085d7e1ab1d2054e355b0e2bc404522 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/_path.py @@ -0,0 +1,90 @@ +import functools +import pathlib +from typing import Protocol, Union, runtime_checkable + +#### +# from jaraco.path 3.7.1 + + +class Symlink(str): + """ + A string indicating the target of a symlink. + """ + + +FilesSpec = dict[str, Union[str, bytes, Symlink, 'FilesSpec']] + + +@runtime_checkable +class TreeMaker(Protocol): + def __truediv__(self, *args, **kwargs): ... # pragma: no cover + + def mkdir(self, **kwargs): ... # pragma: no cover + + def write_text(self, content, **kwargs): ... # pragma: no cover + + def write_bytes(self, content): ... # pragma: no cover + + def symlink_to(self, target): ... # pragma: no cover + + +def _ensure_tree_maker(obj: str | TreeMaker) -> TreeMaker: + return obj if isinstance(obj, TreeMaker) else pathlib.Path(obj) # type: ignore[return-value] + + +def build( + spec: FilesSpec, + prefix: str | TreeMaker = pathlib.Path(), # type: ignore[assignment] +): + """ + Build a set of files/directories, as described by the spec. + + Each key represents a pathname, and the value represents + the content. Content may be a nested directory. + + >>> spec = { + ... 'README.txt': "A README file", + ... "foo": { + ... "__init__.py": "", + ... "bar": { + ... "__init__.py": "", + ... }, + ... "baz.py": "# Some code", + ... "bar.py": Symlink("baz.py"), + ... }, + ... "bing": Symlink("foo"), + ... } + >>> target = getfixture('tmp_path') + >>> build(spec, target) + >>> target.joinpath('foo/baz.py').read_text(encoding='utf-8') + '# Some code' + >>> target.joinpath('bing/bar.py').read_text(encoding='utf-8') + '# Some code' + """ + for name, contents in spec.items(): + create(contents, _ensure_tree_maker(prefix) / name) + + +@functools.singledispatch +def create(content: str | bytes | FilesSpec, path): + path.mkdir(exist_ok=True) + build(content, prefix=path) # type: ignore[arg-type] + + +@create.register +def _(content: bytes, path): + path.write_bytes(content) + + +@create.register +def _(content: str, path): + path.write_text(content, encoding='utf-8') + + +@create.register +def _(content: Symlink, path): + path.symlink_to(content) + + +# end from jaraco.path +#### diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_compatibilty_files.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_compatibilty_files.py new file mode 100644 index 0000000000000000000000000000000000000000..6b3b1696cf10dcc834c12b8e2d7ae26859fd6595 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_compatibilty_files.py @@ -0,0 +1,98 @@ +import io +import unittest + +import importlib_resources as resources +from importlib_resources._adapters import ( + CompatibilityFiles, + wrap_spec, +) + +from . import util + + +class CompatibilityFilesTests(unittest.TestCase): + @property + def package(self): + bytes_data = io.BytesIO(b'Hello, world!') + return util.create_package( + file=bytes_data, + path='some_path', + contents=('a', 'b', 'c'), + ) + + @property + def files(self): + return resources.files(self.package) + + def test_spec_path_iter(self): + assert sorted(path.name for path in self.files.iterdir()) == ['a', 'b', 'c'] + + def test_child_path_iter(self): + assert list((self.files / 'a').iterdir()) == [] + + def test_orphan_path_iter(self): + assert list((self.files / 'a' / 'a').iterdir()) == [] + assert list((self.files / 'a' / 'a' / 'a').iterdir()) == [] + + def test_spec_path_is(self): + assert not self.files.is_file() + assert not self.files.is_dir() + + def test_child_path_is(self): + assert (self.files / 'a').is_file() + assert not (self.files / 'a').is_dir() + + def test_orphan_path_is(self): + assert not (self.files / 'a' / 'a').is_file() + assert not (self.files / 'a' / 'a').is_dir() + assert not (self.files / 'a' / 'a' / 'a').is_file() + assert not (self.files / 'a' / 'a' / 'a').is_dir() + + def test_spec_path_name(self): + assert self.files.name == 'testingpackage' + + def test_child_path_name(self): + assert (self.files / 'a').name == 'a' + + def test_orphan_path_name(self): + assert (self.files / 'a' / 'b').name == 'b' + assert (self.files / 'a' / 'b' / 'c').name == 'c' + + def test_spec_path_open(self): + assert self.files.read_bytes() == b'Hello, world!' + assert self.files.read_text(encoding='utf-8') == 'Hello, world!' + + def test_child_path_open(self): + assert (self.files / 'a').read_bytes() == b'Hello, world!' + assert (self.files / 'a').read_text(encoding='utf-8') == 'Hello, world!' + + def test_orphan_path_open(self): + with self.assertRaises(FileNotFoundError): + (self.files / 'a' / 'b').read_bytes() + with self.assertRaises(FileNotFoundError): + (self.files / 'a' / 'b' / 'c').read_bytes() + + def test_open_invalid_mode(self): + with self.assertRaises(ValueError): + self.files.open('0') + + def test_orphan_path_invalid(self): + with self.assertRaises(ValueError): + CompatibilityFiles.OrphanPath() + + def test_wrap_spec(self): + spec = wrap_spec(self.package) + assert isinstance(spec.loader.get_resource_reader(None), CompatibilityFiles) + + +class CompatibilityFilesNoReaderTests(unittest.TestCase): + @property + def package(self): + return util.create_package_from_loader(None) + + @property + def files(self): + return resources.files(self.package) + + def test_spec_path_joinpath(self): + assert isinstance(self.files / 'a', CompatibilityFiles.OrphanPath) diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_contents.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_contents.py new file mode 100644 index 0000000000000000000000000000000000000000..dcb872ec05fd05a266ee5a4b69e3ade31fa1cc0d --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_contents.py @@ -0,0 +1,39 @@ +import unittest + +import importlib_resources as resources + +from . import util + + +class ContentsTests: + expected = { + '__init__.py', + 'binary.file', + 'subdirectory', + 'utf-16.file', + 'utf-8.file', + } + + def test_contents(self): + contents = {path.name for path in resources.files(self.data).iterdir()} + assert self.expected <= contents + + +class ContentsDiskTests(ContentsTests, util.DiskSetup, unittest.TestCase): + pass + + +class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase): + pass + + +class ContentsNamespaceTests(ContentsTests, util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + expected = { + # no __init__ because of namespace design + 'binary.file', + 'subdirectory', + 'utf-16.file', + 'utf-8.file', + } diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_custom.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_custom.py new file mode 100644 index 0000000000000000000000000000000000000000..25ae0e75784d9021aea6d089206fe87b05ee8831 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_custom.py @@ -0,0 +1,48 @@ +import contextlib +import pathlib +import unittest + +import importlib_resources as resources + +from .. import abc +from ..abc import ResourceReader, TraversableResources +from . import util +from .compat.py39 import os_helper + + +class SimpleLoader: + """ + A simple loader that only implements a resource reader. + """ + + def __init__(self, reader: ResourceReader): + self.reader = reader + + def get_resource_reader(self, package): + return self.reader + + +class MagicResources(TraversableResources): + """ + Magically returns the resources at path. + """ + + def __init__(self, path: pathlib.Path): + self.path = path + + def files(self): + return self.path + + +class CustomTraversableResourcesTests(unittest.TestCase): + def setUp(self): + self.fixtures = contextlib.ExitStack() + self.addCleanup(self.fixtures.close) + + def test_custom_loader(self): + temp_dir = pathlib.Path(self.fixtures.enter_context(os_helper.temp_dir())) + loader = SimpleLoader(MagicResources(temp_dir)) + pkg = util.create_package_from_loader(loader) + files = resources.files(pkg) + assert isinstance(files, abc.Traversable) + assert list(files.iterdir()) == [] diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_files.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_files.py new file mode 100644 index 0000000000000000000000000000000000000000..06237d7b3b5a2ea641a92fa80c9d93e4284b6670 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_files.py @@ -0,0 +1,186 @@ +import contextlib +import importlib +import pathlib +import py_compile +import textwrap +import unittest +import warnings + +import importlib_resources as resources + +from ..abc import Traversable +from . import util +from .compat.py39 import import_helper, os_helper + + +@contextlib.contextmanager +def suppress_known_deprecation(): + with warnings.catch_warnings(record=True) as ctx: + warnings.simplefilter('default', category=DeprecationWarning) + yield ctx + + +class FilesTests: + def test_read_bytes(self): + files = resources.files(self.data) + actual = files.joinpath('utf-8.file').read_bytes() + assert actual == b'Hello, UTF-8 world!\n' + + def test_read_text(self): + files = resources.files(self.data) + actual = files.joinpath('utf-8.file').read_text(encoding='utf-8') + assert actual == 'Hello, UTF-8 world!\n' + + def test_traversable(self): + assert isinstance(resources.files(self.data), Traversable) + + def test_joinpath_with_multiple_args(self): + files = resources.files(self.data) + binfile = files.joinpath('subdirectory', 'binary.file') + assert binfile.is_file() + + +class OpenDiskTests(FilesTests, util.DiskSetup, unittest.TestCase): + pass + + +class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase): + pass + + +class OpenNamespaceTests(FilesTests, util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + def test_non_paths_in_dunder_path(self): + """ + Non-path items in a namespace package's ``__path__`` are ignored. + + As reported in python/importlib_resources#311, some tools + like Setuptools, when creating editable packages, will inject + non-paths into a namespace package's ``__path__``, a + sentinel like + ``__editable__.sample_namespace-1.0.finder.__path_hook__`` + to cause the ``PathEntryFinder`` to be called when searching + for packages. In that case, resources should still be loadable. + """ + import namespacedata01 # type: ignore[import-not-found] + + namespacedata01.__path__.append( + '__editable__.sample_namespace-1.0.finder.__path_hook__' + ) + + resources.files(namespacedata01) + + +class OpenNamespaceZipTests(FilesTests, util.ZipSetup, unittest.TestCase): + ZIP_MODULE = 'namespacedata01' + + +class DirectSpec: + """ + Override behavior of ModuleSetup to write a full spec directly. + """ + + MODULE = 'unused' + + def load_fixture(self, name): + self.tree_on_path(self.spec) + + +class ModulesFiles: + spec = { + 'mod.py': '', + 'res.txt': 'resources are the best', + } + + def test_module_resources(self): + """ + A module can have resources found adjacent to the module. + """ + import mod # type: ignore[import-not-found] + + actual = resources.files(mod).joinpath('res.txt').read_text(encoding='utf-8') + assert actual == self.spec['res.txt'] + + +class ModuleFilesDiskTests(DirectSpec, util.DiskSetup, ModulesFiles, unittest.TestCase): + pass + + +class ModuleFilesZipTests(DirectSpec, util.ZipSetup, ModulesFiles, unittest.TestCase): + pass + + +class ImplicitContextFiles: + set_val = textwrap.dedent( + f""" + import {resources.__name__} as res + val = res.files().joinpath('res.txt').read_text(encoding='utf-8') + """ + ) + spec = { + 'somepkg': { + '__init__.py': set_val, + 'submod.py': set_val, + 'res.txt': 'resources are the best', + }, + 'frozenpkg': { + '__init__.py': set_val.replace(resources.__name__, 'c_resources'), + 'res.txt': 'resources are the best', + }, + } + + def test_implicit_files_package(self): + """ + Without any parameter, files() will infer the location as the caller. + """ + assert importlib.import_module('somepkg').val == 'resources are the best' + + def test_implicit_files_submodule(self): + """ + Without any parameter, files() will infer the location as the caller. + """ + assert importlib.import_module('somepkg.submod').val == 'resources are the best' + + def _compile_importlib(self): + """ + Make a compiled-only copy of the importlib resources package. + + Currently only code is copied, as importlib resources doesn't itself + have any resources. + """ + bin_site = self.fixtures.enter_context(os_helper.temp_dir()) + c_resources = pathlib.Path(bin_site, 'c_resources') + sources = pathlib.Path(resources.__file__).parent + + for source_path in sources.glob('**/*.py'): + c_path = c_resources.joinpath(source_path.relative_to(sources)).with_suffix( + '.pyc' + ) + py_compile.compile(source_path, c_path) + self.fixtures.enter_context(import_helper.DirsOnSysPath(bin_site)) + + def test_implicit_files_with_compiled_importlib(self): + """ + Caller detection works for compiled-only resources module. + + python/cpython#123085 + """ + self._compile_importlib() + assert importlib.import_module('frozenpkg').val == 'resources are the best' + + +class ImplicitContextFilesDiskTests( + DirectSpec, util.DiskSetup, ImplicitContextFiles, unittest.TestCase +): + pass + + +class ImplicitContextFilesZipTests( + DirectSpec, util.ZipSetup, ImplicitContextFiles, unittest.TestCase +): + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_functional.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_functional.py new file mode 100644 index 0000000000000000000000000000000000000000..91612095aadcd5e937c6f755c78b28e2ebc19c89 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_functional.py @@ -0,0 +1,261 @@ +import importlib +import os +import unittest + +import importlib_resources as resources + +from . import util +from .compat.py39 import warnings_helper + + +class StringAnchorMixin: + anchor01 = 'data01' + anchor02 = 'data02' + + +class ModuleAnchorMixin: + @property + def anchor01(self): + return importlib.import_module('data01') + + @property + def anchor02(self): + return importlib.import_module('data02') + + +class FunctionalAPIBase: + def setUp(self): + super().setUp() + self.load_fixture('data02') + + def _gen_resourcetxt_path_parts(self): + """Yield various names of a text file in anchor02, each in a subTest""" + for path_parts in ( + ('subdirectory', 'subsubdir', 'resource.txt'), + ('subdirectory/subsubdir/resource.txt',), + ('subdirectory/subsubdir', 'resource.txt'), + ): + with self.subTest(path_parts=path_parts): + yield path_parts + + @staticmethod + def remove_utf16_bom(string): + """Remove an architecture-specific UTF-16 BOM prefix when present. + + Some platforms surface UTF-16 BOM bytes as escaped text when the + fixture is intentionally decoded as UTF-8 with ``errors='backslashreplace'``. + Strip that prefix so assertions validate content consistently.""" + for bom in ('\\xff\\xfe', '\\xfe\\xff', '\ufeff'): + if string.startswith(bom): + return string[len(bom) :] + return string + + def test_read_text(self): + assert ( + resources.read_text(self.anchor01, 'utf-8.file') == 'Hello, UTF-8 world!\n' + ) + assert ( + resources.read_text( + self.anchor02, + 'subdirectory', + 'subsubdir', + 'resource.txt', + encoding='utf-8', + ) + == 'a resource' + ) + for path_parts in self._gen_resourcetxt_path_parts(): + assert ( + resources.read_text( + self.anchor02, + *path_parts, + encoding='utf-8', + ) + == 'a resource' + ) + # Use generic OSError, since e.g. attempting to read a directory can + # fail with PermissionError rather than IsADirectoryError + with self.assertRaises(OSError): + resources.read_text(self.anchor01) + with self.assertRaises((OSError, resources.abc.TraversalError)): + resources.read_text(self.anchor01, 'no-such-file') + with self.assertRaises(UnicodeDecodeError): + resources.read_text(self.anchor01, 'utf-16.file') + assert ( + resources.read_text( + self.anchor01, + 'binary.file', + encoding='latin1', + ) + == '\x00\x01\x02\x03' + ) + assert self.remove_utf16_bom( + resources.read_text( + self.anchor01, + 'utf-16.file', + errors='backslashreplace', + ), + ) == 'Hello, UTF-16 world!\n'.encode('utf-16-le').decode( + errors='backslashreplace', + ) + + def test_read_binary(self): + assert ( + resources.read_binary(self.anchor01, 'utf-8.file') + == b'Hello, UTF-8 world!\n' + ) + for path_parts in self._gen_resourcetxt_path_parts(): + assert resources.read_binary(self.anchor02, *path_parts) == b'a resource' + + def test_open_text(self): + with resources.open_text(self.anchor01, 'utf-8.file') as f: + assert f.read() == 'Hello, UTF-8 world!\n' + for path_parts in self._gen_resourcetxt_path_parts(): + with resources.open_text( + self.anchor02, + *path_parts, + encoding='utf-8', + ) as f: + assert f.read() == 'a resource' + # Use generic OSError, since e.g. attempting to read a directory can + # fail with PermissionError rather than IsADirectoryError + with self.assertRaises(OSError): + resources.open_text(self.anchor01) + with self.assertRaises((OSError, resources.abc.TraversalError)): + resources.open_text(self.anchor01, 'no-such-file') + with resources.open_text(self.anchor01, 'utf-16.file') as f: + with self.assertRaises(UnicodeDecodeError): + f.read() + with resources.open_text( + self.anchor01, + 'binary.file', + encoding='latin1', + ) as f: + assert f.read() == '\x00\x01\x02\x03' + with resources.open_text( + self.anchor01, + 'utf-16.file', + errors='backslashreplace', + ) as f: + assert self.remove_utf16_bom(f.read()) == 'Hello, UTF-16 world!\n'.encode( + 'utf-16-le' + ).decode( + errors='backslashreplace', + ) + + def test_open_binary(self): + with resources.open_binary(self.anchor01, 'utf-8.file') as f: + assert f.read() == b'Hello, UTF-8 world!\n' + for path_parts in self._gen_resourcetxt_path_parts(): + with resources.open_binary( + self.anchor02, + *path_parts, + ) as f: + assert f.read() == b'a resource' + + def test_path(self): + with resources.path(self.anchor01, 'utf-8.file') as path: + with open(str(path), encoding='utf-8') as f: + assert f.read() == 'Hello, UTF-8 world!\n' + with resources.path(self.anchor01) as path: + with open(os.path.join(path, 'utf-8.file'), encoding='utf-8') as f: + assert f.read() == 'Hello, UTF-8 world!\n' + + def test_is_resource(self): + is_resource = resources.is_resource + assert is_resource(self.anchor01, 'utf-8.file') + assert not is_resource(self.anchor01, 'no_such_file') + assert not is_resource(self.anchor01) + assert not is_resource(self.anchor01, 'subdirectory') + for path_parts in self._gen_resourcetxt_path_parts(): + assert is_resource(self.anchor02, *path_parts) + + def test_contents(self): + with warnings_helper.check_warnings((".*contents.*", DeprecationWarning)): + c = resources.contents(self.anchor01) + assert set(c) >= {'utf-8.file', 'utf-16.file', 'binary.file', 'subdirectory'} + with ( + self.assertRaises(OSError), + warnings_helper.check_warnings(( + ".*contents.*", + DeprecationWarning, + )), + ): + list(resources.contents(self.anchor01, 'utf-8.file')) + + for path_parts in self._gen_resourcetxt_path_parts(): + with ( + self.assertRaises((OSError, resources.abc.TraversalError)), + warnings_helper.check_warnings(( + ".*contents.*", + DeprecationWarning, + )), + ): + list(resources.contents(self.anchor01, *path_parts)) + with warnings_helper.check_warnings((".*contents.*", DeprecationWarning)): + c = resources.contents(self.anchor01, 'subdirectory') + assert set(c) >= {'binary.file'} + + @warnings_helper.ignore_warnings(category=DeprecationWarning) + def test_common_errors(self): + for func in ( + resources.read_text, + resources.read_binary, + resources.open_text, + resources.open_binary, + resources.path, + resources.is_resource, + resources.contents, + ): + with self.subTest(func=func): + # Rejecting None anchor + with self.assertRaises(TypeError): + func(None) + # Rejecting invalid anchor type + with self.assertRaises((TypeError, AttributeError)): + func(1234) + # Unknown module + with self.assertRaises(ModuleNotFoundError): + func('$missing module$') + + def test_text_errors(self): + for func in ( + resources.read_text, + resources.open_text, + ): + with self.subTest(func=func): + # Multiple path arguments need explicit encoding argument. + with self.assertRaises(TypeError): + func( + self.anchor02, + 'subdirectory', + 'subsubdir', + 'resource.txt', + ) + + +class FunctionalAPITest_StringAnchor_Disk( + StringAnchorMixin, + FunctionalAPIBase, + util.DiskSetup, + unittest.TestCase, +): + pass + + +class FunctionalAPITest_ModuleAnchor_Disk( + ModuleAnchorMixin, + FunctionalAPIBase, + util.DiskSetup, + unittest.TestCase, +): + pass + + +class FunctionalAPITest_StringAnchor_Memory( + StringAnchorMixin, + FunctionalAPIBase, + util.MemorySetup, + unittest.TestCase, +): + pass diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_open.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_open.py new file mode 100644 index 0000000000000000000000000000000000000000..720a833ccda1fdb13c8068c14279d657d68f2cd4 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_open.py @@ -0,0 +1,84 @@ +import unittest + +import importlib_resources as resources + +from . import util + + +class CommonBinaryTests(util.CommonTests, unittest.TestCase): + def execute(self, package, path): + target = resources.files(package).joinpath(path) + with target.open('rb'): + pass + + +class CommonTextTests(util.CommonTests, unittest.TestCase): + def execute(self, package, path): + target = resources.files(package).joinpath(path) + with target.open(encoding='utf-8'): + pass + + +class OpenTests: + def test_open_binary(self): + target = resources.files(self.data) / 'binary.file' + with target.open('rb') as fp: + result = fp.read() + assert result == bytes(range(4)) + + def test_open_text_default_encoding(self): + target = resources.files(self.data) / 'utf-8.file' + with target.open(encoding='utf-8') as fp: + result = fp.read() + assert result == 'Hello, UTF-8 world!\n' + + def test_open_text_given_encoding(self): + target = resources.files(self.data) / 'utf-16.file' + with target.open(encoding='utf-16', errors='strict') as fp: + result = fp.read() + assert result == 'Hello, UTF-16 world!\n' + + def test_open_text_with_errors(self): + """ + Raises UnicodeError without the 'errors' argument. + """ + target = resources.files(self.data) / 'utf-16.file' + with target.open(encoding='utf-8', errors='strict') as fp: + self.assertRaises(UnicodeError, fp.read) + with target.open(encoding='utf-8', errors='ignore') as fp: + result = fp.read() + assert result == ( + 'H\x00e\x00l\x00l\x00o\x00,\x00 ' + '\x00U\x00T\x00F\x00-\x001\x006\x00 ' + '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00' + ) + + def test_open_binary_FileNotFoundError(self): + target = resources.files(self.data) / 'does-not-exist' + with self.assertRaises(FileNotFoundError): + target.open('rb') + + def test_open_text_FileNotFoundError(self): + target = resources.files(self.data) / 'does-not-exist' + with self.assertRaises(FileNotFoundError): + target.open(encoding='utf-8') + + +class OpenDiskTests(OpenTests, util.DiskSetup, unittest.TestCase): + pass + + +class OpenDiskNamespaceTests(OpenTests, util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + +class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase): + pass + + +class OpenNamespaceZipTests(OpenTests, util.ZipSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_path.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_path.py new file mode 100644 index 0000000000000000000000000000000000000000..eb33d1f84ccd8a86f1bafb9af9885186c6722cc2 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_path.py @@ -0,0 +1,63 @@ +import io +import pathlib +import unittest + +import importlib_resources as resources + +from . import util + + +class CommonTests(util.CommonTests, unittest.TestCase): + def execute(self, package, path): + with resources.as_file(resources.files(package).joinpath(path)): + pass + + +class PathTests: + def test_reading(self): + """ + Path should be readable and a pathlib.Path instance. + """ + target = resources.files(self.data) / 'utf-8.file' + with resources.as_file(target) as path: + assert isinstance(path, pathlib.Path) + assert path.name.endswith("utf-8.file"), repr(path) + assert 'Hello, UTF-8 world!\n' == path.read_text(encoding='utf-8') + + +class PathDiskTests(PathTests, util.DiskSetup, unittest.TestCase): + def test_natural_path(self): + """ + Guarantee the internal implementation detail that + file-system-backed resources do not get the tempdir + treatment. + """ + target = resources.files(self.data) / 'utf-8.file' + with resources.as_file(target) as path: + assert 'data' in str(path) + + +class PathMemoryTests(PathTests, unittest.TestCase): + def setUp(self): + file = io.BytesIO(b'Hello, UTF-8 world!\n') + self.addCleanup(file.close) + self.data = util.create_package( + file=file, path=FileNotFoundError("package exists only in memory") + ) + self.data.__spec__.origin = None + self.data.__spec__.has_location = False + + +class PathZipTests(PathTests, util.ZipSetup, unittest.TestCase): + def test_remove_in_context_manager(self): + """ + It is not an error if the file that was temporarily stashed on the + file system is removed inside the `with` stanza. + """ + target = resources.files(self.data) / 'utf-8.file' + with resources.as_file(target) as path: + path.unlink() + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_read.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_read.py new file mode 100644 index 0000000000000000000000000000000000000000..9865953d951cc164eb82f216dcb3ca540dfcb6ba --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_read.py @@ -0,0 +1,96 @@ +import unittest +from importlib import import_module + +import importlib_resources as resources + +from . import util + + +class CommonBinaryTests(util.CommonTests, unittest.TestCase): + def execute(self, package, path): + resources.files(package).joinpath(path).read_bytes() + + +class CommonTextTests(util.CommonTests, unittest.TestCase): + def execute(self, package, path): + resources.files(package).joinpath(path).read_text(encoding='utf-8') + + +class ReadTests: + def test_read_bytes(self): + result = resources.files(self.data).joinpath('binary.file').read_bytes() + assert result == bytes(range(4)) + + def test_read_text_default_encoding(self): + result = ( + resources + .files(self.data) + .joinpath('utf-8.file') + .read_text(encoding='utf-8') + ) + assert result == 'Hello, UTF-8 world!\n' + + def test_read_text_given_encoding(self): + result = ( + resources + .files(self.data) + .joinpath('utf-16.file') + .read_text(encoding='utf-16') + ) + assert result == 'Hello, UTF-16 world!\n' + + def test_read_text_with_errors(self): + """ + Raises UnicodeError without the 'errors' argument. + """ + target = resources.files(self.data) / 'utf-16.file' + self.assertRaises(UnicodeError, target.read_text, encoding='utf-8') + result = target.read_text(encoding='utf-8', errors='ignore') + assert result == ( + 'H\x00e\x00l\x00l\x00o\x00,\x00 ' + '\x00U\x00T\x00F\x00-\x001\x006\x00 ' + '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00' + ) + + +class ReadDiskTests(ReadTests, util.DiskSetup, unittest.TestCase): + pass + + +class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase): + def test_read_submodule_resource(self): + submodule = import_module('data01.subdirectory') + result = resources.files(submodule).joinpath('binary.file').read_bytes() + assert result == bytes(range(4, 8)) + + def test_read_submodule_resource_by_name(self): + result = ( + resources.files('data01.subdirectory').joinpath('binary.file').read_bytes() + ) + assert result == bytes(range(4, 8)) + + +class ReadNamespaceTests(ReadTests, util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + +class ReadNamespaceZipTests(ReadTests, util.ZipSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + def test_read_submodule_resource(self): + submodule = import_module('namespacedata01.subdirectory') + result = resources.files(submodule).joinpath('binary.file').read_bytes() + assert result == bytes(range(12, 16)) + + def test_read_submodule_resource_by_name(self): + result = ( + resources + .files('namespacedata01.subdirectory') + .joinpath('binary.file') + .read_bytes() + ) + assert result == bytes(range(12, 16)) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_reader.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..3fdaac0c5dfe6c08dbeef05baa8bc04d6780b6bc --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_reader.py @@ -0,0 +1,125 @@ +import os.path +import pathlib +import unittest +from importlib import import_module + +from importlib_resources.readers import MultiplexedPath, NamespaceReader + +from . import util + + +class MultiplexedPathTest(util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + def setUp(self): + super().setUp() + self.folder = pathlib.Path(self.data.__path__[0]) + self.data01 = pathlib.Path(self.load_fixture('data01').__file__).parent + self.data02 = pathlib.Path(self.load_fixture('data02').__file__).parent + + def test_init_no_paths(self): + with self.assertRaises(FileNotFoundError): + MultiplexedPath() + + def test_init_file(self): + with self.assertRaises(NotADirectoryError): + MultiplexedPath(self.folder / 'binary.file') + + def test_iterdir(self): + contents = {path.name for path in MultiplexedPath(self.folder).iterdir()} + try: + contents.remove('__pycache__') + except (KeyError, ValueError): + pass + assert contents == {'subdirectory', 'binary.file', 'utf-16.file', 'utf-8.file'} + + def test_iterdir_duplicate(self): + contents = { + path.name for path in MultiplexedPath(self.folder, self.data01).iterdir() + } + for remove in ('__pycache__', '__init__.pyc'): + try: + contents.remove(remove) + except (KeyError, ValueError): + pass + assert contents == { + '__init__.py', + 'binary.file', + 'subdirectory', + 'utf-16.file', + 'utf-8.file', + } + + def test_is_dir(self): + assert MultiplexedPath(self.folder).is_dir() + + def test_is_file(self): + assert not MultiplexedPath(self.folder).is_file() + + def test_open_file(self): + path = MultiplexedPath(self.folder) + with self.assertRaises(FileNotFoundError): + path.read_bytes() + with self.assertRaises(FileNotFoundError): + path.read_text() + with self.assertRaises(FileNotFoundError): + path.open() + + def test_join_path(self): + prefix = str(self.folder.parent) + path = MultiplexedPath(self.folder, self.data01) + assert str(path.joinpath('binary.file'))[len(prefix) + 1 :] == os.path.join( + 'namespacedata01', 'binary.file' + ) + sub = path.joinpath('subdirectory') + assert isinstance(sub, MultiplexedPath) + assert 'namespacedata01' in str(sub) + assert 'data01' in str(sub) + assert str(path.joinpath('imaginary'))[len(prefix) + 1 :] == os.path.join( + 'namespacedata01', 'imaginary' + ) + assert path.joinpath() == path + + def test_join_path_compound(self): + path = MultiplexedPath(self.folder) + assert not path.joinpath('imaginary/foo.py').exists() + + def test_join_path_common_subdir(self): + prefix = str(self.data02.parent) + path = MultiplexedPath(self.data01, self.data02) + assert isinstance(path.joinpath('subdirectory'), MultiplexedPath) + assert str(path.joinpath('subdirectory', 'subsubdir'))[len(prefix) + 1 :] == ( + os.path.join('data02', 'subdirectory', 'subsubdir') + ) + + def test_repr(self): + assert repr(MultiplexedPath(self.folder)) == f"MultiplexedPath('{self.folder}')" + + def test_name(self): + assert MultiplexedPath(self.folder).name == os.path.basename(self.folder) + + +class NamespaceReaderTest(util.DiskSetup, unittest.TestCase): + MODULE = 'namespacedata01' + + def test_init_error(self): + with self.assertRaises(ValueError): + NamespaceReader(['path1', 'path2']) + + def test_resource_path(self): + namespacedata01 = import_module('namespacedata01') + reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations) + + root = self.data.__path__[0] + assert reader.resource_path('binary.file') == os.path.join(root, 'binary.file') + assert reader.resource_path('imaginary') == os.path.join(root, 'imaginary') + + def test_files(self): + reader = NamespaceReader(self.data.__spec__.submodule_search_locations) + root = self.data.__path__[0] + assert isinstance(reader.files(), MultiplexedPath) + assert repr(reader.files()) == f"MultiplexedPath('{root}')" + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_resource.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_resource.py new file mode 100644 index 0000000000000000000000000000000000000000..63a8bfbe173090bf9f588ed880ab0115a06fafef --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_resource.py @@ -0,0 +1,243 @@ +import types +import unittest +from importlib import import_module + +import importlib_resources as resources + +from . import util + + +class ResourceTests: + # Subclasses are expected to set the `data` attribute. + + def test_is_file_exists(self): + target = resources.files(self.data) / 'binary.file' + assert target.is_file() + + def test_is_file_missing(self): + target = resources.files(self.data) / 'not-a-file' + assert not target.is_file() + + def test_is_dir(self): + target = resources.files(self.data) / 'subdirectory' + assert not target.is_file() + assert target.is_dir() + + +class ResourceDiskTests(ResourceTests, util.DiskSetup, unittest.TestCase): + pass + + +class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase): + pass + + +def names(traversable): + return {item.name for item in traversable.iterdir()} + + +class ResourceLoaderTests(util.DiskSetup, unittest.TestCase): + def test_resource_contents(self): + package = util.create_package( + file=self.data, path=self.data.__file__, contents=['A', 'B', 'C'] + ) + assert names(resources.files(package)) == {'A', 'B', 'C'} + + def test_is_file(self): + package = util.create_package( + file=self.data, + path=self.data.__file__, + contents=['A', 'B', 'C', 'D/E', 'D/F'], + ) + assert resources.files(package).joinpath('B').is_file() + + def test_is_dir(self): + package = util.create_package( + file=self.data, + path=self.data.__file__, + contents=['A', 'B', 'C', 'D/E', 'D/F'], + ) + assert resources.files(package).joinpath('D').is_dir() + + def test_resource_missing(self): + package = util.create_package( + file=self.data, + path=self.data.__file__, + contents=['A', 'B', 'C', 'D/E', 'D/F'], + ) + assert not resources.files(package).joinpath('Z').is_file() + + +class ResourceCornerCaseTests(util.DiskSetup, unittest.TestCase): + def test_package_has_no_reader_fallback(self): + """ + Test odd ball packages which: + # 1. Do not have a ResourceReader as a loader + # 2. Are not on the file system + # 3. Are not in a zip file + """ + module = util.create_package( + file=self.data, path=self.data.__file__, contents=['A', 'B', 'C'] + ) + # Give the module a dummy loader. + module.__loader__ = object() + # Give the module a dummy origin. + module.__file__ = '/path/which/shall/not/be/named' + module.__spec__.loader = module.__loader__ + module.__spec__.origin = module.__file__ + assert not resources.files(module).joinpath('A').is_file() + + +class ResourceFromZipsTest01(util.ZipSetup, unittest.TestCase): + def test_is_submodule_resource(self): + submodule = import_module('data01.subdirectory') + assert resources.files(submodule).joinpath('binary.file').is_file() + + def test_read_submodule_resource_by_name(self): + assert resources.files('data01.subdirectory').joinpath('binary.file').is_file() + + def test_submodule_contents(self): + submodule = import_module('data01.subdirectory') + assert names(resources.files(submodule)) == {'__init__.py', 'binary.file'} + + def test_submodule_contents_by_name(self): + assert names(resources.files('data01.subdirectory')) == { + '__init__.py', + 'binary.file', + } + + def test_as_file_directory(self): + with resources.as_file(resources.files('data01')) as data: + assert data.name == 'data01' + assert data.is_dir() + assert data.joinpath('subdirectory').is_dir() + assert len(list(data.iterdir())) + assert not data.parent.exists() + + +class ResourceFromZipsTest02(util.ZipSetup, unittest.TestCase): + MODULE = 'data02' + + def test_unrelated_contents(self): + """ + Test thata zip with two unrelated subpackages return + distinct resources. Ref python/importlib_resources#44. + """ + assert names(resources.files('data02.one')) == {'__init__.py', 'resource1.txt'} + assert names(resources.files('data02.two')) == {'__init__.py', 'resource2.txt'} + + +class DeletingZipsTest(util.ZipSetup, unittest.TestCase): + """Having accessed resources in a zip file should not keep an open + reference to the zip. + """ + + def test_iterdir_does_not_keep_open(self): + [item.name for item in resources.files('data01').iterdir()] + + def test_is_file_does_not_keep_open(self): + resources.files('data01').joinpath('binary.file').is_file() + + def test_is_file_failure_does_not_keep_open(self): + resources.files('data01').joinpath('not-present').is_file() + + @unittest.skip("Desired but not supported.") + def test_as_file_does_not_keep_open(self): # pragma: no cover + resources.as_file(resources.files('data01') / 'binary.file') + + def test_entered_path_does_not_keep_open(self): + """ + Mimic what certifi does on import to make its bundle + available for the process duration. + """ + resources.as_file(resources.files('data01') / 'binary.file').__enter__() + + def test_read_binary_does_not_keep_open(self): + resources.files('data01').joinpath('binary.file').read_bytes() + + def test_read_text_does_not_keep_open(self): + resources.files('data01').joinpath('utf-8.file').read_text(encoding='utf-8') + + +class ResourceFromNamespaceTests: + def test_is_submodule_resource(self): + assert ( + resources + .files(import_module('namespacedata01')) + .joinpath('binary.file') + .is_file() + ) + + def test_read_submodule_resource_by_name(self): + assert resources.files('namespacedata01').joinpath('binary.file').is_file() + + def test_submodule_contents(self): + contents = names(resources.files(import_module('namespacedata01'))) + try: + contents.remove('__pycache__') + except KeyError: + pass + assert contents == {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'} + + def test_submodule_contents_by_name(self): + contents = names(resources.files('namespacedata01')) + try: + contents.remove('__pycache__') + except KeyError: + pass + assert contents == {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'} + + def test_submodule_sub_contents(self): + contents = names(resources.files(import_module('namespacedata01.subdirectory'))) + try: + contents.remove('__pycache__') + except KeyError: + pass + assert contents == {'binary.file'} + + def test_submodule_sub_contents_by_name(self): + contents = names(resources.files('namespacedata01.subdirectory')) + try: + contents.remove('__pycache__') + except KeyError: + pass + assert contents == {'binary.file'} + + +class ResourceFromNamespaceDiskTests( + util.DiskSetup, + ResourceFromNamespaceTests, + unittest.TestCase, +): + MODULE = 'namespacedata01' + + +class ResourceFromNamespaceZipTests( + util.ZipSetup, + ResourceFromNamespaceTests, + unittest.TestCase, +): + MODULE = 'namespacedata01' + + +class MainModuleTests(unittest.TestCase): + def test_main_module_with_none_spec(self): + """ + __main__ module with no spec should raise TypeError (for clarity). + + See python/cpython#138531 for details. + """ + # construct a __main__ module with no __spec__. + mainmodule = types.ModuleType("__main__") + + assert mainmodule.__spec__ is None + + with self.assertRaises( + TypeError, + msg="Cannot access resources for '__main__' as it does not appear to correspond to an importable module (its __spec__ is None).", + ): + resources.files(mainmodule) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/test_util.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_util.py new file mode 100644 index 0000000000000000000000000000000000000000..de304b6f3510a6975f596de99822c1359adc18db --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/test_util.py @@ -0,0 +1,29 @@ +import unittest + +from .util import MemorySetup, Traversable + + +class TestMemoryTraversableImplementation(unittest.TestCase): + def test_concrete_methods_are_not_overridden(self): + """`MemoryTraversable` must not override `Traversable` concrete methods. + + This test is not an attempt to enforce a particular `Traversable` protocol; + it merely catches changes in the `Traversable` abstract/concrete methods + that have not been mirrored in the `MemoryTraversable` subclass. + """ + + traversable_concrete_methods = { + method + for method, value in Traversable.__dict__.items() + if callable(value) and method not in Traversable.__abstractmethods__ + } + memory_traversable_concrete_methods = { + method + for method, value in MemorySetup.MemoryTraversable.__dict__.items() + if callable(value) and not method.startswith("__") + } + overridden_methods = ( + memory_traversable_concrete_methods & traversable_concrete_methods + ) + + assert not overridden_methods diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/util.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/util.py new file mode 100644 index 0000000000000000000000000000000000000000..67088a6605382830b76af9fcce117e810c8508b8 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/util.py @@ -0,0 +1,308 @@ +import abc +import contextlib +import functools +import importlib +import io +import pathlib +import sys +import types +from importlib.machinery import ModuleSpec + +from ..abc import ResourceReader, Traversable, TraversableResources +from . import _path +from . import zip as zip_ +from .compat.py39 import import_helper, os_helper + + +class Reader(ResourceReader): + def __init__(self, **kwargs): + vars(self).update(kwargs) + + def get_resource_reader(self, package): + return self + + def open_resource(self, path): + self._path = path + if isinstance(self.file, Exception): + raise self.file + return self.file + + def resource_path(self, path_): + self._path = path_ + if isinstance(self.path, Exception): + raise self.path + return self.path + + def is_resource(self, path_): + self._path = path_ + if isinstance(self.path, Exception): + raise self.path + + def part(entry): + return entry.split('/') + + return any( + len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents) + ) + + def contents(self): + if isinstance(self.path, Exception): + raise self.path + yield from self._contents + + +def create_package_from_loader(loader, is_package=True): + name = 'testingpackage' + module = types.ModuleType(name) + spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package) + module.__spec__ = spec + module.__loader__ = loader + return module + + +def create_package(file=None, path=None, is_package=True, contents=()): + return create_package_from_loader( + Reader(file=file, path=path, _contents=contents), + is_package, + ) + + +class CommonTestsBase(metaclass=abc.ABCMeta): + """ + Tests shared by test_open, test_path, and test_read. + """ + + @abc.abstractmethod + def execute(self, package, path): + """ + Call the pertinent legacy API function (e.g. open_text, path) + on package and path. + """ + + def test_package_name(self): + """ + Passing in the package name should succeed. + """ + self.execute(self.data.__name__, 'utf-8.file') + + def test_package_object(self): + """ + Passing in the package itself should succeed. + """ + self.execute(self.data, 'utf-8.file') + + def test_string_path(self): + """ + Passing in a string for the path should succeed. + """ + path = 'utf-8.file' + self.execute(self.data, path) + + def test_pathlib_path(self): + """ + Passing in a pathlib.PurePath object for the path should succeed. + """ + path = pathlib.PurePath('utf-8.file') + self.execute(self.data, path) + + def test_importing_module_as_side_effect(self): + """ + The anchor package can already be imported. + """ + del sys.modules[self.data.__name__] + self.execute(self.data.__name__, 'utf-8.file') + + def test_missing_path(self): + """ + Attempting to open or read or request the path for a + non-existent path should succeed if open_resource + can return a viable data stream. + """ + bytes_data = io.BytesIO(b'Hello, world!') + package = create_package(file=bytes_data, path=FileNotFoundError()) + self.execute(package, 'utf-8.file') + assert package.__loader__._path == 'utf-8.file' + + def test_extant_path(self): + # Attempting to open or read or request the path when the + # path does exist should still succeed. Does not assert + # anything about the result. + bytes_data = io.BytesIO(b'Hello, world!') + # any path that exists + path = __file__ + package = create_package(file=bytes_data, path=path) + self.execute(package, 'utf-8.file') + assert package.__loader__._path == 'utf-8.file' + + def test_useless_loader(self): + package = create_package(file=FileNotFoundError(), path=FileNotFoundError()) + with self.assertRaises(FileNotFoundError): + self.execute(package, 'utf-8.file') + + +fixtures = dict( + data01={ + '__init__.py': '', + 'binary.file': bytes(range(4)), + 'utf-16.file': '\ufeffHello, UTF-16 world!\n'.encode('utf-16-le'), + 'utf-8.file': 'Hello, UTF-8 world!\n'.encode('utf-8'), + 'subdirectory': { + '__init__.py': '', + 'binary.file': bytes(range(4, 8)), + }, + }, + data02={ + '__init__.py': '', + 'one': {'__init__.py': '', 'resource1.txt': 'one resource'}, + 'two': {'__init__.py': '', 'resource2.txt': 'two resource'}, + 'subdirectory': {'subsubdir': {'resource.txt': 'a resource'}}, + }, + namespacedata01={ + 'binary.file': bytes(range(4)), + 'utf-16.file': '\ufeffHello, UTF-16 world!\n'.encode('utf-16-le'), + 'utf-8.file': 'Hello, UTF-8 world!\n'.encode('utf-8'), + 'subdirectory': { + 'binary.file': bytes(range(12, 16)), + }, + }, +) + + +class ModuleSetup: + def setUp(self): + self.fixtures = contextlib.ExitStack() + self.addCleanup(self.fixtures.close) + + self.fixtures.enter_context(import_helper.isolated_modules()) + self.data = self.load_fixture(self.MODULE) + + def load_fixture(self, module): + self.tree_on_path({module: fixtures[module]}) + return importlib.import_module(module) + + +class ZipSetup(ModuleSetup): + MODULE = 'data01' + + def tree_on_path(self, spec): + temp_dir = self.fixtures.enter_context(os_helper.temp_dir()) + modules = pathlib.Path(temp_dir) / 'zipped modules.zip' + self.fixtures.enter_context( + import_helper.DirsOnSysPath(str(zip_.make_zip_file(spec, modules))) + ) + + +class DiskSetup(ModuleSetup): + MODULE = 'data01' + + def tree_on_path(self, spec): + temp_dir = self.fixtures.enter_context(os_helper.temp_dir()) + _path.build(spec, pathlib.Path(temp_dir)) + self.fixtures.enter_context(import_helper.DirsOnSysPath(temp_dir)) + + +class MemorySetup(ModuleSetup): + """Support loading a module in memory.""" + + MODULE = 'data01' + + def load_fixture(self, module): + self.fixtures.enter_context(self.augment_sys_metapath(module)) + return importlib.import_module(module) + + @contextlib.contextmanager + def augment_sys_metapath(self, module): + finder_instance = self.MemoryFinder(module) + sys.meta_path.append(finder_instance) + yield + sys.meta_path.remove(finder_instance) + + class MemoryFinder(importlib.abc.MetaPathFinder): + def __init__(self, module): + self._module = module + + def find_spec(self, fullname, path, target=None): + if fullname != self._module: + return None + + return importlib.machinery.ModuleSpec( + name=fullname, + loader=MemorySetup.MemoryLoader(self._module), + is_package=True, + ) + + class MemoryLoader(importlib.abc.Loader): + def __init__(self, module): + self._module = module + + def exec_module(self, module): + pass + + def get_resource_reader(self, fullname): + return MemorySetup.MemoryTraversableResources(self._module, fullname) + + class MemoryTraversableResources(TraversableResources): + def __init__(self, module, fullname): + self._module = module + self._fullname = fullname + + def files(self): + return MemorySetup.MemoryTraversable(self._module, self._fullname) + + class MemoryTraversable(Traversable): + """Implement only the abstract methods of `Traversable`. + + Besides `.__init__()`, no other methods may be implemented or overridden. + This is critical for validating the concrete `Traversable` implementations. + """ + + def __init__(self, module, fullname): + self._module = module + self._fullname = fullname + + def _resolve(self): + """ + Fully traverse the `fixtures` dictionary. + + This should be wrapped in a `try/except KeyError` + but it is not currently needed and lowers the code coverage numbers. + """ + path = pathlib.PurePosixPath(self._fullname) + return functools.reduce(lambda d, p: d[p], path.parts, fixtures) + + def iterdir(self): + directory = self._resolve() + if not isinstance(directory, dict): + # Filesystem openers raise OSError, and that exception is mirrored here. + raise OSError(f"{self._fullname} is not a directory") + for path in directory: + yield MemorySetup.MemoryTraversable( + self._module, f"{self._fullname}/{path}" + ) + + def is_dir(self) -> bool: + return isinstance(self._resolve(), dict) + + def is_file(self) -> bool: + return not self.is_dir() + + def open(self, mode='r', encoding=None, errors=None, *_, **__): + contents = self._resolve() + if isinstance(contents, dict): + # Filesystem openers raise OSError when attempting to open a directory, + # and that exception is mirrored here. + raise OSError(f"{self._fullname} is a directory") + if isinstance(contents, str): + contents = contents.encode("utf-8") + result = io.BytesIO(contents) + if "b" in mode: + return result + return io.TextIOWrapper(result, encoding=encoding, errors=errors) + + @property + def name(self): + return pathlib.PurePosixPath(self._fullname).name + + +class CommonTests(DiskSetup, CommonTestsBase): + pass diff --git a/python/user_packages/Python313/site-packages/importlib_resources/tests/zip.py b/python/user_packages/Python313/site-packages/importlib_resources/tests/zip.py new file mode 100644 index 0000000000000000000000000000000000000000..51ee564870c101bd447969c8433148eba597ab26 --- /dev/null +++ b/python/user_packages/Python313/site-packages/importlib_resources/tests/zip.py @@ -0,0 +1,26 @@ +""" +Generate zip test data files. +""" + +import zipfile + +import zipp + + +def make_zip_file(tree, dst): + """ + Zip the files in tree into a new zipfile at dst. + """ + with zipfile.ZipFile(dst, 'w') as zf: + for name, contents in walk(tree): + zf.writestr(name, contents) + zipp.CompleteDirs.inject(zf) + return dst + + +def walk(tree, prefix=''): + for name, contents in tree.items(): + if isinstance(contents, dict): + yield from walk(contents, prefix=f'{prefix}{name}/') + else: + yield f'{prefix}{name}', contents diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1e7a5c945999093ff01f975910c4385283d4d253 Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/_json.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/_json.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f30e3f0c70a7e86b10fb39de00e99a48eaaca0aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/_json.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/encoding.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/encoding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7da75b55b8141fb9a89abacac67f314e16fd701 Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/encoding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/exc.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/exc.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29c30b122b0c56796c6534909ddec49d5898734b Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/exc.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/serializer.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/serializer.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0460431dc4d1a77a0c5d8034562162509a43642a Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/serializer.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/signer.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/signer.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a02283a193368720a32219254e4d5092d486e8ac Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/signer.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/timed.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/timed.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3172b4c6dd9b180e2ddfdb50837e204b8078b60 Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/timed.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/url_safe.cpython-313.pyc b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/url_safe.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01e5cc347986d0c4f4bf6b78ec3f562bfd5e17c8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/itsdangerous/__pycache__/url_safe.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt b/python/user_packages/Python313/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..c37cae49ec77ad6ebb25568c1605f1fee5313cfb --- /dev/null +++ b/python/user_packages/Python313/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt @@ -0,0 +1,28 @@ +Copyright 2007 Pallets + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd238db75632c21983c3e19cf8cd4b6342d46392 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/_identifier.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/_identifier.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b223be7d3de0871fe6e83d8df6ff5c1c8ba07d3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/_identifier.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/async_utils.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/async_utils.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e333f3cdde25a9201f6890549dd9f31085aee91d Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/async_utils.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/bccache.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/bccache.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a31c3933865724d1e5ef89ce4b150c9a3a22ad6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/bccache.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/constants.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/constants.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..038c93621e622ec99fc1bd9645f7d80216a66eba Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/constants.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/debug.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/debug.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7e9a55044da19ce15773e118324d6cfb9bd9304 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/debug.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/defaults.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/defaults.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0991beef6491f28bae2e0cdba9078dfce94f49c0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/defaults.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/environment.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/environment.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..208e0c8155b3f04a01d4f0e669df1a4f8b2682c3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/environment.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/exceptions.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/exceptions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b1126f590984d76d2b58104cf4281083b29ced3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/exceptions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/ext.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/ext.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fb832e300b5bf226cddc09da978ce760169302d Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/ext.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/filters.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/filters.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..479ce812df45046c1699def19785ccb495f9f658 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/filters.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/idtracking.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/idtracking.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4d3038ec8ce5d9d9e4d7d03f145b801178e1721 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/idtracking.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/lexer.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/lexer.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ede42c403acece3e2fb5ab8b4eea18375d08d96b Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/lexer.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/loaders.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/loaders.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ddf861512c239901249658abec581482182246b5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/loaders.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/meta.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/meta.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b594ba3821313503cfbe712609b3c1ddc6df1b7a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/meta.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/nativetypes.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/nativetypes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..389ee6afa468f975facf8c42066c62ae4ee94f22 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/nativetypes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/nodes.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/nodes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e7e23da63f8273490484dd0cb12a156dbf261cf Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/nodes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/optimizer.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/optimizer.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f361d644c7bd491f75eaf2c9ff6577a4d04912ec Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/optimizer.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/parser.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/parser.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..307dcbc59b848dd701f12b5cb29d4d2f7e4bb625 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/parser.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/runtime.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/runtime.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfc7be38a71f6473571efe912e48521ae7f51b6a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/runtime.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/sandbox.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/sandbox.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ac605270a91878d4b9c75d6c6309aff35e0c9cb Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/sandbox.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/tests.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/tests.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42aa3862821c25e22453274312d11ee2f2ef2f03 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/tests.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/utils.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/utils.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df20cc5676c518eac07e483508ae85fbe3e0ebad Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/utils.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jinja2/__pycache__/visitor.cpython-313.pyc b/python/user_packages/Python313/site-packages/jinja2/__pycache__/visitor.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..786fa1c3f02a0b23e242dafe5dc5d93a67f02c1c Binary files /dev/null and b/python/user_packages/Python313/site-packages/jinja2/__pycache__/visitor.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/AUTHORS b/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/AUTHORS new file mode 100644 index 0000000000000000000000000000000000000000..8319fec44d8e4d467b2e4827738b91ff706f93d5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/AUTHORS @@ -0,0 +1,3 @@ +Stefan Kögl +Alexander Shorin +Christopher J. White diff --git a/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/LICENSE.txt b/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..491196d773493c591f1287107c3d368f2f8263d3 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonpointer-3.1.1.dist-info/licenses/LICENSE.txt @@ -0,0 +1,26 @@ +Copyright (c) 2011 Stefan Kögl +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/python/user_packages/Python313/site-packages/jsonschema-4.26.0.dist-info/licenses/COPYING b/python/user_packages/Python313/site-packages/jsonschema-4.26.0.dist-info/licenses/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..af9cfbdb134f42e5205ecbad597421d778826481 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema-4.26.0.dist-info/licenses/COPYING @@ -0,0 +1,19 @@ +Copyright (c) 2013 Julian Berman + +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. diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec1013f3e4f061ea3f27b5052ec05705a5345ba7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__main__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__main__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cca345f3a9383c68ba80c1f8fc9358e0e6730bba Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/__main__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_format.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_format.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f171732f6d14a00ad10f2ed5c8109c4d4e441638 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_format.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_keywords.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_keywords.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1756168b0d00d9528e5bb2ed9f8e7a3a203cf2e4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_keywords.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_legacy_keywords.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_legacy_keywords.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8bd89a22ea70b86cdb635f439a50c4071babec7e Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_legacy_keywords.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_types.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_types.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0967fa73b66b8a817d2850c1c99189db5b581c29 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_types.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_typing.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_typing.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7a6c63ef30716f61964d9fb61b9879666368341 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_typing.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_utils.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_utils.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4da40625784acf2ed1d070fafd264fc4a97e73a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/_utils.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/cli.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/cli.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..698962543a9634cfa1ee89dbb176adfffbc0bdc8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/cli.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/exceptions.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/exceptions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daf006086fa2560520b79c81108c5594dfcfc07a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/exceptions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/protocols.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/protocols.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..548930187efd66150512331a566f8fd388a993d8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/protocols.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/__pycache__/validators.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/validators.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f842edc48a5da3a93f28ff6b0cf3460265751cf9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/__pycache__/validators.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__init__.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e3dcc689930da95198c251ce806637d6413c8b1e --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__init__.py @@ -0,0 +1,5 @@ +""" +Benchmarks for validation. + +This package is *not* public API. +""" diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a1f8f0c43022c7120849ee5829480e1aaa799aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/const_vs_enum.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/const_vs_enum.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ae4a125d67a47efb8b0783571d91d1de77ff20f Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/const_vs_enum.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/contains.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/contains.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bcca8945aee29131332ba170bf537afac23ecf2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/contains.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/import_benchmark.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/import_benchmark.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b066d15363f8f0e19ab76fbdc65c3c9d9bb12898 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/import_benchmark.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/issue232.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/issue232.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..414040ceb205044c74d77ea320df0a01bc82dfc0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/issue232.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/json_schema_test_suite.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/json_schema_test_suite.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d533916c27a6592a3e24bda75465bc2031d813f Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/json_schema_test_suite.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/nested_schemas.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/nested_schemas.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9d1daa327628114638f12e694af0a314bf4788f Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/nested_schemas.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/subcomponents.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/subcomponents.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42680c040adf9e2710ab2e34e02d5a6d2a086186 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/subcomponents.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/unused_registry.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/unused_registry.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4f3dacd05f5503392a2e19c37e4e1a87ddeed6b Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/unused_registry.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_applicator_schemas.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_applicator_schemas.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7387af37665fa3f26447bc34a6c70ea17c25369a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_applicator_schemas.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_keywords.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_keywords.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edca335cca6c0a39ede48c86053e9e179fd53d02 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/useless_keywords.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/validator_creation.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/validator_creation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8cf4154b65d6d6b2a8225bbec25500b83f1b0d4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/__pycache__/validator_creation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/const_vs_enum.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/const_vs_enum.py new file mode 100644 index 0000000000000000000000000000000000000000..c6fecd10f6d8b845c675be9c19e9b504b08d30b9 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/const_vs_enum.py @@ -0,0 +1,30 @@ +""" +A benchmark for comparing equivalent validation of `const` and `enum`. +""" + +from pyperf import Runner + +from jsonschema import Draft202012Validator + +value = [37] * 100 +const_schema = {"const": list(value)} +enum_schema = {"enum": [list(value)]} + +valid = list(value) +invalid = [*valid, 73] + +const = Draft202012Validator(const_schema) +enum = Draft202012Validator(enum_schema) + +assert const.is_valid(valid) +assert enum.is_valid(valid) +assert not const.is_valid(invalid) +assert not enum.is_valid(invalid) + + +if __name__ == "__main__": + runner = Runner() + runner.bench_func("const valid", lambda: const.is_valid(valid)) + runner.bench_func("const invalid", lambda: const.is_valid(invalid)) + runner.bench_func("enum valid", lambda: enum.is_valid(valid)) + runner.bench_func("enum invalid", lambda: enum.is_valid(invalid)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/contains.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/contains.py new file mode 100644 index 0000000000000000000000000000000000000000..739cd044cceb807b4029dca9447e954214a24809 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/contains.py @@ -0,0 +1,28 @@ +""" +A benchmark for validation of the `contains` keyword. +""" + +from pyperf import Runner + +from jsonschema import Draft202012Validator + +schema = { + "type": "array", + "contains": {"const": 37}, +} +validator = Draft202012Validator(schema) + +size = 1000 +beginning = [37] + [0] * (size - 1) +middle = [0] * (size // 2) + [37] + [0] * (size // 2) +end = [0] * (size - 1) + [37] +invalid = [0] * size + + +if __name__ == "__main__": + runner = Runner() + runner.bench_func("baseline", lambda: validator.is_valid([])) + runner.bench_func("beginning", lambda: validator.is_valid(beginning)) + runner.bench_func("middle", lambda: validator.is_valid(middle)) + runner.bench_func("end", lambda: validator.is_valid(end)) + runner.bench_func("invalid", lambda: validator.is_valid(invalid)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/import_benchmark.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/import_benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..59fa921dd8c871b6eb3d13ccd6e04c9df4312a4a --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/import_benchmark.py @@ -0,0 +1,31 @@ +""" +A benchmark which measures the import time of jsonschema +""" + +import subprocess +import sys + + +def import_time(loops): + total_us = 0 + for _ in range(loops): + p = subprocess.run( # noqa: S603 (arguments are static) + [sys.executable, "-X", "importtime", "-c", "import jsonschema"], + stderr=subprocess.PIPE, + stdout=subprocess.DEVNULL, + check=True, + ) + + line = p.stderr.splitlines()[-1] + field = line.split(b"|")[-2].strip() + us = int(field) # microseconds + total_us += us + + # pyperf expects seconds + return total_us / 1_000_000.0 + +if __name__ == "__main__": + from pyperf import Runner + runner = Runner() + + runner.bench_time_func("Import time (cumulative)", import_time) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232.py new file mode 100644 index 0000000000000000000000000000000000000000..efd07154822e4b0609900482eb26636fc3c100eb --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232.py @@ -0,0 +1,25 @@ +""" +A performance benchmark using the example from issue #232. + +See https://github.com/python-jsonschema/jsonschema/pull/232. +""" +from pathlib import Path + +from pyperf import Runner +from referencing import Registry + +from jsonschema.tests._suite import Version +import jsonschema + +issue232 = Version( + path=Path(__file__).parent / "issue232", + remotes=Registry(), + name="issue232", +) + + +if __name__ == "__main__": + issue232.benchmark( + runner=Runner(), + Validator=jsonschema.Draft4Validator, + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232/issue.json b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232/issue.json new file mode 100644 index 0000000000000000000000000000000000000000..804c340845fa0694e8db1083cfe7c290c04f36b1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/issue232/issue.json @@ -0,0 +1,2653 @@ +[ + { + "description": "Petstore", + "schema": { + "title": "A JSON Schema for Swagger 2.0 API.", + "id": "http://swagger.io/v2/schema.json#", + "$schema": "http://json-schema.org/draft-04/schema#", + "type": "object", + "required": [ + "swagger", + "info", + "paths" + ], + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "swagger": { + "type": "string", + "enum": [ + "2.0" + ], + "description": "The Swagger version of this document." + }, + "info": { + "$ref": "#/definitions/info" + }, + "host": { + "type": "string", + "pattern": "^[^{}/ :\\\\]+(?::\\d+)?$", + "description": "The host (name or ip) of the API. Example: 'swagger.io'" + }, + "basePath": { + "type": "string", + "pattern": "^/", + "description": "The base path to the API. Example: '/api'." + }, + "schemes": { + "$ref": "#/definitions/schemesList" + }, + "consumes": { + "description": "A list of MIME types accepted by the API.", + "allOf": [ + { + "$ref": "#/definitions/mediaTypeList" + } + ] + }, + "produces": { + "description": "A list of MIME types the API can produce.", + "allOf": [ + { + "$ref": "#/definitions/mediaTypeList" + } + ] + }, + "paths": { + "$ref": "#/definitions/paths" + }, + "definitions": { + "$ref": "#/definitions/definitions" + }, + "parameters": { + "$ref": "#/definitions/parameterDefinitions" + }, + "responses": { + "$ref": "#/definitions/responseDefinitions" + }, + "security": { + "$ref": "#/definitions/security" + }, + "securityDefinitions": { + "$ref": "#/definitions/securityDefinitions" + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/definitions/tag" + }, + "uniqueItems": true + }, + "externalDocs": { + "$ref": "#/definitions/externalDocs" + } + }, + "definitions": { + "info": { + "type": "object", + "description": "General information about the API.", + "required": [ + "version", + "title" + ], + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "title": { + "type": "string", + "description": "A unique and precise title of the API." + }, + "version": { + "type": "string", + "description": "A semantic version number of the API." + }, + "description": { + "type": "string", + "description": "A longer description of the API. Should be different from the title. GitHub Flavored Markdown is allowed." + }, + "termsOfService": { + "type": "string", + "description": "The terms of service for the API." + }, + "contact": { + "$ref": "#/definitions/contact" + }, + "license": { + "$ref": "#/definitions/license" + } + } + }, + "contact": { + "type": "object", + "description": "Contact information for the owners of the API.", + "additionalProperties": false, + "properties": { + "name": { + "type": "string", + "description": "The identifying name of the contact person/organization." + }, + "url": { + "type": "string", + "description": "The URL pointing to the contact information.", + "format": "uri" + }, + "email": { + "type": "string", + "description": "The email address of the contact person/organization.", + "format": "email" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "license": { + "type": "object", + "required": [ + "name" + ], + "additionalProperties": false, + "properties": { + "name": { + "type": "string", + "description": "The name of the license type. It's encouraged to use an OSI compatible license." + }, + "url": { + "type": "string", + "description": "The URL pointing to the license.", + "format": "uri" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "paths": { + "type": "object", + "description": "Relative paths to the individual endpoints. They must be relative to the 'basePath'.", + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + }, + "^/": { + "$ref": "#/definitions/pathItem" + } + }, + "additionalProperties": false + }, + "definitions": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/schema" + }, + "description": "One or more JSON objects describing the schemas being consumed and produced by the API." + }, + "parameterDefinitions": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/parameter" + }, + "description": "One or more JSON representations for parameters" + }, + "responseDefinitions": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/response" + }, + "description": "One or more JSON representations for parameters" + }, + "externalDocs": { + "type": "object", + "additionalProperties": false, + "description": "information about external documentation", + "required": [ + "url" + ], + "properties": { + "description": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "examples": { + "type": "object", + "additionalProperties": true + }, + "mimeType": { + "type": "string", + "description": "The MIME type of the HTTP message." + }, + "operation": { + "type": "object", + "required": [ + "responses" + ], + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "tags": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "summary": { + "type": "string", + "description": "A brief summary of the operation." + }, + "description": { + "type": "string", + "description": "A longer description of the operation, GitHub Flavored Markdown is allowed." + }, + "externalDocs": { + "$ref": "#/definitions/externalDocs" + }, + "operationId": { + "type": "string", + "description": "A unique identifier of the operation." + }, + "produces": { + "description": "A list of MIME types the API can produce.", + "allOf": [ + { + "$ref": "#/definitions/mediaTypeList" + } + ] + }, + "consumes": { + "description": "A list of MIME types the API can consume.", + "allOf": [ + { + "$ref": "#/definitions/mediaTypeList" + } + ] + }, + "parameters": { + "$ref": "#/definitions/parametersList" + }, + "responses": { + "$ref": "#/definitions/responses" + }, + "schemes": { + "$ref": "#/definitions/schemesList" + }, + "deprecated": { + "type": "boolean", + "default": false + }, + "security": { + "$ref": "#/definitions/security" + } + } + }, + "pathItem": { + "type": "object", + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "$ref": { + "type": "string" + }, + "get": { + "$ref": "#/definitions/operation" + }, + "put": { + "$ref": "#/definitions/operation" + }, + "post": { + "$ref": "#/definitions/operation" + }, + "delete": { + "$ref": "#/definitions/operation" + }, + "options": { + "$ref": "#/definitions/operation" + }, + "head": { + "$ref": "#/definitions/operation" + }, + "patch": { + "$ref": "#/definitions/operation" + }, + "parameters": { + "$ref": "#/definitions/parametersList" + } + } + }, + "responses": { + "type": "object", + "description": "Response objects names can either be any valid HTTP status code or 'default'.", + "minProperties": 1, + "additionalProperties": false, + "patternProperties": { + "^([0-9]{3})$|^(default)$": { + "$ref": "#/definitions/responseValue" + }, + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "not": { + "type": "object", + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + } + }, + "responseValue": { + "oneOf": [ + { + "$ref": "#/definitions/response" + }, + { + "$ref": "#/definitions/jsonReference" + } + ] + }, + "response": { + "type": "object", + "required": [ + "description" + ], + "properties": { + "description": { + "type": "string" + }, + "schema": { + "oneOf": [ + { + "$ref": "#/definitions/schema" + }, + { + "$ref": "#/definitions/fileSchema" + } + ] + }, + "headers": { + "$ref": "#/definitions/headers" + }, + "examples": { + "$ref": "#/definitions/examples" + } + }, + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "headers": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/header" + } + }, + "header": { + "type": "object", + "additionalProperties": false, + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "string", + "number", + "integer", + "boolean", + "array" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormat" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "vendorExtension": { + "description": "Any property starting with x- is valid.", + "additionalProperties": true, + "additionalItems": true + }, + "bodyParameter": { + "type": "object", + "required": [ + "name", + "in", + "schema" + ], + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "description": { + "type": "string", + "description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed." + }, + "name": { + "type": "string", + "description": "The name of the parameter." + }, + "in": { + "type": "string", + "description": "Determines the location of the parameter.", + "enum": [ + "body" + ] + }, + "required": { + "type": "boolean", + "description": "Determines whether or not this parameter is required or optional.", + "default": false + }, + "schema": { + "$ref": "#/definitions/schema" + } + }, + "additionalProperties": false + }, + "headerParameterSubSchema": { + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "required": { + "type": "boolean", + "description": "Determines whether or not this parameter is required or optional.", + "default": false + }, + "in": { + "type": "string", + "description": "Determines the location of the parameter.", + "enum": [ + "header" + ] + }, + "description": { + "type": "string", + "description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed." + }, + "name": { + "type": "string", + "description": "The name of the parameter." + }, + "type": { + "type": "string", + "enum": [ + "string", + "number", + "boolean", + "integer", + "array" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormat" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + } + } + }, + "queryParameterSubSchema": { + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "required": { + "type": "boolean", + "description": "Determines whether or not this parameter is required or optional.", + "default": false + }, + "in": { + "type": "string", + "description": "Determines the location of the parameter.", + "enum": [ + "query" + ] + }, + "description": { + "type": "string", + "description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed." + }, + "name": { + "type": "string", + "description": "The name of the parameter." + }, + "allowEmptyValue": { + "type": "boolean", + "default": false, + "description": "allows sending a parameter by name only or with an empty value." + }, + "type": { + "type": "string", + "enum": [ + "string", + "number", + "boolean", + "integer", + "array" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormatWithMulti" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + } + } + }, + "formDataParameterSubSchema": { + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "required": { + "type": "boolean", + "description": "Determines whether or not this parameter is required or optional.", + "default": false + }, + "in": { + "type": "string", + "description": "Determines the location of the parameter.", + "enum": [ + "formData" + ] + }, + "description": { + "type": "string", + "description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed." + }, + "name": { + "type": "string", + "description": "The name of the parameter." + }, + "allowEmptyValue": { + "type": "boolean", + "default": false, + "description": "allows sending a parameter by name only or with an empty value." + }, + "type": { + "type": "string", + "enum": [ + "string", + "number", + "boolean", + "integer", + "array", + "file" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormatWithMulti" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + } + } + }, + "pathParameterSubSchema": { + "additionalProperties": false, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "required": [ + "required" + ], + "properties": { + "required": { + "type": "boolean", + "enum": [ + true + ], + "description": "Determines whether or not this parameter is required or optional." + }, + "in": { + "type": "string", + "description": "Determines the location of the parameter.", + "enum": [ + "path" + ] + }, + "description": { + "type": "string", + "description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed." + }, + "name": { + "type": "string", + "description": "The name of the parameter." + }, + "type": { + "type": "string", + "enum": [ + "string", + "number", + "boolean", + "integer", + "array" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormat" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + } + } + }, + "nonBodyParameter": { + "type": "object", + "required": [ + "name", + "in", + "type" + ], + "oneOf": [ + { + "$ref": "#/definitions/headerParameterSubSchema" + }, + { + "$ref": "#/definitions/formDataParameterSubSchema" + }, + { + "$ref": "#/definitions/queryParameterSubSchema" + }, + { + "$ref": "#/definitions/pathParameterSubSchema" + } + ] + }, + "parameter": { + "oneOf": [ + { + "$ref": "#/definitions/bodyParameter" + }, + { + "$ref": "#/definitions/nonBodyParameter" + } + ] + }, + "schema": { + "type": "object", + "description": "A deterministic version of a JSON Schema object.", + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "properties": { + "$ref": { + "type": "string" + }, + "format": { + "type": "string" + }, + "title": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/title" + }, + "description": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/description" + }, + "default": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/default" + }, + "multipleOf": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf" + }, + "maximum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum" + }, + "exclusiveMaximum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum" + }, + "minimum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum" + }, + "exclusiveMinimum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum" + }, + "maxLength": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" + }, + "minLength": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" + }, + "pattern": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern" + }, + "maxItems": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" + }, + "minItems": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" + }, + "uniqueItems": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems" + }, + "maxProperties": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" + }, + "minProperties": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" + }, + "required": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" + }, + "enum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/enum" + }, + "additionalProperties": { + "anyOf": [ + { + "$ref": "#/definitions/schema" + }, + { + "type": "boolean" + } + ], + "default": {} + }, + "type": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/type" + }, + "items": { + "anyOf": [ + { + "$ref": "#/definitions/schema" + }, + { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/definitions/schema" + } + } + ], + "default": {} + }, + "allOf": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/definitions/schema" + } + }, + "properties": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/schema" + }, + "default": {} + }, + "discriminator": { + "type": "string" + }, + "readOnly": { + "type": "boolean", + "default": false + }, + "xml": { + "$ref": "#/definitions/xml" + }, + "externalDocs": { + "$ref": "#/definitions/externalDocs" + }, + "example": {} + }, + "additionalProperties": false + }, + "fileSchema": { + "type": "object", + "description": "A deterministic version of a JSON Schema object.", + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + }, + "required": [ + "type" + ], + "properties": { + "format": { + "type": "string" + }, + "title": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/title" + }, + "description": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/description" + }, + "default": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/default" + }, + "required": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" + }, + "type": { + "type": "string", + "enum": [ + "file" + ] + }, + "readOnly": { + "type": "boolean", + "default": false + }, + "externalDocs": { + "$ref": "#/definitions/externalDocs" + }, + "example": {} + }, + "additionalProperties": false + }, + "primitivesItems": { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "enum": [ + "string", + "number", + "integer", + "boolean", + "array" + ] + }, + "format": { + "type": "string" + }, + "items": { + "$ref": "#/definitions/primitivesItems" + }, + "collectionFormat": { + "$ref": "#/definitions/collectionFormat" + }, + "default": { + "$ref": "#/definitions/default" + }, + "maximum": { + "$ref": "#/definitions/maximum" + }, + "exclusiveMaximum": { + "$ref": "#/definitions/exclusiveMaximum" + }, + "minimum": { + "$ref": "#/definitions/minimum" + }, + "exclusiveMinimum": { + "$ref": "#/definitions/exclusiveMinimum" + }, + "maxLength": { + "$ref": "#/definitions/maxLength" + }, + "minLength": { + "$ref": "#/definitions/minLength" + }, + "pattern": { + "$ref": "#/definitions/pattern" + }, + "maxItems": { + "$ref": "#/definitions/maxItems" + }, + "minItems": { + "$ref": "#/definitions/minItems" + }, + "uniqueItems": { + "$ref": "#/definitions/uniqueItems" + }, + "enum": { + "$ref": "#/definitions/enum" + }, + "multipleOf": { + "$ref": "#/definitions/multipleOf" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "security": { + "type": "array", + "items": { + "$ref": "#/definitions/securityRequirement" + }, + "uniqueItems": true + }, + "securityRequirement": { + "type": "object", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + } + }, + "xml": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "namespace": { + "type": "string" + }, + "prefix": { + "type": "string" + }, + "attribute": { + "type": "boolean", + "default": false + }, + "wrapped": { + "type": "boolean", + "default": false + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "tag": { + "type": "object", + "additionalProperties": false, + "required": [ + "name" + ], + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "externalDocs": { + "$ref": "#/definitions/externalDocs" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "securityDefinitions": { + "type": "object", + "additionalProperties": { + "oneOf": [ + { + "$ref": "#/definitions/basicAuthenticationSecurity" + }, + { + "$ref": "#/definitions/apiKeySecurity" + }, + { + "$ref": "#/definitions/oauth2ImplicitSecurity" + }, + { + "$ref": "#/definitions/oauth2PasswordSecurity" + }, + { + "$ref": "#/definitions/oauth2ApplicationSecurity" + }, + { + "$ref": "#/definitions/oauth2AccessCodeSecurity" + } + ] + } + }, + "basicAuthenticationSecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "basic" + ] + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "apiKeySecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "name", + "in" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "apiKey" + ] + }, + "name": { + "type": "string" + }, + "in": { + "type": "string", + "enum": [ + "header", + "query" + ] + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "oauth2ImplicitSecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "flow", + "authorizationUrl" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "oauth2" + ] + }, + "flow": { + "type": "string", + "enum": [ + "implicit" + ] + }, + "scopes": { + "$ref": "#/definitions/oauth2Scopes" + }, + "authorizationUrl": { + "type": "string", + "format": "uri" + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "oauth2PasswordSecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "flow", + "tokenUrl" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "oauth2" + ] + }, + "flow": { + "type": "string", + "enum": [ + "password" + ] + }, + "scopes": { + "$ref": "#/definitions/oauth2Scopes" + }, + "tokenUrl": { + "type": "string", + "format": "uri" + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "oauth2ApplicationSecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "flow", + "tokenUrl" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "oauth2" + ] + }, + "flow": { + "type": "string", + "enum": [ + "application" + ] + }, + "scopes": { + "$ref": "#/definitions/oauth2Scopes" + }, + "tokenUrl": { + "type": "string", + "format": "uri" + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "oauth2AccessCodeSecurity": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "flow", + "authorizationUrl", + "tokenUrl" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "oauth2" + ] + }, + "flow": { + "type": "string", + "enum": [ + "accessCode" + ] + }, + "scopes": { + "$ref": "#/definitions/oauth2Scopes" + }, + "authorizationUrl": { + "type": "string", + "format": "uri" + }, + "tokenUrl": { + "type": "string", + "format": "uri" + }, + "description": { + "type": "string" + } + }, + "patternProperties": { + "^x-": { + "$ref": "#/definitions/vendorExtension" + } + } + }, + "oauth2Scopes": { + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "mediaTypeList": { + "type": "array", + "items": { + "$ref": "#/definitions/mimeType" + }, + "uniqueItems": true + }, + "parametersList": { + "type": "array", + "description": "The parameters needed to send a valid API call.", + "additionalItems": false, + "items": { + "oneOf": [ + { + "$ref": "#/definitions/parameter" + }, + { + "$ref": "#/definitions/jsonReference" + } + ] + }, + "uniqueItems": true + }, + "schemesList": { + "type": "array", + "description": "The transfer protocol of the API.", + "items": { + "type": "string", + "enum": [ + "http", + "https", + "ws", + "wss" + ] + }, + "uniqueItems": true + }, + "collectionFormat": { + "type": "string", + "enum": [ + "csv", + "ssv", + "tsv", + "pipes" + ], + "default": "csv" + }, + "collectionFormatWithMulti": { + "type": "string", + "enum": [ + "csv", + "ssv", + "tsv", + "pipes", + "multi" + ], + "default": "csv" + }, + "title": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/title" + }, + "description": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/description" + }, + "default": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/default" + }, + "multipleOf": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf" + }, + "maximum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum" + }, + "exclusiveMaximum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum" + }, + "minimum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum" + }, + "exclusiveMinimum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum" + }, + "maxLength": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" + }, + "minLength": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" + }, + "pattern": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern" + }, + "maxItems": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" + }, + "minItems": { + "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" + }, + "uniqueItems": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems" + }, + "enum": { + "$ref": "http://json-schema.org/draft-04/schema#/properties/enum" + }, + "jsonReference": { + "type": "object", + "required": [ + "$ref" + ], + "additionalProperties": false, + "properties": { + "$ref": { + "type": "string" + } + } + } + } + }, + "tests": [ + { + "description": "Example petsore", + "data": { + "swagger": "2.0", + "info": { + "description": "This is a sample server Petstore server. You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/). For this sample, you can use the api key `special-key` to test the authorization filters.", + "version": "1.0.0", + "title": "Swagger Petstore", + "termsOfService": "http://swagger.io/terms/", + "contact": { + "email": "apiteam@swagger.io" + }, + "license": { + "name": "Apache 2.0", + "url": "http://www.apache.org/licenses/LICENSE-2.0.html" + } + }, + "host": "petstore.swagger.io", + "basePath": "/v2", + "tags": [ + { + "name": "pet", + "description": "Everything about your Pets", + "externalDocs": { + "description": "Find out more", + "url": "http://swagger.io" + } + }, + { + "name": "store", + "description": "Access to Petstore orders" + }, + { + "name": "user", + "description": "Operations about user", + "externalDocs": { + "description": "Find out more about our store", + "url": "http://swagger.io" + } + } + ], + "schemes": [ + "http" + ], + "paths": { + "/pet": { + "post": { + "tags": [ + "pet" + ], + "summary": "Add a new pet to the store", + "description": "", + "operationId": "addPet", + "consumes": [ + "application/json", + "application/xml" + ], + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "Pet object that needs to be added to the store", + "required": true, + "schema": { + "$ref": "#/definitions/Pet" + } + } + ], + "responses": { + "405": { + "description": "Invalid input" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + }, + "put": { + "tags": [ + "pet" + ], + "summary": "Update an existing pet", + "description": "", + "operationId": "updatePet", + "consumes": [ + "application/json", + "application/xml" + ], + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "Pet object that needs to be added to the store", + "required": true, + "schema": { + "$ref": "#/definitions/Pet" + } + } + ], + "responses": { + "400": { + "description": "Invalid ID supplied" + }, + "404": { + "description": "Pet not found" + }, + "405": { + "description": "Validation exception" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + } + }, + "/pet/findByStatus": { + "get": { + "tags": [ + "pet" + ], + "summary": "Finds Pets by status", + "description": "Multiple status values can be provided with comma separated strings", + "operationId": "findPetsByStatus", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "status", + "in": "query", + "description": "Status values that need to be considered for filter", + "required": true, + "type": "array", + "items": { + "type": "string", + "enum": [ + "available", + "pending", + "sold" + ], + "default": "available" + }, + "collectionFormat": "multi" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "type": "array", + "items": { + "$ref": "#/definitions/Pet" + } + } + }, + "400": { + "description": "Invalid status value" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + } + }, + "/pet/findByTags": { + "get": { + "tags": [ + "pet" + ], + "summary": "Finds Pets by tags", + "description": "Muliple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.", + "operationId": "findPetsByTags", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "tags", + "in": "query", + "description": "Tags to filter by", + "required": true, + "type": "array", + "items": { + "type": "string" + }, + "collectionFormat": "multi" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "type": "array", + "items": { + "$ref": "#/definitions/Pet" + } + } + }, + "400": { + "description": "Invalid tag value" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ], + "deprecated": true + } + }, + "/pet/{petId}": { + "get": { + "tags": [ + "pet" + ], + "summary": "Find pet by ID", + "description": "Returns a single pet", + "operationId": "getPetById", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "petId", + "in": "path", + "description": "ID of pet to return", + "required": true, + "type": "integer", + "format": "int64" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "$ref": "#/definitions/Pet" + } + }, + "400": { + "description": "Invalid ID supplied" + }, + "404": { + "description": "Pet not found" + } + }, + "security": [ + { + "api_key": [] + } + ] + }, + "post": { + "tags": [ + "pet" + ], + "summary": "Updates a pet in the store with form data", + "description": "", + "operationId": "updatePetWithForm", + "consumes": [ + "application/x-www-form-urlencoded" + ], + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "petId", + "in": "path", + "description": "ID of pet that needs to be updated", + "required": true, + "type": "integer", + "format": "int64" + }, + { + "name": "name", + "in": "formData", + "description": "Updated name of the pet", + "required": false, + "type": "string" + }, + { + "name": "status", + "in": "formData", + "description": "Updated status of the pet", + "required": false, + "type": "string" + } + ], + "responses": { + "405": { + "description": "Invalid input" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + }, + "delete": { + "tags": [ + "pet" + ], + "summary": "Deletes a pet", + "description": "", + "operationId": "deletePet", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "api_key", + "in": "header", + "required": false, + "type": "string" + }, + { + "name": "petId", + "in": "path", + "description": "Pet id to delete", + "required": true, + "type": "integer", + "format": "int64" + } + ], + "responses": { + "400": { + "description": "Invalid ID supplied" + }, + "404": { + "description": "Pet not found" + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + } + }, + "/pet/{petId}/uploadImage": { + "post": { + "tags": [ + "pet" + ], + "summary": "uploads an image", + "description": "", + "operationId": "uploadFile", + "consumes": [ + "multipart/form-data" + ], + "produces": [ + "application/json" + ], + "parameters": [ + { + "name": "petId", + "in": "path", + "description": "ID of pet to update", + "required": true, + "type": "integer", + "format": "int64" + }, + { + "name": "additionalMetadata", + "in": "formData", + "description": "Additional data to pass to server", + "required": false, + "type": "string" + }, + { + "name": "file", + "in": "formData", + "description": "file to upload", + "required": false, + "type": "file" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "$ref": "#/definitions/ApiResponse" + } + } + }, + "security": [ + { + "petstore_auth": [ + "write:pets", + "read:pets" + ] + } + ] + } + }, + "/store/inventory": { + "get": { + "tags": [ + "store" + ], + "summary": "Returns pet inventories by status", + "description": "Returns a map of status codes to quantities", + "operationId": "getInventory", + "produces": [ + "application/json" + ], + "parameters": [], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "type": "object", + "additionalProperties": { + "type": "integer", + "format": "int32" + } + } + } + }, + "security": [ + { + "api_key": [] + } + ] + } + }, + "/store/order": { + "post": { + "tags": [ + "store" + ], + "summary": "Place an order for a pet", + "description": "", + "operationId": "placeOrder", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "order placed for purchasing the pet", + "required": true, + "schema": { + "$ref": "#/definitions/Order" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "$ref": "#/definitions/Order" + } + }, + "400": { + "description": "Invalid Order" + } + } + } + }, + "/store/order/{orderId}": { + "get": { + "tags": [ + "store" + ], + "summary": "Find purchase order by ID", + "description": "For valid response try integer IDs with value >= 1 and <= 10. Other values will generated exceptions", + "operationId": "getOrderById", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "orderId", + "in": "path", + "description": "ID of pet that needs to be fetched", + "required": true, + "type": "integer", + "maximum": 10.0, + "minimum": 1.0, + "format": "int64" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "$ref": "#/definitions/Order" + } + }, + "400": { + "description": "Invalid ID supplied" + }, + "404": { + "description": "Order not found" + } + } + }, + "delete": { + "tags": [ + "store" + ], + "summary": "Delete purchase order by ID", + "description": "For valid response try integer IDs with positive integer value. Negative or non-integer values will generate API errors", + "operationId": "deleteOrder", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "orderId", + "in": "path", + "description": "ID of the order that needs to be deleted", + "required": true, + "type": "integer", + "minimum": 1.0, + "format": "int64" + } + ], + "responses": { + "400": { + "description": "Invalid ID supplied" + }, + "404": { + "description": "Order not found" + } + } + } + }, + "/user": { + "post": { + "tags": [ + "user" + ], + "summary": "Create user", + "description": "This can only be done by the logged in user.", + "operationId": "createUser", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "Created user object", + "required": true, + "schema": { + "$ref": "#/definitions/User" + } + } + ], + "responses": { + "default": { + "description": "successful operation" + } + } + } + }, + "/user/createWithArray": { + "post": { + "tags": [ + "user" + ], + "summary": "Creates list of users with given input array", + "description": "", + "operationId": "createUsersWithArrayInput", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "List of user object", + "required": true, + "schema": { + "type": "array", + "items": { + "$ref": "#/definitions/User" + } + } + } + ], + "responses": { + "default": { + "description": "successful operation" + } + } + } + }, + "/user/createWithList": { + "post": { + "tags": [ + "user" + ], + "summary": "Creates list of users with given input array", + "description": "", + "operationId": "createUsersWithListInput", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "in": "body", + "name": "body", + "description": "List of user object", + "required": true, + "schema": { + "type": "array", + "items": { + "$ref": "#/definitions/User" + } + } + } + ], + "responses": { + "default": { + "description": "successful operation" + } + } + } + }, + "/user/login": { + "get": { + "tags": [ + "user" + ], + "summary": "Logs user into the system", + "description": "", + "operationId": "loginUser", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "username", + "in": "query", + "description": "The user name for login", + "required": true, + "type": "string" + }, + { + "name": "password", + "in": "query", + "description": "The password for login in clear text", + "required": true, + "type": "string" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "type": "string" + }, + "headers": { + "X-Rate-Limit": { + "type": "integer", + "format": "int32", + "description": "calls per hour allowed by the user" + }, + "X-Expires-After": { + "type": "string", + "format": "date-time", + "description": "date in UTC when token expires" + } + } + }, + "400": { + "description": "Invalid username/password supplied" + } + } + } + }, + "/user/logout": { + "get": { + "tags": [ + "user" + ], + "summary": "Logs out current logged in user session", + "description": "", + "operationId": "logoutUser", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [], + "responses": { + "default": { + "description": "successful operation" + } + } + } + }, + "/user/{username}": { + "get": { + "tags": [ + "user" + ], + "summary": "Get user by user name", + "description": "", + "operationId": "getUserByName", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "username", + "in": "path", + "description": "The name that needs to be fetched. Use user1 for testing. ", + "required": true, + "type": "string" + } + ], + "responses": { + "200": { + "description": "successful operation", + "schema": { + "$ref": "#/definitions/User" + } + }, + "400": { + "description": "Invalid username supplied" + }, + "404": { + "description": "User not found" + } + } + }, + "put": { + "tags": [ + "user" + ], + "summary": "Updated user", + "description": "This can only be done by the logged in user.", + "operationId": "updateUser", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "username", + "in": "path", + "description": "name that need to be updated", + "required": true, + "type": "string" + }, + { + "in": "body", + "name": "body", + "description": "Updated user object", + "required": true, + "schema": { + "$ref": "#/definitions/User" + } + } + ], + "responses": { + "400": { + "description": "Invalid user supplied" + }, + "404": { + "description": "User not found" + } + } + }, + "delete": { + "tags": [ + "user" + ], + "summary": "Delete user", + "description": "This can only be done by the logged in user.", + "operationId": "deleteUser", + "produces": [ + "application/xml", + "application/json" + ], + "parameters": [ + { + "name": "username", + "in": "path", + "description": "The name that needs to be deleted", + "required": true, + "type": "string" + } + ], + "responses": { + "400": { + "description": "Invalid username supplied" + }, + "404": { + "description": "User not found" + } + } + } + } + }, + "securityDefinitions": { + "petstore_auth": { + "type": "oauth2", + "authorizationUrl": "http://petstore.swagger.io/oauth/dialog", + "flow": "implicit", + "scopes": { + "write:pets": "modify pets in your account", + "read:pets": "read your pets" + } + }, + "api_key": { + "type": "apiKey", + "name": "api_key", + "in": "header" + } + }, + "definitions": { + "Order": { + "type": "object", + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "petId": { + "type": "integer", + "format": "int64" + }, + "quantity": { + "type": "integer", + "format": "int32" + }, + "shipDate": { + "type": "string", + "format": "date-time" + }, + "status": { + "type": "string", + "description": "Order Status", + "enum": [ + "placed", + "approved", + "delivered" + ] + }, + "complete": { + "type": "boolean", + "default": false + } + }, + "xml": { + "name": "Order" + } + }, + "Category": { + "type": "object", + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "name": { + "type": "string" + } + }, + "xml": { + "name": "Category" + } + }, + "User": { + "type": "object", + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "username": { + "type": "string" + }, + "firstName": { + "type": "string" + }, + "lastName": { + "type": "string" + }, + "email": { + "type": "string" + }, + "password": { + "type": "string" + }, + "phone": { + "type": "string" + }, + "userStatus": { + "type": "integer", + "format": "int32", + "description": "User Status" + } + }, + "xml": { + "name": "User" + } + }, + "Tag": { + "type": "object", + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "name": { + "type": "string" + } + }, + "xml": { + "name": "Tag" + } + }, + "Pet": { + "type": "object", + "required": [ + "name", + "photoUrls" + ], + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "category": { + "$ref": "#/definitions/Category" + }, + "name": { + "type": "string", + "example": "doggie" + }, + "photoUrls": { + "type": "array", + "xml": { + "name": "photoUrl", + "wrapped": true + }, + "items": { + "type": "string" + } + }, + "tags": { + "type": "array", + "xml": { + "name": "tag", + "wrapped": true + }, + "items": { + "$ref": "#/definitions/Tag" + } + }, + "status": { + "type": "string", + "description": "pet status in the store", + "enum": [ + "available", + "pending", + "sold" + ] + } + }, + "xml": { + "name": "Pet" + } + }, + "ApiResponse": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32" + }, + "type": { + "type": "string" + }, + "message": { + "type": "string" + } + } + } + }, + "externalDocs": { + "description": "Find out more about Swagger", + "url": "http://swagger.io" + } + }, + "valid": true + } + ] + } +] diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/json_schema_test_suite.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/json_schema_test_suite.py new file mode 100644 index 0000000000000000000000000000000000000000..905fb6a3b88faf56e3288f7eb5053172f97abe8b --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/json_schema_test_suite.py @@ -0,0 +1,12 @@ +""" +A performance benchmark using the official test suite. + +This benchmarks jsonschema using every valid example in the +JSON-Schema-Test-Suite. It will take some time to complete. +""" +from pyperf import Runner + +from jsonschema.tests._suite import Suite + +if __name__ == "__main__": + Suite().benchmark(runner=Runner()) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/nested_schemas.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/nested_schemas.py new file mode 100644 index 0000000000000000000000000000000000000000..b025c47cfd6736b0ea3d36856c1e2c8de35dde79 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/nested_schemas.py @@ -0,0 +1,56 @@ +""" +Validating highly nested schemas shouldn't cause exponential time blowups. + +See https://github.com/python-jsonschema/jsonschema/issues/1097. +""" +from itertools import cycle + +from jsonschema.validators import validator_for + +metaschemaish = { + "$id": "https://example.com/draft/2020-12/schema/strict", + "$schema": "https://json-schema.org/draft/2020-12/schema", + + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/core": True, + "https://json-schema.org/draft/2020-12/vocab/applicator": True, + "https://json-schema.org/draft/2020-12/vocab/unevaluated": True, + "https://json-schema.org/draft/2020-12/vocab/validation": True, + "https://json-schema.org/draft/2020-12/vocab/meta-data": True, + "https://json-schema.org/draft/2020-12/vocab/format-annotation": True, + "https://json-schema.org/draft/2020-12/vocab/content": True, + }, + "$dynamicAnchor": "meta", + + "$ref": "https://json-schema.org/draft/2020-12/schema", + "unevaluatedProperties": False, +} + + +def nested_schema(levels): + """ + Produce a schema which validates deeply nested objects and arrays. + """ + + names = cycle(["foo", "bar", "baz", "quux", "spam", "eggs"]) + schema = {"type": "object", "properties": {"ham": {"type": "string"}}} + for _, name in zip(range(levels - 1), names): + schema = {"type": "object", "properties": {name: schema}} + return schema + + +validator = validator_for(metaschemaish)(metaschemaish) + +if __name__ == "__main__": + from pyperf import Runner + runner = Runner() + + not_nested = nested_schema(levels=1) + runner.bench_func("not nested", lambda: validator.is_valid(not_nested)) + + for levels in range(1, 11, 3): + schema = nested_schema(levels=levels) + runner.bench_func( + f"nested * {levels}", + lambda schema=schema: validator.is_valid(schema), + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/subcomponents.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/subcomponents.py new file mode 100644 index 0000000000000000000000000000000000000000..6d78c7be6c88d177b89dfc80e52acae7820156a5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/subcomponents.py @@ -0,0 +1,42 @@ +""" +A benchmark which tries to compare the possible slow subparts of validation. +""" +from referencing import Registry +from referencing.jsonschema import DRAFT202012 +from rpds import HashTrieMap, HashTrieSet + +from jsonschema import Draft202012Validator + +schema = { + "type": "array", + "minLength": 1, + "maxLength": 1, + "items": {"type": "integer"}, +} + +hmap = HashTrieMap() +hset = HashTrieSet() + +registry = Registry() + +v = Draft202012Validator(schema) + + +def registry_data_structures(): + return hmap.insert("foo", "bar"), hset.insert("foo") + + +def registry_add(): + resource = DRAFT202012.create_resource(schema) + return registry.with_resource(uri="urn:example", resource=resource) + + +if __name__ == "__main__": + from pyperf import Runner + runner = Runner() + + runner.bench_func("HashMap/HashSet insertion", registry_data_structures) + runner.bench_func("Registry insertion", registry_add) + runner.bench_func("Success", lambda: v.is_valid([1])) + runner.bench_func("Failure", lambda: v.is_valid(["foo"])) + runner.bench_func("Metaschema validation", lambda: v.check_schema(schema)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/unused_registry.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/unused_registry.py new file mode 100644 index 0000000000000000000000000000000000000000..7b272c235625378b231d1c113bcb8ef45851cbc7 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/unused_registry.py @@ -0,0 +1,35 @@ +""" +An unused schema registry should not cause slower validation. + +"Unused" here means one where no reference resolution is occurring anyhow. + +See https://github.com/python-jsonschema/jsonschema/issues/1088. +""" +from pyperf import Runner +from referencing import Registry +from referencing.jsonschema import DRAFT201909 + +from jsonschema import Draft201909Validator + +registry = Registry().with_resource( + "urn:example:foo", + DRAFT201909.create_resource({}), +) + +schema = {"$ref": "https://json-schema.org/draft/2019-09/schema"} +instance = {"maxLength": 4} + +no_registry = Draft201909Validator(schema) +with_useless_registry = Draft201909Validator(schema, registry=registry) + +if __name__ == "__main__": + runner = Runner() + + runner.bench_func( + "no registry", + lambda: no_registry.is_valid(instance), + ) + runner.bench_func( + "useless registry", + lambda: with_useless_registry.is_valid(instance), + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_applicator_schemas.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_applicator_schemas.py new file mode 100644 index 0000000000000000000000000000000000000000..f3229c0b8b9341e80ed087297efe31b04aa77fd7 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_applicator_schemas.py @@ -0,0 +1,106 @@ + +""" +A benchmark for validation of applicators containing lots of useless schemas. + +Signals a small possible optimization to remove all such schemas ahead of time. +""" + +from pyperf import Runner + +from jsonschema import Draft202012Validator as Validator + +NUM_USELESS = 100000 + +subschema = {"const": 37} + +valid = 37 +invalid = 12 + +baseline = Validator(subschema) + + +# These should be indistinguishable from just `subschema` +by_name = { + "single subschema": { + "anyOf": Validator({"anyOf": [subschema]}), + "allOf": Validator({"allOf": [subschema]}), + "oneOf": Validator({"oneOf": [subschema]}), + }, + "redundant subschemas": { + "anyOf": Validator({"anyOf": [subschema] * NUM_USELESS}), + "allOf": Validator({"allOf": [subschema] * NUM_USELESS}), + }, + "useless successful subschemas (beginning)": { + "anyOf": Validator({"anyOf": [subschema, *[True] * NUM_USELESS]}), + "allOf": Validator({"allOf": [subschema, *[True] * NUM_USELESS]}), + }, + "useless successful subschemas (middle)": { + "anyOf": Validator( + { + "anyOf": [ + *[True] * (NUM_USELESS // 2), + subschema, + *[True] * (NUM_USELESS // 2), + ], + }, + ), + "allOf": Validator( + { + "allOf": [ + *[True] * (NUM_USELESS // 2), + subschema, + *[True] * (NUM_USELESS // 2), + ], + }, + ), + }, + "useless successful subschemas (end)": { + "anyOf": Validator({"anyOf": [*[True] * NUM_USELESS, subschema]}), + "allOf": Validator({"allOf": [*[True] * NUM_USELESS, subschema]}), + }, + "useless failing subschemas (beginning)": { + "anyOf": Validator({"anyOf": [subschema, *[False] * NUM_USELESS]}), + "oneOf": Validator({"oneOf": [subschema, *[False] * NUM_USELESS]}), + }, + "useless failing subschemas (middle)": { + "anyOf": Validator( + { + "anyOf": [ + *[False] * (NUM_USELESS // 2), + subschema, + *[False] * (NUM_USELESS // 2), + ], + }, + ), + "oneOf": Validator( + { + "oneOf": [ + *[False] * (NUM_USELESS // 2), + subschema, + *[False] * (NUM_USELESS // 2), + ], + }, + ), + }, + "useless failing subschemas (end)": { + "anyOf": Validator({"anyOf": [*[False] * NUM_USELESS, subschema]}), + "oneOf": Validator({"oneOf": [*[False] * NUM_USELESS, subschema]}), + }, +} + +if __name__ == "__main__": + runner = Runner() + + runner.bench_func("baseline valid", lambda: baseline.is_valid(valid)) + runner.bench_func("baseline invalid", lambda: baseline.is_valid(invalid)) + + for group, applicators in by_name.items(): + for applicator, validator in applicators.items(): + runner.bench_func( + f"{group}: {applicator} valid", + lambda validator=validator: validator.is_valid(valid), + ) + runner.bench_func( + f"{group}: {applicator} invalid", + lambda validator=validator: validator.is_valid(invalid), + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_keywords.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_keywords.py new file mode 100644 index 0000000000000000000000000000000000000000..50f435989dd14d34d804508067e91e5fae4a275c --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/useless_keywords.py @@ -0,0 +1,32 @@ +""" +A benchmark for validation of schemas containing lots of useless keywords. + +Checks we filter them out once, ahead of time. +""" + +from pyperf import Runner + +from jsonschema import Draft202012Validator + +NUM_USELESS = 100000 +schema = dict( + [ + ("not", {"const": 42}), + *((str(i), i) for i in range(NUM_USELESS)), + ("type", "integer"), + *((str(i), i) for i in range(NUM_USELESS, NUM_USELESS)), + ("minimum", 37), + ], +) +validator = Draft202012Validator(schema) + +valid = 3737 +invalid = 12 + + +if __name__ == "__main__": + runner = Runner() + runner.bench_func("beginning of schema", lambda: validator.is_valid(42)) + runner.bench_func("middle of schema", lambda: validator.is_valid("foo")) + runner.bench_func("end of schema", lambda: validator.is_valid(12)) + runner.bench_func("valid", lambda: validator.is_valid(3737)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/benchmarks/validator_creation.py b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/validator_creation.py new file mode 100644 index 0000000000000000000000000000000000000000..4baeb3a31641a027496732a6f10e200346551209 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/benchmarks/validator_creation.py @@ -0,0 +1,14 @@ +from pyperf import Runner + +from jsonschema import Draft202012Validator + +schema = { + "type": "array", + "minLength": 1, + "maxLength": 1, + "items": {"type": "integer"}, +} + + +if __name__ == "__main__": + Runner().bench_func("validator creation", Draft202012Validator, schema) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__init__.py b/python/user_packages/Python313/site-packages/jsonschema/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03f2ea1890c46618ce649247fb0d6f719328762b Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/_suite.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/_suite.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0c79fd04039c897763283e8e6bc998214e13f3f Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/_suite.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/fuzz_validate.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/fuzz_validate.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0e21b82cdc8d393d73d6ab70eb28030f093c1bc Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/fuzz_validate.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_cli.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_cli.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76bf47036c583ff237836652d9c6535810c2806f Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_cli.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_deprecations.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_deprecations.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b311b1257aebe5216c7bae2d8a513c28d169b9a Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_deprecations.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_exceptions.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_exceptions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be8e32dd7de57af9fd27367a25f46b6cf054a263 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_exceptions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_format.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_format.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9958127b5ff054a5ee35adc7bd9fa35459490003 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_format.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_jsonschema_test_suite.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_jsonschema_test_suite.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d7ba9c437401dd96af60241a3790f58eec417a4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_jsonschema_test_suite.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_types.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_types.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a685fdc9f7f571727c313b0f9260c1ba53e0207 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_types.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_utils.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_utils.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22b6f9a6c03a85763580280551392fc1bfcf4bb6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/__pycache__/test_utils.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/_suite.py b/python/user_packages/Python313/site-packages/jsonschema/tests/_suite.py new file mode 100644 index 0000000000000000000000000000000000000000..d61d38277d31d3eba23f6681d92066b8dba3ffc6 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/_suite.py @@ -0,0 +1,285 @@ +""" +Python representations of the JSON Schema Test Suite tests. +""" +from __future__ import annotations + +from contextlib import suppress +from functools import partial +from pathlib import Path +from typing import TYPE_CHECKING, Any +import json +import os +import re +import sys +import unittest + +from attrs import field, frozen +from referencing import Registry +import referencing.jsonschema + +if TYPE_CHECKING: + from collections.abc import Iterable, Mapping, Sequence + + from referencing.jsonschema import Schema + import pyperf + +from jsonschema.validators import _VALIDATORS +import jsonschema + +MAGIC_REMOTE_URL = "http://localhost:1234" + +_DELIMITERS = re.compile(r"[\W\- ]+") + + +def _find_suite(): + root = os.environ.get("JSON_SCHEMA_TEST_SUITE") + if root is not None: + return Path(root) + + root = Path(jsonschema.__file__).parent.parent / "json" + if not root.is_dir(): # pragma: no cover + raise ValueError( + ( + "Can't find the JSON-Schema-Test-Suite directory. " + "Set the 'JSON_SCHEMA_TEST_SUITE' environment " + "variable or run the tests from alongside a checkout " + "of the suite." + ), + ) + return root + + +@frozen +class Suite: + + _root: Path = field(factory=_find_suite) + + + def benchmark(self, runner: pyperf.Runner): # pragma: no cover + for name, Validator in _VALIDATORS.items(): + self.version(name=name).benchmark( + runner=runner, + Validator=Validator, + ) + + def version(self, name) -> Version: + Validator = _VALIDATORS[name] + uri: str = Validator.ID_OF(Validator.META_SCHEMA) # type: ignore[assignment] + specification = referencing.jsonschema.specification_with(uri) + + registry = Registry().with_contents( + remotes_in(root=self._root / "remotes", name=name, uri=uri), + default_specification=specification, + ) + return Version( + name=name, + path=self._root / "tests" / name, + remotes=registry, + ) + + +@frozen +class Version: + + _path: Path + _remotes: referencing.jsonschema.SchemaRegistry + + name: str + + def benchmark(self, **kwargs): # pragma: no cover + for case in self.cases(): + case.benchmark(**kwargs) + + def cases(self) -> Iterable[_Case]: + return self._cases_in(paths=self._path.glob("*.json")) + + def format_cases(self) -> Iterable[_Case]: + return self._cases_in(paths=self._path.glob("optional/format/*.json")) + + def optional_cases_of(self, name: str) -> Iterable[_Case]: + return self._cases_in(paths=[self._path / "optional" / f"{name}.json"]) + + def to_unittest_testcase(self, *groups, **kwargs): + name = kwargs.pop("name", "Test" + self.name.title().replace("-", "")) + methods = { + method.__name__: method + for method in ( + test.to_unittest_method(**kwargs) + for group in groups + for case in group + for test in case.tests + ) + } + cls = type(name, (unittest.TestCase,), methods) + + # We're doing crazy things, so if they go wrong, like a function + # behaving differently on some other interpreter, just make them + # not happen. + with suppress(Exception): + cls.__module__ = _someone_save_us_the_module_of_the_caller() + + return cls + + def _cases_in(self, paths: Iterable[Path]) -> Iterable[_Case]: + for path in paths: + for case in json.loads(path.read_text(encoding="utf-8")): + yield _Case.from_dict( + case, + version=self, + subject=path.stem, + remotes=self._remotes, + ) + + +@frozen +class _Case: + + version: Version + + subject: str + description: str + schema: Mapping[str, Any] | bool + tests: list[_Test] + comment: str | None = None + specification: Sequence[dict[str, str]] = () + + @classmethod + def from_dict(cls, data, remotes, **kwargs): + data.update(kwargs) + tests = [ + _Test( + version=data["version"], + subject=data["subject"], + case_description=data["description"], + schema=data["schema"], + remotes=remotes, + **test, + ) for test in data.pop("tests") + ] + return cls(tests=tests, **data) + + def benchmark(self, runner: pyperf.Runner, **kwargs): # pragma: no cover + for test in self.tests: + runner.bench_func( + test.fully_qualified_name, + partial(test.validate_ignoring_errors, **kwargs), + ) + + +def remotes_in( + root: Path, + name: str, + uri: str, +) -> Iterable[tuple[str, Schema]]: + # This messy logic is because the test suite is terrible at indicating + # what remotes are needed for what drafts, and mixes in schemas which + # have no $schema and which are invalid under earlier versions, in with + # other schemas which are needed for tests. + + for each in root.rglob("*.json"): + schema = json.loads(each.read_text()) + + relative = str(each.relative_to(root)).replace("\\", "/") + + if ( + ( # invalid boolean schema + name in {"draft3", "draft4"} + and each.stem == "tree" + ) or + ( # draft/*.json + "$schema" not in schema + and relative.startswith("draft") + and not relative.startswith(name) + ) + ): + continue + yield f"{MAGIC_REMOTE_URL}/{relative}", schema + + +@frozen(repr=False) +class _Test: + + version: Version + + subject: str + case_description: str + description: str + + data: Any + schema: Mapping[str, Any] | bool + + valid: bool + + _remotes: referencing.jsonschema.SchemaRegistry + + comment: str | None = None + + def __repr__(self): # pragma: no cover + return f"" + + @property + def fully_qualified_name(self): # pragma: no cover + return " > ".join( # noqa: FLY002 + [ + self.version.name, + self.subject, + self.case_description, + self.description, + ], + ) + + def to_unittest_method(self, skip=lambda test: None, **kwargs): + if self.valid: + def fn(this): + self.validate(**kwargs) + else: + def fn(this): + with this.assertRaises(jsonschema.ValidationError): + self.validate(**kwargs) + + fn.__name__ = "_".join( + [ + "test", + _DELIMITERS.sub("_", self.subject), + _DELIMITERS.sub("_", self.case_description), + _DELIMITERS.sub("_", self.description), + ], + ) + reason = skip(self) + if reason is None or os.environ.get("JSON_SCHEMA_DEBUG", "0") != "0": + return fn + elif os.environ.get("JSON_SCHEMA_EXPECTED_FAILURES", "0") != "0": # pragma: no cover # noqa: E501 + return unittest.expectedFailure(fn) + else: + return unittest.skip(reason)(fn) + + def validate(self, Validator, **kwargs): + Validator.check_schema(self.schema) + validator = Validator( + schema=self.schema, + registry=self._remotes, + **kwargs, + ) + if os.environ.get("JSON_SCHEMA_DEBUG", "0") != "0": # pragma: no cover + breakpoint() # noqa: T100 + validator.validate(instance=self.data) + + def validate_ignoring_errors(self, Validator): # pragma: no cover + with suppress(jsonschema.ValidationError): + self.validate(Validator=Validator) + + +def _someone_save_us_the_module_of_the_caller(): + """ + The FQON of the module 2nd stack frames up from here. + + This is intended to allow us to dynamically return test case classes that + are indistinguishable from being defined in the module that wants them. + + Otherwise, trial will mis-print the FQON, and copy pasting it won't re-run + the class that really is running. + + Save us all, this is all so so so so so terrible. + """ + + return sys._getframe(2).f_globals["__name__"] diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/fuzz_validate.py b/python/user_packages/Python313/site-packages/jsonschema/tests/fuzz_validate.py new file mode 100644 index 0000000000000000000000000000000000000000..c12e88bcfe9bfdc0e0ffaab502789a6b585d4be2 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/fuzz_validate.py @@ -0,0 +1,50 @@ +""" +Fuzzing setup for OSS-Fuzz. + +See https://github.com/google/oss-fuzz/tree/master/projects/jsonschema for the +other half of the setup here. +""" +import sys + +from hypothesis import given, strategies + +import jsonschema + +PRIM = strategies.one_of( + strategies.booleans(), + strategies.integers(), + strategies.floats(allow_nan=False, allow_infinity=False), + strategies.text(), +) +DICT = strategies.recursive( + base=strategies.one_of( + strategies.booleans(), + strategies.dictionaries(strategies.text(), PRIM), + ), + extend=lambda inner: strategies.dictionaries(strategies.text(), inner), +) + + +@given(obj1=DICT, obj2=DICT) +def test_schemas(obj1, obj2): + try: + jsonschema.validate(instance=obj1, schema=obj2) + except jsonschema.exceptions.ValidationError: + pass + except jsonschema.exceptions.SchemaError: + pass + + +def main(): + atheris.instrument_all() + atheris.Setup( + sys.argv, + test_schemas.hypothesis.fuzz_one_input, + enable_python_coverage=True, + ) + atheris.Fuzz() + + +if __name__ == "__main__": + import atheris + main() diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_cli.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..bed9f3e4c4089a4cc653ffdb02d3648042df4088 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_cli.py @@ -0,0 +1,904 @@ +from contextlib import redirect_stderr, redirect_stdout +from importlib import metadata +from io import StringIO +from json import JSONDecodeError +from pathlib import Path +from textwrap import dedent +from unittest import TestCase +import json +import os +import subprocess +import sys +import tempfile +import warnings + +from jsonschema import Draft4Validator, Draft202012Validator +from jsonschema.exceptions import ( + SchemaError, + ValidationError, + _RefResolutionError, +) +from jsonschema.validators import _LATEST_VERSION, validate + +with warnings.catch_warnings(): + warnings.simplefilter("ignore") + from jsonschema import cli + + +def fake_validator(*errors): + errors = list(reversed(errors)) + + class FakeValidator: + def __init__(self, *args, **kwargs): + pass + + def iter_errors(self, instance): + if errors: + return errors.pop() + return [] # pragma: no cover + + @classmethod + def check_schema(self, schema): + pass + + return FakeValidator + + +def fake_open(all_contents): + def open(path): + contents = all_contents.get(path) + if contents is None: + raise FileNotFoundError(path) + return StringIO(contents) + return open + + +def _message_for(non_json): + try: + json.loads(non_json) + except JSONDecodeError as error: + return str(error) + else: # pragma: no cover + raise RuntimeError("Tried and failed to capture a JSON dump error.") + + +class TestCLI(TestCase): + def run_cli( + self, argv, files=None, stdin=StringIO(), exit_code=0, **override, + ): + arguments = cli.parse_args(argv) + arguments.update(override) + + self.assertFalse(hasattr(cli, "open")) + cli.open = fake_open(files or {}) + try: + stdout, stderr = StringIO(), StringIO() + actual_exit_code = cli.run( + arguments, + stdin=stdin, + stdout=stdout, + stderr=stderr, + ) + finally: + del cli.open + + self.assertEqual( + actual_exit_code, exit_code, msg=dedent( + f""" + Expected an exit code of {exit_code} != {actual_exit_code}. + + stdout: {stdout.getvalue()} + + stderr: {stderr.getvalue()} + """, + ), + ) + return stdout.getvalue(), stderr.getvalue() + + def assertOutputs(self, stdout="", stderr="", **kwargs): + self.assertEqual( + self.run_cli(**kwargs), + (dedent(stdout), dedent(stderr)), + ) + + def test_invalid_instance(self): + error = ValidationError("I am an error!", instance=12) + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_instance=json.dumps(error.instance), + ), + validator=fake_validator([error]), + + argv=["-i", "some_instance", "some_schema"], + + exit_code=1, + stderr="12: I am an error!\n", + ) + + def test_invalid_instance_pretty_output(self): + error = ValidationError("I am an error!", instance=12) + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_instance=json.dumps(error.instance), + ), + validator=fake_validator([error]), + + argv=["-i", "some_instance", "--output", "pretty", "some_schema"], + + exit_code=1, + stderr="""\ + ===[ValidationError]===(some_instance)=== + + I am an error! + ----------------------------- + """, + ) + + def test_invalid_instance_explicit_plain_output(self): + error = ValidationError("I am an error!", instance=12) + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_instance=json.dumps(error.instance), + ), + validator=fake_validator([error]), + + argv=["--output", "plain", "-i", "some_instance", "some_schema"], + + exit_code=1, + stderr="12: I am an error!\n", + ) + + def test_invalid_instance_multiple_errors(self): + instance = 12 + first = ValidationError("First error", instance=instance) + second = ValidationError("Second error", instance=instance) + + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_instance=json.dumps(instance), + ), + validator=fake_validator([first, second]), + + argv=["-i", "some_instance", "some_schema"], + + exit_code=1, + stderr="""\ + 12: First error + 12: Second error + """, + ) + + def test_invalid_instance_multiple_errors_pretty_output(self): + instance = 12 + first = ValidationError("First error", instance=instance) + second = ValidationError("Second error", instance=instance) + + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_instance=json.dumps(instance), + ), + validator=fake_validator([first, second]), + + argv=["-i", "some_instance", "--output", "pretty", "some_schema"], + + exit_code=1, + stderr="""\ + ===[ValidationError]===(some_instance)=== + + First error + ----------------------------- + ===[ValidationError]===(some_instance)=== + + Second error + ----------------------------- + """, + ) + + def test_multiple_invalid_instances(self): + first_instance = 12 + first_errors = [ + ValidationError("An error", instance=first_instance), + ValidationError("Another error", instance=first_instance), + ] + second_instance = "foo" + second_errors = [ValidationError("BOOM", instance=second_instance)] + + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_first_instance=json.dumps(first_instance), + some_second_instance=json.dumps(second_instance), + ), + validator=fake_validator(first_errors, second_errors), + + argv=[ + "-i", "some_first_instance", + "-i", "some_second_instance", + "some_schema", + ], + + exit_code=1, + stderr="""\ + 12: An error + 12: Another error + foo: BOOM + """, + ) + + def test_multiple_invalid_instances_pretty_output(self): + first_instance = 12 + first_errors = [ + ValidationError("An error", instance=first_instance), + ValidationError("Another error", instance=first_instance), + ] + second_instance = "foo" + second_errors = [ValidationError("BOOM", instance=second_instance)] + + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_first_instance=json.dumps(first_instance), + some_second_instance=json.dumps(second_instance), + ), + validator=fake_validator(first_errors, second_errors), + + argv=[ + "--output", "pretty", + "-i", "some_first_instance", + "-i", "some_second_instance", + "some_schema", + ], + + exit_code=1, + stderr="""\ + ===[ValidationError]===(some_first_instance)=== + + An error + ----------------------------- + ===[ValidationError]===(some_first_instance)=== + + Another error + ----------------------------- + ===[ValidationError]===(some_second_instance)=== + + BOOM + ----------------------------- + """, + ) + + def test_custom_error_format(self): + first_instance = 12 + first_errors = [ + ValidationError("An error", instance=first_instance), + ValidationError("Another error", instance=first_instance), + ] + second_instance = "foo" + second_errors = [ValidationError("BOOM", instance=second_instance)] + + self.assertOutputs( + files=dict( + some_schema='{"does not": "matter since it is stubbed"}', + some_first_instance=json.dumps(first_instance), + some_second_instance=json.dumps(second_instance), + ), + validator=fake_validator(first_errors, second_errors), + + argv=[ + "--error-format", ":{error.message}._-_.{error.instance}:", + "-i", "some_first_instance", + "-i", "some_second_instance", + "some_schema", + ], + + exit_code=1, + stderr=":An error._-_.12::Another error._-_.12::BOOM._-_.foo:", + ) + + def test_invalid_schema(self): + self.assertOutputs( + files=dict(some_schema='{"type": 12}'), + argv=["some_schema"], + + exit_code=1, + stderr="""\ + 12: 12 is not valid under any of the given schemas + """, + ) + + def test_invalid_schema_pretty_output(self): + schema = {"type": 12} + + with self.assertRaises(SchemaError) as e: + validate(schema=schema, instance="") + error = str(e.exception) + + self.assertOutputs( + files=dict(some_schema=json.dumps(schema)), + argv=["--output", "pretty", "some_schema"], + + exit_code=1, + stderr=( + "===[SchemaError]===(some_schema)===\n\n" + + str(error) + + "\n-----------------------------\n" + ), + ) + + def test_invalid_schema_multiple_errors(self): + self.assertOutputs( + files=dict(some_schema='{"type": 12, "items": 57}'), + argv=["some_schema"], + + exit_code=1, + stderr="""\ + 57: 57 is not of type 'object', 'boolean' + """, + ) + + def test_invalid_schema_multiple_errors_pretty_output(self): + schema = {"type": 12, "items": 57} + + with self.assertRaises(SchemaError) as e: + validate(schema=schema, instance="") + error = str(e.exception) + + self.assertOutputs( + files=dict(some_schema=json.dumps(schema)), + argv=["--output", "pretty", "some_schema"], + + exit_code=1, + stderr=( + "===[SchemaError]===(some_schema)===\n\n" + + str(error) + + "\n-----------------------------\n" + ), + ) + + def test_invalid_schema_with_invalid_instance(self): + """ + "Validating" an instance that's invalid under an invalid schema + just shows the schema error. + """ + self.assertOutputs( + files=dict( + some_schema='{"type": 12, "minimum": 30}', + some_instance="13", + ), + argv=["-i", "some_instance", "some_schema"], + + exit_code=1, + stderr="""\ + 12: 12 is not valid under any of the given schemas + """, + ) + + def test_invalid_schema_with_invalid_instance_pretty_output(self): + instance, schema = 13, {"type": 12, "minimum": 30} + + with self.assertRaises(SchemaError) as e: + validate(schema=schema, instance=instance) + error = str(e.exception) + + self.assertOutputs( + files=dict( + some_schema=json.dumps(schema), + some_instance=json.dumps(instance), + ), + argv=["--output", "pretty", "-i", "some_instance", "some_schema"], + + exit_code=1, + stderr=( + "===[SchemaError]===(some_schema)===\n\n" + + str(error) + + "\n-----------------------------\n" + ), + ) + + def test_invalid_instance_continues_with_the_rest(self): + self.assertOutputs( + files=dict( + some_schema='{"minimum": 30}', + first_instance="not valid JSON!", + second_instance="12", + ), + argv=[ + "-i", "first_instance", + "-i", "second_instance", + "some_schema", + ], + + exit_code=1, + stderr="""\ + Failed to parse 'first_instance': {} + 12: 12 is less than the minimum of 30 + """.format(_message_for("not valid JSON!")), + ) + + def test_custom_error_format_applies_to_schema_errors(self): + instance, schema = 13, {"type": 12, "minimum": 30} + + with self.assertRaises(SchemaError): + validate(schema=schema, instance=instance) + + self.assertOutputs( + files=dict(some_schema=json.dumps(schema)), + + argv=[ + "--error-format", ":{error.message}._-_.{error.instance}:", + "some_schema", + ], + + exit_code=1, + stderr=":12 is not valid under any of the given schemas._-_.12:", + ) + + def test_instance_is_invalid_JSON(self): + instance = "not valid JSON!" + + self.assertOutputs( + files=dict(some_schema="{}", some_instance=instance), + argv=["-i", "some_instance", "some_schema"], + + exit_code=1, + stderr=f"""\ + Failed to parse 'some_instance': {_message_for(instance)} + """, + ) + + def test_instance_is_invalid_JSON_pretty_output(self): + stdout, stderr = self.run_cli( + files=dict( + some_schema="{}", + some_instance="not valid JSON!", + ), + + argv=["--output", "pretty", "-i", "some_instance", "some_schema"], + + exit_code=1, + ) + self.assertFalse(stdout) + self.assertIn( + "(some_instance)===\n\nTraceback (most recent call last):\n", + stderr, + ) + self.assertNotIn("some_schema", stderr) + + def test_instance_is_invalid_JSON_on_stdin(self): + instance = "not valid JSON!" + + self.assertOutputs( + files=dict(some_schema="{}"), + stdin=StringIO(instance), + + argv=["some_schema"], + + exit_code=1, + stderr=f"""\ + Failed to parse : {_message_for(instance)} + """, + ) + + def test_instance_is_invalid_JSON_on_stdin_pretty_output(self): + stdout, stderr = self.run_cli( + files=dict(some_schema="{}"), + stdin=StringIO("not valid JSON!"), + + argv=["--output", "pretty", "some_schema"], + + exit_code=1, + ) + self.assertFalse(stdout) + self.assertIn( + "()===\n\nTraceback (most recent call last):\n", + stderr, + ) + self.assertNotIn("some_schema", stderr) + + def test_schema_is_invalid_JSON(self): + schema = "not valid JSON!" + + self.assertOutputs( + files=dict(some_schema=schema), + + argv=["some_schema"], + + exit_code=1, + stderr=f"""\ + Failed to parse 'some_schema': {_message_for(schema)} + """, + ) + + def test_schema_is_invalid_JSON_pretty_output(self): + stdout, stderr = self.run_cli( + files=dict(some_schema="not valid JSON!"), + + argv=["--output", "pretty", "some_schema"], + + exit_code=1, + ) + self.assertFalse(stdout) + self.assertIn( + "(some_schema)===\n\nTraceback (most recent call last):\n", + stderr, + ) + + def test_schema_and_instance_are_both_invalid_JSON(self): + """ + Only the schema error is reported, as we abort immediately. + """ + schema, instance = "not valid JSON!", "also not valid JSON!" + self.assertOutputs( + files=dict(some_schema=schema, some_instance=instance), + + argv=["some_schema"], + + exit_code=1, + stderr=f"""\ + Failed to parse 'some_schema': {_message_for(schema)} + """, + ) + + def test_schema_and_instance_are_both_invalid_JSON_pretty_output(self): + """ + Only the schema error is reported, as we abort immediately. + """ + stdout, stderr = self.run_cli( + files=dict( + some_schema="not valid JSON!", + some_instance="also not valid JSON!", + ), + + argv=["--output", "pretty", "-i", "some_instance", "some_schema"], + + exit_code=1, + ) + self.assertFalse(stdout) + self.assertIn( + "(some_schema)===\n\nTraceback (most recent call last):\n", + stderr, + ) + self.assertNotIn("some_instance", stderr) + + def test_instance_does_not_exist(self): + self.assertOutputs( + files=dict(some_schema="{}"), + argv=["-i", "nonexisting_instance", "some_schema"], + + exit_code=1, + stderr="""\ + 'nonexisting_instance' does not exist. + """, + ) + + def test_instance_does_not_exist_pretty_output(self): + self.assertOutputs( + files=dict(some_schema="{}"), + argv=[ + "--output", "pretty", + "-i", "nonexisting_instance", + "some_schema", + ], + + exit_code=1, + stderr="""\ + ===[FileNotFoundError]===(nonexisting_instance)=== + + 'nonexisting_instance' does not exist. + ----------------------------- + """, + ) + + def test_schema_does_not_exist(self): + self.assertOutputs( + argv=["nonexisting_schema"], + + exit_code=1, + stderr="'nonexisting_schema' does not exist.\n", + ) + + def test_schema_does_not_exist_pretty_output(self): + self.assertOutputs( + argv=["--output", "pretty", "nonexisting_schema"], + + exit_code=1, + stderr="""\ + ===[FileNotFoundError]===(nonexisting_schema)=== + + 'nonexisting_schema' does not exist. + ----------------------------- + """, + ) + + def test_neither_instance_nor_schema_exist(self): + self.assertOutputs( + argv=["-i", "nonexisting_instance", "nonexisting_schema"], + + exit_code=1, + stderr="'nonexisting_schema' does not exist.\n", + ) + + def test_neither_instance_nor_schema_exist_pretty_output(self): + self.assertOutputs( + argv=[ + "--output", "pretty", + "-i", "nonexisting_instance", + "nonexisting_schema", + ], + + exit_code=1, + stderr="""\ + ===[FileNotFoundError]===(nonexisting_schema)=== + + 'nonexisting_schema' does not exist. + ----------------------------- + """, + ) + + def test_successful_validation(self): + self.assertOutputs( + files=dict(some_schema="{}", some_instance="{}"), + argv=["-i", "some_instance", "some_schema"], + stdout="", + stderr="", + ) + + def test_successful_validation_pretty_output(self): + self.assertOutputs( + files=dict(some_schema="{}", some_instance="{}"), + argv=["--output", "pretty", "-i", "some_instance", "some_schema"], + stdout="===[SUCCESS]===(some_instance)===\n", + stderr="", + ) + + def test_successful_validation_of_stdin(self): + self.assertOutputs( + files=dict(some_schema="{}"), + stdin=StringIO("{}"), + argv=["some_schema"], + stdout="", + stderr="", + ) + + def test_successful_validation_of_stdin_pretty_output(self): + self.assertOutputs( + files=dict(some_schema="{}"), + stdin=StringIO("{}"), + argv=["--output", "pretty", "some_schema"], + stdout="===[SUCCESS]===()===\n", + stderr="", + ) + + def test_successful_validation_of_just_the_schema(self): + self.assertOutputs( + files=dict(some_schema="{}", some_instance="{}"), + argv=["-i", "some_instance", "some_schema"], + stdout="", + stderr="", + ) + + def test_successful_validation_of_just_the_schema_pretty_output(self): + self.assertOutputs( + files=dict(some_schema="{}", some_instance="{}"), + argv=["--output", "pretty", "-i", "some_instance", "some_schema"], + stdout="===[SUCCESS]===(some_instance)===\n", + stderr="", + ) + + def test_successful_validation_via_explicit_base_uri(self): + ref_schema_file = tempfile.NamedTemporaryFile(delete=False) # noqa: SIM115 + ref_schema_file.close() + self.addCleanup(os.remove, ref_schema_file.name) + + ref_path = Path(ref_schema_file.name) + ref_path.write_text('{"definitions": {"num": {"type": "integer"}}}') + + schema = f'{{"$ref": "{ref_path.name}#/definitions/num"}}' + + self.assertOutputs( + files=dict(some_schema=schema, some_instance="1"), + argv=[ + "-i", "some_instance", + "--base-uri", ref_path.parent.as_uri() + "/", + "some_schema", + ], + stdout="", + stderr="", + ) + + def test_unsuccessful_validation_via_explicit_base_uri(self): + ref_schema_file = tempfile.NamedTemporaryFile(delete=False) # noqa: SIM115 + ref_schema_file.close() + self.addCleanup(os.remove, ref_schema_file.name) + + ref_path = Path(ref_schema_file.name) + ref_path.write_text('{"definitions": {"num": {"type": "integer"}}}') + + schema = f'{{"$ref": "{ref_path.name}#/definitions/num"}}' + + self.assertOutputs( + files=dict(some_schema=schema, some_instance='"1"'), + argv=[ + "-i", "some_instance", + "--base-uri", ref_path.parent.as_uri() + "/", + "some_schema", + ], + exit_code=1, + stdout="", + stderr="1: '1' is not of type 'integer'\n", + ) + + def test_nonexistent_file_with_explicit_base_uri(self): + schema = '{"$ref": "someNonexistentFile.json#definitions/num"}' + instance = "1" + + with self.assertRaises(_RefResolutionError) as e: + self.assertOutputs( + files=dict( + some_schema=schema, + some_instance=instance, + ), + argv=[ + "-i", "some_instance", + "--base-uri", Path.cwd().as_uri(), + "some_schema", + ], + ) + error = str(e.exception) + self.assertIn(f"{os.sep}someNonexistentFile.json'", error) + + def test_invalid_explicit_base_uri(self): + schema = '{"$ref": "foo.json#definitions/num"}' + instance = "1" + + with self.assertRaises(_RefResolutionError) as e: + self.assertOutputs( + files=dict( + some_schema=schema, + some_instance=instance, + ), + argv=[ + "-i", "some_instance", + "--base-uri", "not@UR1", + "some_schema", + ], + ) + error = str(e.exception) + self.assertEqual( + error, "unknown url type: 'foo.json'", + ) + + def test_it_validates_using_the_latest_validator_when_unspecified(self): + # There isn't a better way now I can think of to ensure that the + # latest version was used, given that the call to validator_for + # is hidden inside the CLI, so guard that that's the case, and + # this test will have to be updated when versions change until + # we can think of a better way to ensure this behavior. + self.assertIs(Draft202012Validator, _LATEST_VERSION) + + self.assertOutputs( + files=dict(some_schema='{"const": "check"}', some_instance='"a"'), + argv=["-i", "some_instance", "some_schema"], + exit_code=1, + stdout="", + stderr="a: 'check' was expected\n", + ) + + def test_it_validates_using_draft7_when_specified(self): + """ + Specifically, `const` validation applies for Draft 7. + """ + schema = """ + { + "$schema": "http://json-schema.org/draft-07/schema#", + "const": "check" + } + """ + instance = '"foo"' + self.assertOutputs( + files=dict(some_schema=schema, some_instance=instance), + argv=["-i", "some_instance", "some_schema"], + exit_code=1, + stdout="", + stderr="foo: 'check' was expected\n", + ) + + def test_it_validates_using_draft4_when_specified(self): + """ + Specifically, `const` validation *does not* apply for Draft 4. + """ + schema = """ + { + "$schema": "http://json-schema.org/draft-04/schema#", + "const": "check" + } + """ + instance = '"foo"' + self.assertOutputs( + files=dict(some_schema=schema, some_instance=instance), + argv=["-i", "some_instance", "some_schema"], + stdout="", + stderr="", + ) + + +class TestParser(TestCase): + + FakeValidator = fake_validator() + + def test_find_validator_by_fully_qualified_object_name(self): + arguments = cli.parse_args( + [ + "--validator", + "jsonschema.tests.test_cli.TestParser.FakeValidator", + "--instance", "mem://some/instance", + "mem://some/schema", + ], + ) + self.assertIs(arguments["validator"], self.FakeValidator) + + def test_find_validator_in_jsonschema(self): + arguments = cli.parse_args( + [ + "--validator", "Draft4Validator", + "--instance", "mem://some/instance", + "mem://some/schema", + ], + ) + self.assertIs(arguments["validator"], Draft4Validator) + + def cli_output_for(self, *argv): + stdout, stderr = StringIO(), StringIO() + with redirect_stdout(stdout), redirect_stderr(stderr): # noqa: SIM117 + with self.assertRaises(SystemExit): + cli.parse_args(argv) + return stdout.getvalue(), stderr.getvalue() + + def test_unknown_output(self): + stdout, stderr = self.cli_output_for( + "--output", "foo", + "mem://some/schema", + ) + self.assertIn("invalid choice: 'foo'", stderr) + self.assertFalse(stdout) + + def test_useless_error_format(self): + stdout, stderr = self.cli_output_for( + "--output", "pretty", + "--error-format", "foo", + "mem://some/schema", + ) + self.assertIn( + "--error-format can only be used with --output plain", + stderr, + ) + self.assertFalse(stdout) + + +class TestCLIIntegration(TestCase): + def test_license(self): + our_metadata = metadata.metadata("jsonschema") + self.assertEqual(our_metadata.get("License-Expression"), "MIT") + + def test_version(self): + version = subprocess.check_output( + [sys.executable, "-W", "ignore", "-m", "jsonschema", "--version"], + stderr=subprocess.STDOUT, + ) + version = version.decode("utf-8").strip() + self.assertEqual(version, metadata.version("jsonschema")) + + def test_no_arguments_shows_usage_notes(self): + output = subprocess.check_output( + [sys.executable, "-m", "jsonschema"], + stderr=subprocess.STDOUT, + ) + output_for_help = subprocess.check_output( + [sys.executable, "-m", "jsonschema", "--help"], + stderr=subprocess.STDOUT, + ) + self.assertEqual(output, output_for_help) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_deprecations.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_deprecations.py new file mode 100644 index 0000000000000000000000000000000000000000..a54b02f380ae098ba7b3f2c518a44935859f1ce6 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_deprecations.py @@ -0,0 +1,432 @@ +from contextlib import contextmanager +from io import BytesIO +from unittest import TestCase, mock +import importlib.metadata +import json +import subprocess +import sys +import urllib.request + +import referencing.exceptions + +from jsonschema import FormatChecker, exceptions, protocols, validators + + +class TestDeprecations(TestCase): + def test_version(self): + """ + As of v4.0.0, __version__ is deprecated in favor of importlib.metadata. + """ + + message = "Accessing jsonschema.__version__ is deprecated" + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import __version__ + + self.assertEqual(__version__, importlib.metadata.version("jsonschema")) + self.assertEqual(w.filename, __file__) + + def test_validators_ErrorTree(self): + """ + As of v4.0.0, importing ErrorTree from jsonschema.validators is + deprecated in favor of doing so from jsonschema.exceptions. + """ + + message = "Importing ErrorTree from jsonschema.validators is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema.validators import ErrorTree + + self.assertEqual(ErrorTree, exceptions.ErrorTree) + self.assertEqual(w.filename, __file__) + + def test_import_ErrorTree(self): + """ + As of v4.18.0, importing ErrorTree from the package root is + deprecated in favor of doing so from jsonschema.exceptions. + """ + + message = "Importing ErrorTree directly from the jsonschema package " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import ErrorTree + + self.assertEqual(ErrorTree, exceptions.ErrorTree) + self.assertEqual(w.filename, __file__) + + def test_ErrorTree_setitem(self): + """ + As of v4.20.0, setting items on an ErrorTree is deprecated. + """ + + e = exceptions.ValidationError("some error", path=["foo"]) + tree = exceptions.ErrorTree() + subtree = exceptions.ErrorTree(errors=[e]) + + message = "ErrorTree.__setitem__ is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + tree["foo"] = subtree + + self.assertEqual(tree["foo"], subtree) + self.assertEqual(w.filename, __file__) + + def test_import_FormatError(self): + """ + As of v4.18.0, importing FormatError from the package root is + deprecated in favor of doing so from jsonschema.exceptions. + """ + + message = "Importing FormatError directly from the jsonschema package " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import FormatError + + self.assertEqual(FormatError, exceptions.FormatError) + self.assertEqual(w.filename, __file__) + + def test_import_Validator(self): + """ + As of v4.19.0, importing Validator from the package root is + deprecated in favor of doing so from jsonschema.protocols. + """ + + message = "Importing Validator directly from the jsonschema package " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import Validator + + self.assertEqual(Validator, protocols.Validator) + self.assertEqual(w.filename, __file__) + + def test_validators_validators(self): + """ + As of v4.0.0, accessing jsonschema.validators.validators is + deprecated. + """ + + message = "Accessing jsonschema.validators.validators is deprecated" + with self.assertWarnsRegex(DeprecationWarning, message) as w: + value = validators.validators + + self.assertEqual(value, validators._VALIDATORS) + self.assertEqual(w.filename, __file__) + + def test_validators_meta_schemas(self): + """ + As of v4.0.0, accessing jsonschema.validators.meta_schemas is + deprecated. + """ + + message = "Accessing jsonschema.validators.meta_schemas is deprecated" + with self.assertWarnsRegex(DeprecationWarning, message) as w: + value = validators.meta_schemas + + self.assertEqual(value, validators._META_SCHEMAS) + self.assertEqual(w.filename, __file__) + + def test_RefResolver_in_scope(self): + """ + As of v4.0.0, RefResolver.in_scope is deprecated. + """ + + resolver = validators._RefResolver.from_schema({}) + message = "jsonschema.RefResolver.in_scope is deprecated " + with self.assertWarnsRegex(DeprecationWarning, message) as w: # noqa: SIM117 + with resolver.in_scope("foo"): + pass + + self.assertEqual(w.filename, __file__) + + def test_Validator_is_valid_two_arguments(self): + """ + As of v4.0.0, calling is_valid with two arguments (to provide a + different schema) is deprecated. + """ + + validator = validators.Draft7Validator({}) + message = "Passing a schema to Validator.is_valid is deprecated " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + result = validator.is_valid("foo", {"type": "number"}) + + self.assertFalse(result) + self.assertEqual(w.filename, __file__) + + def test_Validator_iter_errors_two_arguments(self): + """ + As of v4.0.0, calling iter_errors with two arguments (to provide a + different schema) is deprecated. + """ + + validator = validators.Draft7Validator({}) + message = "Passing a schema to Validator.iter_errors is deprecated " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + error, = validator.iter_errors("foo", {"type": "number"}) + + self.assertEqual(error.validator, "type") + self.assertEqual(w.filename, __file__) + + def test_Validator_resolver(self): + """ + As of v4.18.0, accessing Validator.resolver is deprecated. + """ + + validator = validators.Draft7Validator({}) + message = "Accessing Draft7Validator.resolver is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + self.assertIsInstance(validator.resolver, validators._RefResolver) + + self.assertEqual(w.filename, __file__) + + def test_RefResolver(self): + """ + As of v4.18.0, RefResolver is fully deprecated. + """ + + message = "jsonschema.RefResolver is deprecated" + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import RefResolver + self.assertEqual(w.filename, __file__) + + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema.validators import RefResolver # noqa: F401 + self.assertEqual(w.filename, __file__) + + def test_RefResolutionError(self): + """ + As of v4.18.0, RefResolutionError is deprecated in favor of directly + catching errors from the referencing library. + """ + + message = "jsonschema.exceptions.RefResolutionError is deprecated" + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import RefResolutionError + + self.assertEqual(RefResolutionError, exceptions._RefResolutionError) + self.assertEqual(w.filename, __file__) + + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema.exceptions import RefResolutionError + + self.assertEqual(RefResolutionError, exceptions._RefResolutionError) + self.assertEqual(w.filename, __file__) + + def test_catching_Unresolvable_directly(self): + """ + This behavior is the intended behavior (i.e. it's not deprecated), but + given we do "tricksy" things in the iterim to wrap exceptions in a + multiple inheritance subclass, we need to be extra sure it works and + stays working. + """ + validator = validators.Draft202012Validator({"$ref": "urn:nothing"}) + + with self.assertRaises(referencing.exceptions.Unresolvable) as e: + validator.validate(12) + + expected = referencing.exceptions.Unresolvable(ref="urn:nothing") + self.assertEqual( + (e.exception, str(e.exception)), + (expected, "Unresolvable: urn:nothing"), + ) + + def test_catching_Unresolvable_via_RefResolutionError(self): + """ + Until RefResolutionError is removed, it is still possible to catch + exceptions from reference resolution using it, even though they may + have been raised by referencing. + """ + with self.assertWarns(DeprecationWarning): + from jsonschema import RefResolutionError + + validator = validators.Draft202012Validator({"$ref": "urn:nothing"}) + + with self.assertRaises(referencing.exceptions.Unresolvable) as u: + validator.validate(12) + + with self.assertRaises(RefResolutionError) as e: + validator.validate(12) + + self.assertEqual( + (e.exception, str(e.exception)), + (u.exception, "Unresolvable: urn:nothing"), + ) + + def test_WrappedReferencingError_hashability(self): + """ + Ensure the wrapped referencing errors are hashable when possible. + """ + with self.assertWarns(DeprecationWarning): + from jsonschema import RefResolutionError + + validator = validators.Draft202012Validator({"$ref": "urn:nothing"}) + + with self.assertRaises(referencing.exceptions.Unresolvable) as u: + validator.validate(12) + + with self.assertRaises(RefResolutionError) as e: + validator.validate(12) + + self.assertIn(e.exception, {u.exception}) + self.assertIn(u.exception, {e.exception}) + + def test_Validator_subclassing(self): + """ + As of v4.12.0, subclassing a validator class produces an explicit + deprecation warning. + + This was never intended to be public API (and some comments over the + years in issues said so, but obviously that's not a great way to make + sure it's followed). + + A future version will explicitly raise an error. + """ + + message = "Subclassing validator classes is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + class Subclass(validators.Draft202012Validator): + pass + + self.assertEqual(w.filename, __file__) + + with self.assertWarnsRegex(DeprecationWarning, message) as w: + class AnotherSubclass(validators.create(meta_schema={})): + pass + + def test_FormatChecker_cls_checks(self): + """ + As of v4.14.0, FormatChecker.cls_checks is deprecated without + replacement. + """ + + self.addCleanup(FormatChecker.checkers.pop, "boom", None) + + message = "FormatChecker.cls_checks " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + FormatChecker.cls_checks("boom") + + self.assertEqual(w.filename, __file__) + + def test_draftN_format_checker(self): + """ + As of v4.16.0, accessing jsonschema.draftn_format_checker is deprecated + in favor of Validator.FORMAT_CHECKER. + """ + + message = "Accessing jsonschema.draft202012_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft202012_format_checker + + self.assertIs( + draft202012_format_checker, + validators.Draft202012Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + message = "Accessing jsonschema.draft201909_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft201909_format_checker + + self.assertIs( + draft201909_format_checker, + validators.Draft201909Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + message = "Accessing jsonschema.draft7_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft7_format_checker + + self.assertIs( + draft7_format_checker, + validators.Draft7Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + message = "Accessing jsonschema.draft6_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft6_format_checker + + self.assertIs( + draft6_format_checker, + validators.Draft6Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + message = "Accessing jsonschema.draft4_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft4_format_checker + + self.assertIs( + draft4_format_checker, + validators.Draft4Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + message = "Accessing jsonschema.draft3_format_checker is " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + from jsonschema import draft3_format_checker + + self.assertIs( + draft3_format_checker, + validators.Draft3Validator.FORMAT_CHECKER, + ) + self.assertEqual(w.filename, __file__) + + with self.assertRaises(ImportError): + from jsonschema import draft1234_format_checker # noqa: F401 + + def test_import_cli(self): + """ + As of v4.17.0, importing jsonschema.cli is deprecated. + """ + + message = "The jsonschema CLI is deprecated and will be removed " + with self.assertWarnsRegex(DeprecationWarning, message) as w: + import jsonschema.cli + importlib.reload(jsonschema.cli) + + self.assertEqual(w.filename, importlib.__file__) + + def test_cli(self): + """ + As of v4.17.0, the jsonschema CLI is deprecated. + """ + + process = subprocess.run( + [sys.executable, "-m", "jsonschema"], + capture_output=True, + check=True, + ) + self.assertIn(b"The jsonschema CLI is deprecated ", process.stderr) + + def test_automatic_remote_retrieval(self): + """ + Automatic retrieval of remote references is deprecated as of v4.18.0. + """ + ref = "http://bar#/$defs/baz" + schema = {"$defs": {"baz": {"type": "integer"}}} + + if "requests" in sys.modules: # pragma: no cover + self.addCleanup( + sys.modules.__setitem__, "requests", sys.modules["requests"], + ) + sys.modules["requests"] = None + + @contextmanager + def fake_urlopen(request): + self.assertIsInstance(request, urllib.request.Request) + self.assertEqual(request.full_url, "http://bar") + + # Ha ha urllib.request.Request "normalizes" header names and + # Request.get_header does not also normalize them... + (header, value), = request.header_items() + self.assertEqual(header.lower(), "user-agent") + self.assertEqual( + value, "python-jsonschema (deprecated $ref resolution)", + ) + yield BytesIO(json.dumps(schema).encode("utf8")) + + validator = validators.Draft202012Validator({"$ref": ref}) + + message = "Automatically retrieving remote references " + patch = mock.patch.object(urllib.request, "urlopen", new=fake_urlopen) + + with patch, self.assertWarnsRegex(DeprecationWarning, message): + self.assertEqual( + (validator.is_valid({}), validator.is_valid(37)), + (False, True), + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_exceptions.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..358b924252c3d67373b7924d11fdfaf2878ab5b5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_exceptions.py @@ -0,0 +1,759 @@ +from unittest import TestCase +import textwrap + +import jsonpath_ng + +from jsonschema import exceptions +from jsonschema.validators import _LATEST_VERSION + + +class TestBestMatch(TestCase): + def best_match_of(self, instance, schema): + errors = list(_LATEST_VERSION(schema).iter_errors(instance)) + msg = f"No errors found for {instance} under {schema!r}!" + self.assertTrue(errors, msg=msg) + + best = exceptions.best_match(iter(errors)) + reversed_best = exceptions.best_match(reversed(errors)) + + self.assertEqual( + best._contents(), + reversed_best._contents(), + f"No consistent best match!\nGot: {best}\n\nThen: {reversed_best}", + ) + return best + + def test_shallower_errors_are_better_matches(self): + schema = { + "properties": { + "foo": { + "minProperties": 2, + "properties": {"bar": {"type": "object"}}, + }, + }, + } + best = self.best_match_of(instance={"foo": {"bar": []}}, schema=schema) + self.assertEqual(best.validator, "minProperties") + + def test_oneOf_and_anyOf_are_weak_matches(self): + """ + A property you *must* match is probably better than one you have to + match a part of. + """ + + schema = { + "minProperties": 2, + "anyOf": [{"type": "string"}, {"type": "number"}], + "oneOf": [{"type": "string"}, {"type": "number"}], + } + best = self.best_match_of(instance={}, schema=schema) + self.assertEqual(best.validator, "minProperties") + + def test_if_the_most_relevant_error_is_anyOf_it_is_traversed(self): + """ + If the most relevant error is an anyOf, then we traverse its context + and select the otherwise *least* relevant error, since in this case + that means the most specific, deep, error inside the instance. + + I.e. since only one of the schemas must match, we look for the most + relevant one. + """ + + schema = { + "properties": { + "foo": { + "anyOf": [ + {"type": "string"}, + {"properties": {"bar": {"type": "array"}}}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) + self.assertEqual(best.validator_value, "array") + + def test_no_anyOf_traversal_for_equally_relevant_errors(self): + """ + We don't traverse into an anyOf (as above) if all of its context errors + seem to be equally "wrong" against the instance. + """ + + schema = { + "anyOf": [ + {"type": "string"}, + {"type": "integer"}, + {"type": "object"}, + ], + } + best = self.best_match_of(instance=[], schema=schema) + self.assertEqual(best.validator, "anyOf") + + def test_anyOf_traversal_for_single_equally_relevant_error(self): + """ + We *do* traverse anyOf with a single nested error, even though it is + vacuously equally relevant to itself. + """ + + schema = { + "anyOf": [ + {"type": "string"}, + ], + } + best = self.best_match_of(instance=[], schema=schema) + self.assertEqual(best.validator, "type") + + def test_anyOf_traversal_for_single_sibling_errors(self): + """ + We *do* traverse anyOf with a single subschema that fails multiple + times (e.g. on multiple items). + """ + + schema = { + "anyOf": [ + {"items": {"const": 37}}, + ], + } + best = self.best_match_of(instance=[12, 12], schema=schema) + self.assertEqual(best.validator, "const") + + def test_anyOf_traversal_for_non_type_matching_sibling_errors(self): + """ + We *do* traverse anyOf with multiple subschemas when one does not type + match. + """ + + schema = { + "anyOf": [ + {"type": "object"}, + {"items": {"const": 37}}, + ], + } + best = self.best_match_of(instance=[12, 12], schema=schema) + self.assertEqual(best.validator, "const") + + def test_if_the_most_relevant_error_is_oneOf_it_is_traversed(self): + """ + If the most relevant error is an oneOf, then we traverse its context + and select the otherwise *least* relevant error, since in this case + that means the most specific, deep, error inside the instance. + + I.e. since only one of the schemas must match, we look for the most + relevant one. + """ + + schema = { + "properties": { + "foo": { + "oneOf": [ + {"type": "string"}, + {"properties": {"bar": {"type": "array"}}}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) + self.assertEqual(best.validator_value, "array") + + def test_no_oneOf_traversal_for_equally_relevant_errors(self): + """ + We don't traverse into an oneOf (as above) if all of its context errors + seem to be equally "wrong" against the instance. + """ + + schema = { + "oneOf": [ + {"type": "string"}, + {"type": "integer"}, + {"type": "object"}, + ], + } + best = self.best_match_of(instance=[], schema=schema) + self.assertEqual(best.validator, "oneOf") + + def test_oneOf_traversal_for_single_equally_relevant_error(self): + """ + We *do* traverse oneOf with a single nested error, even though it is + vacuously equally relevant to itself. + """ + + schema = { + "oneOf": [ + {"type": "string"}, + ], + } + best = self.best_match_of(instance=[], schema=schema) + self.assertEqual(best.validator, "type") + + def test_oneOf_traversal_for_single_sibling_errors(self): + """ + We *do* traverse oneOf with a single subschema that fails multiple + times (e.g. on multiple items). + """ + + schema = { + "oneOf": [ + {"items": {"const": 37}}, + ], + } + best = self.best_match_of(instance=[12, 12], schema=schema) + self.assertEqual(best.validator, "const") + + def test_oneOf_traversal_for_non_type_matching_sibling_errors(self): + """ + We *do* traverse oneOf with multiple subschemas when one does not type + match. + """ + + schema = { + "oneOf": [ + {"type": "object"}, + {"items": {"const": 37}}, + ], + } + best = self.best_match_of(instance=[12, 12], schema=schema) + self.assertEqual(best.validator, "const") + + def test_if_the_most_relevant_error_is_allOf_it_is_traversed(self): + """ + Now, if the error is allOf, we traverse but select the *most* relevant + error from the context, because all schemas here must match anyways. + """ + + schema = { + "properties": { + "foo": { + "allOf": [ + {"type": "string"}, + {"properties": {"bar": {"type": "array"}}}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) + self.assertEqual(best.validator_value, "string") + + def test_nested_context_for_oneOf(self): + """ + We traverse into nested contexts (a oneOf containing an error in a + nested oneOf here). + """ + + schema = { + "properties": { + "foo": { + "oneOf": [ + {"type": "string"}, + { + "oneOf": [ + {"type": "string"}, + { + "properties": { + "bar": {"type": "array"}, + }, + }, + ], + }, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) + self.assertEqual(best.validator_value, "array") + + def test_it_prioritizes_matching_types(self): + schema = { + "properties": { + "foo": { + "anyOf": [ + {"type": "array", "minItems": 2}, + {"type": "string", "minLength": 10}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": "bar"}, schema=schema) + self.assertEqual(best.validator, "minLength") + + reordered = { + "properties": { + "foo": { + "anyOf": [ + {"type": "string", "minLength": 10}, + {"type": "array", "minItems": 2}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": "bar"}, schema=reordered) + self.assertEqual(best.validator, "minLength") + + def test_it_prioritizes_matching_union_types(self): + schema = { + "properties": { + "foo": { + "anyOf": [ + {"type": ["array", "object"], "minItems": 2}, + {"type": ["integer", "string"], "minLength": 10}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": "bar"}, schema=schema) + self.assertEqual(best.validator, "minLength") + + reordered = { + "properties": { + "foo": { + "anyOf": [ + {"type": "string", "minLength": 10}, + {"type": "array", "minItems": 2}, + ], + }, + }, + } + best = self.best_match_of(instance={"foo": "bar"}, schema=reordered) + self.assertEqual(best.validator, "minLength") + + def test_boolean_schemas(self): + schema = {"properties": {"foo": False}} + best = self.best_match_of(instance={"foo": "bar"}, schema=schema) + self.assertIsNone(best.validator) + + def test_one_error(self): + validator = _LATEST_VERSION({"minProperties": 2}) + validator.iter_errors({}) + self.assertEqual( + exceptions.best_match(validator.iter_errors({})).validator, + "minProperties", + ) + + def test_no_errors(self): + validator = _LATEST_VERSION({}) + self.assertIsNone(exceptions.best_match(validator.iter_errors({}))) + + +class TestByRelevance(TestCase): + def test_short_paths_are_better_matches(self): + shallow = exceptions.ValidationError("Oh no!", path=["baz"]) + deep = exceptions.ValidationError("Oh yes!", path=["foo", "bar"]) + match = max([shallow, deep], key=exceptions.relevance) + self.assertIs(match, shallow) + + match = max([deep, shallow], key=exceptions.relevance) + self.assertIs(match, shallow) + + def test_global_errors_are_even_better_matches(self): + shallow = exceptions.ValidationError("Oh no!", path=[]) + deep = exceptions.ValidationError("Oh yes!", path=["foo"]) + + errors = sorted([shallow, deep], key=exceptions.relevance) + self.assertEqual( + [list(error.path) for error in errors], + [["foo"], []], + ) + + errors = sorted([deep, shallow], key=exceptions.relevance) + self.assertEqual( + [list(error.path) for error in errors], + [["foo"], []], + ) + + def test_weak_keywords_are_lower_priority(self): + weak = exceptions.ValidationError("Oh no!", path=[], validator="a") + normal = exceptions.ValidationError("Oh yes!", path=[], validator="b") + + best_match = exceptions.by_relevance(weak="a") + + match = max([weak, normal], key=best_match) + self.assertIs(match, normal) + + match = max([normal, weak], key=best_match) + self.assertIs(match, normal) + + def test_strong_keywords_are_higher_priority(self): + weak = exceptions.ValidationError("Oh no!", path=[], validator="a") + normal = exceptions.ValidationError("Oh yes!", path=[], validator="b") + strong = exceptions.ValidationError("Oh fine!", path=[], validator="c") + + best_match = exceptions.by_relevance(weak="a", strong="c") + + match = max([weak, normal, strong], key=best_match) + self.assertIs(match, strong) + + match = max([strong, normal, weak], key=best_match) + self.assertIs(match, strong) + + +class TestErrorTree(TestCase): + def test_it_knows_how_many_total_errors_it_contains(self): + # FIXME: #442 + errors = [ + exceptions.ValidationError("Something", validator=i) + for i in range(8) + ] + tree = exceptions.ErrorTree(errors) + self.assertEqual(tree.total_errors, 8) + + def test_it_contains_an_item_if_the_item_had_an_error(self): + errors = [exceptions.ValidationError("a message", path=["bar"])] + tree = exceptions.ErrorTree(errors) + self.assertIn("bar", tree) + + def test_it_does_not_contain_an_item_if_the_item_had_no_error(self): + errors = [exceptions.ValidationError("a message", path=["bar"])] + tree = exceptions.ErrorTree(errors) + self.assertNotIn("foo", tree) + + def test_keywords_that_failed_appear_in_errors_dict(self): + error = exceptions.ValidationError("a message", validator="foo") + tree = exceptions.ErrorTree([error]) + self.assertEqual(tree.errors, {"foo": error}) + + def test_it_creates_a_child_tree_for_each_nested_path(self): + errors = [ + exceptions.ValidationError("a bar message", path=["bar"]), + exceptions.ValidationError("a bar -> 0 message", path=["bar", 0]), + ] + tree = exceptions.ErrorTree(errors) + self.assertIn(0, tree["bar"]) + self.assertNotIn(1, tree["bar"]) + + def test_children_have_their_errors_dicts_built(self): + e1, e2 = ( + exceptions.ValidationError("1", validator="foo", path=["bar", 0]), + exceptions.ValidationError("2", validator="quux", path=["bar", 0]), + ) + tree = exceptions.ErrorTree([e1, e2]) + self.assertEqual(tree["bar"][0].errors, {"foo": e1, "quux": e2}) + + def test_multiple_errors_with_instance(self): + e1, e2 = ( + exceptions.ValidationError( + "1", + validator="foo", + path=["bar", "bar2"], + instance="i1"), + exceptions.ValidationError( + "2", + validator="quux", + path=["foobar", 2], + instance="i2"), + ) + exceptions.ErrorTree([e1, e2]) + + def test_it_does_not_contain_subtrees_that_are_not_in_the_instance(self): + error = exceptions.ValidationError("123", validator="foo", instance=[]) + tree = exceptions.ErrorTree([error]) + + with self.assertRaises(IndexError): + tree[0] + + def test_if_its_in_the_tree_anyhow_it_does_not_raise_an_error(self): + """ + If a keyword refers to a path that isn't in the instance, the + tree still properly returns a subtree for that path. + """ + + error = exceptions.ValidationError( + "a message", validator="foo", instance={}, path=["foo"], + ) + tree = exceptions.ErrorTree([error]) + self.assertIsInstance(tree["foo"], exceptions.ErrorTree) + + def test_iter(self): + e1, e2 = ( + exceptions.ValidationError( + "1", + validator="foo", + path=["bar", "bar2"], + instance="i1"), + exceptions.ValidationError( + "2", + validator="quux", + path=["foobar", 2], + instance="i2"), + ) + tree = exceptions.ErrorTree([e1, e2]) + self.assertEqual(set(tree), {"bar", "foobar"}) + + def test_repr_single(self): + error = exceptions.ValidationError( + "1", + validator="foo", + path=["bar", "bar2"], + instance="i1", + ) + tree = exceptions.ErrorTree([error]) + self.assertEqual(repr(tree), "") + + def test_repr_multiple(self): + e1, e2 = ( + exceptions.ValidationError( + "1", + validator="foo", + path=["bar", "bar2"], + instance="i1"), + exceptions.ValidationError( + "2", + validator="quux", + path=["foobar", 2], + instance="i2"), + ) + tree = exceptions.ErrorTree([e1, e2]) + self.assertEqual(repr(tree), "") + + def test_repr_empty(self): + tree = exceptions.ErrorTree([]) + self.assertEqual(repr(tree), "") + + +class TestErrorInitReprStr(TestCase): + def make_error(self, **kwargs): + defaults = dict( + message="hello", + validator="type", + validator_value="string", + instance=5, + schema={"type": "string"}, + ) + defaults.update(kwargs) + return exceptions.ValidationError(**defaults) + + def assertShows(self, expected, **kwargs): + expected = textwrap.dedent(expected).rstrip("\n") + + error = self.make_error(**kwargs) + message_line, _, rest = str(error).partition("\n") + self.assertEqual(message_line, error.message) + self.assertEqual(rest, expected) + + def test_it_calls_super_and_sets_args(self): + error = self.make_error() + self.assertGreater(len(error.args), 1) + + def test_repr(self): + self.assertEqual( + repr(exceptions.ValidationError(message="Hello!")), + "", + ) + + def test_unset_error(self): + error = exceptions.ValidationError("message") + self.assertEqual(str(error), "message") + + kwargs = { + "validator": "type", + "validator_value": "string", + "instance": 5, + "schema": {"type": "string"}, + } + # Just the message should show if any of the attributes are unset + for attr in kwargs: + k = dict(kwargs) + del k[attr] + error = exceptions.ValidationError("message", **k) + self.assertEqual(str(error), "message") + + def test_empty_paths(self): + self.assertShows( + """ + Failed validating 'type' in schema: + {'type': 'string'} + + On instance: + 5 + """, + path=[], + schema_path=[], + ) + + def test_one_item_paths(self): + self.assertShows( + """ + Failed validating 'type' in schema: + {'type': 'string'} + + On instance[0]: + 5 + """, + path=[0], + schema_path=["items"], + ) + + def test_multiple_item_paths(self): + self.assertShows( + """ + Failed validating 'type' in schema['items'][0]: + {'type': 'string'} + + On instance[0]['a']: + 5 + """, + path=[0, "a"], + schema_path=["items", 0, 1], + ) + + def test_uses_pprint(self): + self.assertShows( + """ + Failed validating 'maxLength' in schema: + {0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + 10: 10, + 11: 11, + 12: 12, + 13: 13, + 14: 14, + 15: 15, + 16: 16, + 17: 17, + 18: 18, + 19: 19} + + On instance: + [0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24] + """, + instance=list(range(25)), + schema=dict(zip(range(20), range(20))), + validator="maxLength", + ) + + def test_does_not_reorder_dicts(self): + self.assertShows( + """ + Failed validating 'type' in schema: + {'do': 3, 'not': 7, 'sort': 37, 'me': 73} + + On instance: + {'here': 73, 'too': 37, 'no': 7, 'sorting': 3} + """, + schema={ + "do": 3, + "not": 7, + "sort": 37, + "me": 73, + }, + instance={ + "here": 73, + "too": 37, + "no": 7, + "sorting": 3, + }, + ) + + def test_str_works_with_instances_having_overriden_eq_operator(self): + """ + Check for #164 which rendered exceptions unusable when a + `ValidationError` involved instances with an `__eq__` method + that returned truthy values. + """ + + class DontEQMeBro: + def __eq__(this, other): # pragma: no cover + self.fail("Don't!") + + def __ne__(this, other): # pragma: no cover + self.fail("Don't!") + + instance = DontEQMeBro() + error = exceptions.ValidationError( + "a message", + validator="foo", + instance=instance, + validator_value="some", + schema="schema", + ) + self.assertIn(repr(instance), str(error)) + + +class TestHashable(TestCase): + def test_hashable(self): + {exceptions.ValidationError("")} + {exceptions.SchemaError("")} + + +class TestJsonPathRendering(TestCase): + def validate_json_path_rendering(self, property_name, expected_path): + error = exceptions.ValidationError( + path=[property_name], + message="1", + validator="foo", + instance="i1", + ) + + rendered_json_path = error.json_path + self.assertEqual(rendered_json_path, expected_path) + + re_parsed_name = jsonpath_ng.parse(rendered_json_path).right.fields[0] + self.assertEqual(re_parsed_name, property_name) + + def test_basic(self): + self.validate_json_path_rendering("x", "$.x") + + def test_empty(self): + self.validate_json_path_rendering("", "$['']") + + def test_number(self): + self.validate_json_path_rendering("1", "$['1']") + + def test_period(self): + self.validate_json_path_rendering(".", "$['.']") + + def test_single_quote(self): + self.validate_json_path_rendering("'", r"$['\'']") + + def test_space(self): + self.validate_json_path_rendering(" ", "$[' ']") + + def test_backslash(self): + self.validate_json_path_rendering("\\", r"$['\\']") + + def test_backslash_single_quote(self): + self.validate_json_path_rendering(r"\'", r"$['\\\'']") + + def test_underscore(self): + self.validate_json_path_rendering("_", r"$['_']") + + def test_double_quote(self): + self.validate_json_path_rendering('"', """$['"']""") + + def test_hyphen(self): + self.validate_json_path_rendering("-", "$['-']") + + def test_json_path_injection(self): + self.validate_json_path_rendering("a[0]", "$['a[0]']") + + def test_open_bracket(self): + self.validate_json_path_rendering("[", "$['[']") diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_format.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_format.py new file mode 100644 index 0000000000000000000000000000000000000000..d829f9848f51f882d5a3f9413c80e0dbdcdaf292 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_format.py @@ -0,0 +1,91 @@ +""" +Tests for the parts of jsonschema related to the :kw:`format` keyword. +""" + +from unittest import TestCase + +from jsonschema import FormatChecker, ValidationError +from jsonschema.exceptions import FormatError +from jsonschema.validators import Draft4Validator + +BOOM = ValueError("Boom!") +BANG = ZeroDivisionError("Bang!") + + +def boom(thing): + if thing == "bang": + raise BANG + raise BOOM + + +class TestFormatChecker(TestCase): + def test_it_can_validate_no_formats(self): + checker = FormatChecker(formats=()) + self.assertFalse(checker.checkers) + + def test_it_raises_a_key_error_for_unknown_formats(self): + with self.assertRaises(KeyError): + FormatChecker(formats=["o noes"]) + + def test_it_can_register_cls_checkers(self): + original = dict(FormatChecker.checkers) + self.addCleanup(FormatChecker.checkers.pop, "boom") + with self.assertWarns(DeprecationWarning): + FormatChecker.cls_checks("boom")(boom) + self.assertEqual( + FormatChecker.checkers, + dict(original, boom=(boom, ())), + ) + + def test_it_can_register_checkers(self): + checker = FormatChecker() + checker.checks("boom")(boom) + self.assertEqual( + checker.checkers, + dict(FormatChecker.checkers, boom=(boom, ())), + ) + + def test_it_catches_registered_errors(self): + checker = FormatChecker() + checker.checks("boom", raises=type(BOOM))(boom) + + with self.assertRaises(FormatError) as cm: + checker.check(instance=12, format="boom") + + self.assertIs(cm.exception.cause, BOOM) + self.assertIs(cm.exception.__cause__, BOOM) + self.assertEqual(str(cm.exception), "12 is not a 'boom'") + + # Unregistered errors should not be caught + with self.assertRaises(type(BANG)): + checker.check(instance="bang", format="boom") + + def test_format_error_causes_become_validation_error_causes(self): + checker = FormatChecker() + checker.checks("boom", raises=ValueError)(boom) + validator = Draft4Validator({"format": "boom"}, format_checker=checker) + + with self.assertRaises(ValidationError) as cm: + validator.validate("BOOM") + + self.assertIs(cm.exception.cause, BOOM) + self.assertIs(cm.exception.__cause__, BOOM) + + def test_format_checkers_come_with_defaults(self): + # This is bad :/ but relied upon. + # The docs for quite awhile recommended people do things like + # validate(..., format_checker=FormatChecker()) + # We should change that, but we can't without deprecation... + checker = FormatChecker() + with self.assertRaises(FormatError): + checker.check(instance="not-an-ipv4", format="ipv4") + + def test_repr(self): + checker = FormatChecker(formats=()) + checker.checks("foo")(lambda thing: True) # pragma: no cover + checker.checks("bar")(lambda thing: True) # pragma: no cover + checker.checks("baz")(lambda thing: True) # pragma: no cover + self.assertEqual( + repr(checker), + "", + ) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_jsonschema_test_suite.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_jsonschema_test_suite.py new file mode 100644 index 0000000000000000000000000000000000000000..41c982553688ab179dcb95eedc3aae78648e2a4d --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_jsonschema_test_suite.py @@ -0,0 +1,262 @@ +""" +Test runner for the JSON Schema official test suite + +Tests comprehensive correctness of each draft's validator. + +See https://github.com/json-schema-org/JSON-Schema-Test-Suite for details. +""" + + +from jsonschema.tests._suite import Suite +import jsonschema + +SUITE = Suite() +DRAFT3 = SUITE.version(name="draft3") +DRAFT4 = SUITE.version(name="draft4") +DRAFT6 = SUITE.version(name="draft6") +DRAFT7 = SUITE.version(name="draft7") +DRAFT201909 = SUITE.version(name="draft2019-09") +DRAFT202012 = SUITE.version(name="draft2020-12") + + +def skip(message, **kwargs): + def skipper(test): + if all(value == getattr(test, attr) for attr, value in kwargs.items()): + return message + return skipper + + +def ecmascript_regex(test): + if test.subject == "ecmascript-regex": + return "ECMA regex support will be added in #1142." + + +def missing_format(Validator): + def missing_format(test): # pragma: no cover + schema = test.schema + if ( + schema is True + or schema is False + or "format" not in schema + or schema["format"] in Validator.FORMAT_CHECKER.checkers + or test.valid + ): + return + + return f"Format checker {schema['format']!r} not found." + return missing_format + + +def complex_email_validation(test): + if test.subject != "email": + return + + message = "Complex email validation is (intentionally) unsupported." + return skip( + message=message, + description="an invalid domain", + )(test) or skip( + message=message, + description="an invalid IPv4-address-literal", + )(test) or skip( + message=message, + description="dot after local part is not valid", + )(test) or skip( + message=message, + description="dot before local part is not valid", + )(test) or skip( + message=message, + description="two subsequent dots inside local part are not valid", + )(test) + + +def leap_second(test): + message = "Leap seconds are unsupported." + return skip( + message=message, + subject="time", + description="a valid time string with leap second", + )(test) or skip( + message=message, + subject="time", + description="a valid time string with leap second, Zulu", + )(test) or skip( + message=message, + subject="time", + description="a valid time string with leap second with offset", + )(test) or skip( + message=message, + subject="time", + description="valid leap second, positive time-offset", + )(test) or skip( + message=message, + subject="time", + description="valid leap second, negative time-offset", + )(test) or skip( + message=message, + subject="time", + description="valid leap second, large positive time-offset", + )(test) or skip( + message=message, + subject="time", + description="valid leap second, large negative time-offset", + )(test) or skip( + message=message, + subject="time", + description="valid leap second, zero time-offset", + )(test) or skip( + message=message, + subject="date-time", + description="a valid date-time with a leap second, UTC", + )(test) or skip( + message=message, + subject="date-time", + description="a valid date-time with a leap second, with minus offset", + )(test) + + +TestDraft3 = DRAFT3.to_unittest_testcase( + DRAFT3.cases(), + DRAFT3.format_cases(), + DRAFT3.optional_cases_of(name="bignum"), + DRAFT3.optional_cases_of(name="non-bmp-regex"), + DRAFT3.optional_cases_of(name="zeroTerminatedFloats"), + Validator=jsonschema.Draft3Validator, + format_checker=jsonschema.Draft3Validator.FORMAT_CHECKER, + skip=lambda test: ( + ecmascript_regex(test) + or missing_format(jsonschema.Draft3Validator)(test) + or complex_email_validation(test) + ), +) + + +TestDraft4 = DRAFT4.to_unittest_testcase( + DRAFT4.cases(), + DRAFT4.format_cases(), + DRAFT4.optional_cases_of(name="bignum"), + DRAFT4.optional_cases_of(name="float-overflow"), + DRAFT4.optional_cases_of(name="id"), + DRAFT4.optional_cases_of(name="non-bmp-regex"), + DRAFT4.optional_cases_of(name="zeroTerminatedFloats"), + Validator=jsonschema.Draft4Validator, + format_checker=jsonschema.Draft4Validator.FORMAT_CHECKER, + skip=lambda test: ( + ecmascript_regex(test) + or leap_second(test) + or missing_format(jsonschema.Draft4Validator)(test) + or complex_email_validation(test) + ), +) + + +TestDraft6 = DRAFT6.to_unittest_testcase( + DRAFT6.cases(), + DRAFT6.format_cases(), + DRAFT6.optional_cases_of(name="bignum"), + DRAFT6.optional_cases_of(name="float-overflow"), + DRAFT6.optional_cases_of(name="id"), + DRAFT6.optional_cases_of(name="non-bmp-regex"), + Validator=jsonschema.Draft6Validator, + format_checker=jsonschema.Draft6Validator.FORMAT_CHECKER, + skip=lambda test: ( + ecmascript_regex(test) + or leap_second(test) + or missing_format(jsonschema.Draft6Validator)(test) + or complex_email_validation(test) + ), +) + + +TestDraft7 = DRAFT7.to_unittest_testcase( + DRAFT7.cases(), + DRAFT7.format_cases(), + DRAFT7.optional_cases_of(name="bignum"), + DRAFT7.optional_cases_of(name="cross-draft"), + DRAFT7.optional_cases_of(name="float-overflow"), + DRAFT6.optional_cases_of(name="id"), + DRAFT7.optional_cases_of(name="non-bmp-regex"), + DRAFT7.optional_cases_of(name="unknownKeyword"), + Validator=jsonschema.Draft7Validator, + format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER, + skip=lambda test: ( + ecmascript_regex(test) + or leap_second(test) + or missing_format(jsonschema.Draft7Validator)(test) + or complex_email_validation(test) + ), +) + + +TestDraft201909 = DRAFT201909.to_unittest_testcase( + DRAFT201909.cases(), + DRAFT201909.optional_cases_of(name="anchor"), + DRAFT201909.optional_cases_of(name="bignum"), + DRAFT201909.optional_cases_of(name="cross-draft"), + DRAFT201909.optional_cases_of(name="float-overflow"), + DRAFT201909.optional_cases_of(name="id"), + DRAFT201909.optional_cases_of(name="no-schema"), + DRAFT201909.optional_cases_of(name="non-bmp-regex"), + DRAFT201909.optional_cases_of(name="refOfUnknownKeyword"), + DRAFT201909.optional_cases_of(name="unknownKeyword"), + Validator=jsonschema.Draft201909Validator, + skip=skip( + message="Vocabulary support is still in-progress.", + subject="vocabulary", + description=( + "no validation: invalid number, but it still validates" + ), + ), +) + + +TestDraft201909Format = DRAFT201909.to_unittest_testcase( + DRAFT201909.format_cases(), + name="TestDraft201909Format", + Validator=jsonschema.Draft201909Validator, + format_checker=jsonschema.Draft201909Validator.FORMAT_CHECKER, + skip=lambda test: ( + complex_email_validation(test) + or ecmascript_regex(test) + or leap_second(test) + or missing_format(jsonschema.Draft201909Validator)(test) + or complex_email_validation(test) + ), +) + + +TestDraft202012 = DRAFT202012.to_unittest_testcase( + DRAFT202012.cases(), + DRAFT201909.optional_cases_of(name="anchor"), + DRAFT202012.optional_cases_of(name="bignum"), + DRAFT202012.optional_cases_of(name="cross-draft"), + DRAFT202012.optional_cases_of(name="float-overflow"), + DRAFT202012.optional_cases_of(name="id"), + DRAFT202012.optional_cases_of(name="no-schema"), + DRAFT202012.optional_cases_of(name="non-bmp-regex"), + DRAFT202012.optional_cases_of(name="refOfUnknownKeyword"), + DRAFT202012.optional_cases_of(name="unknownKeyword"), + Validator=jsonschema.Draft202012Validator, + skip=skip( + message="Vocabulary support is still in-progress.", + subject="vocabulary", + description=( + "no validation: invalid number, but it still validates" + ), + ), +) + + +TestDraft202012Format = DRAFT202012.to_unittest_testcase( + DRAFT202012.format_cases(), + name="TestDraft202012Format", + Validator=jsonschema.Draft202012Validator, + format_checker=jsonschema.Draft202012Validator.FORMAT_CHECKER, + skip=lambda test: ( + complex_email_validation(test) + or ecmascript_regex(test) + or leap_second(test) + or missing_format(jsonschema.Draft202012Validator)(test) + or complex_email_validation(test) + ), +) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_types.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_types.py new file mode 100644 index 0000000000000000000000000000000000000000..bd97b180029ae05d7f3b22f1048f9adcb769f36f --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_types.py @@ -0,0 +1,221 @@ +""" +Tests for the `TypeChecker`-based type interface. + +The actual correctness of the type checking is handled in +`test_jsonschema_test_suite`; these tests check that TypeChecker +functions correctly at a more granular level. +""" +from collections import namedtuple +from unittest import TestCase + +from jsonschema import ValidationError, _keywords +from jsonschema._types import TypeChecker +from jsonschema.exceptions import UndefinedTypeCheck, UnknownType +from jsonschema.validators import Draft202012Validator, extend + + +def equals_2(checker, instance): + return instance == 2 + + +def is_namedtuple(instance): + return isinstance(instance, tuple) and getattr(instance, "_fields", None) + + +def is_object_or_named_tuple(checker, instance): + if Draft202012Validator.TYPE_CHECKER.is_type(instance, "object"): + return True + return is_namedtuple(instance) + + +class TestTypeChecker(TestCase): + def test_is_type(self): + checker = TypeChecker({"two": equals_2}) + self.assertEqual( + ( + checker.is_type(instance=2, type="two"), + checker.is_type(instance="bar", type="two"), + ), + (True, False), + ) + + def test_is_unknown_type(self): + with self.assertRaises(UndefinedTypeCheck) as e: + TypeChecker().is_type(4, "foobar") + self.assertIn( + "'foobar' is unknown to this type checker", + str(e.exception), + ) + self.assertTrue( + e.exception.__suppress_context__, + msg="Expected the internal KeyError to be hidden.", + ) + + def test_checks_can_be_added_at_init(self): + checker = TypeChecker({"two": equals_2}) + self.assertEqual(checker, TypeChecker().redefine("two", equals_2)) + + def test_redefine_existing_type(self): + self.assertEqual( + TypeChecker().redefine("two", object()).redefine("two", equals_2), + TypeChecker().redefine("two", equals_2), + ) + + def test_remove(self): + self.assertEqual( + TypeChecker({"two": equals_2}).remove("two"), + TypeChecker(), + ) + + def test_remove_unknown_type(self): + with self.assertRaises(UndefinedTypeCheck) as context: + TypeChecker().remove("foobar") + self.assertIn("foobar", str(context.exception)) + + def test_redefine_many(self): + self.assertEqual( + TypeChecker().redefine_many({"foo": int, "bar": str}), + TypeChecker().redefine("foo", int).redefine("bar", str), + ) + + def test_remove_multiple(self): + self.assertEqual( + TypeChecker({"foo": int, "bar": str}).remove("foo", "bar"), + TypeChecker(), + ) + + def test_type_check_can_raise_key_error(self): + """ + Make sure no one writes: + + try: + self._type_checkers[type](...) + except KeyError: + + ignoring the fact that the function itself can raise that. + """ + + error = KeyError("Stuff") + + def raises_keyerror(checker, instance): + raise error + + with self.assertRaises(KeyError) as context: + TypeChecker({"foo": raises_keyerror}).is_type(4, "foo") + + self.assertIs(context.exception, error) + + def test_repr(self): + checker = TypeChecker({"foo": is_namedtuple, "bar": is_namedtuple}) + self.assertEqual(repr(checker), "") + + +class TestCustomTypes(TestCase): + def test_simple_type_can_be_extended(self): + def int_or_str_int(checker, instance): + if not isinstance(instance, (int, str)): + return False + try: + int(instance) + except ValueError: + return False + return True + + CustomValidator = extend( + Draft202012Validator, + type_checker=Draft202012Validator.TYPE_CHECKER.redefine( + "integer", int_or_str_int, + ), + ) + validator = CustomValidator({"type": "integer"}) + + validator.validate(4) + validator.validate("4") + + with self.assertRaises(ValidationError): + validator.validate(4.4) + + with self.assertRaises(ValidationError): + validator.validate("foo") + + def test_object_can_be_extended(self): + schema = {"type": "object"} + + Point = namedtuple("Point", ["x", "y"]) + + type_checker = Draft202012Validator.TYPE_CHECKER.redefine( + "object", is_object_or_named_tuple, + ) + + CustomValidator = extend( + Draft202012Validator, + type_checker=type_checker, + ) + validator = CustomValidator(schema) + + validator.validate(Point(x=4, y=5)) + + def test_object_extensions_require_custom_validators(self): + schema = {"type": "object", "required": ["x"]} + + type_checker = Draft202012Validator.TYPE_CHECKER.redefine( + "object", is_object_or_named_tuple, + ) + + CustomValidator = extend( + Draft202012Validator, + type_checker=type_checker, + ) + validator = CustomValidator(schema) + + Point = namedtuple("Point", ["x", "y"]) + # Cannot handle required + with self.assertRaises(ValidationError): + validator.validate(Point(x=4, y=5)) + + def test_object_extensions_can_handle_custom_validators(self): + schema = { + "type": "object", + "required": ["x"], + "properties": {"x": {"type": "integer"}}, + } + + type_checker = Draft202012Validator.TYPE_CHECKER.redefine( + "object", is_object_or_named_tuple, + ) + + def coerce_named_tuple(fn): + def coerced(validator, value, instance, schema): + if is_namedtuple(instance): + instance = instance._asdict() + return fn(validator, value, instance, schema) + return coerced + + required = coerce_named_tuple(_keywords.required) + properties = coerce_named_tuple(_keywords.properties) + + CustomValidator = extend( + Draft202012Validator, + type_checker=type_checker, + validators={"required": required, "properties": properties}, + ) + + validator = CustomValidator(schema) + + Point = namedtuple("Point", ["x", "y"]) + # Can now process required and properties + validator.validate(Point(x=4, y=5)) + + with self.assertRaises(ValidationError): + validator.validate(Point(x="not an integer", y=5)) + + # As well as still handle objects. + validator.validate({"x": 4, "y": 5}) + + with self.assertRaises(ValidationError): + validator.validate({"x": "not an integer", "y": 5}) + + def test_unknown_type(self): + with self.assertRaises(UnknownType) as e: + Draft202012Validator({}).is_type(12, "some unknown type") + self.assertIn("'some unknown type'", str(e.exception)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_utils.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d9764b0f9e92edb38c19e1fc43b248a20186ef6b --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_utils.py @@ -0,0 +1,138 @@ +from math import nan +from unittest import TestCase + +from jsonschema._utils import equal + + +class TestEqual(TestCase): + def test_none(self): + self.assertTrue(equal(None, None)) + + def test_nan(self): + self.assertTrue(equal(nan, nan)) + + +class TestDictEqual(TestCase): + def test_equal_dictionaries(self): + dict_1 = {"a": "b", "c": "d"} + dict_2 = {"c": "d", "a": "b"} + self.assertTrue(equal(dict_1, dict_2)) + + def test_equal_dictionaries_with_nan(self): + dict_1 = {"a": nan, "c": "d"} + dict_2 = {"c": "d", "a": nan} + self.assertTrue(equal(dict_1, dict_2)) + + def test_missing_key(self): + dict_1 = {"a": "b", "c": "d"} + dict_2 = {"c": "d", "x": "b"} + self.assertFalse(equal(dict_1, dict_2)) + + def test_additional_key(self): + dict_1 = {"a": "b", "c": "d"} + dict_2 = {"c": "d", "a": "b", "x": "x"} + self.assertFalse(equal(dict_1, dict_2)) + + def test_missing_value(self): + dict_1 = {"a": "b", "c": "d"} + dict_2 = {"c": "d", "a": "x"} + self.assertFalse(equal(dict_1, dict_2)) + + def test_empty_dictionaries(self): + dict_1 = {} + dict_2 = {} + self.assertTrue(equal(dict_1, dict_2)) + + def test_one_none(self): + dict_1 = None + dict_2 = {"a": "b", "c": "d"} + self.assertFalse(equal(dict_1, dict_2)) + + def test_same_item(self): + dict_1 = {"a": "b", "c": "d"} + self.assertTrue(equal(dict_1, dict_1)) + + def test_nested_equal(self): + dict_1 = {"a": {"a": "b", "c": "d"}, "c": "d"} + dict_2 = {"c": "d", "a": {"a": "b", "c": "d"}} + self.assertTrue(equal(dict_1, dict_2)) + + def test_nested_dict_unequal(self): + dict_1 = {"a": {"a": "b", "c": "d"}, "c": "d"} + dict_2 = {"c": "d", "a": {"a": "b", "c": "x"}} + self.assertFalse(equal(dict_1, dict_2)) + + def test_mixed_nested_equal(self): + dict_1 = {"a": ["a", "b", "c", "d"], "c": "d"} + dict_2 = {"c": "d", "a": ["a", "b", "c", "d"]} + self.assertTrue(equal(dict_1, dict_2)) + + def test_nested_list_unequal(self): + dict_1 = {"a": ["a", "b", "c", "d"], "c": "d"} + dict_2 = {"c": "d", "a": ["b", "c", "d", "a"]} + self.assertFalse(equal(dict_1, dict_2)) + + +class TestListEqual(TestCase): + def test_equal_lists(self): + list_1 = ["a", "b", "c"] + list_2 = ["a", "b", "c"] + self.assertTrue(equal(list_1, list_2)) + + def test_equal_lists_with_nan(self): + list_1 = ["a", nan, "c"] + list_2 = ["a", nan, "c"] + self.assertTrue(equal(list_1, list_2)) + + def test_unsorted_lists(self): + list_1 = ["a", "b", "c"] + list_2 = ["b", "b", "a"] + self.assertFalse(equal(list_1, list_2)) + + def test_first_list_larger(self): + list_1 = ["a", "b", "c"] + list_2 = ["a", "b"] + self.assertFalse(equal(list_1, list_2)) + + def test_second_list_larger(self): + list_1 = ["a", "b"] + list_2 = ["a", "b", "c"] + self.assertFalse(equal(list_1, list_2)) + + def test_list_with_none_unequal(self): + list_1 = ["a", "b", None] + list_2 = ["a", "b", "c"] + self.assertFalse(equal(list_1, list_2)) + + list_1 = ["a", "b", None] + list_2 = [None, "b", "c"] + self.assertFalse(equal(list_1, list_2)) + + def test_list_with_none_equal(self): + list_1 = ["a", None, "c"] + list_2 = ["a", None, "c"] + self.assertTrue(equal(list_1, list_2)) + + def test_empty_list(self): + list_1 = [] + list_2 = [] + self.assertTrue(equal(list_1, list_2)) + + def test_one_none(self): + list_1 = None + list_2 = [] + self.assertFalse(equal(list_1, list_2)) + + def test_same_list(self): + list_1 = ["a", "b", "c"] + self.assertTrue(equal(list_1, list_1)) + + def test_equal_nested_lists(self): + list_1 = ["a", ["b", "c"], "d"] + list_2 = ["a", ["b", "c"], "d"] + self.assertTrue(equal(list_1, list_2)) + + def test_unequal_nested_lists(self): + list_1 = ["a", ["b", "c"], "d"] + list_2 = ["a", [], "c"] + self.assertFalse(equal(list_1, list_2)) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/test_validators.py b/python/user_packages/Python313/site-packages/jsonschema/tests/test_validators.py new file mode 100644 index 0000000000000000000000000000000000000000..d419ddf8e354333f5794cb761348517595167f28 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/test_validators.py @@ -0,0 +1,2573 @@ +from __future__ import annotations + +from collections import deque, namedtuple +from contextlib import contextmanager +from decimal import Decimal +from io import BytesIO +from typing import Any +from unittest import TestCase, mock +from urllib.request import pathname2url +import json +import os +import sys +import tempfile +import warnings + +from attrs import define, field +from referencing.jsonschema import DRAFT202012 +import referencing.exceptions + +from jsonschema import ( + FormatChecker, + TypeChecker, + exceptions, + protocols, + validators, +) + + +def fail(validator, errors, instance, schema): + for each in errors: + each.setdefault("message", "You told me to fail!") + yield exceptions.ValidationError(**each) + + +class TestCreateAndExtend(TestCase): + def setUp(self): + self.addCleanup( + self.assertEqual, + validators._META_SCHEMAS, + dict(validators._META_SCHEMAS), + ) + self.addCleanup( + self.assertEqual, + validators._VALIDATORS, + dict(validators._VALIDATORS), + ) + + self.meta_schema = {"$id": "some://meta/schema"} + self.validators = {"fail": fail} + self.type_checker = TypeChecker() + self.Validator = validators.create( + meta_schema=self.meta_schema, + validators=self.validators, + type_checker=self.type_checker, + ) + + def test_attrs(self): + self.assertEqual( + ( + self.Validator.VALIDATORS, + self.Validator.META_SCHEMA, + self.Validator.TYPE_CHECKER, + ), ( + self.validators, + self.meta_schema, + self.type_checker, + ), + ) + + def test_init(self): + schema = {"fail": []} + self.assertEqual(self.Validator(schema).schema, schema) + + def test_iter_errors_successful(self): + schema = {"fail": []} + validator = self.Validator(schema) + + errors = list(validator.iter_errors("hello")) + self.assertEqual(errors, []) + + def test_iter_errors_one_error(self): + schema = {"fail": [{"message": "Whoops!"}]} + validator = self.Validator(schema) + + expected_error = exceptions.ValidationError( + "Whoops!", + instance="goodbye", + schema=schema, + validator="fail", + validator_value=[{"message": "Whoops!"}], + schema_path=deque(["fail"]), + ) + + errors = list(validator.iter_errors("goodbye")) + self.assertEqual(len(errors), 1) + self.assertEqual(errors[0]._contents(), expected_error._contents()) + + def test_iter_errors_multiple_errors(self): + schema = { + "fail": [ + {"message": "First"}, + {"message": "Second!", "validator": "asdf"}, + {"message": "Third"}, + ], + } + validator = self.Validator(schema) + + errors = list(validator.iter_errors("goodbye")) + self.assertEqual(len(errors), 3) + + def test_if_a_version_is_provided_it_is_registered(self): + Validator = validators.create( + meta_schema={"$id": "something"}, + version="my version", + ) + self.addCleanup(validators._META_SCHEMAS.pop, "something") + self.addCleanup(validators._VALIDATORS.pop, "my version") + self.assertEqual(Validator.__name__, "MyVersionValidator") + self.assertEqual(Validator.__qualname__, "MyVersionValidator") + + def test_repr(self): + Validator = validators.create( + meta_schema={"$id": "something"}, + version="my version", + ) + self.addCleanup(validators._META_SCHEMAS.pop, "something") + self.addCleanup(validators._VALIDATORS.pop, "my version") + self.assertEqual( + repr(Validator({})), + "MyVersionValidator(schema={}, format_checker=None)", + ) + + def test_long_repr(self): + Validator = validators.create( + meta_schema={"$id": "something"}, + version="my version", + ) + self.addCleanup(validators._META_SCHEMAS.pop, "something") + self.addCleanup(validators._VALIDATORS.pop, "my version") + self.assertEqual( + repr(Validator({"a": list(range(1000))})), ( + "MyVersionValidator(schema={'a': [0, 1, 2, 3, 4, 5, ...]}, " + "format_checker=None)" + ), + ) + + def test_repr_no_version(self): + Validator = validators.create(meta_schema={}) + self.assertEqual( + repr(Validator({})), + "Validator(schema={}, format_checker=None)", + ) + + def test_dashes_are_stripped_from_validator_names(self): + Validator = validators.create( + meta_schema={"$id": "something"}, + version="foo-bar", + ) + self.addCleanup(validators._META_SCHEMAS.pop, "something") + self.addCleanup(validators._VALIDATORS.pop, "foo-bar") + self.assertEqual(Validator.__qualname__, "FooBarValidator") + + def test_if_a_version_is_not_provided_it_is_not_registered(self): + original = dict(validators._META_SCHEMAS) + validators.create(meta_schema={"id": "id"}) + self.assertEqual(validators._META_SCHEMAS, original) + + def test_validates_registers_meta_schema_id(self): + meta_schema_key = "meta schema id" + my_meta_schema = {"id": meta_schema_key} + + validators.create( + meta_schema=my_meta_schema, + version="my version", + id_of=lambda s: s.get("id", ""), + ) + self.addCleanup(validators._META_SCHEMAS.pop, meta_schema_key) + self.addCleanup(validators._VALIDATORS.pop, "my version") + + self.assertIn(meta_schema_key, validators._META_SCHEMAS) + + def test_validates_registers_meta_schema_draft6_id(self): + meta_schema_key = "meta schema $id" + my_meta_schema = {"$id": meta_schema_key} + + validators.create( + meta_schema=my_meta_schema, + version="my version", + ) + self.addCleanup(validators._META_SCHEMAS.pop, meta_schema_key) + self.addCleanup(validators._VALIDATORS.pop, "my version") + + self.assertIn(meta_schema_key, validators._META_SCHEMAS) + + def test_create_default_types(self): + Validator = validators.create(meta_schema={}, validators=()) + self.assertTrue( + all( + Validator({}).is_type(instance=instance, type=type) + for type, instance in [ + ("array", []), + ("boolean", True), + ("integer", 12), + ("null", None), + ("number", 12.0), + ("object", {}), + ("string", "foo"), + ] + ), + ) + + def test_check_schema_with_different_metaschema(self): + """ + One can create a validator class whose metaschema uses a different + dialect than itself. + """ + + NoEmptySchemasValidator = validators.create( + meta_schema={ + "$schema": validators.Draft202012Validator.META_SCHEMA["$id"], + "not": {"const": {}}, + }, + ) + NoEmptySchemasValidator.check_schema({"foo": "bar"}) + + with self.assertRaises(exceptions.SchemaError): + NoEmptySchemasValidator.check_schema({}) + + NoEmptySchemasValidator({"foo": "bar"}).validate("foo") + + def test_check_schema_with_different_metaschema_defaults_to_self(self): + """ + A validator whose metaschema doesn't declare $schema defaults to its + own validation behavior, not the latest "normal" specification. + """ + + NoEmptySchemasValidator = validators.create( + meta_schema={"fail": [{"message": "Meta schema whoops!"}]}, + validators={"fail": fail}, + ) + with self.assertRaises(exceptions.SchemaError): + NoEmptySchemasValidator.check_schema({}) + + def test_extend(self): + original = dict(self.Validator.VALIDATORS) + new = object() + + Extended = validators.extend( + self.Validator, + validators={"new": new}, + ) + self.assertEqual( + ( + Extended.VALIDATORS, + Extended.META_SCHEMA, + Extended.TYPE_CHECKER, + self.Validator.VALIDATORS, + ), ( + dict(original, new=new), + self.Validator.META_SCHEMA, + self.Validator.TYPE_CHECKER, + original, + ), + ) + + def test_extend_idof(self): + """ + Extending a validator preserves its notion of schema IDs. + """ + def id_of(schema): + return schema.get("__test__", self.Validator.ID_OF(schema)) + correct_id = "the://correct/id/" + meta_schema = { + "$id": "the://wrong/id/", + "__test__": correct_id, + } + Original = validators.create( + meta_schema=meta_schema, + validators=self.validators, + type_checker=self.type_checker, + id_of=id_of, + ) + self.assertEqual(Original.ID_OF(Original.META_SCHEMA), correct_id) + + Derived = validators.extend(Original) + self.assertEqual(Derived.ID_OF(Derived.META_SCHEMA), correct_id) + + def test_extend_applicable_validators(self): + """ + Extending a validator preserves its notion of applicable validators. + """ + + schema = { + "$defs": {"test": {"type": "number"}}, + "$ref": "#/$defs/test", + "maximum": 1, + } + + draft4 = validators.Draft4Validator(schema) + self.assertTrue(draft4.is_valid(37)) # as $ref ignores siblings + + Derived = validators.extend(validators.Draft4Validator) + self.assertTrue(Derived(schema).is_valid(37)) + + +class TestValidationErrorMessages(TestCase): + def message_for(self, instance, schema, *args, **kwargs): + cls = kwargs.pop("cls", validators._LATEST_VERSION) + cls.check_schema(schema) + validator = cls(schema, *args, **kwargs) + errors = list(validator.iter_errors(instance)) + self.assertTrue(errors, msg=f"No errors were raised for {instance!r}") + self.assertEqual( + len(errors), + 1, + msg=f"Expected exactly one error, found {errors!r}", + ) + return errors[0].message + + def test_single_type_failure(self): + message = self.message_for(instance=1, schema={"type": "string"}) + self.assertEqual(message, "1 is not of type 'string'") + + def test_single_type_list_failure(self): + message = self.message_for(instance=1, schema={"type": ["string"]}) + self.assertEqual(message, "1 is not of type 'string'") + + def test_multiple_type_failure(self): + types = "string", "object" + message = self.message_for(instance=1, schema={"type": list(types)}) + self.assertEqual(message, "1 is not of type 'string', 'object'") + + def test_object_with_named_type_failure(self): + schema = {"type": [{"name": "Foo", "minimum": 3}]} + message = self.message_for( + instance=1, + schema=schema, + cls=validators.Draft3Validator, + ) + self.assertEqual(message, "1 is not of type 'Foo'") + + def test_minimum(self): + message = self.message_for(instance=1, schema={"minimum": 2}) + self.assertEqual(message, "1 is less than the minimum of 2") + + def test_maximum(self): + message = self.message_for(instance=1, schema={"maximum": 0}) + self.assertEqual(message, "1 is greater than the maximum of 0") + + def test_dependencies_single_element(self): + depend, on = "bar", "foo" + schema = {"dependencies": {depend: on}} + message = self.message_for( + instance={"bar": 2}, + schema=schema, + cls=validators.Draft3Validator, + ) + self.assertEqual(message, "'foo' is a dependency of 'bar'") + + def test_object_without_title_type_failure_draft3(self): + type = {"type": [{"minimum": 3}]} + message = self.message_for( + instance=1, + schema={"type": [type]}, + cls=validators.Draft3Validator, + ) + self.assertEqual( + message, + "1 is not of type {'type': [{'minimum': 3}]}", + ) + + def test_dependencies_list_draft3(self): + depend, on = "bar", "foo" + schema = {"dependencies": {depend: [on]}} + message = self.message_for( + instance={"bar": 2}, + schema=schema, + cls=validators.Draft3Validator, + ) + self.assertEqual(message, "'foo' is a dependency of 'bar'") + + def test_dependencies_list_draft7(self): + depend, on = "bar", "foo" + schema = {"dependencies": {depend: [on]}} + message = self.message_for( + instance={"bar": 2}, + schema=schema, + cls=validators.Draft7Validator, + ) + self.assertEqual(message, "'foo' is a dependency of 'bar'") + + def test_additionalItems_single_failure(self): + message = self.message_for( + instance=[2], + schema={"items": [], "additionalItems": False}, + cls=validators.Draft3Validator, + ) + self.assertIn("(2 was unexpected)", message) + + def test_additionalItems_multiple_failures(self): + message = self.message_for( + instance=[1, 2, 3], + schema={"items": [], "additionalItems": False}, + cls=validators.Draft3Validator, + ) + self.assertIn("(1, 2, 3 were unexpected)", message) + + def test_additionalProperties_single_failure(self): + additional = "foo" + schema = {"additionalProperties": False} + message = self.message_for(instance={additional: 2}, schema=schema) + self.assertIn("('foo' was unexpected)", message) + + def test_additionalProperties_multiple_failures(self): + schema = {"additionalProperties": False} + message = self.message_for( + instance=dict.fromkeys(["foo", "bar"]), + schema=schema, + ) + + self.assertIn(repr("foo"), message) + self.assertIn(repr("bar"), message) + self.assertIn("were unexpected)", message) + + def test_const(self): + schema = {"const": 12} + message = self.message_for( + instance={"foo": "bar"}, + schema=schema, + ) + self.assertIn("12 was expected", message) + + def test_contains_draft_6(self): + schema = {"contains": {"const": 12}} + message = self.message_for( + instance=[2, {}, []], + schema=schema, + cls=validators.Draft6Validator, + ) + self.assertEqual( + message, + "None of [2, {}, []] are valid under the given schema", + ) + + def test_invalid_format_default_message(self): + checker = FormatChecker(formats=()) + checker.checks("thing")(lambda value: False) + + schema = {"format": "thing"} + message = self.message_for( + instance="bla", + schema=schema, + format_checker=checker, + ) + + self.assertIn(repr("bla"), message) + self.assertIn(repr("thing"), message) + self.assertIn("is not a", message) + + def test_additionalProperties_false_patternProperties(self): + schema = {"type": "object", + "additionalProperties": False, + "patternProperties": { + "^abc$": {"type": "string"}, + "^def$": {"type": "string"}, + }} + message = self.message_for( + instance={"zebra": 123}, + schema=schema, + cls=validators.Draft4Validator, + ) + self.assertEqual( + message, + "{} does not match any of the regexes: {}, {}".format( + repr("zebra"), repr("^abc$"), repr("^def$"), + ), + ) + message = self.message_for( + instance={"zebra": 123, "fish": 456}, + schema=schema, + cls=validators.Draft4Validator, + ) + self.assertEqual( + message, + "{}, {} do not match any of the regexes: {}, {}".format( + repr("fish"), repr("zebra"), repr("^abc$"), repr("^def$"), + ), + ) + + def test_False_schema(self): + message = self.message_for( + instance="something", + schema=False, + ) + self.assertEqual(message, "False schema does not allow 'something'") + + def test_multipleOf(self): + message = self.message_for( + instance=3, + schema={"multipleOf": 2}, + ) + self.assertEqual(message, "3 is not a multiple of 2") + + def test_minItems(self): + message = self.message_for(instance=[], schema={"minItems": 2}) + self.assertEqual(message, "[] is too short") + + def test_maxItems(self): + message = self.message_for(instance=[1, 2, 3], schema={"maxItems": 2}) + self.assertEqual(message, "[1, 2, 3] is too long") + + def test_minItems_1(self): + message = self.message_for(instance=[], schema={"minItems": 1}) + self.assertEqual(message, "[] should be non-empty") + + def test_maxItems_0(self): + message = self.message_for(instance=[1, 2, 3], schema={"maxItems": 0}) + self.assertEqual(message, "[1, 2, 3] is expected to be empty") + + def test_minLength(self): + message = self.message_for( + instance="", + schema={"minLength": 2}, + ) + self.assertEqual(message, "'' is too short") + + def test_maxLength(self): + message = self.message_for( + instance="abc", + schema={"maxLength": 2}, + ) + self.assertEqual(message, "'abc' is too long") + + def test_minLength_1(self): + message = self.message_for(instance="", schema={"minLength": 1}) + self.assertEqual(message, "'' should be non-empty") + + def test_maxLength_0(self): + message = self.message_for(instance="abc", schema={"maxLength": 0}) + self.assertEqual(message, "'abc' is expected to be empty") + + def test_minProperties(self): + message = self.message_for(instance={}, schema={"minProperties": 2}) + self.assertEqual(message, "{} does not have enough properties") + + def test_maxProperties(self): + message = self.message_for( + instance={"a": {}, "b": {}, "c": {}}, + schema={"maxProperties": 2}, + ) + self.assertEqual( + message, + "{'a': {}, 'b': {}, 'c': {}} has too many properties", + ) + + def test_minProperties_1(self): + message = self.message_for(instance={}, schema={"minProperties": 1}) + self.assertEqual(message, "{} should be non-empty") + + def test_maxProperties_0(self): + message = self.message_for( + instance={1: 2}, + schema={"maxProperties": 0}, + ) + self.assertEqual(message, "{1: 2} is expected to be empty") + + def test_prefixItems_with_items(self): + message = self.message_for( + instance=[1, 2, "foo"], + schema={"items": False, "prefixItems": [{}, {}]}, + ) + self.assertEqual( + message, + "Expected at most 2 items but found 1 extra: 'foo'", + ) + + def test_prefixItems_with_multiple_extra_items(self): + message = self.message_for( + instance=[1, 2, "foo", 5], + schema={"items": False, "prefixItems": [{}, {}]}, + ) + self.assertEqual( + message, + "Expected at most 2 items but found 2 extra: ['foo', 5]", + ) + + def test_pattern(self): + message = self.message_for( + instance="bbb", + schema={"pattern": "^a*$"}, + ) + self.assertEqual(message, "'bbb' does not match '^a*$'") + + def test_does_not_contain(self): + message = self.message_for( + instance=[], + schema={"contains": {"type": "string"}}, + ) + self.assertEqual( + message, + "[] does not contain items matching the given schema", + ) + + def test_contains_too_few(self): + message = self.message_for( + instance=["foo", 1], + schema={"contains": {"type": "string"}, "minContains": 2}, + ) + self.assertEqual( + message, + "Too few items match the given schema " + "(expected at least 2 but only 1 matched)", + ) + + def test_contains_too_few_both_constrained(self): + message = self.message_for( + instance=["foo", 1], + schema={ + "contains": {"type": "string"}, + "minContains": 2, + "maxContains": 4, + }, + ) + self.assertEqual( + message, + "Too few items match the given schema (expected at least 2 but " + "only 1 matched)", + ) + + def test_contains_too_many(self): + message = self.message_for( + instance=["foo", "bar", "baz"], + schema={"contains": {"type": "string"}, "maxContains": 2}, + ) + self.assertEqual( + message, + "Too many items match the given schema (expected at most 2)", + ) + + def test_contains_too_many_both_constrained(self): + message = self.message_for( + instance=["foo"] * 5, + schema={ + "contains": {"type": "string"}, + "minContains": 2, + "maxContains": 4, + }, + ) + self.assertEqual( + message, + "Too many items match the given schema (expected at most 4)", + ) + + def test_exclusiveMinimum(self): + message = self.message_for( + instance=3, + schema={"exclusiveMinimum": 5}, + ) + self.assertEqual( + message, + "3 is less than or equal to the minimum of 5", + ) + + def test_exclusiveMaximum(self): + message = self.message_for(instance=3, schema={"exclusiveMaximum": 2}) + self.assertEqual( + message, + "3 is greater than or equal to the maximum of 2", + ) + + def test_required(self): + message = self.message_for(instance={}, schema={"required": ["foo"]}) + self.assertEqual(message, "'foo' is a required property") + + def test_dependentRequired(self): + message = self.message_for( + instance={"foo": {}}, + schema={"dependentRequired": {"foo": ["bar"]}}, + ) + self.assertEqual(message, "'bar' is a dependency of 'foo'") + + def test_oneOf_matches_none(self): + message = self.message_for(instance={}, schema={"oneOf": [False]}) + self.assertEqual( + message, + "{} is not valid under any of the given schemas", + ) + + def test_oneOf_matches_too_many(self): + message = self.message_for(instance={}, schema={"oneOf": [True, True]}) + self.assertEqual(message, "{} is valid under each of True, True") + + def test_unevaluated_items(self): + schema = {"type": "array", "unevaluatedItems": False} + message = self.message_for(instance=["foo", "bar"], schema=schema) + self.assertIn( + message, + "Unevaluated items are not allowed ('foo', 'bar' were unexpected)", + ) + + def test_unevaluated_items_on_invalid_type(self): + schema = {"type": "array", "unevaluatedItems": False} + message = self.message_for(instance="foo", schema=schema) + self.assertEqual(message, "'foo' is not of type 'array'") + + def test_unevaluated_properties_invalid_against_subschema(self): + schema = { + "properties": {"foo": {"type": "string"}}, + "unevaluatedProperties": {"const": 12}, + } + message = self.message_for( + instance={ + "foo": "foo", + "bar": "bar", + "baz": 12, + }, + schema=schema, + ) + self.assertEqual( + message, + "Unevaluated properties are not valid under the given schema " + "('bar' was unevaluated and invalid)", + ) + + def test_unevaluated_properties_disallowed(self): + schema = {"type": "object", "unevaluatedProperties": False} + message = self.message_for( + instance={ + "foo": "foo", + "bar": "bar", + }, + schema=schema, + ) + self.assertEqual( + message, + "Unevaluated properties are not allowed " + "('bar', 'foo' were unexpected)", + ) + + def test_unevaluated_properties_on_invalid_type(self): + schema = {"type": "object", "unevaluatedProperties": False} + message = self.message_for(instance="foo", schema=schema) + self.assertEqual(message, "'foo' is not of type 'object'") + + def test_single_item(self): + schema = {"prefixItems": [{}], "items": False} + message = self.message_for( + instance=["foo", "bar", "baz"], + schema=schema, + ) + self.assertEqual( + message, + "Expected at most 1 item but found 2 extra: ['bar', 'baz']", + ) + + def test_heterogeneous_additionalItems_with_Items(self): + schema = {"items": [{}], "additionalItems": False} + message = self.message_for( + instance=["foo", "bar", 37], + schema=schema, + cls=validators.Draft7Validator, + ) + self.assertEqual( + message, + "Additional items are not allowed ('bar', 37 were unexpected)", + ) + + def test_heterogeneous_items_prefixItems(self): + schema = {"prefixItems": [{}], "items": False} + message = self.message_for( + instance=["foo", "bar", 37], + schema=schema, + ) + self.assertEqual( + message, + "Expected at most 1 item but found 2 extra: ['bar', 37]", + ) + + def test_heterogeneous_unevaluatedItems_prefixItems(self): + schema = {"prefixItems": [{}], "unevaluatedItems": False} + message = self.message_for( + instance=["foo", "bar", 37], + schema=schema, + ) + self.assertEqual( + message, + "Unevaluated items are not allowed ('bar', 37 were unexpected)", + ) + + def test_heterogeneous_properties_additionalProperties(self): + """ + Not valid deserialized JSON, but this should not blow up. + """ + schema = {"properties": {"foo": {}}, "additionalProperties": False} + message = self.message_for( + instance={"foo": {}, "a": "baz", 37: 12}, + schema=schema, + ) + self.assertEqual( + message, + "Additional properties are not allowed (37, 'a' were unexpected)", + ) + + def test_heterogeneous_properties_unevaluatedProperties(self): + """ + Not valid deserialized JSON, but this should not blow up. + """ + schema = {"properties": {"foo": {}}, "unevaluatedProperties": False} + message = self.message_for( + instance={"foo": {}, "a": "baz", 37: 12}, + schema=schema, + ) + self.assertEqual( + message, + "Unevaluated properties are not allowed (37, 'a' were unexpected)", + ) + + +class TestValidationErrorDetails(TestCase): + # TODO: These really need unit tests for each individual keyword, rather + # than just these higher level tests. + def test_anyOf(self): + instance = 5 + schema = { + "anyOf": [ + {"minimum": 20}, + {"type": "string"}, + ], + } + + validator = validators.Draft4Validator(schema) + errors = list(validator.iter_errors(instance)) + self.assertEqual(len(errors), 1) + e = errors[0] + + self.assertEqual(e.validator, "anyOf") + self.assertEqual(e.validator_value, schema["anyOf"]) + self.assertEqual(e.instance, instance) + self.assertEqual(e.schema, schema) + self.assertIsNone(e.parent) + + self.assertEqual(e.path, deque([])) + self.assertEqual(e.relative_path, deque([])) + self.assertEqual(e.absolute_path, deque([])) + self.assertEqual(e.json_path, "$") + + self.assertEqual(e.schema_path, deque(["anyOf"])) + self.assertEqual(e.relative_schema_path, deque(["anyOf"])) + self.assertEqual(e.absolute_schema_path, deque(["anyOf"])) + + self.assertEqual(len(e.context), 2) + + e1, e2 = sorted_errors(e.context) + + self.assertEqual(e1.validator, "minimum") + self.assertEqual(e1.validator_value, schema["anyOf"][0]["minimum"]) + self.assertEqual(e1.instance, instance) + self.assertEqual(e1.schema, schema["anyOf"][0]) + self.assertIs(e1.parent, e) + + self.assertEqual(e1.path, deque([])) + self.assertEqual(e1.absolute_path, deque([])) + self.assertEqual(e1.relative_path, deque([])) + self.assertEqual(e1.json_path, "$") + + self.assertEqual(e1.schema_path, deque([0, "minimum"])) + self.assertEqual(e1.relative_schema_path, deque([0, "minimum"])) + self.assertEqual( + e1.absolute_schema_path, deque(["anyOf", 0, "minimum"]), + ) + + self.assertFalse(e1.context) + + self.assertEqual(e2.validator, "type") + self.assertEqual(e2.validator_value, schema["anyOf"][1]["type"]) + self.assertEqual(e2.instance, instance) + self.assertEqual(e2.schema, schema["anyOf"][1]) + self.assertIs(e2.parent, e) + + self.assertEqual(e2.path, deque([])) + self.assertEqual(e2.relative_path, deque([])) + self.assertEqual(e2.absolute_path, deque([])) + self.assertEqual(e2.json_path, "$") + + self.assertEqual(e2.schema_path, deque([1, "type"])) + self.assertEqual(e2.relative_schema_path, deque([1, "type"])) + self.assertEqual(e2.absolute_schema_path, deque(["anyOf", 1, "type"])) + + self.assertEqual(len(e2.context), 0) + + def test_type(self): + instance = {"foo": 1} + schema = { + "type": [ + {"type": "integer"}, + { + "type": "object", + "properties": {"foo": {"enum": [2]}}, + }, + ], + } + + validator = validators.Draft3Validator(schema) + errors = list(validator.iter_errors(instance)) + self.assertEqual(len(errors), 1) + e = errors[0] + + self.assertEqual(e.validator, "type") + self.assertEqual(e.validator_value, schema["type"]) + self.assertEqual(e.instance, instance) + self.assertEqual(e.schema, schema) + self.assertIsNone(e.parent) + + self.assertEqual(e.path, deque([])) + self.assertEqual(e.relative_path, deque([])) + self.assertEqual(e.absolute_path, deque([])) + self.assertEqual(e.json_path, "$") + + self.assertEqual(e.schema_path, deque(["type"])) + self.assertEqual(e.relative_schema_path, deque(["type"])) + self.assertEqual(e.absolute_schema_path, deque(["type"])) + + self.assertEqual(len(e.context), 2) + + e1, e2 = sorted_errors(e.context) + + self.assertEqual(e1.validator, "type") + self.assertEqual(e1.validator_value, schema["type"][0]["type"]) + self.assertEqual(e1.instance, instance) + self.assertEqual(e1.schema, schema["type"][0]) + self.assertIs(e1.parent, e) + + self.assertEqual(e1.path, deque([])) + self.assertEqual(e1.relative_path, deque([])) + self.assertEqual(e1.absolute_path, deque([])) + self.assertEqual(e1.json_path, "$") + + self.assertEqual(e1.schema_path, deque([0, "type"])) + self.assertEqual(e1.relative_schema_path, deque([0, "type"])) + self.assertEqual(e1.absolute_schema_path, deque(["type", 0, "type"])) + + self.assertFalse(e1.context) + + self.assertEqual(e2.validator, "enum") + self.assertEqual(e2.validator_value, [2]) + self.assertEqual(e2.instance, 1) + self.assertEqual(e2.schema, {"enum": [2]}) + self.assertIs(e2.parent, e) + + self.assertEqual(e2.path, deque(["foo"])) + self.assertEqual(e2.relative_path, deque(["foo"])) + self.assertEqual(e2.absolute_path, deque(["foo"])) + self.assertEqual(e2.json_path, "$.foo") + + self.assertEqual( + e2.schema_path, deque([1, "properties", "foo", "enum"]), + ) + self.assertEqual( + e2.relative_schema_path, deque([1, "properties", "foo", "enum"]), + ) + self.assertEqual( + e2.absolute_schema_path, + deque(["type", 1, "properties", "foo", "enum"]), + ) + + self.assertFalse(e2.context) + + def test_single_nesting(self): + instance = {"foo": 2, "bar": [1], "baz": 15, "quux": "spam"} + schema = { + "properties": { + "foo": {"type": "string"}, + "bar": {"minItems": 2}, + "baz": {"maximum": 10, "enum": [2, 4, 6, 8]}, + }, + } + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2, e3, e4 = sorted_errors(errors) + + self.assertEqual(e1.path, deque(["bar"])) + self.assertEqual(e2.path, deque(["baz"])) + self.assertEqual(e3.path, deque(["baz"])) + self.assertEqual(e4.path, deque(["foo"])) + + self.assertEqual(e1.relative_path, deque(["bar"])) + self.assertEqual(e2.relative_path, deque(["baz"])) + self.assertEqual(e3.relative_path, deque(["baz"])) + self.assertEqual(e4.relative_path, deque(["foo"])) + + self.assertEqual(e1.absolute_path, deque(["bar"])) + self.assertEqual(e2.absolute_path, deque(["baz"])) + self.assertEqual(e3.absolute_path, deque(["baz"])) + self.assertEqual(e4.absolute_path, deque(["foo"])) + + self.assertEqual(e1.json_path, "$.bar") + self.assertEqual(e2.json_path, "$.baz") + self.assertEqual(e3.json_path, "$.baz") + self.assertEqual(e4.json_path, "$.foo") + + self.assertEqual(e1.validator, "minItems") + self.assertEqual(e2.validator, "enum") + self.assertEqual(e3.validator, "maximum") + self.assertEqual(e4.validator, "type") + + def test_multiple_nesting(self): + instance = [1, {"foo": 2, "bar": {"baz": [1]}}, "quux"] + schema = { + "type": "string", + "items": { + "type": ["string", "object"], + "properties": { + "foo": {"enum": [1, 3]}, + "bar": { + "type": "array", + "properties": { + "bar": {"required": True}, + "baz": {"minItems": 2}, + }, + }, + }, + }, + } + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2, e3, e4, e5, e6 = sorted_errors(errors) + + self.assertEqual(e1.path, deque([])) + self.assertEqual(e2.path, deque([0])) + self.assertEqual(e3.path, deque([1, "bar"])) + self.assertEqual(e4.path, deque([1, "bar", "bar"])) + self.assertEqual(e5.path, deque([1, "bar", "baz"])) + self.assertEqual(e6.path, deque([1, "foo"])) + + self.assertEqual(e1.json_path, "$") + self.assertEqual(e2.json_path, "$[0]") + self.assertEqual(e3.json_path, "$[1].bar") + self.assertEqual(e4.json_path, "$[1].bar.bar") + self.assertEqual(e5.json_path, "$[1].bar.baz") + self.assertEqual(e6.json_path, "$[1].foo") + + self.assertEqual(e1.schema_path, deque(["type"])) + self.assertEqual(e2.schema_path, deque(["items", "type"])) + self.assertEqual( + list(e3.schema_path), ["items", "properties", "bar", "type"], + ) + self.assertEqual( + list(e4.schema_path), + ["items", "properties", "bar", "properties", "bar", "required"], + ) + self.assertEqual( + list(e5.schema_path), + ["items", "properties", "bar", "properties", "baz", "minItems"], + ) + self.assertEqual( + list(e6.schema_path), ["items", "properties", "foo", "enum"], + ) + + self.assertEqual(e1.validator, "type") + self.assertEqual(e2.validator, "type") + self.assertEqual(e3.validator, "type") + self.assertEqual(e4.validator, "required") + self.assertEqual(e5.validator, "minItems") + self.assertEqual(e6.validator, "enum") + + def test_recursive(self): + schema = { + "definitions": { + "node": { + "anyOf": [{ + "type": "object", + "required": ["name", "children"], + "properties": { + "name": { + "type": "string", + }, + "children": { + "type": "object", + "patternProperties": { + "^.*$": { + "$ref": "#/definitions/node", + }, + }, + }, + }, + }], + }, + }, + "type": "object", + "required": ["root"], + "properties": {"root": {"$ref": "#/definitions/node"}}, + } + + instance = { + "root": { + "name": "root", + "children": { + "a": { + "name": "a", + "children": { + "ab": { + "name": "ab", + # missing "children" + }, + }, + }, + }, + }, + } + validator = validators.Draft4Validator(schema) + + e, = validator.iter_errors(instance) + self.assertEqual(e.absolute_path, deque(["root"])) + self.assertEqual( + e.absolute_schema_path, deque(["properties", "root", "anyOf"]), + ) + self.assertEqual(e.json_path, "$.root") + + e1, = e.context + self.assertEqual(e1.absolute_path, deque(["root", "children", "a"])) + self.assertEqual( + e1.absolute_schema_path, deque( + [ + "properties", + "root", + "anyOf", + 0, + "properties", + "children", + "patternProperties", + "^.*$", + "anyOf", + ], + ), + ) + self.assertEqual(e1.json_path, "$.root.children.a") + + e2, = e1.context + self.assertEqual( + e2.absolute_path, deque( + ["root", "children", "a", "children", "ab"], + ), + ) + self.assertEqual( + e2.absolute_schema_path, deque( + [ + "properties", + "root", + "anyOf", + 0, + "properties", + "children", + "patternProperties", + "^.*$", + "anyOf", + 0, + "properties", + "children", + "patternProperties", + "^.*$", + "anyOf", + ], + ), + ) + self.assertEqual(e2.json_path, "$.root.children.a.children.ab") + + def test_additionalProperties(self): + instance = {"bar": "bar", "foo": 2} + schema = {"additionalProperties": {"type": "integer", "minimum": 5}} + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2 = sorted_errors(errors) + + self.assertEqual(e1.path, deque(["bar"])) + self.assertEqual(e2.path, deque(["foo"])) + + self.assertEqual(e1.json_path, "$.bar") + self.assertEqual(e2.json_path, "$.foo") + + self.assertEqual(e1.validator, "type") + self.assertEqual(e2.validator, "minimum") + + def test_patternProperties(self): + instance = {"bar": 1, "foo": 2} + schema = { + "patternProperties": { + "bar": {"type": "string"}, + "foo": {"minimum": 5}, + }, + } + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2 = sorted_errors(errors) + + self.assertEqual(e1.path, deque(["bar"])) + self.assertEqual(e2.path, deque(["foo"])) + + self.assertEqual(e1.json_path, "$.bar") + self.assertEqual(e2.json_path, "$.foo") + + self.assertEqual(e1.validator, "type") + self.assertEqual(e2.validator, "minimum") + + def test_additionalItems(self): + instance = ["foo", 1] + schema = { + "items": [], + "additionalItems": {"type": "integer", "minimum": 5}, + } + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2 = sorted_errors(errors) + + self.assertEqual(e1.path, deque([0])) + self.assertEqual(e2.path, deque([1])) + + self.assertEqual(e1.json_path, "$[0]") + self.assertEqual(e2.json_path, "$[1]") + + self.assertEqual(e1.validator, "type") + self.assertEqual(e2.validator, "minimum") + + def test_additionalItems_with_items(self): + instance = ["foo", "bar", 1] + schema = { + "items": [{}], + "additionalItems": {"type": "integer", "minimum": 5}, + } + + validator = validators.Draft3Validator(schema) + errors = validator.iter_errors(instance) + e1, e2 = sorted_errors(errors) + + self.assertEqual(e1.path, deque([1])) + self.assertEqual(e2.path, deque([2])) + + self.assertEqual(e1.json_path, "$[1]") + self.assertEqual(e2.json_path, "$[2]") + + self.assertEqual(e1.validator, "type") + self.assertEqual(e2.validator, "minimum") + + def test_propertyNames(self): + instance = {"foo": 12} + schema = {"propertyNames": {"not": {"const": "foo"}}} + + validator = validators.Draft7Validator(schema) + error, = validator.iter_errors(instance) + + self.assertEqual(error.validator, "not") + self.assertEqual( + error.message, + "'foo' should not be valid under {'const': 'foo'}", + ) + self.assertEqual(error.path, deque([])) + self.assertEqual(error.json_path, "$") + self.assertEqual(error.schema_path, deque(["propertyNames", "not"])) + + def test_if_then(self): + schema = { + "if": {"const": 12}, + "then": {"const": 13}, + } + + validator = validators.Draft7Validator(schema) + error, = validator.iter_errors(12) + + self.assertEqual(error.validator, "const") + self.assertEqual(error.message, "13 was expected") + self.assertEqual(error.path, deque([])) + self.assertEqual(error.json_path, "$") + self.assertEqual(error.schema_path, deque(["then", "const"])) + + def test_if_else(self): + schema = { + "if": {"const": 12}, + "else": {"const": 13}, + } + + validator = validators.Draft7Validator(schema) + error, = validator.iter_errors(15) + + self.assertEqual(error.validator, "const") + self.assertEqual(error.message, "13 was expected") + self.assertEqual(error.path, deque([])) + self.assertEqual(error.json_path, "$") + self.assertEqual(error.schema_path, deque(["else", "const"])) + + def test_boolean_schema_False(self): + validator = validators.Draft7Validator(False) + error, = validator.iter_errors(12) + + self.assertEqual( + ( + error.message, + error.validator, + error.validator_value, + error.instance, + error.schema, + error.schema_path, + error.json_path, + ), + ( + "False schema does not allow 12", + None, + None, + 12, + False, + deque([]), + "$", + ), + ) + + def test_ref(self): + ref, schema = "someRef", {"additionalProperties": {"type": "integer"}} + validator = validators.Draft7Validator( + {"$ref": ref}, + resolver=validators._RefResolver("", {}, store={ref: schema}), + ) + error, = validator.iter_errors({"foo": "notAnInteger"}) + + self.assertEqual( + ( + error.message, + error.validator, + error.validator_value, + error.instance, + error.absolute_path, + error.schema, + error.schema_path, + error.json_path, + ), + ( + "'notAnInteger' is not of type 'integer'", + "type", + "integer", + "notAnInteger", + deque(["foo"]), + {"type": "integer"}, + deque(["additionalProperties", "type"]), + "$.foo", + ), + ) + + def test_prefixItems(self): + schema = {"prefixItems": [{"type": "string"}, {}, {}, {"maximum": 3}]} + validator = validators.Draft202012Validator(schema) + type_error, min_error = validator.iter_errors([1, 2, "foo", 5]) + self.assertEqual( + ( + type_error.message, + type_error.validator, + type_error.validator_value, + type_error.instance, + type_error.absolute_path, + type_error.schema, + type_error.schema_path, + type_error.json_path, + ), + ( + "1 is not of type 'string'", + "type", + "string", + 1, + deque([0]), + {"type": "string"}, + deque(["prefixItems", 0, "type"]), + "$[0]", + ), + ) + self.assertEqual( + ( + min_error.message, + min_error.validator, + min_error.validator_value, + min_error.instance, + min_error.absolute_path, + min_error.schema, + min_error.schema_path, + min_error.json_path, + ), + ( + "5 is greater than the maximum of 3", + "maximum", + 3, + 5, + deque([3]), + {"maximum": 3}, + deque(["prefixItems", 3, "maximum"]), + "$[3]", + ), + ) + + def test_prefixItems_with_items(self): + schema = { + "items": {"type": "string"}, + "prefixItems": [{}], + } + validator = validators.Draft202012Validator(schema) + e1, e2 = validator.iter_errors(["foo", 2, "bar", 4, "baz"]) + self.assertEqual( + ( + e1.message, + e1.validator, + e1.validator_value, + e1.instance, + e1.absolute_path, + e1.schema, + e1.schema_path, + e1.json_path, + ), + ( + "2 is not of type 'string'", + "type", + "string", + 2, + deque([1]), + {"type": "string"}, + deque(["items", "type"]), + "$[1]", + ), + ) + self.assertEqual( + ( + e2.message, + e2.validator, + e2.validator_value, + e2.instance, + e2.absolute_path, + e2.schema, + e2.schema_path, + e2.json_path, + ), + ( + "4 is not of type 'string'", + "type", + "string", + 4, + deque([3]), + {"type": "string"}, + deque(["items", "type"]), + "$[3]", + ), + ) + + def test_contains_too_many(self): + """ + `contains` + `maxContains` produces only one error, even if there are + many more incorrectly matching elements. + """ + schema = {"contains": {"type": "string"}, "maxContains": 2} + validator = validators.Draft202012Validator(schema) + error, = validator.iter_errors(["foo", 2, "bar", 4, "baz", "quux"]) + self.assertEqual( + ( + error.message, + error.validator, + error.validator_value, + error.instance, + error.absolute_path, + error.schema, + error.schema_path, + error.json_path, + ), + ( + "Too many items match the given schema (expected at most 2)", + "maxContains", + 2, + ["foo", 2, "bar", 4, "baz", "quux"], + deque([]), + {"contains": {"type": "string"}, "maxContains": 2}, + deque(["contains"]), + "$", + ), + ) + + def test_contains_too_few(self): + schema = {"contains": {"type": "string"}, "minContains": 2} + validator = validators.Draft202012Validator(schema) + error, = validator.iter_errors(["foo", 2, 4]) + self.assertEqual( + ( + error.message, + error.validator, + error.validator_value, + error.instance, + error.absolute_path, + error.schema, + error.schema_path, + error.json_path, + ), + ( + ( + "Too few items match the given schema " + "(expected at least 2 but only 1 matched)" + ), + "minContains", + 2, + ["foo", 2, 4], + deque([]), + {"contains": {"type": "string"}, "minContains": 2}, + deque(["contains"]), + "$", + ), + ) + + def test_contains_none(self): + schema = {"contains": {"type": "string"}, "minContains": 2} + validator = validators.Draft202012Validator(schema) + error, = validator.iter_errors([2, 4]) + self.assertEqual( + ( + error.message, + error.validator, + error.validator_value, + error.instance, + error.absolute_path, + error.schema, + error.schema_path, + error.json_path, + ), + ( + "[2, 4] does not contain items matching the given schema", + "contains", + {"type": "string"}, + [2, 4], + deque([]), + {"contains": {"type": "string"}, "minContains": 2}, + deque(["contains"]), + "$", + ), + ) + + def test_ref_sibling(self): + schema = { + "$defs": {"foo": {"required": ["bar"]}}, + "properties": { + "aprop": { + "$ref": "#/$defs/foo", + "required": ["baz"], + }, + }, + } + + validator = validators.Draft202012Validator(schema) + e1, e2 = validator.iter_errors({"aprop": {}}) + self.assertEqual( + ( + e1.message, + e1.validator, + e1.validator_value, + e1.instance, + e1.absolute_path, + e1.schema, + e1.schema_path, + e1.relative_schema_path, + e1.json_path, + ), + ( + "'bar' is a required property", + "required", + ["bar"], + {}, + deque(["aprop"]), + {"required": ["bar"]}, + deque(["properties", "aprop", "required"]), + deque(["properties", "aprop", "required"]), + "$.aprop", + ), + ) + self.assertEqual( + ( + e2.message, + e2.validator, + e2.validator_value, + e2.instance, + e2.absolute_path, + e2.schema, + e2.schema_path, + e2.relative_schema_path, + e2.json_path, + ), + ( + "'baz' is a required property", + "required", + ["baz"], + {}, + deque(["aprop"]), + {"$ref": "#/$defs/foo", "required": ["baz"]}, + deque(["properties", "aprop", "required"]), + deque(["properties", "aprop", "required"]), + "$.aprop", + ), + ) + + +class MetaSchemaTestsMixin: + # TODO: These all belong upstream + def test_invalid_properties(self): + with self.assertRaises(exceptions.SchemaError): + self.Validator.check_schema({"properties": 12}) + + def test_minItems_invalid_string(self): + with self.assertRaises(exceptions.SchemaError): + # needs to be an integer + self.Validator.check_schema({"minItems": "1"}) + + def test_enum_allows_empty_arrays(self): + """ + Technically, all the spec says is they SHOULD have elements, not MUST. + + (As of Draft 6. Previous drafts do say MUST). + + See #529. + """ + if self.Validator in { + validators.Draft3Validator, + validators.Draft4Validator, + }: + with self.assertRaises(exceptions.SchemaError): + self.Validator.check_schema({"enum": []}) + else: + self.Validator.check_schema({"enum": []}) + + def test_enum_allows_non_unique_items(self): + """ + Technically, all the spec says is they SHOULD be unique, not MUST. + + (As of Draft 6. Previous drafts do say MUST). + + See #529. + """ + if self.Validator in { + validators.Draft3Validator, + validators.Draft4Validator, + }: + with self.assertRaises(exceptions.SchemaError): + self.Validator.check_schema({"enum": [12, 12]}) + else: + self.Validator.check_schema({"enum": [12, 12]}) + + def test_schema_with_invalid_regex(self): + with self.assertRaises(exceptions.SchemaError): + self.Validator.check_schema({"pattern": "*notaregex"}) + + def test_schema_with_invalid_regex_with_disabled_format_validation(self): + self.Validator.check_schema( + {"pattern": "*notaregex"}, + format_checker=None, + ) + + +class ValidatorTestMixin(MetaSchemaTestsMixin): + def test_it_implements_the_validator_protocol(self): + self.assertIsInstance(self.Validator({}), protocols.Validator) + + def test_valid_instances_are_valid(self): + schema, instance = self.valid + self.assertTrue(self.Validator(schema).is_valid(instance)) + + def test_invalid_instances_are_not_valid(self): + schema, instance = self.invalid + self.assertFalse(self.Validator(schema).is_valid(instance)) + + def test_non_existent_properties_are_ignored(self): + self.Validator({object(): object()}).validate(instance=object()) + + def test_evolve(self): + schema, format_checker = {"type": "integer"}, FormatChecker() + original = self.Validator( + schema, + format_checker=format_checker, + ) + new = original.evolve( + schema={"type": "string"}, + format_checker=self.Validator.FORMAT_CHECKER, + ) + + expected = self.Validator( + {"type": "string"}, + format_checker=self.Validator.FORMAT_CHECKER, + _resolver=new._resolver, + ) + + self.assertEqual(new, expected) + self.assertNotEqual(new, original) + + def test_evolve_with_subclass(self): + """ + Subclassing validators isn't supported public API, but some users have + done it, because we don't actually error entirely when it's done :/ + + We need to deprecate doing so first to help as many of these users + ensure they can move to supported APIs, but this test ensures that in + the interim, we haven't broken those users. + """ + + with self.assertWarns(DeprecationWarning): + @define + class OhNo(self.Validator): + foo = field(factory=lambda: [1, 2, 3]) + _bar = field(default=37) + + validator = OhNo({}, bar=12) + self.assertEqual(validator.foo, [1, 2, 3]) + + new = validator.evolve(schema={"type": "integer"}) + self.assertEqual(new.foo, [1, 2, 3]) + self.assertEqual(new._bar, 12) + + def test_is_type_is_true_for_valid_type(self): + self.assertTrue(self.Validator({}).is_type("foo", "string")) + + def test_is_type_is_false_for_invalid_type(self): + self.assertFalse(self.Validator({}).is_type("foo", "array")) + + def test_is_type_evades_bool_inheriting_from_int(self): + self.assertFalse(self.Validator({}).is_type(True, "integer")) + self.assertFalse(self.Validator({}).is_type(True, "number")) + + def test_it_can_validate_with_decimals(self): + schema = {"items": {"type": "number"}} + Validator = validators.extend( + self.Validator, + type_checker=self.Validator.TYPE_CHECKER.redefine( + "number", + lambda checker, thing: isinstance( + thing, (int, float, Decimal), + ) and not isinstance(thing, bool), + ), + ) + + validator = Validator(schema) + validator.validate([1, 1.1, Decimal(1) / Decimal(8)]) + + invalid = ["foo", {}, [], True, None] + self.assertEqual( + [error.instance for error in validator.iter_errors(invalid)], + invalid, + ) + + def test_it_returns_true_for_formats_it_does_not_know_about(self): + validator = self.Validator( + {"format": "carrot"}, format_checker=FormatChecker(), + ) + validator.validate("bugs") + + def test_it_does_not_validate_formats_by_default(self): + validator = self.Validator({}) + self.assertIsNone(validator.format_checker) + + def test_it_validates_formats_if_a_checker_is_provided(self): + checker = FormatChecker() + bad = ValueError("Bad!") + + @checker.checks("foo", raises=ValueError) + def check(value): + if value == "good": + return True + elif value == "bad": + raise bad + else: # pragma: no cover + self.fail(f"What is {value}? [Baby Don't Hurt Me]") + + validator = self.Validator( + {"format": "foo"}, format_checker=checker, + ) + + validator.validate("good") + with self.assertRaises(exceptions.ValidationError) as cm: + validator.validate("bad") + + # Make sure original cause is attached + self.assertIs(cm.exception.cause, bad) + + def test_non_string_custom_type(self): + non_string_type = object() + schema = {"type": [non_string_type]} + Crazy = validators.extend( + self.Validator, + type_checker=self.Validator.TYPE_CHECKER.redefine( + non_string_type, + lambda checker, thing: isinstance(thing, int), + ), + ) + Crazy(schema).validate(15) + + def test_it_properly_formats_tuples_in_errors(self): + """ + A tuple instance properly formats validation errors for uniqueItems. + + See #224 + """ + TupleValidator = validators.extend( + self.Validator, + type_checker=self.Validator.TYPE_CHECKER.redefine( + "array", + lambda checker, thing: isinstance(thing, tuple), + ), + ) + with self.assertRaises(exceptions.ValidationError) as e: + TupleValidator({"uniqueItems": True}).validate((1, 1)) + self.assertIn("(1, 1) has non-unique elements", str(e.exception)) + + def test_check_redefined_sequence(self): + """ + Allow array to validate against another defined sequence type + """ + schema = {"type": "array", "uniqueItems": True} + MyMapping = namedtuple("MyMapping", "a, b") + Validator = validators.extend( + self.Validator, + type_checker=self.Validator.TYPE_CHECKER.redefine_many( + { + "array": lambda checker, thing: isinstance( + thing, (list, deque), + ), + "object": lambda checker, thing: isinstance( + thing, (dict, MyMapping), + ), + }, + ), + ) + validator = Validator(schema) + + valid_instances = [ + deque(["a", None, "1", "", True]), + deque([[False], [0]]), + [deque([False]), deque([0])], + [[deque([False])], [deque([0])]], + [[[[[deque([False])]]]], [[[[deque([0])]]]]], + [deque([deque([False])]), deque([deque([0])])], + [MyMapping("a", 0), MyMapping("a", False)], + [ + MyMapping("a", [deque([0])]), + MyMapping("a", [deque([False])]), + ], + [ + MyMapping("a", [MyMapping("a", deque([0]))]), + MyMapping("a", [MyMapping("a", deque([False]))]), + ], + [deque(deque(deque([False]))), deque(deque(deque([0])))], + ] + + for instance in valid_instances: + validator.validate(instance) + + invalid_instances = [ + deque(["a", "b", "a"]), + deque([[False], [False]]), + [deque([False]), deque([False])], + [[deque([False])], [deque([False])]], + [[[[[deque([False])]]]], [[[[deque([False])]]]]], + [deque([deque([False])]), deque([deque([False])])], + [MyMapping("a", False), MyMapping("a", False)], + [ + MyMapping("a", [deque([False])]), + MyMapping("a", [deque([False])]), + ], + [ + MyMapping("a", [MyMapping("a", deque([False]))]), + MyMapping("a", [MyMapping("a", deque([False]))]), + ], + [deque(deque(deque([False]))), deque(deque(deque([False])))], + ] + + for instance in invalid_instances: + with self.assertRaises(exceptions.ValidationError): + validator.validate(instance) + + def test_it_creates_a_ref_resolver_if_not_provided(self): + with self.assertWarns(DeprecationWarning): + resolver = self.Validator({}).resolver + self.assertIsInstance(resolver, validators._RefResolver) + + def test_it_upconverts_from_deprecated_RefResolvers(self): + ref, schema = "someCoolRef", {"type": "integer"} + resolver = validators._RefResolver("", {}, store={ref: schema}) + validator = self.Validator({"$ref": ref}, resolver=resolver) + + with self.assertRaises(exceptions.ValidationError): + validator.validate(None) + + def test_it_upconverts_from_yet_older_deprecated_legacy_RefResolvers(self): + """ + Legacy RefResolvers support only the context manager form of + resolution. + """ + + class LegacyRefResolver: + @contextmanager + def resolving(this, ref): + self.assertEqual(ref, "the ref") + yield {"type": "integer"} + + resolver = LegacyRefResolver() + schema = {"$ref": "the ref"} + + with self.assertRaises(exceptions.ValidationError): + self.Validator(schema, resolver=resolver).validate(None) + + +class AntiDraft6LeakMixin: + """ + Make sure functionality from draft 6 doesn't leak backwards in time. + """ + + def test_True_is_not_a_schema(self): + with self.assertRaises(exceptions.SchemaError) as e: + self.Validator.check_schema(True) + self.assertIn("True is not of type", str(e.exception)) + + def test_False_is_not_a_schema(self): + with self.assertRaises(exceptions.SchemaError) as e: + self.Validator.check_schema(False) + self.assertIn("False is not of type", str(e.exception)) + + def test_True_is_not_a_schema_even_if_you_forget_to_check(self): + with self.assertRaises(Exception) as e: + self.Validator(True).validate(12) + self.assertNotIsInstance(e.exception, exceptions.ValidationError) + + def test_False_is_not_a_schema_even_if_you_forget_to_check(self): + with self.assertRaises(Exception) as e: + self.Validator(False).validate(12) + self.assertNotIsInstance(e.exception, exceptions.ValidationError) + + +class TestDraft3Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase): + Validator = validators.Draft3Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + def test_any_type_is_valid_for_type_any(self): + validator = self.Validator({"type": "any"}) + validator.validate(object()) + + def test_any_type_is_redefinable(self): + """ + Sigh, because why not. + """ + Crazy = validators.extend( + self.Validator, + type_checker=self.Validator.TYPE_CHECKER.redefine( + "any", lambda checker, thing: isinstance(thing, int), + ), + ) + validator = Crazy({"type": "any"}) + validator.validate(12) + with self.assertRaises(exceptions.ValidationError): + validator.validate("foo") + + def test_is_type_is_true_for_any_type(self): + self.assertTrue(self.Validator({"type": "any"}).is_valid(object())) + + def test_is_type_does_not_evade_bool_if_it_is_being_tested(self): + self.assertTrue(self.Validator({}).is_type(True, "boolean")) + self.assertTrue(self.Validator({"type": "any"}).is_valid(True)) + + +class TestDraft4Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase): + Validator = validators.Draft4Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + +class TestDraft6Validator(ValidatorTestMixin, TestCase): + Validator = validators.Draft6Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + +class TestDraft7Validator(ValidatorTestMixin, TestCase): + Validator = validators.Draft7Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + +class TestDraft201909Validator(ValidatorTestMixin, TestCase): + Validator = validators.Draft201909Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + +class TestDraft202012Validator(ValidatorTestMixin, TestCase): + Validator = validators.Draft202012Validator + valid: tuple[dict, dict] = ({}, {}) + invalid = {"type": "integer"}, "foo" + + +class TestLatestValidator(TestCase): + """ + These really apply to multiple versions but are easiest to test on one. + """ + + def test_ref_resolvers_may_have_boolean_schemas_stored(self): + ref = "someCoolRef" + schema = {"$ref": ref} + resolver = validators._RefResolver("", {}, store={ref: False}) + validator = validators._LATEST_VERSION(schema, resolver=resolver) + + with self.assertRaises(exceptions.ValidationError): + validator.validate(None) + + +class TestValidatorFor(TestCase): + def test_draft_3(self): + schema = {"$schema": "http://json-schema.org/draft-03/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft3Validator, + ) + + schema = {"$schema": "http://json-schema.org/draft-03/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft3Validator, + ) + + def test_draft_4(self): + schema = {"$schema": "http://json-schema.org/draft-04/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft4Validator, + ) + + schema = {"$schema": "http://json-schema.org/draft-04/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft4Validator, + ) + + def test_draft_6(self): + schema = {"$schema": "http://json-schema.org/draft-06/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft6Validator, + ) + + schema = {"$schema": "http://json-schema.org/draft-06/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft6Validator, + ) + + def test_draft_7(self): + schema = {"$schema": "http://json-schema.org/draft-07/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft7Validator, + ) + + schema = {"$schema": "http://json-schema.org/draft-07/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft7Validator, + ) + + def test_draft_201909(self): + schema = {"$schema": "https://json-schema.org/draft/2019-09/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft201909Validator, + ) + + schema = {"$schema": "https://json-schema.org/draft/2019-09/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft201909Validator, + ) + + def test_draft_202012(self): + schema = {"$schema": "https://json-schema.org/draft/2020-12/schema"} + self.assertIs( + validators.validator_for(schema), + validators.Draft202012Validator, + ) + + schema = {"$schema": "https://json-schema.org/draft/2020-12/schema#"} + self.assertIs( + validators.validator_for(schema), + validators.Draft202012Validator, + ) + + def test_True(self): + self.assertIs( + validators.validator_for(True), + validators._LATEST_VERSION, + ) + + def test_False(self): + self.assertIs( + validators.validator_for(False), + validators._LATEST_VERSION, + ) + + def test_custom_validator(self): + Validator = validators.create( + meta_schema={"id": "meta schema id"}, + version="12", + id_of=lambda s: s.get("id", ""), + ) + schema = {"$schema": "meta schema id"} + self.assertIs( + validators.validator_for(schema), + Validator, + ) + + def test_custom_validator_draft6(self): + Validator = validators.create( + meta_schema={"$id": "meta schema $id"}, + version="13", + ) + schema = {"$schema": "meta schema $id"} + self.assertIs( + validators.validator_for(schema), + Validator, + ) + + def test_validator_for_jsonschema_default(self): + self.assertIs(validators.validator_for({}), validators._LATEST_VERSION) + + def test_validator_for_custom_default(self): + self.assertIs(validators.validator_for({}, default=None), None) + + def test_warns_if_meta_schema_specified_was_not_found(self): + with self.assertWarns(DeprecationWarning) as cm: + validators.validator_for(schema={"$schema": "unknownSchema"}) + + self.assertEqual(cm.filename, __file__) + self.assertEqual( + str(cm.warning), + "The metaschema specified by $schema was not found. " + "Using the latest draft to validate, but this will raise " + "an error in the future.", + ) + + def test_does_not_warn_if_meta_schema_is_unspecified(self): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + validators.validator_for(schema={}, default={}) + self.assertFalse(w) + + def test_validator_for_custom_default_with_schema(self): + schema, default = {"$schema": "mailto:foo@example.com"}, object() + self.assertIs(validators.validator_for(schema, default), default) + + +class TestValidate(TestCase): + def assertUses(self, schema, Validator): + result = [] + with mock.patch.object(Validator, "check_schema", result.append): + validators.validate({}, schema) + self.assertEqual(result, [schema]) + + def test_draft3_validator_is_chosen(self): + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-03/schema#"}, + Validator=validators.Draft3Validator, + ) + # Make sure it works without the empty fragment + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-03/schema"}, + Validator=validators.Draft3Validator, + ) + + def test_draft4_validator_is_chosen(self): + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-04/schema#"}, + Validator=validators.Draft4Validator, + ) + # Make sure it works without the empty fragment + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-04/schema"}, + Validator=validators.Draft4Validator, + ) + + def test_draft6_validator_is_chosen(self): + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-06/schema#"}, + Validator=validators.Draft6Validator, + ) + # Make sure it works without the empty fragment + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-06/schema"}, + Validator=validators.Draft6Validator, + ) + + def test_draft7_validator_is_chosen(self): + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-07/schema#"}, + Validator=validators.Draft7Validator, + ) + # Make sure it works without the empty fragment + self.assertUses( + schema={"$schema": "http://json-schema.org/draft-07/schema"}, + Validator=validators.Draft7Validator, + ) + + def test_draft202012_validator_is_chosen(self): + self.assertUses( + schema={ + "$schema": "https://json-schema.org/draft/2020-12/schema#", + }, + Validator=validators.Draft202012Validator, + ) + # Make sure it works without the empty fragment + self.assertUses( + schema={ + "$schema": "https://json-schema.org/draft/2020-12/schema", + }, + Validator=validators.Draft202012Validator, + ) + + def test_draft202012_validator_is_the_default(self): + self.assertUses(schema={}, Validator=validators.Draft202012Validator) + + def test_validation_error_message(self): + with self.assertRaises(exceptions.ValidationError) as e: + validators.validate(12, {"type": "string"}) + self.assertRegex( + str(e.exception), + "(?s)Failed validating '.*' in schema.*On instance", + ) + + def test_schema_error_message(self): + with self.assertRaises(exceptions.SchemaError) as e: + validators.validate(12, {"type": 12}) + self.assertRegex( + str(e.exception), + "(?s)Failed validating '.*' in metaschema.*On schema", + ) + + def test_it_uses_best_match(self): + schema = { + "oneOf": [ + {"type": "number", "minimum": 20}, + {"type": "array"}, + ], + } + with self.assertRaises(exceptions.ValidationError) as e: + validators.validate(12, schema) + self.assertIn("12 is less than the minimum of 20", str(e.exception)) + + +class TestThreading(TestCase): + """ + Threading-related functionality tests. + + jsonschema doesn't promise thread safety, and its validation behavior + across multiple threads may change at any time, but that means it isn't + safe to share *validators* across threads, not that anytime one has + multiple threads that jsonschema won't work (it certainly is intended to). + + These tests ensure that this minimal level of functionality continues to + work. + """ + + def test_validation_across_a_second_thread(self): + failed = [] + + def validate(): + try: + validators.validate(instance=37, schema=True) + except: # pragma: no cover # noqa: E722 + failed.append(sys.exc_info()) + + validate() # just verify it succeeds + + from threading import Thread + thread = Thread(target=validate) + thread.start() + thread.join() + self.assertEqual((thread.is_alive(), failed), (False, [])) + + +class TestReferencing(TestCase): + def test_registry_with_retrieve(self): + def retrieve(uri): + return DRAFT202012.create_resource({"type": "integer"}) + + registry = referencing.Registry(retrieve=retrieve) + schema = {"$ref": "https://example.com/"} + validator = validators.Draft202012Validator(schema, registry=registry) + + self.assertEqual( + (validator.is_valid(12), validator.is_valid("foo")), + (True, False), + ) + + def test_custom_registries_do_not_autoretrieve_remote_resources(self): + registry = referencing.Registry() + schema = {"$ref": "https://example.com/"} + validator = validators.Draft202012Validator(schema, registry=registry) + + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + with self.assertRaises(referencing.exceptions.Unresolvable): + validator.validate(12) + self.assertFalse(w) + + +class TestRefResolver(TestCase): + + base_uri = "" + stored_uri = "foo://stored" + stored_schema = {"stored": "schema"} + + def setUp(self): + self.referrer = {} + self.store = {self.stored_uri: self.stored_schema} + self.resolver = validators._RefResolver( + self.base_uri, self.referrer, self.store, + ) + + def test_it_does_not_retrieve_schema_urls_from_the_network(self): + ref = validators.Draft3Validator.META_SCHEMA["id"] + with mock.patch.object(self.resolver, "resolve_remote") as patched: # noqa: SIM117 + with self.resolver.resolving(ref) as resolved: + pass + self.assertEqual(resolved, validators.Draft3Validator.META_SCHEMA) + self.assertFalse(patched.called) + + def test_it_resolves_local_refs(self): + ref = "#/properties/foo" + self.referrer["properties"] = {"foo": object()} + with self.resolver.resolving(ref) as resolved: + self.assertEqual(resolved, self.referrer["properties"]["foo"]) + + def test_it_resolves_local_refs_with_id(self): + schema = {"id": "http://bar/schema#", "a": {"foo": "bar"}} + resolver = validators._RefResolver.from_schema( + schema, + id_of=lambda schema: schema.get("id", ""), + ) + with resolver.resolving("#/a") as resolved: + self.assertEqual(resolved, schema["a"]) + with resolver.resolving("http://bar/schema#/a") as resolved: + self.assertEqual(resolved, schema["a"]) + + def test_it_retrieves_stored_refs(self): + with self.resolver.resolving(self.stored_uri) as resolved: + self.assertIs(resolved, self.stored_schema) + + self.resolver.store["cached_ref"] = {"foo": 12} + with self.resolver.resolving("cached_ref#/foo") as resolved: + self.assertEqual(resolved, 12) + + def test_it_retrieves_unstored_refs_via_requests(self): + ref = "http://bar#baz" + schema = {"baz": 12} + + if "requests" in sys.modules: # pragma: no cover + self.addCleanup( + sys.modules.__setitem__, "requests", sys.modules["requests"], + ) + sys.modules["requests"] = ReallyFakeRequests({"http://bar": schema}) + + with self.resolver.resolving(ref) as resolved: + self.assertEqual(resolved, 12) + + def test_it_retrieves_unstored_refs_via_urlopen(self): + ref = "http://bar#baz" + schema = {"baz": 12} + + if "requests" in sys.modules: # pragma: no cover + self.addCleanup( + sys.modules.__setitem__, "requests", sys.modules["requests"], + ) + sys.modules["requests"] = None + + @contextmanager + def fake_urlopen(url): + self.assertEqual(url, "http://bar") + yield BytesIO(json.dumps(schema).encode("utf8")) + + with mock.patch("urllib.request.urlopen", new=fake_urlopen): # noqa: SIM117 + with self.resolver.resolving(ref) as resolved: + pass + self.assertEqual(resolved, 12) + + def test_it_retrieves_local_refs_via_urlopen(self): + with tempfile.NamedTemporaryFile(delete=False, mode="wt") as tempf: + self.addCleanup(os.remove, tempf.name) + json.dump({"foo": "bar"}, tempf) + + ref = f"file://{pathname2url(tempf.name)}#foo" + with self.resolver.resolving(ref) as resolved: + self.assertEqual(resolved, "bar") + + def test_it_can_construct_a_base_uri_from_a_schema(self): + schema = {"id": "foo"} + resolver = validators._RefResolver.from_schema( + schema, + id_of=lambda schema: schema.get("id", ""), + ) + self.assertEqual(resolver.base_uri, "foo") + self.assertEqual(resolver.resolution_scope, "foo") + with resolver.resolving("") as resolved: + self.assertEqual(resolved, schema) + with resolver.resolving("#") as resolved: + self.assertEqual(resolved, schema) + with resolver.resolving("foo") as resolved: + self.assertEqual(resolved, schema) + with resolver.resolving("foo#") as resolved: + self.assertEqual(resolved, schema) + + def test_it_can_construct_a_base_uri_from_a_schema_without_id(self): + schema = {} + resolver = validators._RefResolver.from_schema(schema) + self.assertEqual(resolver.base_uri, "") + self.assertEqual(resolver.resolution_scope, "") + with resolver.resolving("") as resolved: + self.assertEqual(resolved, schema) + with resolver.resolving("#") as resolved: + self.assertEqual(resolved, schema) + + def test_custom_uri_scheme_handlers(self): + def handler(url): + self.assertEqual(url, ref) + return schema + + schema = {"foo": "bar"} + ref = "foo://bar" + resolver = validators._RefResolver("", {}, handlers={"foo": handler}) + with resolver.resolving(ref) as resolved: + self.assertEqual(resolved, schema) + + def test_cache_remote_on(self): + response = [object()] + + def handler(url): + try: + return response.pop() + except IndexError: # pragma: no cover + self.fail("Response must not have been cached!") + + ref = "foo://bar" + resolver = validators._RefResolver( + "", {}, cache_remote=True, handlers={"foo": handler}, + ) + with resolver.resolving(ref): + pass + with resolver.resolving(ref): + pass + + def test_cache_remote_off(self): + response = [object()] + + def handler(url): + try: + return response.pop() + except IndexError: # pragma: no cover + self.fail("Handler called twice!") + + ref = "foo://bar" + resolver = validators._RefResolver( + "", {}, cache_remote=False, handlers={"foo": handler}, + ) + with resolver.resolving(ref): + pass + + def test_if_you_give_it_junk_you_get_a_resolution_error(self): + error = ValueError("Oh no! What's this?") + + def handler(url): + raise error + + ref = "foo://bar" + resolver = validators._RefResolver("", {}, handlers={"foo": handler}) + with self.assertRaises(exceptions._RefResolutionError) as err: # noqa: SIM117 + with resolver.resolving(ref): + self.fail("Shouldn't get this far!") # pragma: no cover + self.assertEqual(err.exception, exceptions._RefResolutionError(error)) + + def test_helpful_error_message_on_failed_pop_scope(self): + resolver = validators._RefResolver("", {}) + resolver.pop_scope() + with self.assertRaises(exceptions._RefResolutionError) as exc: + resolver.pop_scope() + self.assertIn("Failed to pop the scope", str(exc.exception)) + + def test_pointer_within_schema_with_different_id(self): + """ + See #1085. + """ + schema = validators.Draft7Validator.META_SCHEMA + one = validators._RefResolver("", schema) + validator = validators.Draft7Validator(schema, resolver=one) + self.assertFalse(validator.is_valid({"maxLength": "foo"})) + + another = { + "allOf": [{"$ref": validators.Draft7Validator.META_SCHEMA["$id"]}], + } + two = validators._RefResolver("", another) + validator = validators.Draft7Validator(another, resolver=two) + self.assertFalse(validator.is_valid({"maxLength": "foo"})) + + def test_newly_created_validator_with_ref_resolver(self): + """ + See https://github.com/python-jsonschema/jsonschema/issues/1061#issuecomment-1624266555. + """ + + def handle(uri): + self.assertEqual(uri, "http://example.com/foo") + return {"type": "integer"} + + resolver = validators._RefResolver("", {}, handlers={"http": handle}) + Validator = validators.create( + meta_schema={}, + validators=validators.Draft4Validator.VALIDATORS, + ) + schema = {"$id": "http://example.com/bar", "$ref": "foo"} + validator = Validator(schema, resolver=resolver) + self.assertEqual( + (validator.is_valid({}), validator.is_valid(37)), + (False, True), + ) + + def test_refresolver_with_pointer_in_schema_with_no_id(self): + """ + See https://github.com/python-jsonschema/jsonschema/issues/1124#issuecomment-1632574249. + """ + + schema = { + "properties": {"x": {"$ref": "#/definitions/x"}}, + "definitions": {"x": {"type": "integer"}}, + } + + validator = validators.Draft202012Validator( + schema, + resolver=validators._RefResolver("", schema), + ) + self.assertEqual( + (validator.is_valid({"x": "y"}), validator.is_valid({"x": 37})), + (False, True), + ) + + + +def sorted_errors(errors): + def key(error): + return ( + [str(e) for e in error.path], + [str(e) for e in error.schema_path], + ) + return sorted(errors, key=key) + + +@define +class ReallyFakeRequests: + + _responses: dict[str, Any] + + def get(self, url): + response = self._responses.get(url) + if url is None: # pragma: no cover + raise ValueError("Unknown URL: " + repr(url)) + return _ReallyFakeJSONResponse(json.dumps(response)) + + +@define +class _ReallyFakeJSONResponse: + + _response: str + + def json(self): + return json.loads(self._response) diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__init__.py b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24a69c45d660889c5f954c278ecad6dfda9b7e29 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/test_all_concrete_validators_match_protocol.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/test_all_concrete_validators_match_protocol.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..07e75765d9fb1433994735b63726abdeeefb4e4c Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/__pycache__/test_all_concrete_validators_match_protocol.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema/tests/typing/test_all_concrete_validators_match_protocol.py b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/test_all_concrete_validators_match_protocol.py new file mode 100644 index 0000000000000000000000000000000000000000..63e8bd4052055e387854ae8a4bb906d78502cb69 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema/tests/typing/test_all_concrete_validators_match_protocol.py @@ -0,0 +1,38 @@ +""" +This module acts as a test that type checkers will allow each validator +class to be assigned to a variable of type `type[Validator]` + +The assignation is only valid if type checkers recognize each Validator +implementation as a valid implementer of the protocol. +""" +from jsonschema.protocols import Validator +from jsonschema.validators import ( + Draft3Validator, + Draft4Validator, + Draft6Validator, + Draft7Validator, + Draft201909Validator, + Draft202012Validator, +) + +my_validator: type[Validator] + +my_validator = Draft3Validator +my_validator = Draft4Validator +my_validator = Draft6Validator +my_validator = Draft7Validator +my_validator = Draft201909Validator +my_validator = Draft202012Validator + + +# in order to confirm that none of the above were incorrectly typed as 'Any' +# ensure that each of these assignments to a non-validator variable requires an +# ignore +none_var: None + +none_var = Draft3Validator # type: ignore[assignment] +none_var = Draft4Validator # type: ignore[assignment] +none_var = Draft6Validator # type: ignore[assignment] +none_var = Draft7Validator # type: ignore[assignment] +none_var = Draft201909Validator # type: ignore[assignment] +none_var = Draft202012Validator # type: ignore[assignment] diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications-2025.9.1.dist-info/licenses/COPYING b/python/user_packages/Python313/site-packages/jsonschema_specifications-2025.9.1.dist-info/licenses/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..a9f853e43069b8e3f8a156a4af2b1198a004230d --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications-2025.9.1.dist-info/licenses/COPYING @@ -0,0 +1,19 @@ +Copyright (c) 2022 Julian Berman + +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. diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..740ec31a879172abf049334308113f7ea0485828 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/_core.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/_core.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c57c24b76b627f5d359e4c3309131c5cec25fe0b Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema_specifications/__pycache__/_core.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..2248a0c80bbfc51b67863f848f60466f135cdb2b --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json @@ -0,0 +1,42 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/schema", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/core": true, + "https://json-schema.org/draft/2019-09/vocab/applicator": true, + "https://json-schema.org/draft/2019-09/vocab/validation": true, + "https://json-schema.org/draft/2019-09/vocab/meta-data": true, + "https://json-schema.org/draft/2019-09/vocab/format": false, + "https://json-schema.org/draft/2019-09/vocab/content": true + }, + "$recursiveAnchor": true, + + "title": "Core and Validation specifications meta-schema", + "allOf": [ + {"$ref": "meta/core"}, + {"$ref": "meta/applicator"}, + {"$ref": "meta/validation"}, + {"$ref": "meta/meta-data"}, + {"$ref": "meta/format"}, + {"$ref": "meta/content"} + ], + "type": ["object", "boolean"], + "properties": { + "definitions": { + "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.", + "type": "object", + "additionalProperties": { "$recursiveRef": "#" }, + "default": {} + }, + "dependencies": { + "$comment": "\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"", + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$recursiveRef": "#" }, + { "$ref": "meta/validation#/$defs/stringArray" } + ] + } + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator new file mode 100644 index 0000000000000000000000000000000000000000..24a1cc4f4f54b5a556de93c2799853b31e78e512 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator @@ -0,0 +1,56 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/applicator", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/applicator": true + }, + "$recursiveAnchor": true, + + "title": "Applicator vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "additionalItems": { "$recursiveRef": "#" }, + "unevaluatedItems": { "$recursiveRef": "#" }, + "items": { + "anyOf": [ + { "$recursiveRef": "#" }, + { "$ref": "#/$defs/schemaArray" } + ] + }, + "contains": { "$recursiveRef": "#" }, + "additionalProperties": { "$recursiveRef": "#" }, + "unevaluatedProperties": { "$recursiveRef": "#" }, + "properties": { + "type": "object", + "additionalProperties": { "$recursiveRef": "#" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$recursiveRef": "#" }, + "propertyNames": { "format": "regex" }, + "default": {} + }, + "dependentSchemas": { + "type": "object", + "additionalProperties": { + "$recursiveRef": "#" + } + }, + "propertyNames": { "$recursiveRef": "#" }, + "if": { "$recursiveRef": "#" }, + "then": { "$recursiveRef": "#" }, + "else": { "$recursiveRef": "#" }, + "allOf": { "$ref": "#/$defs/schemaArray" }, + "anyOf": { "$ref": "#/$defs/schemaArray" }, + "oneOf": { "$ref": "#/$defs/schemaArray" }, + "not": { "$recursiveRef": "#" } + }, + "$defs": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$recursiveRef": "#" } + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content new file mode 100644 index 0000000000000000000000000000000000000000..f6752a8efbeb74a7b7b2e74cbb272c422a975363 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content @@ -0,0 +1,17 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/content", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/content": true + }, + "$recursiveAnchor": true, + + "title": "Content vocabulary meta-schema", + + "type": ["object", "boolean"], + "properties": { + "contentMediaType": { "type": "string" }, + "contentEncoding": { "type": "string" }, + "contentSchema": { "$recursiveRef": "#" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core new file mode 100644 index 0000000000000000000000000000000000000000..eb708a56044146bb7903fd59159725a0c693aefe --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core @@ -0,0 +1,57 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/core", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/core": true + }, + "$recursiveAnchor": true, + + "title": "Core vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "$id": { + "type": "string", + "format": "uri-reference", + "$comment": "Non-empty fragments not allowed.", + "pattern": "^[^#]*#?$" + }, + "$schema": { + "type": "string", + "format": "uri" + }, + "$anchor": { + "type": "string", + "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$" + }, + "$ref": { + "type": "string", + "format": "uri-reference" + }, + "$recursiveRef": { + "type": "string", + "format": "uri-reference" + }, + "$recursiveAnchor": { + "type": "boolean", + "default": false + }, + "$vocabulary": { + "type": "object", + "propertyNames": { + "type": "string", + "format": "uri" + }, + "additionalProperties": { + "type": "boolean" + } + }, + "$comment": { + "type": "string" + }, + "$defs": { + "type": "object", + "additionalProperties": { "$recursiveRef": "#" }, + "default": {} + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/format b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/format new file mode 100644 index 0000000000000000000000000000000000000000..09bbfdda972ca77cd26e290d70ab59db4bbe8a27 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/format @@ -0,0 +1,14 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/format", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/format": true + }, + "$recursiveAnchor": true, + + "title": "Format vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "format": { "type": "string" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data new file mode 100644 index 0000000000000000000000000000000000000000..da04cff6d346f26bfe5bd21b636609fecd583628 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data @@ -0,0 +1,37 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/meta-data", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/meta-data": true + }, + "$recursiveAnchor": true, + + "title": "Meta-data vocabulary meta-schema", + + "type": ["object", "boolean"], + "properties": { + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": true, + "deprecated": { + "type": "boolean", + "default": false + }, + "readOnly": { + "type": "boolean", + "default": false + }, + "writeOnly": { + "type": "boolean", + "default": false + }, + "examples": { + "type": "array", + "items": true + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation new file mode 100644 index 0000000000000000000000000000000000000000..9f59677b30c238f07a358c0c8ee72c3b710dc24d --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation @@ -0,0 +1,98 @@ +{ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://json-schema.org/draft/2019-09/meta/validation", + "$vocabulary": { + "https://json-schema.org/draft/2019-09/vocab/validation": true + }, + "$recursiveAnchor": true, + + "title": "Validation vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "multipleOf": { + "type": "number", + "exclusiveMinimum": 0 + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "number" + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "number" + }, + "maxLength": { "$ref": "#/$defs/nonNegativeInteger" }, + "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "maxItems": { "$ref": "#/$defs/nonNegativeInteger" }, + "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "maxContains": { "$ref": "#/$defs/nonNegativeInteger" }, + "minContains": { + "$ref": "#/$defs/nonNegativeInteger", + "default": 1 + }, + "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" }, + "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "required": { "$ref": "#/$defs/stringArray" }, + "dependentRequired": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/stringArray" + } + }, + "const": true, + "enum": { + "type": "array", + "items": true + }, + "type": { + "anyOf": [ + { "$ref": "#/$defs/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/$defs/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + } + }, + "$defs": { + "nonNegativeInteger": { + "type": "integer", + "minimum": 0 + }, + "nonNegativeIntegerDefault0": { + "$ref": "#/$defs/nonNegativeInteger", + "default": 0 + }, + "simpleTypes": { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "uniqueItems": true, + "default": [] + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..d5e2d31c3c88e61f4c204cb6616887bba7e105dd --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json @@ -0,0 +1,58 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/schema", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/core": true, + "https://json-schema.org/draft/2020-12/vocab/applicator": true, + "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, + "https://json-schema.org/draft/2020-12/vocab/validation": true, + "https://json-schema.org/draft/2020-12/vocab/meta-data": true, + "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, + "https://json-schema.org/draft/2020-12/vocab/content": true + }, + "$dynamicAnchor": "meta", + + "title": "Core and Validation specifications meta-schema", + "allOf": [ + {"$ref": "meta/core"}, + {"$ref": "meta/applicator"}, + {"$ref": "meta/unevaluated"}, + {"$ref": "meta/validation"}, + {"$ref": "meta/meta-data"}, + {"$ref": "meta/format-annotation"}, + {"$ref": "meta/content"} + ], + "type": ["object", "boolean"], + "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", + "properties": { + "definitions": { + "$comment": "\"definitions\" has been replaced by \"$defs\".", + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" }, + "deprecated": true, + "default": {} + }, + "dependencies": { + "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$dynamicRef": "#meta" }, + { "$ref": "meta/validation#/$defs/stringArray" } + ] + }, + "deprecated": true, + "default": {} + }, + "$recursiveAnchor": { + "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", + "$ref": "meta/core#/$defs/anchorString", + "deprecated": true + }, + "$recursiveRef": { + "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", + "$ref": "meta/core#/$defs/uriReferenceString", + "deprecated": true + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator new file mode 100644 index 0000000000000000000000000000000000000000..ca69923096f3a2e4fe5eb8152a92d87d146cf021 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator @@ -0,0 +1,48 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/applicator", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/applicator": true + }, + "$dynamicAnchor": "meta", + + "title": "Applicator vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "prefixItems": { "$ref": "#/$defs/schemaArray" }, + "items": { "$dynamicRef": "#meta" }, + "contains": { "$dynamicRef": "#meta" }, + "additionalProperties": { "$dynamicRef": "#meta" }, + "properties": { + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" }, + "propertyNames": { "format": "regex" }, + "default": {} + }, + "dependentSchemas": { + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" }, + "default": {} + }, + "propertyNames": { "$dynamicRef": "#meta" }, + "if": { "$dynamicRef": "#meta" }, + "then": { "$dynamicRef": "#meta" }, + "else": { "$dynamicRef": "#meta" }, + "allOf": { "$ref": "#/$defs/schemaArray" }, + "anyOf": { "$ref": "#/$defs/schemaArray" }, + "oneOf": { "$ref": "#/$defs/schemaArray" }, + "not": { "$dynamicRef": "#meta" } + }, + "$defs": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$dynamicRef": "#meta" } + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content new file mode 100644 index 0000000000000000000000000000000000000000..2f6e056a9ac2399582eaf05985a26acf9161f213 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content @@ -0,0 +1,17 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/content", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/content": true + }, + "$dynamicAnchor": "meta", + + "title": "Content vocabulary meta-schema", + + "type": ["object", "boolean"], + "properties": { + "contentEncoding": { "type": "string" }, + "contentMediaType": { "type": "string" }, + "contentSchema": { "$dynamicRef": "#meta" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core new file mode 100644 index 0000000000000000000000000000000000000000..dfc092d9646e1ea89e4d771bfcf2a4ca87eeac75 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core @@ -0,0 +1,51 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/core", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/core": true + }, + "$dynamicAnchor": "meta", + + "title": "Core vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "$id": { + "$ref": "#/$defs/uriReferenceString", + "$comment": "Non-empty fragments not allowed.", + "pattern": "^[^#]*#?$" + }, + "$schema": { "$ref": "#/$defs/uriString" }, + "$ref": { "$ref": "#/$defs/uriReferenceString" }, + "$anchor": { "$ref": "#/$defs/anchorString" }, + "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" }, + "$dynamicAnchor": { "$ref": "#/$defs/anchorString" }, + "$vocabulary": { + "type": "object", + "propertyNames": { "$ref": "#/$defs/uriString" }, + "additionalProperties": { + "type": "boolean" + } + }, + "$comment": { + "type": "string" + }, + "$defs": { + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" } + } + }, + "$defs": { + "anchorString": { + "type": "string", + "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$" + }, + "uriString": { + "type": "string", + "format": "uri" + }, + "uriReferenceString": { + "type": "string", + "format": "uri-reference" + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation new file mode 100644 index 0000000000000000000000000000000000000000..51ef7ea118c34e8ac3da66c973bae02b9e8325d8 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation @@ -0,0 +1,14 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/format-annotation": true + }, + "$dynamicAnchor": "meta", + + "title": "Format vocabulary meta-schema for annotation results", + "type": ["object", "boolean"], + "properties": { + "format": { "type": "string" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion new file mode 100644 index 0000000000000000000000000000000000000000..5e73fd7571e504990f7a055da960056f07dcdb19 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion @@ -0,0 +1,14 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/format-assertion": true + }, + "$dynamicAnchor": "meta", + + "title": "Format vocabulary meta-schema for assertion results", + "type": ["object", "boolean"], + "properties": { + "format": { "type": "string" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data new file mode 100644 index 0000000000000000000000000000000000000000..05cbc22afde5ebe6ba84957ca412277bde1e4b08 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data @@ -0,0 +1,37 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/meta-data", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/meta-data": true + }, + "$dynamicAnchor": "meta", + + "title": "Meta-data vocabulary meta-schema", + + "type": ["object", "boolean"], + "properties": { + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": true, + "deprecated": { + "type": "boolean", + "default": false + }, + "readOnly": { + "type": "boolean", + "default": false + }, + "writeOnly": { + "type": "boolean", + "default": false + }, + "examples": { + "type": "array", + "items": true + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated new file mode 100644 index 0000000000000000000000000000000000000000..5f62a3ffa20be07dc813d6b8a154fa8451d0dc61 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated @@ -0,0 +1,15 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/unevaluated": true + }, + "$dynamicAnchor": "meta", + + "title": "Unevaluated applicator vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "unevaluatedItems": { "$dynamicRef": "#meta" }, + "unevaluatedProperties": { "$dynamicRef": "#meta" } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation new file mode 100644 index 0000000000000000000000000000000000000000..606b87ba2ec213d63b9e2035a6acc4edcb4b8357 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation @@ -0,0 +1,98 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/meta/validation", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/validation": true + }, + "$dynamicAnchor": "meta", + + "title": "Validation vocabulary meta-schema", + "type": ["object", "boolean"], + "properties": { + "type": { + "anyOf": [ + { "$ref": "#/$defs/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/$defs/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + }, + "const": true, + "enum": { + "type": "array", + "items": true + }, + "multipleOf": { + "type": "number", + "exclusiveMinimum": 0 + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "number" + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "number" + }, + "maxLength": { "$ref": "#/$defs/nonNegativeInteger" }, + "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "maxItems": { "$ref": "#/$defs/nonNegativeInteger" }, + "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "maxContains": { "$ref": "#/$defs/nonNegativeInteger" }, + "minContains": { + "$ref": "#/$defs/nonNegativeInteger", + "default": 1 + }, + "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" }, + "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, + "required": { "$ref": "#/$defs/stringArray" }, + "dependentRequired": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/stringArray" + } + } + }, + "$defs": { + "nonNegativeInteger": { + "type": "integer", + "minimum": 0 + }, + "nonNegativeIntegerDefault0": { + "$ref": "#/$defs/nonNegativeInteger", + "default": 0 + }, + "simpleTypes": { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "uniqueItems": true, + "default": [] + } + } +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..8b26b1f89f9852e4f69f466dd7d718b21ba5b989 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json @@ -0,0 +1,172 @@ +{ + "$schema" : "http://json-schema.org/draft-03/schema#", + "id" : "http://json-schema.org/draft-03/schema#", + "type" : "object", + + "properties" : { + "type" : { + "type" : ["string", "array"], + "items" : { + "type" : ["string", {"$ref" : "#"}] + }, + "uniqueItems" : true, + "default" : "any" + }, + + "properties" : { + "type" : "object", + "additionalProperties" : {"$ref" : "#"}, + "default" : {} + }, + + "patternProperties" : { + "type" : "object", + "additionalProperties" : {"$ref" : "#"}, + "default" : {} + }, + + "additionalProperties" : { + "type" : [{"$ref" : "#"}, "boolean"], + "default" : {} + }, + + "items" : { + "type" : [{"$ref" : "#"}, "array"], + "items" : {"$ref" : "#"}, + "default" : {} + }, + + "additionalItems" : { + "type" : [{"$ref" : "#"}, "boolean"], + "default" : {} + }, + + "required" : { + "type" : "boolean", + "default" : false + }, + + "dependencies" : { + "type" : "object", + "additionalProperties" : { + "type" : ["string", "array", {"$ref" : "#"}], + "items" : { + "type" : "string" + } + }, + "default" : {} + }, + + "minimum" : { + "type" : "number" + }, + + "maximum" : { + "type" : "number" + }, + + "exclusiveMinimum" : { + "type" : "boolean", + "default" : false + }, + + "exclusiveMaximum" : { + "type" : "boolean", + "default" : false + }, + + "minItems" : { + "type" : "integer", + "minimum" : 0, + "default" : 0 + }, + + "maxItems" : { + "type" : "integer", + "minimum" : 0 + }, + + "uniqueItems" : { + "type" : "boolean", + "default" : false + }, + + "pattern" : { + "type" : "string", + "format" : "regex" + }, + + "minLength" : { + "type" : "integer", + "minimum" : 0, + "default" : 0 + }, + + "maxLength" : { + "type" : "integer" + }, + + "enum" : { + "type" : "array", + "minItems" : 1, + "uniqueItems" : true + }, + + "default" : { + "type" : "any" + }, + + "title" : { + "type" : "string" + }, + + "description" : { + "type" : "string" + }, + + "format" : { + "type" : "string" + }, + + "divisibleBy" : { + "type" : "number", + "minimum" : 0, + "exclusiveMinimum" : true, + "default" : 1 + }, + + "disallow" : { + "type" : ["string", "array"], + "items" : { + "type" : ["string", {"$ref" : "#"}] + }, + "uniqueItems" : true + }, + + "extends" : { + "type" : [{"$ref" : "#"}, "array"], + "items" : {"$ref" : "#"}, + "default" : {} + }, + + "id" : { + "type" : "string" + }, + + "$ref" : { + "type" : "string" + }, + + "$schema" : { + "type" : "string", + "format" : "uri" + } + }, + + "dependencies" : { + "exclusiveMinimum" : "minimum", + "exclusiveMaximum" : "maximum" + }, + + "default" : {} +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..bcbb84743e3838fab7cbec5f0a5bcbafcfc99136 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json @@ -0,0 +1,149 @@ +{ + "id": "http://json-schema.org/draft-04/schema#", + "$schema": "http://json-schema.org/draft-04/schema#", + "description": "Core schema meta-schema", + "definitions": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$ref": "#" } + }, + "positiveInteger": { + "type": "integer", + "minimum": 0 + }, + "positiveIntegerDefault0": { + "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ] + }, + "simpleTypes": { + "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "minItems": 1, + "uniqueItems": true + } + }, + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "$schema": { + "type": "string" + }, + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": {}, + "multipleOf": { + "type": "number", + "minimum": 0, + "exclusiveMinimum": true + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "boolean", + "default": false + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "boolean", + "default": false + }, + "maxLength": { "$ref": "#/definitions/positiveInteger" }, + "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "additionalItems": { + "anyOf": [ + { "type": "boolean" }, + { "$ref": "#" } + ], + "default": {} + }, + "items": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/schemaArray" } + ], + "default": {} + }, + "maxItems": { "$ref": "#/definitions/positiveInteger" }, + "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "maxProperties": { "$ref": "#/definitions/positiveInteger" }, + "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "required": { "$ref": "#/definitions/stringArray" }, + "additionalProperties": { + "anyOf": [ + { "type": "boolean" }, + { "$ref": "#" } + ], + "default": {} + }, + "definitions": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "properties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "dependencies": { + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/stringArray" } + ] + } + }, + "enum": { + "type": "array", + "minItems": 1, + "uniqueItems": true + }, + "type": { + "anyOf": [ + { "$ref": "#/definitions/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/definitions/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + }, + "format": { "type": "string" }, + "allOf": { "$ref": "#/definitions/schemaArray" }, + "anyOf": { "$ref": "#/definitions/schemaArray" }, + "oneOf": { "$ref": "#/definitions/schemaArray" }, + "not": { "$ref": "#" } + }, + "dependencies": { + "exclusiveMaximum": [ "maximum" ], + "exclusiveMinimum": [ "minimum" ] + }, + "default": {} +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..a0d2bf7896c2619ae657cd3b3266660156021706 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json @@ -0,0 +1,153 @@ +{ + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "http://json-schema.org/draft-06/schema#", + "title": "Core schema meta-schema", + "definitions": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$ref": "#" } + }, + "nonNegativeInteger": { + "type": "integer", + "minimum": 0 + }, + "nonNegativeIntegerDefault0": { + "allOf": [ + { "$ref": "#/definitions/nonNegativeInteger" }, + { "default": 0 } + ] + }, + "simpleTypes": { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "uniqueItems": true, + "default": [] + } + }, + "type": ["object", "boolean"], + "properties": { + "$id": { + "type": "string", + "format": "uri-reference" + }, + "$schema": { + "type": "string", + "format": "uri" + }, + "$ref": { + "type": "string", + "format": "uri-reference" + }, + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": {}, + "examples": { + "type": "array", + "items": {} + }, + "multipleOf": { + "type": "number", + "exclusiveMinimum": 0 + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "number" + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "number" + }, + "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, + "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "additionalItems": { "$ref": "#" }, + "items": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/schemaArray" } + ], + "default": {} + }, + "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, + "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "contains": { "$ref": "#" }, + "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, + "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "required": { "$ref": "#/definitions/stringArray" }, + "additionalProperties": { "$ref": "#" }, + "definitions": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "properties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "propertyNames": { "format": "regex" }, + "default": {} + }, + "dependencies": { + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/stringArray" } + ] + } + }, + "propertyNames": { "$ref": "#" }, + "const": {}, + "enum": { + "type": "array" + }, + "type": { + "anyOf": [ + { "$ref": "#/definitions/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/definitions/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + }, + "format": { "type": "string" }, + "allOf": { "$ref": "#/definitions/schemaArray" }, + "anyOf": { "$ref": "#/definitions/schemaArray" }, + "oneOf": { "$ref": "#/definitions/schemaArray" }, + "not": { "$ref": "#" } + }, + "default": {} +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json new file mode 100644 index 0000000000000000000000000000000000000000..746cde9690134529bdcde889f72c7ad5259f24ad --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json @@ -0,0 +1,166 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "http://json-schema.org/draft-07/schema#", + "title": "Core schema meta-schema", + "definitions": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$ref": "#" } + }, + "nonNegativeInteger": { + "type": "integer", + "minimum": 0 + }, + "nonNegativeIntegerDefault0": { + "allOf": [ + { "$ref": "#/definitions/nonNegativeInteger" }, + { "default": 0 } + ] + }, + "simpleTypes": { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "uniqueItems": true, + "default": [] + } + }, + "type": ["object", "boolean"], + "properties": { + "$id": { + "type": "string", + "format": "uri-reference" + }, + "$schema": { + "type": "string", + "format": "uri" + }, + "$ref": { + "type": "string", + "format": "uri-reference" + }, + "$comment": { + "type": "string" + }, + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": true, + "readOnly": { + "type": "boolean", + "default": false + }, + "examples": { + "type": "array", + "items": true + }, + "multipleOf": { + "type": "number", + "exclusiveMinimum": 0 + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "number" + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "number" + }, + "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, + "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "additionalItems": { "$ref": "#" }, + "items": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/schemaArray" } + ], + "default": true + }, + "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, + "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "contains": { "$ref": "#" }, + "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, + "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, + "required": { "$ref": "#/definitions/stringArray" }, + "additionalProperties": { "$ref": "#" }, + "definitions": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "properties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "propertyNames": { "format": "regex" }, + "default": {} + }, + "dependencies": { + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/stringArray" } + ] + } + }, + "propertyNames": { "$ref": "#" }, + "const": true, + "enum": { + "type": "array", + "items": true + }, + "type": { + "anyOf": [ + { "$ref": "#/definitions/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/definitions/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + }, + "format": { "type": "string" }, + "contentMediaType": { "type": "string" }, + "contentEncoding": { "type": "string" }, + "if": {"$ref": "#"}, + "then": {"$ref": "#"}, + "else": {"$ref": "#"}, + "allOf": { "$ref": "#/definitions/schemaArray" }, + "anyOf": { "$ref": "#/definitions/schemaArray" }, + "oneOf": { "$ref": "#/definitions/schemaArray" }, + "not": { "$ref": "#" } + }, + "default": true +} diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__init__.py b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43a2bb6c6530fa60c08c525bda76bd33b66146c0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-313.pyc b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d97fb4ca7bfcfcc6fd79efb2ed9db113d08bc8d6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py new file mode 100644 index 0000000000000000000000000000000000000000..fd2927e0c8381f3eb93029df155758c05ed5eb26 --- /dev/null +++ b/python/user_packages/Python313/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py @@ -0,0 +1,41 @@ +from collections.abc import Mapping +from pathlib import Path + +import pytest + +from jsonschema_specifications import REGISTRY + + +def test_it_contains_metaschemas(): + schema = REGISTRY.contents("http://json-schema.org/draft-07/schema#") + assert isinstance(schema, Mapping) + assert schema["$id"] == "http://json-schema.org/draft-07/schema#" + assert schema["title"] == "Core schema meta-schema" + + +def test_it_is_crawled(): + assert REGISTRY.crawl() == REGISTRY + + +@pytest.mark.parametrize( + "ignored_relative_path", + ["schemas/.DS_Store", "schemas/draft7/.DS_Store"], +) +def test_it_copes_with_dotfiles(ignored_relative_path): + """ + Ignore files like .DS_Store if someone has actually caused one to exist. + + We test here through the private interface as of course the global has + already loaded our schemas. + """ + + import jsonschema_specifications + + package = Path(jsonschema_specifications.__file__).parent + + ignored = package / ignored_relative_path + ignored.touch() + try: + list(jsonschema_specifications._schemas()) + finally: + ignored.unlink() diff --git a/python/user_packages/Python313/site-packages/kaitaistruct-0.11.dist-info/licenses/LICENSE b/python/user_packages/Python313/site-packages/kaitaistruct-0.11.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..416b1e68f6be9d21b56f00ee5ae0553f433c89ae --- /dev/null +++ b/python/user_packages/Python313/site-packages/kaitaistruct-0.11.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2015-2025 Kaitai Project + +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. diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c3c7ac64c1e3f626ddebc13bf46a0e7b6880a51 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/api_client.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/api_client.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..651a112568268c8a32a71c584f0e715b1cae350c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/api_client.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5834358ee063f89fe68b83479d994d69905a5598 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/exceptions.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/exceptions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49cd27d27e40266df083d6cf5ca126c17a2d08fa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/exceptions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/rest.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/rest.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a64946aca3df1a1781a49c850cc0b17d6b087a31 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/__pycache__/rest.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8dc3d190b0778dccdb7f033276b861d4a72e994 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/admissionregistration_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/admissionregistration_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..682700849071d83c6a59a31293674514a21d04ca Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/admissionregistration_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiextensions_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiextensions_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58f3c2586ce4063b06d26a09ea52c6003fb8c83d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiextensions_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiregistration_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiregistration_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8a7e3e34dda019e009b72077b7c1e6a0872a6be Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apiregistration_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apis_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apis_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1e7e961679c90c14b337f421e8c78196b9d5208 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apis_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apps_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apps_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0918b008d6a9b94e093e4d726eb55b87e559396 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/apps_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f870736f2d1dbadb776e00e3d4ca0917191cdf37 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_v1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_v1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e1f625430e7455a4577982e2dec4e022e722e94 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authentication_v1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06032f8fc5eed66ef526afdc96a0e81f5f793310 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_v1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_v1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7a7a701e11d7c275b60aab36c464fac8e90ee9e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/authorization_v1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/autoscaling_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/autoscaling_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f14e2a227d569e64c59bba55d1bd9fbd407274b3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/autoscaling_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/batch_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/batch_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7881568db1cdd9c43707f133b6187f3b106bb4a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/batch_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..715a62f623e02ca0ab8d11229f6ec04b4e12c3eb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_v1alpha1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_v1alpha1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9376235c8e8a7abe6c1d15c1071b0af534732026 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/certificates_v1alpha1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/coordination_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/coordination_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b98774f5fab59b9b8c425a2d5054b92e9712fb31 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/coordination_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/core_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/core_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3c11a2437c6ea6153ea8baaa9bb969c014289cb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/core_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/discovery_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/discovery_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8718c57c5e92aeb1be61b47c9d3a9aeae2eec67 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/discovery_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/events_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/events_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87cc945026464237a55b488e995cbea3a08b24a2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/events_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/flowcontrol_apiserver_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/flowcontrol_apiserver_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..caba70d20e4fbab5a1dff4acf2308b18e2951b32 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/flowcontrol_apiserver_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/internal_apiserver_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/internal_apiserver_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5bce0af6c52956b1acf65ee67318b82f47a33fa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/internal_apiserver_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/logs_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/logs_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1ae004275a6334ab345bd9c561cf7560335a81a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/logs_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/networking_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/networking_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ee8884ba99e40ee5ee8573bd4d934c2f50b6279 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/networking_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdc87db67c45148ae046e65a86e0ca47b40156bc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_v1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_v1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..53475fd0fc24e21f1729df4239a92089147fba53 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/node_v1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/openid_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/openid_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37e5e90542ca7fa1178b8312855fe63d099857e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/openid_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/policy_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/policy_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b37782f1e1b043a2ae2d76702f64c69cd6fc623f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/policy_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/rbac_authorization_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/rbac_authorization_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dc477a8ce13bcd4d1a059a5ade376e5a455acb0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/rbac_authorization_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/resource_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/resource_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7389a17224e229ebd254f4f3de6bafdb3de10c25 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/resource_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb43d29db146f002e990624b827cc14f672c739c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_v1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_v1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12271cb7dc376b53ec54e3c61e24eab67ece8703 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/scheduling_v1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6d32453064aad39dc4bc83df59c26de53c32b9c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_v1beta1_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_v1beta1_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79943e65b7076eb933ea300fd6639fa830314f9f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storage_v1beta1_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storagemigration_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storagemigration_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdb64fc8f0428fc379fb337b2140eb3357f21f37 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/storagemigration_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/version_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/version_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8bda9d3d9f028b0424e5deb7e82dfac2dd02ecb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/version_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/well_known_api.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/well_known_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2f40194c94dee72a5929d65ef79ff4d4a35a8ee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/api/__pycache__/well_known_api.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/apis/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/apis/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21d10f721bdfce7542be4c7d2a3e7e84fb0e9dca Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/apis/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__init__.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e39158b6a3b37ccb7b5f032686107ac83bad50e1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/__init__.py @@ -0,0 +1,737 @@ +# coding: utf-8 + +# flake8: noqa +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +# import models into model package +from kubernetes.client.models.admissionregistration_v1_service_reference import AdmissionregistrationV1ServiceReference +from kubernetes.client.models.admissionregistration_v1_webhook_client_config import AdmissionregistrationV1WebhookClientConfig +from kubernetes.client.models.apiextensions_v1_service_reference import ApiextensionsV1ServiceReference +from kubernetes.client.models.apiextensions_v1_webhook_client_config import ApiextensionsV1WebhookClientConfig +from kubernetes.client.models.apiregistration_v1_service_reference import ApiregistrationV1ServiceReference +from kubernetes.client.models.authentication_v1_token_request import AuthenticationV1TokenRequest +from kubernetes.client.models.core_v1_endpoint_port import CoreV1EndpointPort +from kubernetes.client.models.core_v1_event import CoreV1Event +from kubernetes.client.models.core_v1_event_list import CoreV1EventList +from kubernetes.client.models.core_v1_event_series import CoreV1EventSeries +from kubernetes.client.models.core_v1_resource_claim import CoreV1ResourceClaim +from kubernetes.client.models.discovery_v1_endpoint_port import DiscoveryV1EndpointPort +from kubernetes.client.models.events_v1_event import EventsV1Event +from kubernetes.client.models.events_v1_event_list import EventsV1EventList +from kubernetes.client.models.events_v1_event_series import EventsV1EventSeries +from kubernetes.client.models.flowcontrol_v1_subject import FlowcontrolV1Subject +from kubernetes.client.models.rbac_v1_subject import RbacV1Subject +from kubernetes.client.models.resource_v1_resource_claim import ResourceV1ResourceClaim +from kubernetes.client.models.storage_v1_token_request import StorageV1TokenRequest +from kubernetes.client.models.v1_api_group import V1APIGroup +from kubernetes.client.models.v1_api_group_list import V1APIGroupList +from kubernetes.client.models.v1_api_resource import V1APIResource +from kubernetes.client.models.v1_api_resource_list import V1APIResourceList +from kubernetes.client.models.v1_api_service import V1APIService +from kubernetes.client.models.v1_api_service_condition import V1APIServiceCondition +from kubernetes.client.models.v1_api_service_list import V1APIServiceList +from kubernetes.client.models.v1_api_service_spec import V1APIServiceSpec +from kubernetes.client.models.v1_api_service_status import V1APIServiceStatus +from kubernetes.client.models.v1_api_versions import V1APIVersions +from kubernetes.client.models.v1_aws_elastic_block_store_volume_source import V1AWSElasticBlockStoreVolumeSource +from kubernetes.client.models.v1_affinity import V1Affinity +from kubernetes.client.models.v1_aggregation_rule import V1AggregationRule +from kubernetes.client.models.v1_allocated_device_status import V1AllocatedDeviceStatus +from kubernetes.client.models.v1_allocation_result import V1AllocationResult +from kubernetes.client.models.v1_app_armor_profile import V1AppArmorProfile +from kubernetes.client.models.v1_attached_volume import V1AttachedVolume +from kubernetes.client.models.v1_audit_annotation import V1AuditAnnotation +from kubernetes.client.models.v1_azure_disk_volume_source import V1AzureDiskVolumeSource +from kubernetes.client.models.v1_azure_file_persistent_volume_source import V1AzureFilePersistentVolumeSource +from kubernetes.client.models.v1_azure_file_volume_source import V1AzureFileVolumeSource +from kubernetes.client.models.v1_binding import V1Binding +from kubernetes.client.models.v1_bound_object_reference import V1BoundObjectReference +from kubernetes.client.models.v1_cel_device_selector import V1CELDeviceSelector +from kubernetes.client.models.v1_csi_driver import V1CSIDriver +from kubernetes.client.models.v1_csi_driver_list import V1CSIDriverList +from kubernetes.client.models.v1_csi_driver_spec import V1CSIDriverSpec +from kubernetes.client.models.v1_csi_node import V1CSINode +from kubernetes.client.models.v1_csi_node_driver import V1CSINodeDriver +from kubernetes.client.models.v1_csi_node_list import V1CSINodeList +from kubernetes.client.models.v1_csi_node_spec import V1CSINodeSpec +from kubernetes.client.models.v1_csi_persistent_volume_source import V1CSIPersistentVolumeSource +from kubernetes.client.models.v1_csi_storage_capacity import V1CSIStorageCapacity +from kubernetes.client.models.v1_csi_storage_capacity_list import V1CSIStorageCapacityList +from kubernetes.client.models.v1_csi_volume_source import V1CSIVolumeSource +from kubernetes.client.models.v1_capabilities import V1Capabilities +from kubernetes.client.models.v1_capacity_request_policy import V1CapacityRequestPolicy +from kubernetes.client.models.v1_capacity_request_policy_range import V1CapacityRequestPolicyRange +from kubernetes.client.models.v1_capacity_requirements import V1CapacityRequirements +from kubernetes.client.models.v1_ceph_fs_persistent_volume_source import V1CephFSPersistentVolumeSource +from kubernetes.client.models.v1_ceph_fs_volume_source import V1CephFSVolumeSource +from kubernetes.client.models.v1_certificate_signing_request import V1CertificateSigningRequest +from kubernetes.client.models.v1_certificate_signing_request_condition import V1CertificateSigningRequestCondition +from kubernetes.client.models.v1_certificate_signing_request_list import V1CertificateSigningRequestList +from kubernetes.client.models.v1_certificate_signing_request_spec import V1CertificateSigningRequestSpec +from kubernetes.client.models.v1_certificate_signing_request_status import V1CertificateSigningRequestStatus +from kubernetes.client.models.v1_cinder_persistent_volume_source import V1CinderPersistentVolumeSource +from kubernetes.client.models.v1_cinder_volume_source import V1CinderVolumeSource +from kubernetes.client.models.v1_client_ip_config import V1ClientIPConfig +from kubernetes.client.models.v1_cluster_role import V1ClusterRole +from kubernetes.client.models.v1_cluster_role_binding import V1ClusterRoleBinding +from kubernetes.client.models.v1_cluster_role_binding_list import V1ClusterRoleBindingList +from kubernetes.client.models.v1_cluster_role_list import V1ClusterRoleList +from kubernetes.client.models.v1_cluster_trust_bundle_projection import V1ClusterTrustBundleProjection +from kubernetes.client.models.v1_component_condition import V1ComponentCondition +from kubernetes.client.models.v1_component_status import V1ComponentStatus +from kubernetes.client.models.v1_component_status_list import V1ComponentStatusList +from kubernetes.client.models.v1_condition import V1Condition +from kubernetes.client.models.v1_config_map import V1ConfigMap +from kubernetes.client.models.v1_config_map_env_source import V1ConfigMapEnvSource +from kubernetes.client.models.v1_config_map_key_selector import V1ConfigMapKeySelector +from kubernetes.client.models.v1_config_map_list import V1ConfigMapList +from kubernetes.client.models.v1_config_map_node_config_source import V1ConfigMapNodeConfigSource +from kubernetes.client.models.v1_config_map_projection import V1ConfigMapProjection +from kubernetes.client.models.v1_config_map_volume_source import V1ConfigMapVolumeSource +from kubernetes.client.models.v1_container import V1Container +from kubernetes.client.models.v1_container_extended_resource_request import V1ContainerExtendedResourceRequest +from kubernetes.client.models.v1_container_image import V1ContainerImage +from kubernetes.client.models.v1_container_port import V1ContainerPort +from kubernetes.client.models.v1_container_resize_policy import V1ContainerResizePolicy +from kubernetes.client.models.v1_container_restart_rule import V1ContainerRestartRule +from kubernetes.client.models.v1_container_restart_rule_on_exit_codes import V1ContainerRestartRuleOnExitCodes +from kubernetes.client.models.v1_container_state import V1ContainerState +from kubernetes.client.models.v1_container_state_running import V1ContainerStateRunning +from kubernetes.client.models.v1_container_state_terminated import V1ContainerStateTerminated +from kubernetes.client.models.v1_container_state_waiting import V1ContainerStateWaiting +from kubernetes.client.models.v1_container_status import V1ContainerStatus +from kubernetes.client.models.v1_container_user import V1ContainerUser +from kubernetes.client.models.v1_controller_revision import V1ControllerRevision +from kubernetes.client.models.v1_controller_revision_list import V1ControllerRevisionList +from kubernetes.client.models.v1_counter import V1Counter +from kubernetes.client.models.v1_counter_set import V1CounterSet +from kubernetes.client.models.v1_cron_job import V1CronJob +from kubernetes.client.models.v1_cron_job_list import V1CronJobList +from kubernetes.client.models.v1_cron_job_spec import V1CronJobSpec +from kubernetes.client.models.v1_cron_job_status import V1CronJobStatus +from kubernetes.client.models.v1_cross_version_object_reference import V1CrossVersionObjectReference +from kubernetes.client.models.v1_custom_resource_column_definition import V1CustomResourceColumnDefinition +from kubernetes.client.models.v1_custom_resource_conversion import V1CustomResourceConversion +from kubernetes.client.models.v1_custom_resource_definition import V1CustomResourceDefinition +from kubernetes.client.models.v1_custom_resource_definition_condition import V1CustomResourceDefinitionCondition +from kubernetes.client.models.v1_custom_resource_definition_list import V1CustomResourceDefinitionList +from kubernetes.client.models.v1_custom_resource_definition_names import V1CustomResourceDefinitionNames +from kubernetes.client.models.v1_custom_resource_definition_spec import V1CustomResourceDefinitionSpec +from kubernetes.client.models.v1_custom_resource_definition_status import V1CustomResourceDefinitionStatus +from kubernetes.client.models.v1_custom_resource_definition_version import V1CustomResourceDefinitionVersion +from kubernetes.client.models.v1_custom_resource_subresource_scale import V1CustomResourceSubresourceScale +from kubernetes.client.models.v1_custom_resource_subresources import V1CustomResourceSubresources +from kubernetes.client.models.v1_custom_resource_validation import V1CustomResourceValidation +from kubernetes.client.models.v1_daemon_endpoint import V1DaemonEndpoint +from kubernetes.client.models.v1_daemon_set import V1DaemonSet +from kubernetes.client.models.v1_daemon_set_condition import V1DaemonSetCondition +from kubernetes.client.models.v1_daemon_set_list import V1DaemonSetList +from kubernetes.client.models.v1_daemon_set_spec import V1DaemonSetSpec +from kubernetes.client.models.v1_daemon_set_status import V1DaemonSetStatus +from kubernetes.client.models.v1_daemon_set_update_strategy import V1DaemonSetUpdateStrategy +from kubernetes.client.models.v1_delete_options import V1DeleteOptions +from kubernetes.client.models.v1_deployment import V1Deployment +from kubernetes.client.models.v1_deployment_condition import V1DeploymentCondition +from kubernetes.client.models.v1_deployment_list import V1DeploymentList +from kubernetes.client.models.v1_deployment_spec import V1DeploymentSpec +from kubernetes.client.models.v1_deployment_status import V1DeploymentStatus +from kubernetes.client.models.v1_deployment_strategy import V1DeploymentStrategy +from kubernetes.client.models.v1_device import V1Device +from kubernetes.client.models.v1_device_allocation_configuration import V1DeviceAllocationConfiguration +from kubernetes.client.models.v1_device_allocation_result import V1DeviceAllocationResult +from kubernetes.client.models.v1_device_attribute import V1DeviceAttribute +from kubernetes.client.models.v1_device_capacity import V1DeviceCapacity +from kubernetes.client.models.v1_device_claim import V1DeviceClaim +from kubernetes.client.models.v1_device_claim_configuration import V1DeviceClaimConfiguration +from kubernetes.client.models.v1_device_class import V1DeviceClass +from kubernetes.client.models.v1_device_class_configuration import V1DeviceClassConfiguration +from kubernetes.client.models.v1_device_class_list import V1DeviceClassList +from kubernetes.client.models.v1_device_class_spec import V1DeviceClassSpec +from kubernetes.client.models.v1_device_constraint import V1DeviceConstraint +from kubernetes.client.models.v1_device_counter_consumption import V1DeviceCounterConsumption +from kubernetes.client.models.v1_device_request import V1DeviceRequest +from kubernetes.client.models.v1_device_request_allocation_result import V1DeviceRequestAllocationResult +from kubernetes.client.models.v1_device_selector import V1DeviceSelector +from kubernetes.client.models.v1_device_sub_request import V1DeviceSubRequest +from kubernetes.client.models.v1_device_taint import V1DeviceTaint +from kubernetes.client.models.v1_device_toleration import V1DeviceToleration +from kubernetes.client.models.v1_downward_api_projection import V1DownwardAPIProjection +from kubernetes.client.models.v1_downward_api_volume_file import V1DownwardAPIVolumeFile +from kubernetes.client.models.v1_downward_api_volume_source import V1DownwardAPIVolumeSource +from kubernetes.client.models.v1_empty_dir_volume_source import V1EmptyDirVolumeSource +from kubernetes.client.models.v1_endpoint import V1Endpoint +from kubernetes.client.models.v1_endpoint_address import V1EndpointAddress +from kubernetes.client.models.v1_endpoint_conditions import V1EndpointConditions +from kubernetes.client.models.v1_endpoint_hints import V1EndpointHints +from kubernetes.client.models.v1_endpoint_slice import V1EndpointSlice +from kubernetes.client.models.v1_endpoint_slice_list import V1EndpointSliceList +from kubernetes.client.models.v1_endpoint_subset import V1EndpointSubset +from kubernetes.client.models.v1_endpoints import V1Endpoints +from kubernetes.client.models.v1_endpoints_list import V1EndpointsList +from kubernetes.client.models.v1_env_from_source import V1EnvFromSource +from kubernetes.client.models.v1_env_var import V1EnvVar +from kubernetes.client.models.v1_env_var_source import V1EnvVarSource +from kubernetes.client.models.v1_ephemeral_container import V1EphemeralContainer +from kubernetes.client.models.v1_ephemeral_volume_source import V1EphemeralVolumeSource +from kubernetes.client.models.v1_event_source import V1EventSource +from kubernetes.client.models.v1_eviction import V1Eviction +from kubernetes.client.models.v1_exact_device_request import V1ExactDeviceRequest +from kubernetes.client.models.v1_exec_action import V1ExecAction +from kubernetes.client.models.v1_exempt_priority_level_configuration import V1ExemptPriorityLevelConfiguration +from kubernetes.client.models.v1_expression_warning import V1ExpressionWarning +from kubernetes.client.models.v1_external_documentation import V1ExternalDocumentation +from kubernetes.client.models.v1_fc_volume_source import V1FCVolumeSource +from kubernetes.client.models.v1_field_selector_attributes import V1FieldSelectorAttributes +from kubernetes.client.models.v1_field_selector_requirement import V1FieldSelectorRequirement +from kubernetes.client.models.v1_file_key_selector import V1FileKeySelector +from kubernetes.client.models.v1_flex_persistent_volume_source import V1FlexPersistentVolumeSource +from kubernetes.client.models.v1_flex_volume_source import V1FlexVolumeSource +from kubernetes.client.models.v1_flocker_volume_source import V1FlockerVolumeSource +from kubernetes.client.models.v1_flow_distinguisher_method import V1FlowDistinguisherMethod +from kubernetes.client.models.v1_flow_schema import V1FlowSchema +from kubernetes.client.models.v1_flow_schema_condition import V1FlowSchemaCondition +from kubernetes.client.models.v1_flow_schema_list import V1FlowSchemaList +from kubernetes.client.models.v1_flow_schema_spec import V1FlowSchemaSpec +from kubernetes.client.models.v1_flow_schema_status import V1FlowSchemaStatus +from kubernetes.client.models.v1_for_node import V1ForNode +from kubernetes.client.models.v1_for_zone import V1ForZone +from kubernetes.client.models.v1_gce_persistent_disk_volume_source import V1GCEPersistentDiskVolumeSource +from kubernetes.client.models.v1_grpc_action import V1GRPCAction +from kubernetes.client.models.v1_git_repo_volume_source import V1GitRepoVolumeSource +from kubernetes.client.models.v1_glusterfs_persistent_volume_source import V1GlusterfsPersistentVolumeSource +from kubernetes.client.models.v1_glusterfs_volume_source import V1GlusterfsVolumeSource +from kubernetes.client.models.v1_group_resource import V1GroupResource +from kubernetes.client.models.v1_group_subject import V1GroupSubject +from kubernetes.client.models.v1_group_version_for_discovery import V1GroupVersionForDiscovery +from kubernetes.client.models.v1_http_get_action import V1HTTPGetAction +from kubernetes.client.models.v1_http_header import V1HTTPHeader +from kubernetes.client.models.v1_http_ingress_path import V1HTTPIngressPath +from kubernetes.client.models.v1_http_ingress_rule_value import V1HTTPIngressRuleValue +from kubernetes.client.models.v1_horizontal_pod_autoscaler import V1HorizontalPodAutoscaler +from kubernetes.client.models.v1_horizontal_pod_autoscaler_list import V1HorizontalPodAutoscalerList +from kubernetes.client.models.v1_horizontal_pod_autoscaler_spec import V1HorizontalPodAutoscalerSpec +from kubernetes.client.models.v1_horizontal_pod_autoscaler_status import V1HorizontalPodAutoscalerStatus +from kubernetes.client.models.v1_host_alias import V1HostAlias +from kubernetes.client.models.v1_host_ip import V1HostIP +from kubernetes.client.models.v1_host_path_volume_source import V1HostPathVolumeSource +from kubernetes.client.models.v1_ip_address import V1IPAddress +from kubernetes.client.models.v1_ip_address_list import V1IPAddressList +from kubernetes.client.models.v1_ip_address_spec import V1IPAddressSpec +from kubernetes.client.models.v1_ip_block import V1IPBlock +from kubernetes.client.models.v1_iscsi_persistent_volume_source import V1ISCSIPersistentVolumeSource +from kubernetes.client.models.v1_iscsi_volume_source import V1ISCSIVolumeSource +from kubernetes.client.models.v1_image_volume_source import V1ImageVolumeSource +from kubernetes.client.models.v1_ingress import V1Ingress +from kubernetes.client.models.v1_ingress_backend import V1IngressBackend +from kubernetes.client.models.v1_ingress_class import V1IngressClass +from kubernetes.client.models.v1_ingress_class_list import V1IngressClassList +from kubernetes.client.models.v1_ingress_class_parameters_reference import V1IngressClassParametersReference +from kubernetes.client.models.v1_ingress_class_spec import V1IngressClassSpec +from kubernetes.client.models.v1_ingress_list import V1IngressList +from kubernetes.client.models.v1_ingress_load_balancer_ingress import V1IngressLoadBalancerIngress +from kubernetes.client.models.v1_ingress_load_balancer_status import V1IngressLoadBalancerStatus +from kubernetes.client.models.v1_ingress_port_status import V1IngressPortStatus +from kubernetes.client.models.v1_ingress_rule import V1IngressRule +from kubernetes.client.models.v1_ingress_service_backend import V1IngressServiceBackend +from kubernetes.client.models.v1_ingress_spec import V1IngressSpec +from kubernetes.client.models.v1_ingress_status import V1IngressStatus +from kubernetes.client.models.v1_ingress_tls import V1IngressTLS +from kubernetes.client.models.v1_json_schema_props import V1JSONSchemaProps +from kubernetes.client.models.v1_job import V1Job +from kubernetes.client.models.v1_job_condition import V1JobCondition +from kubernetes.client.models.v1_job_list import V1JobList +from kubernetes.client.models.v1_job_spec import V1JobSpec +from kubernetes.client.models.v1_job_status import V1JobStatus +from kubernetes.client.models.v1_job_template_spec import V1JobTemplateSpec +from kubernetes.client.models.v1_key_to_path import V1KeyToPath +from kubernetes.client.models.v1_label_selector import V1LabelSelector +from kubernetes.client.models.v1_label_selector_attributes import V1LabelSelectorAttributes +from kubernetes.client.models.v1_label_selector_requirement import V1LabelSelectorRequirement +from kubernetes.client.models.v1_lease import V1Lease +from kubernetes.client.models.v1_lease_list import V1LeaseList +from kubernetes.client.models.v1_lease_spec import V1LeaseSpec +from kubernetes.client.models.v1_lifecycle import V1Lifecycle +from kubernetes.client.models.v1_lifecycle_handler import V1LifecycleHandler +from kubernetes.client.models.v1_limit_range import V1LimitRange +from kubernetes.client.models.v1_limit_range_item import V1LimitRangeItem +from kubernetes.client.models.v1_limit_range_list import V1LimitRangeList +from kubernetes.client.models.v1_limit_range_spec import V1LimitRangeSpec +from kubernetes.client.models.v1_limit_response import V1LimitResponse +from kubernetes.client.models.v1_limited_priority_level_configuration import V1LimitedPriorityLevelConfiguration +from kubernetes.client.models.v1_linux_container_user import V1LinuxContainerUser +from kubernetes.client.models.v1_list_meta import V1ListMeta +from kubernetes.client.models.v1_load_balancer_ingress import V1LoadBalancerIngress +from kubernetes.client.models.v1_load_balancer_status import V1LoadBalancerStatus +from kubernetes.client.models.v1_local_object_reference import V1LocalObjectReference +from kubernetes.client.models.v1_local_subject_access_review import V1LocalSubjectAccessReview +from kubernetes.client.models.v1_local_volume_source import V1LocalVolumeSource +from kubernetes.client.models.v1_managed_fields_entry import V1ManagedFieldsEntry +from kubernetes.client.models.v1_match_condition import V1MatchCondition +from kubernetes.client.models.v1_match_resources import V1MatchResources +from kubernetes.client.models.v1_modify_volume_status import V1ModifyVolumeStatus +from kubernetes.client.models.v1_mutating_webhook import V1MutatingWebhook +from kubernetes.client.models.v1_mutating_webhook_configuration import V1MutatingWebhookConfiguration +from kubernetes.client.models.v1_mutating_webhook_configuration_list import V1MutatingWebhookConfigurationList +from kubernetes.client.models.v1_nfs_volume_source import V1NFSVolumeSource +from kubernetes.client.models.v1_named_rule_with_operations import V1NamedRuleWithOperations +from kubernetes.client.models.v1_namespace import V1Namespace +from kubernetes.client.models.v1_namespace_condition import V1NamespaceCondition +from kubernetes.client.models.v1_namespace_list import V1NamespaceList +from kubernetes.client.models.v1_namespace_spec import V1NamespaceSpec +from kubernetes.client.models.v1_namespace_status import V1NamespaceStatus +from kubernetes.client.models.v1_network_device_data import V1NetworkDeviceData +from kubernetes.client.models.v1_network_policy import V1NetworkPolicy +from kubernetes.client.models.v1_network_policy_egress_rule import V1NetworkPolicyEgressRule +from kubernetes.client.models.v1_network_policy_ingress_rule import V1NetworkPolicyIngressRule +from kubernetes.client.models.v1_network_policy_list import V1NetworkPolicyList +from kubernetes.client.models.v1_network_policy_peer import V1NetworkPolicyPeer +from kubernetes.client.models.v1_network_policy_port import V1NetworkPolicyPort +from kubernetes.client.models.v1_network_policy_spec import V1NetworkPolicySpec +from kubernetes.client.models.v1_node import V1Node +from kubernetes.client.models.v1_node_address import V1NodeAddress +from kubernetes.client.models.v1_node_affinity import V1NodeAffinity +from kubernetes.client.models.v1_node_condition import V1NodeCondition +from kubernetes.client.models.v1_node_config_source import V1NodeConfigSource +from kubernetes.client.models.v1_node_config_status import V1NodeConfigStatus +from kubernetes.client.models.v1_node_daemon_endpoints import V1NodeDaemonEndpoints +from kubernetes.client.models.v1_node_features import V1NodeFeatures +from kubernetes.client.models.v1_node_list import V1NodeList +from kubernetes.client.models.v1_node_runtime_handler import V1NodeRuntimeHandler +from kubernetes.client.models.v1_node_runtime_handler_features import V1NodeRuntimeHandlerFeatures +from kubernetes.client.models.v1_node_selector import V1NodeSelector +from kubernetes.client.models.v1_node_selector_requirement import V1NodeSelectorRequirement +from kubernetes.client.models.v1_node_selector_term import V1NodeSelectorTerm +from kubernetes.client.models.v1_node_spec import V1NodeSpec +from kubernetes.client.models.v1_node_status import V1NodeStatus +from kubernetes.client.models.v1_node_swap_status import V1NodeSwapStatus +from kubernetes.client.models.v1_node_system_info import V1NodeSystemInfo +from kubernetes.client.models.v1_non_resource_attributes import V1NonResourceAttributes +from kubernetes.client.models.v1_non_resource_policy_rule import V1NonResourcePolicyRule +from kubernetes.client.models.v1_non_resource_rule import V1NonResourceRule +from kubernetes.client.models.v1_object_field_selector import V1ObjectFieldSelector +from kubernetes.client.models.v1_object_meta import V1ObjectMeta +from kubernetes.client.models.v1_object_reference import V1ObjectReference +from kubernetes.client.models.v1_opaque_device_configuration import V1OpaqueDeviceConfiguration +from kubernetes.client.models.v1_overhead import V1Overhead +from kubernetes.client.models.v1_owner_reference import V1OwnerReference +from kubernetes.client.models.v1_param_kind import V1ParamKind +from kubernetes.client.models.v1_param_ref import V1ParamRef +from kubernetes.client.models.v1_parent_reference import V1ParentReference +from kubernetes.client.models.v1_persistent_volume import V1PersistentVolume +from kubernetes.client.models.v1_persistent_volume_claim import V1PersistentVolumeClaim +from kubernetes.client.models.v1_persistent_volume_claim_condition import V1PersistentVolumeClaimCondition +from kubernetes.client.models.v1_persistent_volume_claim_list import V1PersistentVolumeClaimList +from kubernetes.client.models.v1_persistent_volume_claim_spec import V1PersistentVolumeClaimSpec +from kubernetes.client.models.v1_persistent_volume_claim_status import V1PersistentVolumeClaimStatus +from kubernetes.client.models.v1_persistent_volume_claim_template import V1PersistentVolumeClaimTemplate +from kubernetes.client.models.v1_persistent_volume_claim_volume_source import V1PersistentVolumeClaimVolumeSource +from kubernetes.client.models.v1_persistent_volume_list import V1PersistentVolumeList +from kubernetes.client.models.v1_persistent_volume_spec import V1PersistentVolumeSpec +from kubernetes.client.models.v1_persistent_volume_status import V1PersistentVolumeStatus +from kubernetes.client.models.v1_photon_persistent_disk_volume_source import V1PhotonPersistentDiskVolumeSource +from kubernetes.client.models.v1_pod import V1Pod +from kubernetes.client.models.v1_pod_affinity import V1PodAffinity +from kubernetes.client.models.v1_pod_affinity_term import V1PodAffinityTerm +from kubernetes.client.models.v1_pod_anti_affinity import V1PodAntiAffinity +from kubernetes.client.models.v1_pod_certificate_projection import V1PodCertificateProjection +from kubernetes.client.models.v1_pod_condition import V1PodCondition +from kubernetes.client.models.v1_pod_dns_config import V1PodDNSConfig +from kubernetes.client.models.v1_pod_dns_config_option import V1PodDNSConfigOption +from kubernetes.client.models.v1_pod_disruption_budget import V1PodDisruptionBudget +from kubernetes.client.models.v1_pod_disruption_budget_list import V1PodDisruptionBudgetList +from kubernetes.client.models.v1_pod_disruption_budget_spec import V1PodDisruptionBudgetSpec +from kubernetes.client.models.v1_pod_disruption_budget_status import V1PodDisruptionBudgetStatus +from kubernetes.client.models.v1_pod_extended_resource_claim_status import V1PodExtendedResourceClaimStatus +from kubernetes.client.models.v1_pod_failure_policy import V1PodFailurePolicy +from kubernetes.client.models.v1_pod_failure_policy_on_exit_codes_requirement import V1PodFailurePolicyOnExitCodesRequirement +from kubernetes.client.models.v1_pod_failure_policy_on_pod_conditions_pattern import V1PodFailurePolicyOnPodConditionsPattern +from kubernetes.client.models.v1_pod_failure_policy_rule import V1PodFailurePolicyRule +from kubernetes.client.models.v1_pod_ip import V1PodIP +from kubernetes.client.models.v1_pod_list import V1PodList +from kubernetes.client.models.v1_pod_os import V1PodOS +from kubernetes.client.models.v1_pod_readiness_gate import V1PodReadinessGate +from kubernetes.client.models.v1_pod_resource_claim import V1PodResourceClaim +from kubernetes.client.models.v1_pod_resource_claim_status import V1PodResourceClaimStatus +from kubernetes.client.models.v1_pod_scheduling_gate import V1PodSchedulingGate +from kubernetes.client.models.v1_pod_security_context import V1PodSecurityContext +from kubernetes.client.models.v1_pod_spec import V1PodSpec +from kubernetes.client.models.v1_pod_status import V1PodStatus +from kubernetes.client.models.v1_pod_template import V1PodTemplate +from kubernetes.client.models.v1_pod_template_list import V1PodTemplateList +from kubernetes.client.models.v1_pod_template_spec import V1PodTemplateSpec +from kubernetes.client.models.v1_policy_rule import V1PolicyRule +from kubernetes.client.models.v1_policy_rules_with_subjects import V1PolicyRulesWithSubjects +from kubernetes.client.models.v1_port_status import V1PortStatus +from kubernetes.client.models.v1_portworx_volume_source import V1PortworxVolumeSource +from kubernetes.client.models.v1_preconditions import V1Preconditions +from kubernetes.client.models.v1_preferred_scheduling_term import V1PreferredSchedulingTerm +from kubernetes.client.models.v1_priority_class import V1PriorityClass +from kubernetes.client.models.v1_priority_class_list import V1PriorityClassList +from kubernetes.client.models.v1_priority_level_configuration import V1PriorityLevelConfiguration +from kubernetes.client.models.v1_priority_level_configuration_condition import V1PriorityLevelConfigurationCondition +from kubernetes.client.models.v1_priority_level_configuration_list import V1PriorityLevelConfigurationList +from kubernetes.client.models.v1_priority_level_configuration_reference import V1PriorityLevelConfigurationReference +from kubernetes.client.models.v1_priority_level_configuration_spec import V1PriorityLevelConfigurationSpec +from kubernetes.client.models.v1_priority_level_configuration_status import V1PriorityLevelConfigurationStatus +from kubernetes.client.models.v1_probe import V1Probe +from kubernetes.client.models.v1_projected_volume_source import V1ProjectedVolumeSource +from kubernetes.client.models.v1_queuing_configuration import V1QueuingConfiguration +from kubernetes.client.models.v1_quobyte_volume_source import V1QuobyteVolumeSource +from kubernetes.client.models.v1_rbd_persistent_volume_source import V1RBDPersistentVolumeSource +from kubernetes.client.models.v1_rbd_volume_source import V1RBDVolumeSource +from kubernetes.client.models.v1_replica_set import V1ReplicaSet +from kubernetes.client.models.v1_replica_set_condition import V1ReplicaSetCondition +from kubernetes.client.models.v1_replica_set_list import V1ReplicaSetList +from kubernetes.client.models.v1_replica_set_spec import V1ReplicaSetSpec +from kubernetes.client.models.v1_replica_set_status import V1ReplicaSetStatus +from kubernetes.client.models.v1_replication_controller import V1ReplicationController +from kubernetes.client.models.v1_replication_controller_condition import V1ReplicationControllerCondition +from kubernetes.client.models.v1_replication_controller_list import V1ReplicationControllerList +from kubernetes.client.models.v1_replication_controller_spec import V1ReplicationControllerSpec +from kubernetes.client.models.v1_replication_controller_status import V1ReplicationControllerStatus +from kubernetes.client.models.v1_resource_attributes import V1ResourceAttributes +from kubernetes.client.models.v1_resource_claim_consumer_reference import V1ResourceClaimConsumerReference +from kubernetes.client.models.v1_resource_claim_list import V1ResourceClaimList +from kubernetes.client.models.v1_resource_claim_spec import V1ResourceClaimSpec +from kubernetes.client.models.v1_resource_claim_status import V1ResourceClaimStatus +from kubernetes.client.models.v1_resource_claim_template import V1ResourceClaimTemplate +from kubernetes.client.models.v1_resource_claim_template_list import V1ResourceClaimTemplateList +from kubernetes.client.models.v1_resource_claim_template_spec import V1ResourceClaimTemplateSpec +from kubernetes.client.models.v1_resource_field_selector import V1ResourceFieldSelector +from kubernetes.client.models.v1_resource_health import V1ResourceHealth +from kubernetes.client.models.v1_resource_policy_rule import V1ResourcePolicyRule +from kubernetes.client.models.v1_resource_pool import V1ResourcePool +from kubernetes.client.models.v1_resource_quota import V1ResourceQuota +from kubernetes.client.models.v1_resource_quota_list import V1ResourceQuotaList +from kubernetes.client.models.v1_resource_quota_spec import V1ResourceQuotaSpec +from kubernetes.client.models.v1_resource_quota_status import V1ResourceQuotaStatus +from kubernetes.client.models.v1_resource_requirements import V1ResourceRequirements +from kubernetes.client.models.v1_resource_rule import V1ResourceRule +from kubernetes.client.models.v1_resource_slice import V1ResourceSlice +from kubernetes.client.models.v1_resource_slice_list import V1ResourceSliceList +from kubernetes.client.models.v1_resource_slice_spec import V1ResourceSliceSpec +from kubernetes.client.models.v1_resource_status import V1ResourceStatus +from kubernetes.client.models.v1_role import V1Role +from kubernetes.client.models.v1_role_binding import V1RoleBinding +from kubernetes.client.models.v1_role_binding_list import V1RoleBindingList +from kubernetes.client.models.v1_role_list import V1RoleList +from kubernetes.client.models.v1_role_ref import V1RoleRef +from kubernetes.client.models.v1_rolling_update_daemon_set import V1RollingUpdateDaemonSet +from kubernetes.client.models.v1_rolling_update_deployment import V1RollingUpdateDeployment +from kubernetes.client.models.v1_rolling_update_stateful_set_strategy import V1RollingUpdateStatefulSetStrategy +from kubernetes.client.models.v1_rule_with_operations import V1RuleWithOperations +from kubernetes.client.models.v1_runtime_class import V1RuntimeClass +from kubernetes.client.models.v1_runtime_class_list import V1RuntimeClassList +from kubernetes.client.models.v1_se_linux_options import V1SELinuxOptions +from kubernetes.client.models.v1_scale import V1Scale +from kubernetes.client.models.v1_scale_io_persistent_volume_source import V1ScaleIOPersistentVolumeSource +from kubernetes.client.models.v1_scale_io_volume_source import V1ScaleIOVolumeSource +from kubernetes.client.models.v1_scale_spec import V1ScaleSpec +from kubernetes.client.models.v1_scale_status import V1ScaleStatus +from kubernetes.client.models.v1_scheduling import V1Scheduling +from kubernetes.client.models.v1_scope_selector import V1ScopeSelector +from kubernetes.client.models.v1_scoped_resource_selector_requirement import V1ScopedResourceSelectorRequirement +from kubernetes.client.models.v1_seccomp_profile import V1SeccompProfile +from kubernetes.client.models.v1_secret import V1Secret +from kubernetes.client.models.v1_secret_env_source import V1SecretEnvSource +from kubernetes.client.models.v1_secret_key_selector import V1SecretKeySelector +from kubernetes.client.models.v1_secret_list import V1SecretList +from kubernetes.client.models.v1_secret_projection import V1SecretProjection +from kubernetes.client.models.v1_secret_reference import V1SecretReference +from kubernetes.client.models.v1_secret_volume_source import V1SecretVolumeSource +from kubernetes.client.models.v1_security_context import V1SecurityContext +from kubernetes.client.models.v1_selectable_field import V1SelectableField +from kubernetes.client.models.v1_self_subject_access_review import V1SelfSubjectAccessReview +from kubernetes.client.models.v1_self_subject_access_review_spec import V1SelfSubjectAccessReviewSpec +from kubernetes.client.models.v1_self_subject_review import V1SelfSubjectReview +from kubernetes.client.models.v1_self_subject_review_status import V1SelfSubjectReviewStatus +from kubernetes.client.models.v1_self_subject_rules_review import V1SelfSubjectRulesReview +from kubernetes.client.models.v1_self_subject_rules_review_spec import V1SelfSubjectRulesReviewSpec +from kubernetes.client.models.v1_server_address_by_client_cidr import V1ServerAddressByClientCIDR +from kubernetes.client.models.v1_service import V1Service +from kubernetes.client.models.v1_service_account import V1ServiceAccount +from kubernetes.client.models.v1_service_account_list import V1ServiceAccountList +from kubernetes.client.models.v1_service_account_subject import V1ServiceAccountSubject +from kubernetes.client.models.v1_service_account_token_projection import V1ServiceAccountTokenProjection +from kubernetes.client.models.v1_service_backend_port import V1ServiceBackendPort +from kubernetes.client.models.v1_service_cidr import V1ServiceCIDR +from kubernetes.client.models.v1_service_cidr_list import V1ServiceCIDRList +from kubernetes.client.models.v1_service_cidr_spec import V1ServiceCIDRSpec +from kubernetes.client.models.v1_service_cidr_status import V1ServiceCIDRStatus +from kubernetes.client.models.v1_service_list import V1ServiceList +from kubernetes.client.models.v1_service_port import V1ServicePort +from kubernetes.client.models.v1_service_spec import V1ServiceSpec +from kubernetes.client.models.v1_service_status import V1ServiceStatus +from kubernetes.client.models.v1_session_affinity_config import V1SessionAffinityConfig +from kubernetes.client.models.v1_sleep_action import V1SleepAction +from kubernetes.client.models.v1_stateful_set import V1StatefulSet +from kubernetes.client.models.v1_stateful_set_condition import V1StatefulSetCondition +from kubernetes.client.models.v1_stateful_set_list import V1StatefulSetList +from kubernetes.client.models.v1_stateful_set_ordinals import V1StatefulSetOrdinals +from kubernetes.client.models.v1_stateful_set_persistent_volume_claim_retention_policy import V1StatefulSetPersistentVolumeClaimRetentionPolicy +from kubernetes.client.models.v1_stateful_set_spec import V1StatefulSetSpec +from kubernetes.client.models.v1_stateful_set_status import V1StatefulSetStatus +from kubernetes.client.models.v1_stateful_set_update_strategy import V1StatefulSetUpdateStrategy +from kubernetes.client.models.v1_status import V1Status +from kubernetes.client.models.v1_status_cause import V1StatusCause +from kubernetes.client.models.v1_status_details import V1StatusDetails +from kubernetes.client.models.v1_storage_class import V1StorageClass +from kubernetes.client.models.v1_storage_class_list import V1StorageClassList +from kubernetes.client.models.v1_storage_os_persistent_volume_source import V1StorageOSPersistentVolumeSource +from kubernetes.client.models.v1_storage_os_volume_source import V1StorageOSVolumeSource +from kubernetes.client.models.v1_subject_access_review import V1SubjectAccessReview +from kubernetes.client.models.v1_subject_access_review_spec import V1SubjectAccessReviewSpec +from kubernetes.client.models.v1_subject_access_review_status import V1SubjectAccessReviewStatus +from kubernetes.client.models.v1_subject_rules_review_status import V1SubjectRulesReviewStatus +from kubernetes.client.models.v1_success_policy import V1SuccessPolicy +from kubernetes.client.models.v1_success_policy_rule import V1SuccessPolicyRule +from kubernetes.client.models.v1_sysctl import V1Sysctl +from kubernetes.client.models.v1_tcp_socket_action import V1TCPSocketAction +from kubernetes.client.models.v1_taint import V1Taint +from kubernetes.client.models.v1_token_request_spec import V1TokenRequestSpec +from kubernetes.client.models.v1_token_request_status import V1TokenRequestStatus +from kubernetes.client.models.v1_token_review import V1TokenReview +from kubernetes.client.models.v1_token_review_spec import V1TokenReviewSpec +from kubernetes.client.models.v1_token_review_status import V1TokenReviewStatus +from kubernetes.client.models.v1_toleration import V1Toleration +from kubernetes.client.models.v1_topology_selector_label_requirement import V1TopologySelectorLabelRequirement +from kubernetes.client.models.v1_topology_selector_term import V1TopologySelectorTerm +from kubernetes.client.models.v1_topology_spread_constraint import V1TopologySpreadConstraint +from kubernetes.client.models.v1_type_checking import V1TypeChecking +from kubernetes.client.models.v1_typed_local_object_reference import V1TypedLocalObjectReference +from kubernetes.client.models.v1_typed_object_reference import V1TypedObjectReference +from kubernetes.client.models.v1_uncounted_terminated_pods import V1UncountedTerminatedPods +from kubernetes.client.models.v1_user_info import V1UserInfo +from kubernetes.client.models.v1_user_subject import V1UserSubject +from kubernetes.client.models.v1_validating_admission_policy import V1ValidatingAdmissionPolicy +from kubernetes.client.models.v1_validating_admission_policy_binding import V1ValidatingAdmissionPolicyBinding +from kubernetes.client.models.v1_validating_admission_policy_binding_list import V1ValidatingAdmissionPolicyBindingList +from kubernetes.client.models.v1_validating_admission_policy_binding_spec import V1ValidatingAdmissionPolicyBindingSpec +from kubernetes.client.models.v1_validating_admission_policy_list import V1ValidatingAdmissionPolicyList +from kubernetes.client.models.v1_validating_admission_policy_spec import V1ValidatingAdmissionPolicySpec +from kubernetes.client.models.v1_validating_admission_policy_status import V1ValidatingAdmissionPolicyStatus +from kubernetes.client.models.v1_validating_webhook import V1ValidatingWebhook +from kubernetes.client.models.v1_validating_webhook_configuration import V1ValidatingWebhookConfiguration +from kubernetes.client.models.v1_validating_webhook_configuration_list import V1ValidatingWebhookConfigurationList +from kubernetes.client.models.v1_validation import V1Validation +from kubernetes.client.models.v1_validation_rule import V1ValidationRule +from kubernetes.client.models.v1_variable import V1Variable +from kubernetes.client.models.v1_volume import V1Volume +from kubernetes.client.models.v1_volume_attachment import V1VolumeAttachment +from kubernetes.client.models.v1_volume_attachment_list import V1VolumeAttachmentList +from kubernetes.client.models.v1_volume_attachment_source import V1VolumeAttachmentSource +from kubernetes.client.models.v1_volume_attachment_spec import V1VolumeAttachmentSpec +from kubernetes.client.models.v1_volume_attachment_status import V1VolumeAttachmentStatus +from kubernetes.client.models.v1_volume_attributes_class import V1VolumeAttributesClass +from kubernetes.client.models.v1_volume_attributes_class_list import V1VolumeAttributesClassList +from kubernetes.client.models.v1_volume_device import V1VolumeDevice +from kubernetes.client.models.v1_volume_error import V1VolumeError +from kubernetes.client.models.v1_volume_mount import V1VolumeMount +from kubernetes.client.models.v1_volume_mount_status import V1VolumeMountStatus +from kubernetes.client.models.v1_volume_node_affinity import V1VolumeNodeAffinity +from kubernetes.client.models.v1_volume_node_resources import V1VolumeNodeResources +from kubernetes.client.models.v1_volume_projection import V1VolumeProjection +from kubernetes.client.models.v1_volume_resource_requirements import V1VolumeResourceRequirements +from kubernetes.client.models.v1_vsphere_virtual_disk_volume_source import V1VsphereVirtualDiskVolumeSource +from kubernetes.client.models.v1_watch_event import V1WatchEvent +from kubernetes.client.models.v1_webhook_conversion import V1WebhookConversion +from kubernetes.client.models.v1_weighted_pod_affinity_term import V1WeightedPodAffinityTerm +from kubernetes.client.models.v1_windows_security_context_options import V1WindowsSecurityContextOptions +from kubernetes.client.models.v1_workload_reference import V1WorkloadReference +from kubernetes.client.models.v1alpha1_apply_configuration import V1alpha1ApplyConfiguration +from kubernetes.client.models.v1alpha1_cluster_trust_bundle import V1alpha1ClusterTrustBundle +from kubernetes.client.models.v1alpha1_cluster_trust_bundle_list import V1alpha1ClusterTrustBundleList +from kubernetes.client.models.v1alpha1_cluster_trust_bundle_spec import V1alpha1ClusterTrustBundleSpec +from kubernetes.client.models.v1alpha1_gang_scheduling_policy import V1alpha1GangSchedulingPolicy +from kubernetes.client.models.v1alpha1_json_patch import V1alpha1JSONPatch +from kubernetes.client.models.v1alpha1_match_condition import V1alpha1MatchCondition +from kubernetes.client.models.v1alpha1_match_resources import V1alpha1MatchResources +from kubernetes.client.models.v1alpha1_mutating_admission_policy import V1alpha1MutatingAdmissionPolicy +from kubernetes.client.models.v1alpha1_mutating_admission_policy_binding import V1alpha1MutatingAdmissionPolicyBinding +from kubernetes.client.models.v1alpha1_mutating_admission_policy_binding_list import V1alpha1MutatingAdmissionPolicyBindingList +from kubernetes.client.models.v1alpha1_mutating_admission_policy_binding_spec import V1alpha1MutatingAdmissionPolicyBindingSpec +from kubernetes.client.models.v1alpha1_mutating_admission_policy_list import V1alpha1MutatingAdmissionPolicyList +from kubernetes.client.models.v1alpha1_mutating_admission_policy_spec import V1alpha1MutatingAdmissionPolicySpec +from kubernetes.client.models.v1alpha1_mutation import V1alpha1Mutation +from kubernetes.client.models.v1alpha1_named_rule_with_operations import V1alpha1NamedRuleWithOperations +from kubernetes.client.models.v1alpha1_param_kind import V1alpha1ParamKind +from kubernetes.client.models.v1alpha1_param_ref import V1alpha1ParamRef +from kubernetes.client.models.v1alpha1_pod_group import V1alpha1PodGroup +from kubernetes.client.models.v1alpha1_pod_group_policy import V1alpha1PodGroupPolicy +from kubernetes.client.models.v1alpha1_server_storage_version import V1alpha1ServerStorageVersion +from kubernetes.client.models.v1alpha1_storage_version import V1alpha1StorageVersion +from kubernetes.client.models.v1alpha1_storage_version_condition import V1alpha1StorageVersionCondition +from kubernetes.client.models.v1alpha1_storage_version_list import V1alpha1StorageVersionList +from kubernetes.client.models.v1alpha1_storage_version_status import V1alpha1StorageVersionStatus +from kubernetes.client.models.v1alpha1_typed_local_object_reference import V1alpha1TypedLocalObjectReference +from kubernetes.client.models.v1alpha1_variable import V1alpha1Variable +from kubernetes.client.models.v1alpha1_workload import V1alpha1Workload +from kubernetes.client.models.v1alpha1_workload_list import V1alpha1WorkloadList +from kubernetes.client.models.v1alpha1_workload_spec import V1alpha1WorkloadSpec +from kubernetes.client.models.v1alpha2_lease_candidate import V1alpha2LeaseCandidate +from kubernetes.client.models.v1alpha2_lease_candidate_list import V1alpha2LeaseCandidateList +from kubernetes.client.models.v1alpha2_lease_candidate_spec import V1alpha2LeaseCandidateSpec +from kubernetes.client.models.v1alpha3_device_taint import V1alpha3DeviceTaint +from kubernetes.client.models.v1alpha3_device_taint_rule import V1alpha3DeviceTaintRule +from kubernetes.client.models.v1alpha3_device_taint_rule_list import V1alpha3DeviceTaintRuleList +from kubernetes.client.models.v1alpha3_device_taint_rule_spec import V1alpha3DeviceTaintRuleSpec +from kubernetes.client.models.v1alpha3_device_taint_rule_status import V1alpha3DeviceTaintRuleStatus +from kubernetes.client.models.v1alpha3_device_taint_selector import V1alpha3DeviceTaintSelector +from kubernetes.client.models.v1beta1_allocated_device_status import V1beta1AllocatedDeviceStatus +from kubernetes.client.models.v1beta1_allocation_result import V1beta1AllocationResult +from kubernetes.client.models.v1beta1_apply_configuration import V1beta1ApplyConfiguration +from kubernetes.client.models.v1beta1_basic_device import V1beta1BasicDevice +from kubernetes.client.models.v1beta1_cel_device_selector import V1beta1CELDeviceSelector +from kubernetes.client.models.v1beta1_capacity_request_policy import V1beta1CapacityRequestPolicy +from kubernetes.client.models.v1beta1_capacity_request_policy_range import V1beta1CapacityRequestPolicyRange +from kubernetes.client.models.v1beta1_capacity_requirements import V1beta1CapacityRequirements +from kubernetes.client.models.v1beta1_cluster_trust_bundle import V1beta1ClusterTrustBundle +from kubernetes.client.models.v1beta1_cluster_trust_bundle_list import V1beta1ClusterTrustBundleList +from kubernetes.client.models.v1beta1_cluster_trust_bundle_spec import V1beta1ClusterTrustBundleSpec +from kubernetes.client.models.v1beta1_counter import V1beta1Counter +from kubernetes.client.models.v1beta1_counter_set import V1beta1CounterSet +from kubernetes.client.models.v1beta1_device import V1beta1Device +from kubernetes.client.models.v1beta1_device_allocation_configuration import V1beta1DeviceAllocationConfiguration +from kubernetes.client.models.v1beta1_device_allocation_result import V1beta1DeviceAllocationResult +from kubernetes.client.models.v1beta1_device_attribute import V1beta1DeviceAttribute +from kubernetes.client.models.v1beta1_device_capacity import V1beta1DeviceCapacity +from kubernetes.client.models.v1beta1_device_claim import V1beta1DeviceClaim +from kubernetes.client.models.v1beta1_device_claim_configuration import V1beta1DeviceClaimConfiguration +from kubernetes.client.models.v1beta1_device_class import V1beta1DeviceClass +from kubernetes.client.models.v1beta1_device_class_configuration import V1beta1DeviceClassConfiguration +from kubernetes.client.models.v1beta1_device_class_list import V1beta1DeviceClassList +from kubernetes.client.models.v1beta1_device_class_spec import V1beta1DeviceClassSpec +from kubernetes.client.models.v1beta1_device_constraint import V1beta1DeviceConstraint +from kubernetes.client.models.v1beta1_device_counter_consumption import V1beta1DeviceCounterConsumption +from kubernetes.client.models.v1beta1_device_request import V1beta1DeviceRequest +from kubernetes.client.models.v1beta1_device_request_allocation_result import V1beta1DeviceRequestAllocationResult +from kubernetes.client.models.v1beta1_device_selector import V1beta1DeviceSelector +from kubernetes.client.models.v1beta1_device_sub_request import V1beta1DeviceSubRequest +from kubernetes.client.models.v1beta1_device_taint import V1beta1DeviceTaint +from kubernetes.client.models.v1beta1_device_toleration import V1beta1DeviceToleration +from kubernetes.client.models.v1beta1_ip_address import V1beta1IPAddress +from kubernetes.client.models.v1beta1_ip_address_list import V1beta1IPAddressList +from kubernetes.client.models.v1beta1_ip_address_spec import V1beta1IPAddressSpec +from kubernetes.client.models.v1beta1_json_patch import V1beta1JSONPatch +from kubernetes.client.models.v1beta1_lease_candidate import V1beta1LeaseCandidate +from kubernetes.client.models.v1beta1_lease_candidate_list import V1beta1LeaseCandidateList +from kubernetes.client.models.v1beta1_lease_candidate_spec import V1beta1LeaseCandidateSpec +from kubernetes.client.models.v1beta1_match_condition import V1beta1MatchCondition +from kubernetes.client.models.v1beta1_match_resources import V1beta1MatchResources +from kubernetes.client.models.v1beta1_mutating_admission_policy import V1beta1MutatingAdmissionPolicy +from kubernetes.client.models.v1beta1_mutating_admission_policy_binding import V1beta1MutatingAdmissionPolicyBinding +from kubernetes.client.models.v1beta1_mutating_admission_policy_binding_list import V1beta1MutatingAdmissionPolicyBindingList +from kubernetes.client.models.v1beta1_mutating_admission_policy_binding_spec import V1beta1MutatingAdmissionPolicyBindingSpec +from kubernetes.client.models.v1beta1_mutating_admission_policy_list import V1beta1MutatingAdmissionPolicyList +from kubernetes.client.models.v1beta1_mutating_admission_policy_spec import V1beta1MutatingAdmissionPolicySpec +from kubernetes.client.models.v1beta1_mutation import V1beta1Mutation +from kubernetes.client.models.v1beta1_named_rule_with_operations import V1beta1NamedRuleWithOperations +from kubernetes.client.models.v1beta1_network_device_data import V1beta1NetworkDeviceData +from kubernetes.client.models.v1beta1_opaque_device_configuration import V1beta1OpaqueDeviceConfiguration +from kubernetes.client.models.v1beta1_param_kind import V1beta1ParamKind +from kubernetes.client.models.v1beta1_param_ref import V1beta1ParamRef +from kubernetes.client.models.v1beta1_parent_reference import V1beta1ParentReference +from kubernetes.client.models.v1beta1_pod_certificate_request import V1beta1PodCertificateRequest +from kubernetes.client.models.v1beta1_pod_certificate_request_list import V1beta1PodCertificateRequestList +from kubernetes.client.models.v1beta1_pod_certificate_request_spec import V1beta1PodCertificateRequestSpec +from kubernetes.client.models.v1beta1_pod_certificate_request_status import V1beta1PodCertificateRequestStatus +from kubernetes.client.models.v1beta1_resource_claim import V1beta1ResourceClaim +from kubernetes.client.models.v1beta1_resource_claim_consumer_reference import V1beta1ResourceClaimConsumerReference +from kubernetes.client.models.v1beta1_resource_claim_list import V1beta1ResourceClaimList +from kubernetes.client.models.v1beta1_resource_claim_spec import V1beta1ResourceClaimSpec +from kubernetes.client.models.v1beta1_resource_claim_status import V1beta1ResourceClaimStatus +from kubernetes.client.models.v1beta1_resource_claim_template import V1beta1ResourceClaimTemplate +from kubernetes.client.models.v1beta1_resource_claim_template_list import V1beta1ResourceClaimTemplateList +from kubernetes.client.models.v1beta1_resource_claim_template_spec import V1beta1ResourceClaimTemplateSpec +from kubernetes.client.models.v1beta1_resource_pool import V1beta1ResourcePool +from kubernetes.client.models.v1beta1_resource_slice import V1beta1ResourceSlice +from kubernetes.client.models.v1beta1_resource_slice_list import V1beta1ResourceSliceList +from kubernetes.client.models.v1beta1_resource_slice_spec import V1beta1ResourceSliceSpec +from kubernetes.client.models.v1beta1_service_cidr import V1beta1ServiceCIDR +from kubernetes.client.models.v1beta1_service_cidr_list import V1beta1ServiceCIDRList +from kubernetes.client.models.v1beta1_service_cidr_spec import V1beta1ServiceCIDRSpec +from kubernetes.client.models.v1beta1_service_cidr_status import V1beta1ServiceCIDRStatus +from kubernetes.client.models.v1beta1_storage_version_migration import V1beta1StorageVersionMigration +from kubernetes.client.models.v1beta1_storage_version_migration_list import V1beta1StorageVersionMigrationList +from kubernetes.client.models.v1beta1_storage_version_migration_spec import V1beta1StorageVersionMigrationSpec +from kubernetes.client.models.v1beta1_storage_version_migration_status import V1beta1StorageVersionMigrationStatus +from kubernetes.client.models.v1beta1_variable import V1beta1Variable +from kubernetes.client.models.v1beta1_volume_attributes_class import V1beta1VolumeAttributesClass +from kubernetes.client.models.v1beta1_volume_attributes_class_list import V1beta1VolumeAttributesClassList +from kubernetes.client.models.v1beta2_allocated_device_status import V1beta2AllocatedDeviceStatus +from kubernetes.client.models.v1beta2_allocation_result import V1beta2AllocationResult +from kubernetes.client.models.v1beta2_cel_device_selector import V1beta2CELDeviceSelector +from kubernetes.client.models.v1beta2_capacity_request_policy import V1beta2CapacityRequestPolicy +from kubernetes.client.models.v1beta2_capacity_request_policy_range import V1beta2CapacityRequestPolicyRange +from kubernetes.client.models.v1beta2_capacity_requirements import V1beta2CapacityRequirements +from kubernetes.client.models.v1beta2_counter import V1beta2Counter +from kubernetes.client.models.v1beta2_counter_set import V1beta2CounterSet +from kubernetes.client.models.v1beta2_device import V1beta2Device +from kubernetes.client.models.v1beta2_device_allocation_configuration import V1beta2DeviceAllocationConfiguration +from kubernetes.client.models.v1beta2_device_allocation_result import V1beta2DeviceAllocationResult +from kubernetes.client.models.v1beta2_device_attribute import V1beta2DeviceAttribute +from kubernetes.client.models.v1beta2_device_capacity import V1beta2DeviceCapacity +from kubernetes.client.models.v1beta2_device_claim import V1beta2DeviceClaim +from kubernetes.client.models.v1beta2_device_claim_configuration import V1beta2DeviceClaimConfiguration +from kubernetes.client.models.v1beta2_device_class import V1beta2DeviceClass +from kubernetes.client.models.v1beta2_device_class_configuration import V1beta2DeviceClassConfiguration +from kubernetes.client.models.v1beta2_device_class_list import V1beta2DeviceClassList +from kubernetes.client.models.v1beta2_device_class_spec import V1beta2DeviceClassSpec +from kubernetes.client.models.v1beta2_device_constraint import V1beta2DeviceConstraint +from kubernetes.client.models.v1beta2_device_counter_consumption import V1beta2DeviceCounterConsumption +from kubernetes.client.models.v1beta2_device_request import V1beta2DeviceRequest +from kubernetes.client.models.v1beta2_device_request_allocation_result import V1beta2DeviceRequestAllocationResult +from kubernetes.client.models.v1beta2_device_selector import V1beta2DeviceSelector +from kubernetes.client.models.v1beta2_device_sub_request import V1beta2DeviceSubRequest +from kubernetes.client.models.v1beta2_device_taint import V1beta2DeviceTaint +from kubernetes.client.models.v1beta2_device_toleration import V1beta2DeviceToleration +from kubernetes.client.models.v1beta2_exact_device_request import V1beta2ExactDeviceRequest +from kubernetes.client.models.v1beta2_network_device_data import V1beta2NetworkDeviceData +from kubernetes.client.models.v1beta2_opaque_device_configuration import V1beta2OpaqueDeviceConfiguration +from kubernetes.client.models.v1beta2_resource_claim import V1beta2ResourceClaim +from kubernetes.client.models.v1beta2_resource_claim_consumer_reference import V1beta2ResourceClaimConsumerReference +from kubernetes.client.models.v1beta2_resource_claim_list import V1beta2ResourceClaimList +from kubernetes.client.models.v1beta2_resource_claim_spec import V1beta2ResourceClaimSpec +from kubernetes.client.models.v1beta2_resource_claim_status import V1beta2ResourceClaimStatus +from kubernetes.client.models.v1beta2_resource_claim_template import V1beta2ResourceClaimTemplate +from kubernetes.client.models.v1beta2_resource_claim_template_list import V1beta2ResourceClaimTemplateList +from kubernetes.client.models.v1beta2_resource_claim_template_spec import V1beta2ResourceClaimTemplateSpec +from kubernetes.client.models.v1beta2_resource_pool import V1beta2ResourcePool +from kubernetes.client.models.v1beta2_resource_slice import V1beta2ResourceSlice +from kubernetes.client.models.v1beta2_resource_slice_list import V1beta2ResourceSliceList +from kubernetes.client.models.v1beta2_resource_slice_spec import V1beta2ResourceSliceSpec +from kubernetes.client.models.v2_container_resource_metric_source import V2ContainerResourceMetricSource +from kubernetes.client.models.v2_container_resource_metric_status import V2ContainerResourceMetricStatus +from kubernetes.client.models.v2_cross_version_object_reference import V2CrossVersionObjectReference +from kubernetes.client.models.v2_external_metric_source import V2ExternalMetricSource +from kubernetes.client.models.v2_external_metric_status import V2ExternalMetricStatus +from kubernetes.client.models.v2_hpa_scaling_policy import V2HPAScalingPolicy +from kubernetes.client.models.v2_hpa_scaling_rules import V2HPAScalingRules +from kubernetes.client.models.v2_horizontal_pod_autoscaler import V2HorizontalPodAutoscaler +from kubernetes.client.models.v2_horizontal_pod_autoscaler_behavior import V2HorizontalPodAutoscalerBehavior +from kubernetes.client.models.v2_horizontal_pod_autoscaler_condition import V2HorizontalPodAutoscalerCondition +from kubernetes.client.models.v2_horizontal_pod_autoscaler_list import V2HorizontalPodAutoscalerList +from kubernetes.client.models.v2_horizontal_pod_autoscaler_spec import V2HorizontalPodAutoscalerSpec +from kubernetes.client.models.v2_horizontal_pod_autoscaler_status import V2HorizontalPodAutoscalerStatus +from kubernetes.client.models.v2_metric_identifier import V2MetricIdentifier +from kubernetes.client.models.v2_metric_spec import V2MetricSpec +from kubernetes.client.models.v2_metric_status import V2MetricStatus +from kubernetes.client.models.v2_metric_target import V2MetricTarget +from kubernetes.client.models.v2_metric_value_status import V2MetricValueStatus +from kubernetes.client.models.v2_object_metric_source import V2ObjectMetricSource +from kubernetes.client.models.v2_object_metric_status import V2ObjectMetricStatus +from kubernetes.client.models.v2_pods_metric_source import V2PodsMetricSource +from kubernetes.client.models.v2_pods_metric_status import V2PodsMetricStatus +from kubernetes.client.models.v2_resource_metric_source import V2ResourceMetricSource +from kubernetes.client.models.v2_resource_metric_status import V2ResourceMetricStatus +from kubernetes.client.models.version_info import VersionInfo diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/__init__.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0057fbdb6aa3930263e060e0ec8688da9b2428f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/__init__.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_service_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_service_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc555a2c55e3cd1d13562a8ef4945a84eac30039 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_service_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_webhook_client_config.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_webhook_client_config.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b09f42301dd8b20d56327120b976ed307c323cee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/admissionregistration_v1_webhook_client_config.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_service_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_service_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d19def1716187ca19c8974fa30f4f2b9abe5b959 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_service_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_webhook_client_config.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_webhook_client_config.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d7d92f5b0dce36e50a171122dcf6c7c1cbf0fd5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiextensions_v1_webhook_client_config.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiregistration_v1_service_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiregistration_v1_service_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fa17d1e85a2dedeae875c93582b2b4509ff4dea Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/apiregistration_v1_service_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/authentication_v1_token_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/authentication_v1_token_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9a334ae611df42c640cd663fb2b218f881bd928 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/authentication_v1_token_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_endpoint_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_endpoint_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee5b3543751bd773731d9cc8405b1ab145b9addb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_endpoint_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df97d7ef6d40b44dc4d74b6e07b3eea75f1517cf Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1420fde6af6073db7ce22eff4f5968f78c5f694 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_series.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_series.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..410516ea28f0fd7fa2cc968517b3d209bf0d9656 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_event_series.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_resource_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_resource_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bed998b602f722451735fc5afd4cc7ffe862c55c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/core_v1_resource_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/discovery_v1_endpoint_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/discovery_v1_endpoint_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bca8b75fa16740eb051f5a02f69a57bf5c6414a8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/discovery_v1_endpoint_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca2ad0c37ac39a1e670e14ff6b57cd49bc669634 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77e7a780d93b8c0b099659746aab41872100f749 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_series.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_series.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f0d5b435ba20c914318e92dd845e7f199b8fb2e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/events_v1_event_series.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/flowcontrol_v1_subject.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/flowcontrol_v1_subject.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..698e07b4e86f6bde125de89296adad0c11f72e13 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/flowcontrol_v1_subject.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/rbac_v1_subject.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/rbac_v1_subject.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02b28f00d430e1be5d928480185a910d798086b1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/rbac_v1_subject.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/resource_v1_resource_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/resource_v1_resource_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd8d668f3ceea312d967e57d9d3917ce7f8b10fa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/resource_v1_resource_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/storage_v1_token_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/storage_v1_token_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb1dddab60f30d0498acb0b91844bd95948a7ab8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/storage_v1_token_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_affinity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_affinity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8555126fddcb807e4eb988aef7ee4d929171e76f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_affinity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aggregation_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aggregation_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83868ac2ffb104684d903b2d4db999b760fac8ef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aggregation_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocated_device_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocated_device_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..feb325fe8cc5833ffa474432b671c85410971898 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocated_device_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..220d5f00b8b2b2bb2553a2fdb86f91cef15082f7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fabfe032ec5dfddd7986aa4f8d769617d1c87a69 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63b81369e08895cf2f87085d09175b72152beb9c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_group_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78046aa5876ffe875002bf581b25830f1dd116e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e188cea4af29c81f240c76f2856ebc9907b19b0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_resource_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..670436d1b69649f97f51cf38a01f430d5a5eed4b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c510227d8b1a1367a3f89854b9738e942a7c6711 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7c00bbac6345061821e3883f8860ec3cbea79cf5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1afa6b9b14f771cb5567f6d474c5885370320a4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff9d0d811fd4f41a59dce37496f6dc961d9d6b01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_service_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_versions.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_versions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7047313d3dbb4ce1b09697958233faf8d4ffbc3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_api_versions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_app_armor_profile.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_app_armor_profile.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2ff9a2ee5f22c462193033c41b6ae7ff3085753 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_app_armor_profile.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_attached_volume.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_attached_volume.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25171d84cee44545c6243ce401fe9e759cd1eaa6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_attached_volume.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_audit_annotation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_audit_annotation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..982849e4fdae46192acb0db45c989a166aa5ab59 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_audit_annotation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aws_elastic_block_store_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aws_elastic_block_store_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f30b046505bf87e9eab39af7fe253ec4e1371a84 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_aws_elastic_block_store_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_disk_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_disk_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80733f4a15d7894abc443950e19115c36ce1bb32 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_disk_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41a8d8a9582da86e43602e3e81c7cc8b2b431b62 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8961e8257d9cdade88aa1c9581765fa62b984083 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_azure_file_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2ac70b064b37ea79784274569e3fb9da74ef26f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_bound_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_bound_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..38a326cf9a29e3092cee13b23c809c08a41c8f67 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_bound_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capabilities.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capabilities.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6214bcbeb88ac894ebec0631f704aa458c83488 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capabilities.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a35eb80f905cd8da3b9df6ef10a93bd8dfcd8e50 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy_range.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy_range.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc997a93c39a1f8c3180b6bc0bdb11eb7b0d0c9f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_request_policy_range.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_requirements.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_requirements.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58a13e4f9cc95d5a1e07e70c5667f415ede9cc2c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_capacity_requirements.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cel_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cel_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae55bf11d972c3270cf360d41f9af2ecfed61f27 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cel_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7f3611361da99aa94788e930753da8113db9962 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64e1d11d786cfce2affeb1a99fae71ae114cbad7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ceph_fs_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47b5b92f019eb0bdc29bbd417614bf95b5806452 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f32f0add8d397c143993e84bfe3f47be2cd352ef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a0552795afadbe4d8c5578e053927e890d114a2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2ee3ab8ce2731d50c51e1c7c71e701d3207243b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be9c37f34ef8f0f6c77dfae9bf1b614b38edd8c1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_certificate_signing_request_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aba69b4baf5f82327626de55901255c9f1ac4fe3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d1d1eef7bb0259f477a51e37e0ad964fa914fd9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cinder_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_client_ip_config.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_client_ip_config.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..944395c5d74b02a1d9df9bdeb9079a5c748e3a2a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_client_ip_config.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88e8aaea3e724d73fcf1eeb7b284fe4862e63673 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4141885ccd5ac5b48f322f3a4d553b1bb7d7e90c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2053c4926d8d5df0e97c1e8ed063ffbf2d05f76 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_binding_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1eb6435989bef38c218da69bad53c87ff1da3bc6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_role_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_trust_bundle_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_trust_bundle_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27825426650c04ca60e043d6aa48f93bdb01fd24 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cluster_trust_bundle_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7ba04a3f13542b624e53ec5c8eae657031c873b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a1e3e66583077e36c795c68cbe18a212e43bb1d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ce6c8276c37f3637eaff9a38d7bdf2464e074c0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_component_status_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4aacc88c91c6d850b673ee9724d4a8b966c7e999 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a00c1f77fbc7b27eb454f4382ac8b76ddf14601 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_env_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_env_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b2c8868d6a4e9edc2937815fd516bc0d0e23d01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_env_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_key_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_key_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24a13746182fdebbcabec2820b9b1d7b6a512c0f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_key_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6892d463cb8f5009636cc65f279ab055a705c7b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_node_config_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_node_config_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d75f43ffc7d547a1cc63e15d48394989a0012fc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_node_config_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c068ef8f3e3701aaeb004378e9ff77216d24c10 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1512927a554210c6a2cfe7b8d2245faaab1ac43c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_config_map_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..169d57f429e88874e41b0b7a0e545a4a8c1f1b03 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_extended_resource_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_extended_resource_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eea2e8f88e7e455b0189da1bfb1aed7fffe33e7f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_extended_resource_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_image.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_image.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fab4b8a9760de3a1e42228aae8de2eaa6a908e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_image.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03296d869e5567e72fe7e04fd2b0a6c4439caad1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_resize_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_resize_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7252f3c97a620b30afed0d07139bfc8ba8993859 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_resize_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a44cb3a135194b07b930409176d40e9104a34414 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule_on_exit_codes.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule_on_exit_codes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a783e77bb64fbe8848d43a909e389f51cacc6e4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_restart_rule_on_exit_codes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..14a0c1086c53b25586d340886d74c70975c528a0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_running.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_running.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..652afb02002df3d043e38237fc6bf1ddd28cdb78 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_running.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_terminated.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_terminated.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74cad44f360ac7a7caa82cc3d86679381ec4df8c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_terminated.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_waiting.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_waiting.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46aacdbb8828ee2eb0717bea0139a92e2e4b171d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_state_waiting.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64009be639712072c320993e2f8c887eaa18f3a2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_user.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_user.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af334e2413326ae49c327dc4270bb2a16d9e6e85 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_container_user.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecc601b53d8cd4dbb7ac7ece1d9bf6bed97303a3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12f082e45a4732288fe6ce73f641e218dd3b91bb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_controller_revision_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f409bf43f0f4fdd2d2568f6b04b4d47a1281f4e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23074b29c09ab8a43a0dc7f672c00f8dab91ff15 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_counter_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84581a793deb77aac00a5e238575e96afb7b4d38 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e869266981fd80916af395b03805969bd64f057a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35e99e5f84804b534847ac52a5dd9a1dae15c555 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1484ba628b47dc3b60ee9f9386ecd8320223a8b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cron_job_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cross_version_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cross_version_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6daff396f85b359546d0b98301ded7e15e40a1e8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_cross_version_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ab9fd8d0fea4f9eeeafae106063680ea4a4bc03 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..73e212dc28164ade26f83aab817f9189473fb1a2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0acbb31dc9e56f05a233e88238729b4d7dd7252 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_driver_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b338db2b4cf18b0c22eec3eccd8d9029af891716 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_driver.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_driver.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edb19c5b70086ef91a3cd60d826674e4d9cb7f7a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_driver.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7bd558bfbd90433b751671ed878bf73d48f1d0e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51455d25efd4271b7265aed9c6db1bc7854a255c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_node_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..948c7477e48053df61805ca98182bbf717c3c207 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d515306756381565105ee4b9fe4df1edfc115fa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbb9bcd58cec58cdeb00d4a28783f05ce342d09c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_storage_capacity_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0deb6134829fbd5e19a6d89440c8ee377a393712 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_csi_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_column_definition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_column_definition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7208887694dd6705c032228a8c4f9188b14530a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_column_definition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_conversion.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_conversion.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd89bb96e6d2a7b6756f2185ce4eab6dc608bec0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_conversion.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bd8b1dc771490c9c15adb3ec8f7123019f15e79 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..088561b877f651691b82bd51c70ed21b54d72f94 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..308faa231b56e1a392fe20e2044a394dc94f1652 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_names.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_names.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1757ab017c39408ff70c8a44d1335e973343524 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_names.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..672827fe0c33d4a353c3fe4c0f29bc1ac2cd268f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e3083ebb8ad1bd9942211a3a2814bdd80781bd7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_version.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_version.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc050ab67de857420e927dfa7fa0765473f19b55 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_definition_version.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresource_scale.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresource_scale.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a773fd25272ff170bd82c48f255aa16467daa047 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresource_scale.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresources.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresources.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4dbe6eaf5ea4c006a084aa9d3e387a1792929c8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_subresources.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_validation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_validation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a488125c2dcc332eb4112554e877a6900d0f9af Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_custom_resource_validation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_endpoint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_endpoint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28e71c4da09f2a3fe1db1f86f5a0a6585fd67086 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_endpoint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db47c628d956a7a9287d79e8d32a81ffc3a660eb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efb2baceca0f9d3649e69a5a340ff8e33ecfc3aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21ffa1fe34c90127f4419752eeb72220a2f54d1d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a3afed8e871041b166a624974e65fa83da7c28b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4c380245e64e8442007839cbaa2fe2c2e250aef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_update_strategy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_update_strategy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7623f826d955481c547e5d96bc71878566a9e0c9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_daemon_set_update_strategy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_delete_options.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_delete_options.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..962c19ff913576e5fc5fb68132881962b8960c01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_delete_options.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94623792f4e8d9b67677ab2cbcac4910207591aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c61bd9ea6a3f50d58e33394cc0eaa7b514a79bbe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f8efc4c6c09c36cbc3609281a1be0bbf8502822 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94b2a9a1a23a81891916f003f6677f5448c392cc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffc5637c807acabde9891029c970209239ec1ea4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_strategy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_strategy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28f8b7d6c5fec37fb5377621fb020b0619139ca0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_deployment_strategy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39992cf6f8c81a693ec891f7cfb1ba87e9860b62 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97c1c6857a90367f118f5faa00bcc8563df0a37c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..592794357b683cc08fc5348a63968f3dbcec1ced Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_attribute.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_attribute.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fdcc03fcefd71d51b434d997829efc7524d89aa6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_attribute.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_capacity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_capacity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..244ff578e91cd09a13796b721e089ee88291bc51 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_capacity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..333d7c1d7895a14d56fc02fdb1200ef54b8f3a3f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fd5b34ba58f8a65388c3fb010436f6c2003415b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_claim_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9fcc75c98724fe79446bd95a40c15551ff21de6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ac5bfb89fa60891dfb5a9c2f95b48f8733452d2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd8542961f13c6eed0a32df88afb17ef0f53987e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..058bed0e76282140b43d14d0bc7b1f13b0a6230c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_class_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_constraint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_constraint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f28ca5048323ce3abc0e1737da8381be3e79f0a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_constraint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_counter_consumption.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_counter_consumption.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b6aed000bccaab8180e33968f4448d1b2bf3b9a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_counter_consumption.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95962bc0684d2eaa93c547d73acbfe9348a040ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15b79b425eb32301de72f3988611b4c5428bd249 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_request_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6ff7d2cfb7c0673e63806b977ecf6892ac5f772 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_sub_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_sub_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b5753417ab9c44549d2c2922e82211568cb55dc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_sub_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_taint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_taint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b11310950c53b5dfea4ef99369098b2f8b848c71 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_taint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_toleration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_toleration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f76d8d40ef4ad38fe2b94ec3984b3a11172d83f6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_device_toleration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7906cf295ee7097be0ff3121cffd1b1115de9780 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_file.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_file.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa1547ff87947c3baca89fe12f47e5196355177e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_file.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3693956cf98a435ee2de5754539872b55fc920a1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_downward_api_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_empty_dir_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_empty_dir_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fd99d64325ed49ad60e718fd35abed320569431 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_empty_dir_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f69a775928b24b34c1d7ec52eca6b20792ed022b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_address.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_address.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7c192c31586caa63b18ccee3e7c1dda13dc21dd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_address.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_conditions.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_conditions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96c3fc504ac2bb37fd8dad86463576e714829be9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_conditions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_hints.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_hints.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbc5a98f151dd75bf88a6178b97c0d5071cc5257 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_hints.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33b29ac2050c42db56eeef2a457971ed016383b8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac31d87d6c94303b5e605b3f0b24e3d4f50873a1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_slice_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_subset.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_subset.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46c68448ae348d41bc89e5b106b5a2a34389fd9b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoint_subset.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eab56445ac869578a483c1e90615bdecaed6373b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b54bc9af73929dc9b173fd9aeb66f50f545d86aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_endpoints_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_from_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_from_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ee1833c1df22d2fe2c36fb59ccbf1e25f88fd6d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_from_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb7d866e6ea51d605d97beb0d7d5bb694a5960ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..069ef2ac381f0f229d6c2f133507e738fb06104d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_env_var_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_container.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_container.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da7a71478a5093fcecb58b21fb07d1c2c4921a9a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_container.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b06324c6757e92f85d4dbab4dd094e6d4e3d5b1d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ephemeral_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_event_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_event_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a896ff376a9599b1ca884e488ced171b9cc6e700 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_event_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_eviction.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_eviction.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f808a165bfc369ac080a75b15d9762fd3fa0430 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_eviction.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exact_device_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exact_device_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa4b6949d467c77eed095b306d6e91e3e5ab2e01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exact_device_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exec_action.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exec_action.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ba7566516d6f2e00e5d6b93ce5fdc8c59e8f9f1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exec_action.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exempt_priority_level_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exempt_priority_level_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..872cdec8d00ba7c366cbdda0f02a6a3558d50066 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_exempt_priority_level_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_expression_warning.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_expression_warning.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54843288442764eb4e82e9150fbd0b7634101b39 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_expression_warning.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_external_documentation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_external_documentation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc7140d8759440c7b14fc47ace17cd7ac3ed8c77 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_external_documentation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_fc_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_fc_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8014b598985b4efe553017752666dfb50418b43b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_fc_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_attributes.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_attributes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..980c4d107e9dfab5e0fb43111a366526d4fa663c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_attributes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0344d104d8ad90ba7783a41f326511d00cb163a7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_field_selector_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_file_key_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_file_key_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b7be399093bb010a99f17a928f5d4bb8fcbac73 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_file_key_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37d3dc81114599dc15e5f812944df5b05ab66b1e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..255b29fd36427fbcc46e01a5777acf59eb4ae95f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flex_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flocker_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flocker_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d64b96230775d5b689d5b9da7731b89499a1e865 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flocker_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_distinguisher_method.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_distinguisher_method.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec44e18f1becaa560a9c26bff192e3cbf44293ad Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_distinguisher_method.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..155c69c599095d4608523158661ff9f296aca6cf Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e47dde84a42a47ae827f8756ce1118496ac9cf1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86e849e6cebf3829028fe1a76170953874286fe3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91ff87963e3d4d44d9050c485faa17a54f730376 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de59b9f109ec780519249918ebd7967ac37e7c64 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_flow_schema_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_node.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_node.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dea0f299a9db0c21e6c02bf6e2ff04cccd959998 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_node.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_zone.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_zone.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6a97eab0aede4c18e55003ab12d6aa4081dc22e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_for_zone.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_gce_persistent_disk_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_gce_persistent_disk_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0c7764d21ac5602edcbdbbde84741572688d449 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_gce_persistent_disk_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_git_repo_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_git_repo_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef2d895031b14fd445dcbc24c22dabfabc2f5d47 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_git_repo_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f0b09746d31e3051f327ac37c683d82e172bc52 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b72e513b80c14fbf66fd3877c9b464f3b477e546 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_glusterfs_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_resource.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_resource.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5eb4d9d614f85818deff28f043cfc655294116b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_resource.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_subject.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_subject.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..188876573860b111ef3801ad7ddb44429a70e06a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_subject.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_version_for_discovery.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_version_for_discovery.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3861380a8a5aa076fd10a562cd2f9fb867fa45a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_group_version_for_discovery.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_grpc_action.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_grpc_action.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..385e16b9aeb93beb0ae745ea97eda5562d25f632 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_grpc_action.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f4cbde329997a65eaea3de9f7040aeaa08cd198 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e792a581799817c0af38491abaa9229f62193911 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bb28172ca722db5861053cfcff4f9e37d4479cb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67c2728adc96080f8a45634db9a62c0a33aebf73 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_horizontal_pod_autoscaler_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_alias.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_alias.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8bdfed65e1e661431af85763b8bb894d11f4541 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_alias.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_ip.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_ip.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a71b933172ffac85a63c5c9563b1ca532710c9f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_ip.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_path_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_path_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c26360b035605717c3814be41232c6434b13b402 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_host_path_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_get_action.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_get_action.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b95b4eaa905b5a324fe5712992cdda45a6f0a8b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_get_action.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_header.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_header.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69a73465f7abe62ef68cf2e8ce71f98034e65889 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_header.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_path.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_path.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68b353dc07730ce6897c3b8e6a7312bcddb86313 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_path.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_rule_value.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_rule_value.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7fe677a9c3f95c0f20707cfbc521a6a45d64b3d8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_http_ingress_rule_value.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_image_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_image_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92d31631910269fcd6e862a2dd5b39bb02c6024f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_image_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce77b0afef8b9f3642a166649b4b3b5ef8c3f8bd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_backend.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_backend.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edd27a0c7747e78d0bd1bd8fbb2f3633a6ab9fbc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_backend.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69447c0a2edb34bfefd16766fce3c563f04e0ef3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d504d9c9ecf8694c03b07abea81d7ec63a17f9d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_parameters_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_parameters_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b53c08c977496939abd5d0fb429778da61e1ed85 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_parameters_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b364d2715136235ce42bc1fb7f4f38d1393ad5fb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_class_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db867a8d1d0e9c1ba8f44d9e5546ca2c9cc172ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_ingress.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_ingress.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa126c54c212b4d595f6f4eb738779ed3756c664 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_ingress.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..420b6eb59a5fe7d640e0497c8070312ab65e5a82 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_load_balancer_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_port_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_port_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ed32cbff45210e7548cbe2d9c1e7ac908a74869 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_port_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2aa7e28f083ab16e6eb5c5762e081fc56861edc4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_service_backend.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_service_backend.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7aa7460b01d77c756e21d030cbf16f03ef73ee6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_service_backend.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19b05ce1be5b9a1a6c12d4b0b182056162161f71 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edf9c18db379c320e622b82aacb621586f7550b9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_tls.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_tls.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d413e72b57ee58d8b3f8be7b3f14594a35196f2c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ingress_tls.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce8bc0da7511353ce220a75189bec01c834bb9e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83bd9373b50ed5f4547a7c9d1eeaff496b5167da Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1d4615584558af9066da9eb9d986196a3b25fa4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_address_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_block.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_block.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0627acf18c83c08d6339dd5572a477d5ef369eda Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_ip_block.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df03a202f3acc289ecf7d47ec40a36269b4336c5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd5b75d8ea6399b1cc2c14649265f83bd585b1db Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_iscsi_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6feae742154f15239809a6f6e13218d6741422fe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..765a9ca3e26890c55fbee17db1b728f4c921c235 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7338c0195049db43ecef9a9cab22153f09ea5793 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11c92e501ebf9eb09cd4234639d82f8b4fa4dc42 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74e1abb0be755d9cf691fcc71a4d7c66c676f68e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_template_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_template_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6541baf4cd1324d781203ec2e395cda992b311af Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_job_template_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_json_schema_props.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_json_schema_props.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1bbe3f206fef5d3fdc46d70739a508673098f91 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_json_schema_props.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_key_to_path.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_key_to_path.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02445cbcc0ee62db98a24821a9208ff4d3b5ec09 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_key_to_path.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ece1cd2f13e13045273fd2a6dfd1a155ed76b27 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_attributes.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_attributes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce70a746f2824b09d114ea9a0e78dc3d44ba9fbb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_attributes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7c0478716926b593430312050a6dcfa0d86810bc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_label_selector_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58481436bbe7840482557a9d31befc48b7eba106 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef569bc2d2c03ca7ec8d27ecb5872d26f5fd1f7f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fbe6c4c83a2e71245bfd6d10650797b5511f15e5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lease_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fc05a131654b0124589cfb10d7c2afb03b45b4d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle_handler.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle_handler.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c593bd75a8d6a6bdd8729781fea4f7c32cb06754 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_lifecycle_handler.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f451ec6104ba06f325aa647833b6dc6b7376b0ef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_item.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_item.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c322ff2d833cd498bd52f5e9b772fefc4139d29 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_item.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b334e729b99ae3a64b54aca81f29c480b578417 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5b2d78f3abdd0dc5141b1f73743155ae4d73eab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_range_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_response.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_response.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b734c6f767f1ce6da73152b91fa788b3c4ddde2a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limit_response.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limited_priority_level_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limited_priority_level_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b3630966b2c9dc9b3732d18197c211c5d6d8ea8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_limited_priority_level_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_linux_container_user.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_linux_container_user.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a14673cd864a68fdb269b16081568a1cd542e90 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_linux_container_user.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_list_meta.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_list_meta.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57b3ebf69d4e9901d8a869bd6f9a787d4f60cf70 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_list_meta.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_ingress.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_ingress.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6821df99c46f770c06a9f3da487b182af0f0d01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_ingress.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eec11dc7b4da89b1886dcabd2c900d5744c56665 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_load_balancer_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..93811f72fff401225b1c0fc4722f27a529a88e9c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_subject_access_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_subject_access_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2dc2eb9a68b8c0a691aae8edb12498104b983644 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_subject_access_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f4a46f59c69f8e37b7921e16f0312876376a888 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_local_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_managed_fields_entry.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_managed_fields_entry.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b6a235e1647950f4d08fa9fd777f5f110441383 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_managed_fields_entry.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2b824199b47553cf155981263491a856d6a12eb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_resources.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_resources.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85afe0ee81cfd32f857ae6920d6e1fe64533cd22 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_match_resources.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_modify_volume_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_modify_volume_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1c549b575ee8740d9fd61c27f1ef10f8c15f082 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_modify_volume_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1752c7d17c3a3c47016706a5be66c14035e04906 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0607fe3bd86f34fb07c500bddbbf605810d544f1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f33e118b840c78febbab8eb71d27a1056c72234 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_mutating_webhook_configuration_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_named_rule_with_operations.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_named_rule_with_operations.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4181e46e309d8abec6988f8798e8b2ff53fd2126 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_named_rule_with_operations.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5600033e9d854183af10033b109a843f6280aa93 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..416af55cbd4beb7085a7895a5718e4a1083d1d22 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd2dda848e4d6e1c4ca8e9faae082e490917442e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..472732fda61fc5e6ae81ae01aaa3386aadefe506 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3580273f55151d69ac3318242eafaae5569cb6f3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_namespace_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_device_data.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_device_data.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..700b723da0681db7472fba556a838762d3ef43bc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_device_data.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0535fdb96f5d95d3300f6d672763ea0ab890fdba Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_egress_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_egress_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4472fb40f1ee2885893d2d67fc0817425217a70 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_egress_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_ingress_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_ingress_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26844d46a6204c413d1aa418058bacb16d55c7ab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_ingress_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7abfd8720a2c5312a7a465920a55e1e30bc7ee0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_peer.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_peer.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..275d17540a8002f0ee9d91ebebf5c52a4f2cfdac Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_peer.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c02c2aa3996f25e1fc0397863124ee8adc165401 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bad88f29ca0fe3da949c7d0118f1abb810dd079 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_network_policy_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_nfs_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_nfs_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9574b8dcdf410b1bec4f3efe486df41e99c32e4f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_nfs_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eba2b49aa909047236ac713ee42e65565fc91fe2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_address.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_address.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd8d981cf05d5e1bdbd03b6b030bde7089e89cec Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_address.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_affinity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_affinity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0fba43f6412c9b32d88a22cf77f62e2ef60f181 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_affinity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7762d5b5d862aebe23004bdeff4763a2e08a78ec Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d93add0e2439e13042615320649a9299cee9171 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fca7568af7a30b302c287981450b18db316f2572 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_config_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_daemon_endpoints.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_daemon_endpoints.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b03ee00656edee37e2b127faafae29f5bf4243cd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_daemon_endpoints.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_features.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_features.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d50e0b289d89dde7c41e7fcd3d9c18cd214566ab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_features.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80d8cc37b8d17cecd29d2b4c9774bce605b5291d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12516f028cacb58e315b1d2a6a30098fb0282223 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler_features.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler_features.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43a9bcd5b286bce88dc9d99265c351e2911fded6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_runtime_handler_features.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b30162e278872518004e1adcef141065b4f703e7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2186aa4c542aeba9e3547b33268cfba1579e4bb8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_term.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_term.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24cf10b4242cbc6368aca4fff6082cb2903eec54 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_selector_term.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7750130e26084c0c071400d6e140403d5cde6b86 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b1f1069ba4c2c611a7f0953a3e9eb1ca9583da2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_swap_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_swap_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..59b21d331d0e2f0826b9d6cf992c4ed8486c033f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_swap_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_system_info.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_system_info.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa8ae6350a1ca668a6db0f9f2a3d00789c30ef97 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_node_system_info.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_attributes.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_attributes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7346066bb91f001618578a391392c3099c9aaee3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_attributes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_policy_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_policy_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4003a5031e0983a0fa3834c81ea1514b1a975e7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_policy_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8590dd84b52c3232b69d7475a1e350ad9300bc3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_non_resource_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_field_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_field_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..742092b84acf390048ecab1be6e9f8c7e239c346 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_field_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_meta.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_meta.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7c16f530f44e956e2f4aa13144bdda1d61f8f9ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_meta.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5689f8dc0d5a0873a60250c91c95caa10332cb55 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_opaque_device_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_opaque_device_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ed67b1cf4ed6a9ccfda8815c0df1459cd36b340e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_opaque_device_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_overhead.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_overhead.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2914c0505c5f706b2c0642a679fe5cccefe8e4f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_overhead.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_owner_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_owner_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6208f7b7ed841e24de2cbc9447e0e94ac8ad4137 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_owner_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_kind.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_kind.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8625e97c767ac605a7141a2c345c28e45727270e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_kind.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_ref.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_ref.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a91a9972040e1d5758e2086f1e96627fd442da40 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_param_ref.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_parent_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_parent_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82dd47af537cb89437fb1d215d6a6a5c84a902bd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_parent_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a45a6d351dc77e9f8c791ce283a0971462a575a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45101bbf6d41164ea8235ca0fa10bed4a76b52e5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b829c78e361ccd8e24aedfad6362a2997175959 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94cc06a6683af7b6b4fa9332eddc344e8f0f466c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92d2da03b3317ddb508e6a16d0eae7237644047d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..297900c8cd6bf21449344244acba2a81d108e3be Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_template.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_template.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ba41a9497063c0d0dbbc4c2856c341110c07fb2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_template.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1bcd3d4e7bbcd9b7a40fa493550d299fe723b77 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_claim_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4570812a728396f2273ebff79aeec6713e08afa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41d2d45b1b0c068037c9308aa301fd74e74afac4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..954ea26263fed69b8bb7f12a5a2e8dc051426702 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_persistent_volume_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_photon_persistent_disk_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_photon_persistent_disk_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dac7d7bb1efbc55638d4c6f97bff6a69501d27c3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_photon_persistent_disk_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b96427d11de01e7f63da83bbca28575e665327d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd4c7a5dfe9b5984c087611be34132c13b3f19dc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity_term.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity_term.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..480895924bb044228cd333bed9e5dc4609ce9e91 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_affinity_term.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_anti_affinity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_anti_affinity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..adf86b0ddd511a678a3148f67c4fe30049d77fce Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_anti_affinity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_certificate_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_certificate_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb430ecbbb01ee2a5ff04acd1f989014b772fa89 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_certificate_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09c6c4ede6aa70d70ade5c1416cab378a9574037 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9171eb71ae2584717ee55522106e2a2ed4d5e4f8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ee07e338b8180634ac09e9b37c5c4dbdcc79a0f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb5e472326bd6d836ab84f95ac5fd88ad965f270 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbf7f85037f6a5f17b89a91bd04bb9ab903ffa72 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_disruption_budget_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dcda51dfd6ed688e48c5f02494cd8343cf5a981d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config_option.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config_option.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27cc703169d90b4aded0e95186f5bc8fdd67a607 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_dns_config_option.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_extended_resource_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_extended_resource_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cac4729f6e4dfa346a7b68b4cfe3e099770b6b8e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_extended_resource_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fdb188297616a680b92786056fad916606b3d2b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_exit_codes_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_exit_codes_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d2fb6cbf621a0675a1f34aac86dfe762492700d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_exit_codes_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_pod_conditions_pattern.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_pod_conditions_pattern.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9988ef1247268a6b25454dec910c2c7361de96a5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_on_pod_conditions_pattern.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4cad66635f29af6dd54a2f018c010450036f4d21 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_failure_policy_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_ip.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_ip.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..73762efec4f26775d8b0f75b57a6a6963c6b6318 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_ip.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb7b0899ab034ea0986a29baf0cd2b5bd67de641 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_os.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_os.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b74e6d2e05c19d73ca989bd47104961cf4e3700c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_os.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_readiness_gate.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_readiness_gate.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64af1b4d5f417f5b6c03a0d66ea6d4709bf791dc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_readiness_gate.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..187ed1b458eb3d707e4733eb6e2e2965b388ae37 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf135e75223f487ba24c28586475e3fd6da60a74 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_resource_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_scheduling_gate.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_scheduling_gate.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6ec99072a7e454a0818fcb228defe9600b433c9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_scheduling_gate.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_security_context.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_security_context.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7630e1180e2c12741d543476b17e2015cc18b20 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_security_context.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40a543ab5d821c26cd54b5d31029eb45c1e46230 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f388ae364fbd0be090eb9610126cbd857b5b3805 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..265fb15b155eb9ee26ec45167a675a5dc40a6030 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68ce203d8aa0539f7a679adf46aa884899b0b889 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a0411753ead6df32d2df5793c268b6fb34b5af2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_pod_template_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae5c162e0d826f86ba5c50881c93bf9681f8878b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rules_with_subjects.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rules_with_subjects.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d95f8cd7c0665c8273368c32c1670225feaba5a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_policy_rules_with_subjects.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_port_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_port_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4e814af4ac3d38f489afd210df3b495b47bf671 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_port_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_portworx_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_portworx_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb487cd562d983a839dffd96dada9919653676cc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_portworx_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preconditions.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preconditions.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5aa2bf07eeecda8abdccd02cd157f2cbbfd3ada0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preconditions.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preferred_scheduling_term.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preferred_scheduling_term.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b1ce4c6e403da578117ca4586c4fea11cfa4cf2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_preferred_scheduling_term.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76913681f02fb93e901df00c4c64f253e3c95f35 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cbe5a667e93a6662834efa0718c2e46f5ddceb39 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..033cd3f2a8105ac1091c7361acee947140fc85d9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a916f66ccc917afd7fb2a4b1275925136434681 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..736abbf2a95dbf0d84d1f7d437e6b901613ba85e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68b85557d3751ac86f99ad8f7c88b27ed6dbb28b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e93a7ef53525612b0834869356cc9453ce8cb18 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9bd1af4aa337f0987113fd7498a25e2c0e90bf1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_priority_level_configuration_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_probe.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_probe.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..261499060c14663844f60008a5fa044eebb2f196 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_probe.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_projected_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_projected_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea239a5d3f972075da99d70d6dc185ebea65e228 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_projected_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_queuing_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_queuing_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..072bf97bb01c20ee3cc032eff05992bfe1b2c4f3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_queuing_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_quobyte_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_quobyte_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..725d49f5236eebc0870fa00744726986e57d75ed Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_quobyte_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6326efd46a2a1f31237d8e024b0ed250895476e4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a780c274dbf96f417ce4f88b0915e81c7bc1ff96 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rbd_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de6bf21e05ea07ffdae359e52d20e3785c0c8015 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..07bd51749404a97d833ac61fa1bd81a16f4a4c42 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09e0271a7436f462c19bc5e346091ef0a7473f2e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f06f0888740dea63fefadfa4cbcbf6a2c196d29b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e17014f8f60d3c3de837b5f2cd36668b4beae208 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replica_set_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75d403cce4c070ad47636ca1dd3d71aea87540ca Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ea024e4af24ed58da387bd838c9ff997af9305b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7ad4a510db17e5420b8c3ecfef2264313b58f93 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c9a14ed56519feb00ef4775bbc4809059f3bf11 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fa8a03ab15721ec0a2b91bad1c61427b7763a98 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_replication_controller_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_attributes.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_attributes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2038e1f8aa7cf9b8ae7a53e80df66a0035b1face Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_attributes.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_consumer_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_consumer_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..754631be21dee3b8d350a852781a77e0f5cd2d33 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_consumer_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29678e146b1bca299cfc6f839e94ffc3d5c2efa9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efeaf222d8271376a7cf0d9d4dfa09483f1411a5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbd73fab007e2d6ad13852f58fe53a73b0fe158f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..837510bdb24640ad1afe1e25cc27a67d1b6b9bbb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..383390ed62398c537af6dce56c68a197b8fd67b6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..290e68a2394237a9e6083f2e7f18972908b44631 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_claim_template_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_field_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_field_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecca7b897956d680efa251de9ec7e7124d4dc02e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_field_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_health.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_health.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85d552afa1377000e49079cfc52cc33d1f0e5719 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_health.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_policy_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_policy_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5615f66ee3317a36eda57b5d313cd1e1a9eb594 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_policy_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_pool.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_pool.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1d4455602782f65321e24548f24e644987ee472 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_pool.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..32e18ce6b6ec07f262239fb85f1c42eeac3a42f9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b371f163991090951de04c4b35002b9169d1aa6d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a0e5f3d8995b8dedcf08b8f4d90a01c6a9e696b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90af44bb1d208915ac35ad83a76ef75fc8b58b34 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_quota_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_requirements.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_requirements.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f9ad354d429f2e0b4596ee9fa7613de62ed1963 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_requirements.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..816d73d9a5f6a885b36b407246ad5e82d03bedb8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0228b2d72ad1fc632f1a8400665337537809f68 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1605920dc70975dd45011b86d9295c43567968be Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c010d2e979af383cd60262d12e29c1f27c453260 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_slice_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ccdaada79b0a3d8b8b661b1692bf58190bfeadf7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_resource_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..351e25ca4ed8f15c89784ddf13860512add8334f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8d074733b30fdf65d878f11b7611a0116eabbbd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11d8d18d2f773450d944fe5757719fc54c7dd9f4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_binding_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efcb44e4e52c0c7fe6a905b13ec48938a4ba7520 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_ref.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_ref.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e66ca4ec0e290494a7641e9d90b681400564156 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_role_ref.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_daemon_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_daemon_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd97cc3f95cd629a7c670be0e1de8eb1f7161602 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_daemon_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_deployment.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_deployment.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29f7a5de4dd70df4e96b678566235a6623de02a9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_deployment.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_stateful_set_strategy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_stateful_set_strategy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef4baee6b55c1e4461336a4ffbed0583adee49fd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rolling_update_stateful_set_strategy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rule_with_operations.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rule_with_operations.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5126018a17690f3e824d7045841935c6dce8c7b0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_rule_with_operations.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d135b30e38eecde7fe914755e76ee2ab35d59688 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..730327df83547cf1a54cfe759853b47625727d34 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_runtime_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae09f5932ca0e98b88e1e31ca3a85dc0ae98fcb0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7775ed3ff0aaf0df6511bd278874ed09fe1f32da Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57d45747bcb20777be14a5981c046301de3e8ce1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_io_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ad6e559520456247f010e91823bc9d3ddeec863 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5594826e1c809fd8ba9241856664567da2e8524 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scale_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scheduling.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scheduling.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36586c7749298baf5a63c7ae61dfabda4f3405e0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scheduling.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scope_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scope_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95645795ac5c5d693733fb78dafc36aae25a42ab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scope_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scoped_resource_selector_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scoped_resource_selector_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d549a1f27922e247548345c522246a920b339a46 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_scoped_resource_selector_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_se_linux_options.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_se_linux_options.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cc1e7fe904b6d10842bd07bf07a26ff6be34b57 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_se_linux_options.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_seccomp_profile.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_seccomp_profile.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae4b8ad059341cf66da0676bfb182e07ba391b9b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_seccomp_profile.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f19183d6b7845ad6edd3aa8289f4084f59db0a7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_env_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_env_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc5c9de769b6c9fd477952c759f693a94ea60357 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_env_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_key_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_key_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b94a23bf24810c62d94efaaea137e2135b2bd2e0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_key_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b04ecc435d1cc4b01888accc4210766aa878caa6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8abf86d5afa3c0011d4eefee0bf7b1a8cd68720a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c41996cfb1a5ae775b396c2f78be18d8e3018879 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c1af23cf4a455ca4fe32bc4ad64886d4d9281a0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_secret_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_security_context.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_security_context.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c188ec0d8d2a428462ac018d5e472b288a60d281 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_security_context.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_selectable_field.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_selectable_field.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edfcda2c5bd1b9de249bda575e251a37db3fa220 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_selectable_field.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..595be8ec94af8fd52ce7e13e2c8f407e5abbfd71 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c059326e84768aa93af36c069ac9c2d07dd606c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_access_review_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e7c519baeb9ea75e2828d30c47162d3a7a9ad3e8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b4879302a31b6eeeec046a9212f5ba60df9cf3e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_review_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0ad1d078bfa053ad60c38819d946aef4bbbfb46 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03bc3c1340ec16e5b62d0d0355244ae1c0018cc6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_self_subject_rules_review_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_server_address_by_client_cidr.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_server_address_by_client_cidr.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5167b86d502114ad851f31f2acd7c7ad8c88403 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_server_address_by_client_cidr.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b41f80313f79921eb759655486991c51d332f62d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19353a59a6cc1b3241871521ff780cc7e4b9b60f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8f94b0bde0ac8aa948989237dc3535b33d70b67 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_subject.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_subject.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1331a5ba21b4285a0e95ae95339c4e480a0aafa9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_subject.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_token_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_token_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e364eb2bb87a050afa2078caa7546266618117c9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_account_token_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_backend_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_backend_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3dcc5f6db049a6b1d410ebef4701119392284325 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_backend_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8518df529ef58c632a61bae7b047e5c9fb0b22e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2e74430a63af7ddbd1398227453e5f00f7301ab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..230266fcc78e477b7ca163cef329e8a1686d2c23 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47d7a9597e23f403900a5539479699222f871049 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_cidr_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..afacfdcad768fdfd0987a6d63826db5216bdeed2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_port.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_port.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bbab3dc4707e4f2f1b2dc090eedac2f14a7266d7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_port.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26830e2a5c540a49d35887c528410f1b3aaf97e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ab3815fbf6cffaceedfe53c1898ab10c851d578 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_service_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_session_affinity_config.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_session_affinity_config.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45795ad44716a357003ffa4060183e500b6f4656 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_session_affinity_config.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sleep_action.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sleep_action.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a4e74dea772e9af6d8589e9ece53cdc4612ca92 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sleep_action.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f56172731dae1dd003faded53d627be048f73fc4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..99ed49a844e74f152e967f1244a9f18a18e6ea72 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e929ecf97ff1d5d623f82ac81e732e45d858acd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_ordinals.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_ordinals.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..360621192f034e48538a7632a3d5b34e4eba4f7f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_ordinals.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_persistent_volume_claim_retention_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_persistent_volume_claim_retention_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6211083cca23ceb0236d1f57aaf07bb17a3ce51 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_persistent_volume_claim_retention_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5a8b7b4658f4eeae72d44814f0dff0ae70dc467 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..142a51e3cad453c583bb42c1936eea7965850b9b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_update_strategy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_update_strategy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..589a540daafeab78cfe66fd486571b5030544576 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_stateful_set_update_strategy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56f8d2c947a09f002cb0c95290b33c9b42a998ff Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_cause.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_cause.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..695b7fb42f29676fedc9052c32efaa153365a584 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_cause.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_details.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_details.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98fb1489c73694bd02da9b74cbe5d8b3f9efd360 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_status_details.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88699561e12d5c3f6208dc92325530b1ea4f3924 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4897164a2bacd9adb704177c98f186bd584cbfb8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_persistent_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_persistent_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2a97d314fbada210ab62c3d01eb5444fed00506 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_persistent_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84dbaea83351c0a691ffd7d4697e414651cf1f57 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_storage_os_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..553dc88c427d8a362d1e99591aa4f24995e34176 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..154012d95069ca0bbba285051b9439b7f503dfa3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d21903392b61fd8637c35d2a82850c4dcf01ae83 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_access_review_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_rules_review_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_rules_review_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3722ca61656347a41c3492cdf00c1a8ea7c2f15 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_subject_rules_review_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1598b33184899a86add1be01df572a14ed42bde2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb46c0c745cac0d6e31ab0ab235e97f28c53ee5f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_success_policy_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sysctl.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sysctl.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45915caa2d21533c2a707f58640009f527c72e48 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_sysctl.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_taint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_taint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..73a08a0cd0a262c39df51999db252c934a8205bd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_taint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_tcp_socket_action.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_tcp_socket_action.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0cf87c868c46c079760359d2f2ac6b4fc79baa7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_tcp_socket_action.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c02f8b26873a23100d2ebefc2df01bb0fe1d1de4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..562607d2777d033117b75cce335d708713763c4b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_request_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb8f42c6835b68f2aa190d8a5bf045171bd92e9a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68f57cbedb795c14c383172e235b1c5aee731983 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5850f004883b45c102c45fea1224bae45de7b7bb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_token_review_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_toleration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_toleration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a775a109dcfed999a3ca089b7942399b2d5b6db Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_toleration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_label_requirement.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_label_requirement.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1901e5d519b429563d78667ae245943a82762f98 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_label_requirement.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_term.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_term.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..997c99ddb22bf27e6bee9b5597145a1f37407a42 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_selector_term.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_spread_constraint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_spread_constraint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab1108954e17816f4fed128f8b1717767bf05937 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_topology_spread_constraint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_type_checking.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_type_checking.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec9a9a851e8c78ed994fb80d01b2b00f90d7b4ce Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_type_checking.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_local_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_local_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95c77ca5f4c17c7ed50f426801dc792cd7a03037 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_local_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fb9fd14c94193ea12a011f408e9236544ee33ba Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_typed_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_uncounted_terminated_pods.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_uncounted_terminated_pods.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1fdd67d4eab1c7a8a246ec616e2827184204387e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_uncounted_terminated_pods.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_info.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_info.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d740e105fa67936f351e0a758763ea09dbb302ef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_info.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_subject.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_subject.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91d64cefcf6e5763fd80fe359ccb45d34a0a2c85 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_user_subject.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..584fae94d0899e1e1a281dcafd30f6adcd343a12 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15131cb197263ada7948b755710f396f04b8e5df Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62a6fcae1a176bb1dbe275f792ad8bb7b7f92a95 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49b5ce75e6bb28201a1f99d5fcb5b0dc32c61cd3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_binding_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c450267c04be3860373adb6194079aa4d35a256 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90a521115a2355336352b247515161cae24186fe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f316a4e677948b52cfb1c64b0b796ff7c86098af Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_admission_policy_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bb6df51e7a03a7a2a01d97a581634d43dffcb67 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8bb0fe9fe8bcb1842aa19e15b3db55cc0d3811b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ddf0c8164b1f2d85f35704eee0f9fac87d5e8b5d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validating_webhook_configuration_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f9f45458ed16a1947ea877517f94506fbe1d085 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f2a99df3ef9290d066d77943477eebb5f745cdd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_validation_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_variable.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_variable.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1001d8f9c2fc3b600b465c196ca1e45453148a7e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_variable.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9438772a43eb2f275adc2e089e295e335ecea4e6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0307404feac07f1fc9baf2876654ed117bbf045 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a00d5a3e7a49142e433712615a6777fcfd9387f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..214272929f93266ebaf0d64f3452cf8b31f7e100 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98796416397425ff3063b9e47551a4c5298edb56 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8870b10490d261a4ae799378f5077db81c8f1ee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attachment_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b20e26aa718fe274d04fff5cba7d0ea3f77ced46 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f00990675f2f63a2f48174e540e1503b93154c4b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_attributes_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_device.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_device.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd32a59444b41631538816262793b59741740fca Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_device.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_error.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_error.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6f2dd0b09e65773df8021aa82f0ef947e8632d9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_error.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2318b609d2768d7824ab182d62723f03b0eb0204 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..218f190ae95d2d9e335bdd352d6b3a45f58d8dd1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_mount_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_affinity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_affinity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..825914f90fd50ab91321c194ab2bf87d435cf12f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_affinity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_resources.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_resources.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ced9cb6d68e8990deb48f4cb81783627d6458e7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_node_resources.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_projection.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_projection.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2028151526a9f3231d17e4af90800631fe54c49 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_projection.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_resource_requirements.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_resource_requirements.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bb4fbe363e1c146f4044e084fb43fca329638d1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_volume_resource_requirements.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_vsphere_virtual_disk_volume_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_vsphere_virtual_disk_volume_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e583a588e7cd081a94cc58bb2fe39eea6f61bf8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_vsphere_virtual_disk_volume_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_watch_event.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_watch_event.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c04d4b54b0cc39cc8540b7cd33b3e40eaf470619 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_watch_event.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_webhook_conversion.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_webhook_conversion.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dd1282f35fe28d4d115b9235c03b052cf39190a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_webhook_conversion.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_weighted_pod_affinity_term.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_weighted_pod_affinity_term.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..baf5f7860f7e942a5cb713fb439ff2ec3f153c54 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_weighted_pod_affinity_term.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_windows_security_context_options.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_windows_security_context_options.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7ad857f8d6f41314b715a3378201c701a8da341 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_windows_security_context_options.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_workload_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_workload_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61e7b6cfe6defe7682cd7cc0e909b1a4afb09402 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1_workload_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_apply_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_apply_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1104366a963e2e4688726d3057e5ccb13805de6e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_apply_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..926be7db30b5c2c6a51af04bbc2c1e431f4538ac Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a568f50587cbca4beaa197121f3b4063ba8fce0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e490f0b3189eba3f7b613b05949e089ea5c5c888 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_cluster_trust_bundle_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_gang_scheduling_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_gang_scheduling_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24d992e4acc58f59c5cff3a36569a5278b8421fe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_gang_scheduling_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_json_patch.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_json_patch.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dfc3988a2a6227a75d056d5fcc110834297d9d54 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_json_patch.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2f1b5ab82f96bfd4a9b6f27d5b22440232f10ee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_resources.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_resources.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..305579e440427303446087277b8b4d5dd94e7535 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_match_resources.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f403363711bb2524fb6ff0ce9c779c9cd32c9c6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b68e273c37423f3d47533cc651b1129f09e7c56 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edfffcd78d1f462ca6546a1bfacf498dc2babeff Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d649f9ac892939891c19e5862b4e8be2a9409ddd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_binding_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b1169558b8d78eadc05e9524583a1df7f3af284 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f886ee19aa5b853d7514239f2bce22086f2b073 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutating_admission_policy_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..870460f28c94d28b4f3745b9467a94953710c076 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_mutation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_named_rule_with_operations.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_named_rule_with_operations.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49e5bd249cb38e298b920bef811f1b2741200676 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_named_rule_with_operations.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_kind.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_kind.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bc77a3fbbb0388e957f037ecb9154e85bd8a1b3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_kind.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_ref.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_ref.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29cad0185a0a4f1b90b2ae180e814014da55f873 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_param_ref.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5b11fbd6c9010cb6595ce9d30aac8c70e4f721f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58b08dd5745de80f5d921997e967145bd24efdd6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_pod_group_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_server_storage_version.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_server_storage_version.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0d49c8e8562b0886fb1151a53b04967ac4662b6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_server_storage_version.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52f3b41f0e958f0dd8c2d7f3dfb1719c7d3ca4ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc7be1bd9a01620534e1f5821d1f02b12be28269 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77fb46f06f039398760b60024d8add12bb6e5b11 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6410f228499f02628c768ff0ae7702c0604150d1 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_storage_version_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_typed_local_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_typed_local_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c1f79270888aa2251bb9fe772a87b558ea53dde Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_typed_local_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_variable.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_variable.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..838b06f3e5f16ff2d60ca128d79bcc00c6f85e5a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_variable.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94ef894e27bb4e8f679af8c4276f283b8109d69e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff2d0cbd5e96535617725700b98e30a3d8068334 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56e5ba4322169469448aead723178c486fde80a4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha1_workload_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..080501b0c2de216241387359ec6ef7b433cc33ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76d9311dc21262a1c9a322215a6c91ce42ee1b04 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80ee8b0b138e4be8504e7a576d9105ff2396fb1c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha2_lease_candidate_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..575a4bfca47eaa558b149d1c170c0fb5ed496efd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..169ad9962b1ebd790bd217dce6a1e685a691cf2d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24330ee4a7b571bce8208fd9a7e363db3e23c1e5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5c159f5e1fa472c3bd69ef3d9c71f9bde72fc15 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb9c1a6dc724e77f079cf5cfbc452abe0f33f97e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_rule_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82d76df4403573c28c7147847b3abc15dc992dad Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1alpha3_device_taint_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocated_device_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocated_device_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7caed9655f24e2ca1899954f8fe261e8e378c387 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocated_device_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..021d208e7f5bfd6c20fd3aea96651221dc544ca0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_apply_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_apply_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01ab0c636c0914d9a8a0be9173a6943b87ae0041 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_apply_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_basic_device.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_basic_device.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63780877e64a43c6ee41fbbb2f8f0105c913182c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_basic_device.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97a5cc3f37040276baa146676bdcbb5b8742383a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy_range.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy_range.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f50813734d9af5d642cd1b3509f68cc71281f8fa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_request_policy_range.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_requirements.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_requirements.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c206c926909a0ede6466f7194d23b48dddfaad01 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_capacity_requirements.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cel_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cel_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21d8745f14b29e8bebf3bc8b3cbef97729be583a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cel_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cda32576fa5fee06c96d7fbaed5def9567e15f1d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0312fde98e0d614374dcdafadb29ae2ee47ab74b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f34760367546b4bc30d85cab72cfcde9c847329 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_cluster_trust_bundle_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5036fa12fdf1006a92ba97edeebe429e7b8b94b2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6959d74bd1b17e7bcfa790690f26cc323c972380 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_counter_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..945afc0bcb94c3b61df3270dfd9c184c1bdb0a02 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b9274f9c6b7e1e19953a85b4a89c0fd60398f16 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d20f9bdc88d00d952a2cc89d9b1400bcc4c3f2d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_attribute.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_attribute.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45b918eeba2016b6a7ef171c0115cce324a8eac2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_attribute.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_capacity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_capacity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69912ec49b3e1cb29e85b96802faf98a180e91e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_capacity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2c9856a44b0dcb2fd41cd59f9f7c45c340e1008 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..70186d8ec2a9d67f031b0319007d0e27e7f25802 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_claim_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c48d40a89e390a36479ba834153bf5303e218ee8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b84dbdc7b9c08e077d93eab993fec8337d4eabd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..103acd9fae229fffc0ee1453dd69fc66267de268 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebf360fbf367d7a48e7c9025645a7b915603bf86 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_class_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_constraint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_constraint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e1afbb7d4374da857d7ad64f106936b6760b220 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_constraint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_counter_consumption.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_counter_consumption.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56cc348aebc6ed22d028c8b0025fdfd91a57c7f8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_counter_consumption.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f081f488c6a14703fa758ca677fee28b2a44f17 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81353de3485f0aebaa0a626be3fe5cef7a2fc892 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_request_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0248b17834b97b48f322952946b0b01e94bcd0f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_sub_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_sub_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01069c51331ef246775c366d072cfd0f159a4a1c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_sub_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_taint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_taint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6920ca0e3b984387b8fe96ee4148bab2b2b0126 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_taint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_toleration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_toleration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7c3a6e764c8bbad4e027b91bb26c79fe194e631 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_device_toleration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d845e19c0bdc5be607253a17b1dda72ceb6e492 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9120fd1c193d5ece25e127bbc3c8920a69f105b4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41656afe920f0da8d500d45d6d58a322224c95fd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_ip_address_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_json_patch.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_json_patch.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..460a439af536389b3bd0ed3e7123461ce236e328 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_json_patch.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b450f9481b4eb068ff4ff3d44f380b16f0f2a380 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b686ca98f71523f4048dd2060976706396a8ad6 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81f61d5872ba0b543503ec46fa4672267407db9a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_lease_candidate_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8e119d7a286d33624dc8b7545c9937e8e2d2b98 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_resources.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_resources.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc34c80d6db6d00ff62d605daeba9d12a0119778 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_match_resources.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd822730179b34c65f3bc0e93ce2ce28f7ba1507 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a76829efe29b9748be39b120e11643ac8f5b821b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5784429e0df51ba5229094f9b9e63cc123c1f56d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7a61f5b38ff8db9abed9cc0b78826a1147f601c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_binding_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36d80ae00dbea9c838be7b8b31af4c392444a150 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81f43236abfc8fbd3f604155785ab72eef23c326 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutating_admission_policy_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutation.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3970903f76ae7f687e95376344ec567e2a9254ba Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_mutation.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_named_rule_with_operations.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_named_rule_with_operations.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b78e9cd01c0f9c43e6e2983e235a2b7cfbcf18ef Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_named_rule_with_operations.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_network_device_data.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_network_device_data.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f016cc4be9e172c8c08de5484ea6a5883f3495f2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_network_device_data.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_opaque_device_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_opaque_device_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b2610d6add3e9506767b39ceb940725c185154e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_opaque_device_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_kind.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_kind.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c940e4d2b0f6af922ee52f14518f698d5dc48a77 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_kind.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_ref.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_ref.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3813b5850ff72f51296ba0c0e1286cc16e95f1d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_param_ref.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_parent_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_parent_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8914e2287560c6b828eb17800b56f51f8f3e34f9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_parent_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7284bf18efdd71b0bdc3306b2161d87c4c442416 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba11c2ed4e85eae2a03271b01d408348dd2833a2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68871931acaa0d5ac04d969e052a1455935cd448 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af04e8f3401c474ad1b9c8c971d40ccac5067552 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_pod_certificate_request_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c605908d060cf0c55665e43965009e3a49eeb1e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_consumer_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_consumer_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7cda7b6380a2ec1702ef060c946ccaa84c594f8 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_consumer_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83999a4d6c36380700d1da6006c97f415c373dbe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b64de5dbb88709fa196b788570aa1edab5c7da3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0dcfbc11e674ebea3442db1ad6cf1815eb257916 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f60b6eb32261af54dd5dc04fb05adba4c92cc7ee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6ac8fd68586c8dbb2078fbb4a50e6e615a7779d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5eb1d5a0ffd007c1c3e7bdd0660153ef63a5ba72 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_claim_template_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_pool.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_pool.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09be55626ac6c63a736b709adf225deb355f94ee Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_pool.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eab1695be22b125771064b4424bb7f6eea210f34 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..840d537eee9d2e88b6d38698a469c1a4124db0e0 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..59c309900139558ff5add80396ec2d36df1ed46b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_resource_slice_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02a7a6b6d31bcdb7b258ae011e3ada89ada3d5dc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..99db18e5c0f6706a8c018f4389612bb99e581fab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63ccdc5f908df7a898b1b2398d8a00213ecbb031 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2f88c2c3d32dc817364f9914d08f2047028a8e3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_service_cidr_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40dc505ac27b16f759210e4cb887dd3797983fcd Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af0d416fbc8426fa9125a734f9ac69bd9fba3292 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..758a53af738a8bd70e7f11326706a1f051a3e0ca Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db6275368a66753a78b6d9eb2ce7ec64f18a46a3 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_storage_version_migration_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_variable.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_variable.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df4e7a528917bee2adf2abf0bb19b827d75a2360 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_variable.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3638a443c9b475663a31ad03a55853d983eef3e5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c282107b6f6541071da496aadafcb43c6ae9b486 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta1_volume_attributes_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocated_device_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocated_device_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69c8fc6e1d9e4c7daec460a91363c081c0896267 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocated_device_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a08cf77451c0213876bda381313866642f6f4a32 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7348d32c224e9f10a2c8ac5a1e88c3d04a0bcab Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy_range.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy_range.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ed7171433ebd5e3fc01931f4bc897b32a4f14777 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_request_policy_range.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_requirements.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_requirements.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..872992629185e558edd852db2fe577589e9ec4ba Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_capacity_requirements.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_cel_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_cel_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5336575f272706158caf4ef4cb4c6a4b11c8c0d5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_cel_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..992db6160fe07c9028d3184d090627dc3920567f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter_set.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter_set.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f44e6e769c4a6251d919101040211a13c1470ae Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_counter_set.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff75f6eb0409d4fb93b26b44d687b52b7b3ae4f4 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1b71c2ed5e8789058b2bb9403224600ee1de375 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d15edc6162dde7109989bb1e74f08592335cbe6e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_attribute.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_attribute.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd371834cc598b16d713cc2150f63a4ac0c95e0d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_attribute.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_capacity.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_capacity.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..544a96ebc2f0b730671185e87852beb8892f6f58 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_capacity.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fa71fec89aa596f503321b8022447991e9cb656 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8c380b7dc1fd3daf764c4894002098b4934acce Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_claim_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bdb4ef3d476c2d2b8a20bcedef865ffc3beed3a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cde4ed9f7e2b67dfbd49e4bb0a20dc0d1b671d64 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7be7655fc6feb533e197184812bb4f33475e15c2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6f55c7b09c92823b6896272a9a686a9faa7ba8b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_class_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_constraint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_constraint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fe1ef2233d4447c1f97c7b2b40e2b3aab39a24e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_constraint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_counter_consumption.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_counter_consumption.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62689b5c0d1332d322c971967de695f65fe0be68 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_counter_consumption.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36565b8cfabda3df7278710cad475c9690f0fb84 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request_allocation_result.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request_allocation_result.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..803442c6c26867b0e23940f54f5fade9da1b853e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_request_allocation_result.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_selector.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_selector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da1128308057aad9e1f5135b2d5dde9274c320b5 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_selector.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_sub_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_sub_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54f55f785dede6f6c2c19ca80786a9e0141c9182 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_sub_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_taint.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_taint.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9befb02769b7629ffd24a410ff9a7392fac054b9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_taint.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_toleration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_toleration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4506c83f1d6ad5cabd4c93fdf5d94be5999febbb Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_device_toleration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_exact_device_request.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_exact_device_request.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56be795b5f02815be6693d703dddf9dcab2fb355 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_exact_device_request.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_network_device_data.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_network_device_data.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40b454ad7878867b6be98a182c982b601d34a188 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_network_device_data.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_opaque_device_configuration.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_opaque_device_configuration.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..defaf1ecd19710a57cb2672755e36f2fefcd5f81 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_opaque_device_configuration.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebf1b09796a753d244eef67cf6ea59e094ef0c0e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_consumer_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_consumer_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..037540422ca0a53b39cce5157606ab8a4485686b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_consumer_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83de449f59138eb883898a7c73f368bdf5bd3a4d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa90ec33c7789f1f494155a5dcb24a85f28f32aa Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..958e1a4e3ae9e2b5088738394b75bbd615608c1f Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f921014cf28ff5bd750408181690e2bb5c47e340 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3548d0c9dd7ae2b6a5365e7817878f648cc14b5a Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6bbdd259fca3fb5225d167fcca84716a0ec8057 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_claim_template_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_pool.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_pool.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6d4e5250799e0523cf0ce3ddb4a4f6e6f4c284c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_pool.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81bc419fd9c4b619b32cbc8d0eb49ca502edf61e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dcb9afdbd25e16d37f360c65a757b98496b45245 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d09e3671c522b63eeb337e5425d6089fc0ad540 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v1beta2_resource_slice_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f62331e08c92b516a3878d028bbf78cc60475560 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55a44ba0d7dc0476800d670f9021a642a6a7af73 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_container_resource_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_cross_version_object_reference.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_cross_version_object_reference.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec29d1b35db18acfc76f328eed4cb7aa0e84ebf9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_cross_version_object_reference.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..179d5e25d3d20f9e403881b5fb68d1848350adc7 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8682bb1ab4099e29b40ac1f4776f180d9e7b0a7d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_external_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6a9ea41cc6dd8a2e7757b646a1d2aae8a048aad Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_behavior.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_behavior.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae3d39d464f00064fd2a259a3029b926a332d40b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_behavior.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_condition.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_condition.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68d349b0404f96b3f9ee75f63d2adba17b2d8319 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_condition.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_list.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6830d2d399246e628332b7206ccd356ff2c8d8ff Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_list.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c727ed2b0731de48d311123370b0b6995709ff22 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48c1558f8989ff642c8845c2b9acbb066e96a56c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_horizontal_pod_autoscaler_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_policy.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_policy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ff56b61c22f480f15e587883f00e6523568607d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_policy.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_rules.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_rules.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0788a4906a44c7d905c06c50c4d41449c2b04087 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_hpa_scaling_rules.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_identifier.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_identifier.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e53acb055336622828b8085923ba61136e612c2c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_identifier.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_spec.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_spec.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c354f361726db0a0430f34f32fe4ed431076336 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_spec.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5eee24780a11176a063fef955bac0c4b62af47a9 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_target.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_target.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..386b5c3feb5c288249cb077cd9d1bfbe5215b0cc Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_target.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_value_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_value_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10fc470b6728d1c56cd049ce94738637cfd05ebe Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_metric_value_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6048cb72ae8deb7f9a199efb159f6c04b0d2260e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cffecd52ef79ff489eccea03f12dee507217464d Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_object_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebafa234b5fdb2fa457a19bcc968234a1385f6bf Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86b42007f88127997c367bdee916adc25153e5c2 Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_pods_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_source.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_source.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d7a594af53c101c8b295fa1fc4f60be60bda59e Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_source.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_status.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_status.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df16e1797c03ff8095dcfd536a60e18001e3a77b Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/v2_resource_metric_status.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/version_info.cpython-313.pyc b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/version_info.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb82155c716901e95cc957a533ef5c8f0c80023c Binary files /dev/null and b/python/user_packages/Python313/site-packages/kubernetes/client/models/__pycache__/version_info.cpython-313.pyc differ diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..057101177c9382850dc9d1371c0b4264c0a7ae23 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_spec.py @@ -0,0 +1,258 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1SubjectAccessReviewSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'extra': 'dict(str, list[str])', + 'groups': 'list[str]', + 'non_resource_attributes': 'V1NonResourceAttributes', + 'resource_attributes': 'V1ResourceAttributes', + 'uid': 'str', + 'user': 'str' + } + + attribute_map = { + 'extra': 'extra', + 'groups': 'groups', + 'non_resource_attributes': 'nonResourceAttributes', + 'resource_attributes': 'resourceAttributes', + 'uid': 'uid', + 'user': 'user' + } + + def __init__(self, extra=None, groups=None, non_resource_attributes=None, resource_attributes=None, uid=None, user=None, local_vars_configuration=None): # noqa: E501 + """V1SubjectAccessReviewSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._extra = None + self._groups = None + self._non_resource_attributes = None + self._resource_attributes = None + self._uid = None + self._user = None + self.discriminator = None + + if extra is not None: + self.extra = extra + if groups is not None: + self.groups = groups + if non_resource_attributes is not None: + self.non_resource_attributes = non_resource_attributes + if resource_attributes is not None: + self.resource_attributes = resource_attributes + if uid is not None: + self.uid = uid + if user is not None: + self.user = user + + @property + def extra(self): + """Gets the extra of this V1SubjectAccessReviewSpec. # noqa: E501 + + Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. # noqa: E501 + + :return: The extra of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: dict(str, list[str]) + """ + return self._extra + + @extra.setter + def extra(self, extra): + """Sets the extra of this V1SubjectAccessReviewSpec. + + Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. # noqa: E501 + + :param extra: The extra of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: dict(str, list[str]) + """ + + self._extra = extra + + @property + def groups(self): + """Gets the groups of this V1SubjectAccessReviewSpec. # noqa: E501 + + Groups is the groups you're testing for. # noqa: E501 + + :return: The groups of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: list[str] + """ + return self._groups + + @groups.setter + def groups(self, groups): + """Sets the groups of this V1SubjectAccessReviewSpec. + + Groups is the groups you're testing for. # noqa: E501 + + :param groups: The groups of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: list[str] + """ + + self._groups = groups + + @property + def non_resource_attributes(self): + """Gets the non_resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + + + :return: The non_resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: V1NonResourceAttributes + """ + return self._non_resource_attributes + + @non_resource_attributes.setter + def non_resource_attributes(self, non_resource_attributes): + """Sets the non_resource_attributes of this V1SubjectAccessReviewSpec. + + + :param non_resource_attributes: The non_resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: V1NonResourceAttributes + """ + + self._non_resource_attributes = non_resource_attributes + + @property + def resource_attributes(self): + """Gets the resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + + + :return: The resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: V1ResourceAttributes + """ + return self._resource_attributes + + @resource_attributes.setter + def resource_attributes(self, resource_attributes): + """Sets the resource_attributes of this V1SubjectAccessReviewSpec. + + + :param resource_attributes: The resource_attributes of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: V1ResourceAttributes + """ + + self._resource_attributes = resource_attributes + + @property + def uid(self): + """Gets the uid of this V1SubjectAccessReviewSpec. # noqa: E501 + + UID information about the requesting user. # noqa: E501 + + :return: The uid of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: str + """ + return self._uid + + @uid.setter + def uid(self, uid): + """Sets the uid of this V1SubjectAccessReviewSpec. + + UID information about the requesting user. # noqa: E501 + + :param uid: The uid of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: str + """ + + self._uid = uid + + @property + def user(self): + """Gets the user of this V1SubjectAccessReviewSpec. # noqa: E501 + + User is the user you're testing for. If you specify \"User\" but not \"Groups\", then is it interpreted as \"What if User were not a member of any groups # noqa: E501 + + :return: The user of this V1SubjectAccessReviewSpec. # noqa: E501 + :rtype: str + """ + return self._user + + @user.setter + def user(self, user): + """Sets the user of this V1SubjectAccessReviewSpec. + + User is the user you're testing for. If you specify \"User\" but not \"Groups\", then is it interpreted as \"What if User were not a member of any groups # noqa: E501 + + :param user: The user of this V1SubjectAccessReviewSpec. # noqa: E501 + :type: str + """ + + self._user = user + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1SubjectAccessReviewSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1SubjectAccessReviewSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_status.py new file mode 100644 index 0000000000000000000000000000000000000000..10b0a64b6a62b04ae035b336614e074f07788cc3 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_access_review_status.py @@ -0,0 +1,207 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1SubjectAccessReviewStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'allowed': 'bool', + 'denied': 'bool', + 'evaluation_error': 'str', + 'reason': 'str' + } + + attribute_map = { + 'allowed': 'allowed', + 'denied': 'denied', + 'evaluation_error': 'evaluationError', + 'reason': 'reason' + } + + def __init__(self, allowed=None, denied=None, evaluation_error=None, reason=None, local_vars_configuration=None): # noqa: E501 + """V1SubjectAccessReviewStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._allowed = None + self._denied = None + self._evaluation_error = None + self._reason = None + self.discriminator = None + + self.allowed = allowed + if denied is not None: + self.denied = denied + if evaluation_error is not None: + self.evaluation_error = evaluation_error + if reason is not None: + self.reason = reason + + @property + def allowed(self): + """Gets the allowed of this V1SubjectAccessReviewStatus. # noqa: E501 + + Allowed is required. True if the action would be allowed, false otherwise. # noqa: E501 + + :return: The allowed of this V1SubjectAccessReviewStatus. # noqa: E501 + :rtype: bool + """ + return self._allowed + + @allowed.setter + def allowed(self, allowed): + """Sets the allowed of this V1SubjectAccessReviewStatus. + + Allowed is required. True if the action would be allowed, false otherwise. # noqa: E501 + + :param allowed: The allowed of this V1SubjectAccessReviewStatus. # noqa: E501 + :type: bool + """ + if self.local_vars_configuration.client_side_validation and allowed is None: # noqa: E501 + raise ValueError("Invalid value for `allowed`, must not be `None`") # noqa: E501 + + self._allowed = allowed + + @property + def denied(self): + """Gets the denied of this V1SubjectAccessReviewStatus. # noqa: E501 + + Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. # noqa: E501 + + :return: The denied of this V1SubjectAccessReviewStatus. # noqa: E501 + :rtype: bool + """ + return self._denied + + @denied.setter + def denied(self, denied): + """Sets the denied of this V1SubjectAccessReviewStatus. + + Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. # noqa: E501 + + :param denied: The denied of this V1SubjectAccessReviewStatus. # noqa: E501 + :type: bool + """ + + self._denied = denied + + @property + def evaluation_error(self): + """Gets the evaluation_error of this V1SubjectAccessReviewStatus. # noqa: E501 + + EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. # noqa: E501 + + :return: The evaluation_error of this V1SubjectAccessReviewStatus. # noqa: E501 + :rtype: str + """ + return self._evaluation_error + + @evaluation_error.setter + def evaluation_error(self, evaluation_error): + """Sets the evaluation_error of this V1SubjectAccessReviewStatus. + + EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. # noqa: E501 + + :param evaluation_error: The evaluation_error of this V1SubjectAccessReviewStatus. # noqa: E501 + :type: str + """ + + self._evaluation_error = evaluation_error + + @property + def reason(self): + """Gets the reason of this V1SubjectAccessReviewStatus. # noqa: E501 + + Reason is optional. It indicates why a request was allowed or denied. # noqa: E501 + + :return: The reason of this V1SubjectAccessReviewStatus. # noqa: E501 + :rtype: str + """ + return self._reason + + @reason.setter + def reason(self, reason): + """Sets the reason of this V1SubjectAccessReviewStatus. + + Reason is optional. It indicates why a request was allowed or denied. # noqa: E501 + + :param reason: The reason of this V1SubjectAccessReviewStatus. # noqa: E501 + :type: str + """ + + self._reason = reason + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1SubjectAccessReviewStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1SubjectAccessReviewStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_rules_review_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_rules_review_status.py new file mode 100644 index 0000000000000000000000000000000000000000..9c564915623ea2399c77d7879c29c3a98fb4bc4f --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_subject_rules_review_status.py @@ -0,0 +1,209 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1SubjectRulesReviewStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'evaluation_error': 'str', + 'incomplete': 'bool', + 'non_resource_rules': 'list[V1NonResourceRule]', + 'resource_rules': 'list[V1ResourceRule]' + } + + attribute_map = { + 'evaluation_error': 'evaluationError', + 'incomplete': 'incomplete', + 'non_resource_rules': 'nonResourceRules', + 'resource_rules': 'resourceRules' + } + + def __init__(self, evaluation_error=None, incomplete=None, non_resource_rules=None, resource_rules=None, local_vars_configuration=None): # noqa: E501 + """V1SubjectRulesReviewStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._evaluation_error = None + self._incomplete = None + self._non_resource_rules = None + self._resource_rules = None + self.discriminator = None + + if evaluation_error is not None: + self.evaluation_error = evaluation_error + self.incomplete = incomplete + self.non_resource_rules = non_resource_rules + self.resource_rules = resource_rules + + @property + def evaluation_error(self): + """Gets the evaluation_error of this V1SubjectRulesReviewStatus. # noqa: E501 + + EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. # noqa: E501 + + :return: The evaluation_error of this V1SubjectRulesReviewStatus. # noqa: E501 + :rtype: str + """ + return self._evaluation_error + + @evaluation_error.setter + def evaluation_error(self, evaluation_error): + """Sets the evaluation_error of this V1SubjectRulesReviewStatus. + + EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. # noqa: E501 + + :param evaluation_error: The evaluation_error of this V1SubjectRulesReviewStatus. # noqa: E501 + :type: str + """ + + self._evaluation_error = evaluation_error + + @property + def incomplete(self): + """Gets the incomplete of this V1SubjectRulesReviewStatus. # noqa: E501 + + Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation. # noqa: E501 + + :return: The incomplete of this V1SubjectRulesReviewStatus. # noqa: E501 + :rtype: bool + """ + return self._incomplete + + @incomplete.setter + def incomplete(self, incomplete): + """Sets the incomplete of this V1SubjectRulesReviewStatus. + + Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation. # noqa: E501 + + :param incomplete: The incomplete of this V1SubjectRulesReviewStatus. # noqa: E501 + :type: bool + """ + if self.local_vars_configuration.client_side_validation and incomplete is None: # noqa: E501 + raise ValueError("Invalid value for `incomplete`, must not be `None`") # noqa: E501 + + self._incomplete = incomplete + + @property + def non_resource_rules(self): + """Gets the non_resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + + NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. # noqa: E501 + + :return: The non_resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + :rtype: list[V1NonResourceRule] + """ + return self._non_resource_rules + + @non_resource_rules.setter + def non_resource_rules(self, non_resource_rules): + """Sets the non_resource_rules of this V1SubjectRulesReviewStatus. + + NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. # noqa: E501 + + :param non_resource_rules: The non_resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + :type: list[V1NonResourceRule] + """ + if self.local_vars_configuration.client_side_validation and non_resource_rules is None: # noqa: E501 + raise ValueError("Invalid value for `non_resource_rules`, must not be `None`") # noqa: E501 + + self._non_resource_rules = non_resource_rules + + @property + def resource_rules(self): + """Gets the resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + + ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. # noqa: E501 + + :return: The resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + :rtype: list[V1ResourceRule] + """ + return self._resource_rules + + @resource_rules.setter + def resource_rules(self, resource_rules): + """Sets the resource_rules of this V1SubjectRulesReviewStatus. + + ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. # noqa: E501 + + :param resource_rules: The resource_rules of this V1SubjectRulesReviewStatus. # noqa: E501 + :type: list[V1ResourceRule] + """ + if self.local_vars_configuration.client_side_validation and resource_rules is None: # noqa: E501 + raise ValueError("Invalid value for `resource_rules`, must not be `None`") # noqa: E501 + + self._resource_rules = resource_rules + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1SubjectRulesReviewStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1SubjectRulesReviewStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..0a767b3623d7427d5e2001343c43c04298878019 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy.py @@ -0,0 +1,123 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1SuccessPolicy(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'rules': 'list[V1SuccessPolicyRule]' + } + + attribute_map = { + 'rules': 'rules' + } + + def __init__(self, rules=None, local_vars_configuration=None): # noqa: E501 + """V1SuccessPolicy - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._rules = None + self.discriminator = None + + self.rules = rules + + @property + def rules(self): + """Gets the rules of this V1SuccessPolicy. # noqa: E501 + + rules represents the list of alternative rules for the declaring the Jobs as successful before `.status.succeeded >= .spec.completions`. Once any of the rules are met, the \"SuccessCriteriaMet\" condition is added, and the lingering pods are removed. The terminal state for such a Job has the \"Complete\" condition. Additionally, these rules are evaluated in order; Once the Job meets one of the rules, other rules are ignored. At most 20 elements are allowed. # noqa: E501 + + :return: The rules of this V1SuccessPolicy. # noqa: E501 + :rtype: list[V1SuccessPolicyRule] + """ + return self._rules + + @rules.setter + def rules(self, rules): + """Sets the rules of this V1SuccessPolicy. + + rules represents the list of alternative rules for the declaring the Jobs as successful before `.status.succeeded >= .spec.completions`. Once any of the rules are met, the \"SuccessCriteriaMet\" condition is added, and the lingering pods are removed. The terminal state for such a Job has the \"Complete\" condition. Additionally, these rules are evaluated in order; Once the Job meets one of the rules, other rules are ignored. At most 20 elements are allowed. # noqa: E501 + + :param rules: The rules of this V1SuccessPolicy. # noqa: E501 + :type: list[V1SuccessPolicyRule] + """ + if self.local_vars_configuration.client_side_validation and rules is None: # noqa: E501 + raise ValueError("Invalid value for `rules`, must not be `None`") # noqa: E501 + + self._rules = rules + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1SuccessPolicy): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1SuccessPolicy): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy_rule.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy_rule.py new file mode 100644 index 0000000000000000000000000000000000000000..318e579901c50ca687a68acca82dbe7a67703040 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_success_policy_rule.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1SuccessPolicyRule(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'succeeded_count': 'int', + 'succeeded_indexes': 'str' + } + + attribute_map = { + 'succeeded_count': 'succeededCount', + 'succeeded_indexes': 'succeededIndexes' + } + + def __init__(self, succeeded_count=None, succeeded_indexes=None, local_vars_configuration=None): # noqa: E501 + """V1SuccessPolicyRule - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._succeeded_count = None + self._succeeded_indexes = None + self.discriminator = None + + if succeeded_count is not None: + self.succeeded_count = succeeded_count + if succeeded_indexes is not None: + self.succeeded_indexes = succeeded_indexes + + @property + def succeeded_count(self): + """Gets the succeeded_count of this V1SuccessPolicyRule. # noqa: E501 + + succeededCount specifies the minimal required size of the actual set of the succeeded indexes for the Job. When succeededCount is used along with succeededIndexes, the check is constrained only to the set of indexes specified by succeededIndexes. For example, given that succeededIndexes is \"1-4\", succeededCount is \"3\", and completed indexes are \"1\", \"3\", and \"5\", the Job isn't declared as succeeded because only \"1\" and \"3\" indexes are considered in that rules. When this field is null, this doesn't default to any value and is never evaluated at any time. When specified it needs to be a positive integer. # noqa: E501 + + :return: The succeeded_count of this V1SuccessPolicyRule. # noqa: E501 + :rtype: int + """ + return self._succeeded_count + + @succeeded_count.setter + def succeeded_count(self, succeeded_count): + """Sets the succeeded_count of this V1SuccessPolicyRule. + + succeededCount specifies the minimal required size of the actual set of the succeeded indexes for the Job. When succeededCount is used along with succeededIndexes, the check is constrained only to the set of indexes specified by succeededIndexes. For example, given that succeededIndexes is \"1-4\", succeededCount is \"3\", and completed indexes are \"1\", \"3\", and \"5\", the Job isn't declared as succeeded because only \"1\" and \"3\" indexes are considered in that rules. When this field is null, this doesn't default to any value and is never evaluated at any time. When specified it needs to be a positive integer. # noqa: E501 + + :param succeeded_count: The succeeded_count of this V1SuccessPolicyRule. # noqa: E501 + :type: int + """ + + self._succeeded_count = succeeded_count + + @property + def succeeded_indexes(self): + """Gets the succeeded_indexes of this V1SuccessPolicyRule. # noqa: E501 + + succeededIndexes specifies the set of indexes which need to be contained in the actual set of the succeeded indexes for the Job. The list of indexes must be within 0 to \".spec.completions-1\" and must not contain duplicates. At least one element is required. The indexes are represented as intervals separated by commas. The intervals can be a decimal integer or a pair of decimal integers separated by a hyphen. The number are listed in represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". When this field is null, this field doesn't default to any value and is never evaluated at any time. # noqa: E501 + + :return: The succeeded_indexes of this V1SuccessPolicyRule. # noqa: E501 + :rtype: str + """ + return self._succeeded_indexes + + @succeeded_indexes.setter + def succeeded_indexes(self, succeeded_indexes): + """Sets the succeeded_indexes of this V1SuccessPolicyRule. + + succeededIndexes specifies the set of indexes which need to be contained in the actual set of the succeeded indexes for the Job. The list of indexes must be within 0 to \".spec.completions-1\" and must not contain duplicates. At least one element is required. The indexes are represented as intervals separated by commas. The intervals can be a decimal integer or a pair of decimal integers separated by a hyphen. The number are listed in represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". When this field is null, this field doesn't default to any value and is never evaluated at any time. # noqa: E501 + + :param succeeded_indexes: The succeeded_indexes of this V1SuccessPolicyRule. # noqa: E501 + :type: str + """ + + self._succeeded_indexes = succeeded_indexes + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1SuccessPolicyRule): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1SuccessPolicyRule): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_sysctl.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_sysctl.py new file mode 100644 index 0000000000000000000000000000000000000000..f96ab6dc229e7986cd3f28c0ac57b95067219cb6 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_sysctl.py @@ -0,0 +1,152 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Sysctl(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'name': 'str', + 'value': 'str' + } + + attribute_map = { + 'name': 'name', + 'value': 'value' + } + + def __init__(self, name=None, value=None, local_vars_configuration=None): # noqa: E501 + """V1Sysctl - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._name = None + self._value = None + self.discriminator = None + + self.name = name + self.value = value + + @property + def name(self): + """Gets the name of this V1Sysctl. # noqa: E501 + + Name of a property to set # noqa: E501 + + :return: The name of this V1Sysctl. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1Sysctl. + + Name of a property to set # noqa: E501 + + :param name: The name of this V1Sysctl. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def value(self): + """Gets the value of this V1Sysctl. # noqa: E501 + + Value of a property to set # noqa: E501 + + :return: The value of this V1Sysctl. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V1Sysctl. + + Value of a property to set # noqa: E501 + + :param value: The value of this V1Sysctl. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and value is None: # noqa: E501 + raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501 + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Sysctl): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Sysctl): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_taint.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_taint.py new file mode 100644 index 0000000000000000000000000000000000000000..7b09ba98aa7fe452be71578b5ba9268b3137d570 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_taint.py @@ -0,0 +1,208 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Taint(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'effect': 'str', + 'key': 'str', + 'time_added': 'datetime', + 'value': 'str' + } + + attribute_map = { + 'effect': 'effect', + 'key': 'key', + 'time_added': 'timeAdded', + 'value': 'value' + } + + def __init__(self, effect=None, key=None, time_added=None, value=None, local_vars_configuration=None): # noqa: E501 + """V1Taint - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._effect = None + self._key = None + self._time_added = None + self._value = None + self.discriminator = None + + self.effect = effect + self.key = key + if time_added is not None: + self.time_added = time_added + if value is not None: + self.value = value + + @property + def effect(self): + """Gets the effect of this V1Taint. # noqa: E501 + + Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. # noqa: E501 + + :return: The effect of this V1Taint. # noqa: E501 + :rtype: str + """ + return self._effect + + @effect.setter + def effect(self, effect): + """Sets the effect of this V1Taint. + + Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. # noqa: E501 + + :param effect: The effect of this V1Taint. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and effect is None: # noqa: E501 + raise ValueError("Invalid value for `effect`, must not be `None`") # noqa: E501 + + self._effect = effect + + @property + def key(self): + """Gets the key of this V1Taint. # noqa: E501 + + Required. The taint key to be applied to a node. # noqa: E501 + + :return: The key of this V1Taint. # noqa: E501 + :rtype: str + """ + return self._key + + @key.setter + def key(self, key): + """Sets the key of this V1Taint. + + Required. The taint key to be applied to a node. # noqa: E501 + + :param key: The key of this V1Taint. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and key is None: # noqa: E501 + raise ValueError("Invalid value for `key`, must not be `None`") # noqa: E501 + + self._key = key + + @property + def time_added(self): + """Gets the time_added of this V1Taint. # noqa: E501 + + TimeAdded represents the time at which the taint was added. # noqa: E501 + + :return: The time_added of this V1Taint. # noqa: E501 + :rtype: datetime + """ + return self._time_added + + @time_added.setter + def time_added(self, time_added): + """Sets the time_added of this V1Taint. + + TimeAdded represents the time at which the taint was added. # noqa: E501 + + :param time_added: The time_added of this V1Taint. # noqa: E501 + :type: datetime + """ + + self._time_added = time_added + + @property + def value(self): + """Gets the value of this V1Taint. # noqa: E501 + + The taint value corresponding to the taint key. # noqa: E501 + + :return: The value of this V1Taint. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V1Taint. + + The taint value corresponding to the taint key. # noqa: E501 + + :param value: The value of this V1Taint. # noqa: E501 + :type: str + """ + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Taint): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Taint): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_tcp_socket_action.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_tcp_socket_action.py new file mode 100644 index 0000000000000000000000000000000000000000..2e4fdda09d9f071741439a9c73f96b4f6c109666 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_tcp_socket_action.py @@ -0,0 +1,151 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TCPSocketAction(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'host': 'str', + 'port': 'object' + } + + attribute_map = { + 'host': 'host', + 'port': 'port' + } + + def __init__(self, host=None, port=None, local_vars_configuration=None): # noqa: E501 + """V1TCPSocketAction - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._host = None + self._port = None + self.discriminator = None + + if host is not None: + self.host = host + self.port = port + + @property + def host(self): + """Gets the host of this V1TCPSocketAction. # noqa: E501 + + Optional: Host name to connect to, defaults to the pod IP. # noqa: E501 + + :return: The host of this V1TCPSocketAction. # noqa: E501 + :rtype: str + """ + return self._host + + @host.setter + def host(self, host): + """Sets the host of this V1TCPSocketAction. + + Optional: Host name to connect to, defaults to the pod IP. # noqa: E501 + + :param host: The host of this V1TCPSocketAction. # noqa: E501 + :type: str + """ + + self._host = host + + @property + def port(self): + """Gets the port of this V1TCPSocketAction. # noqa: E501 + + Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. # noqa: E501 + + :return: The port of this V1TCPSocketAction. # noqa: E501 + :rtype: object + """ + return self._port + + @port.setter + def port(self, port): + """Sets the port of this V1TCPSocketAction. + + Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. # noqa: E501 + + :param port: The port of this V1TCPSocketAction. # noqa: E501 + :type: object + """ + if self.local_vars_configuration.client_side_validation and port is None: # noqa: E501 + raise ValueError("Invalid value for `port`, must not be `None`") # noqa: E501 + + self._port = port + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TCPSocketAction): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TCPSocketAction): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..1b2161b7bb4c3937efbadf91a40b471ee18b8d95 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_spec.py @@ -0,0 +1,177 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TokenRequestSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'audiences': 'list[str]', + 'bound_object_ref': 'V1BoundObjectReference', + 'expiration_seconds': 'int' + } + + attribute_map = { + 'audiences': 'audiences', + 'bound_object_ref': 'boundObjectRef', + 'expiration_seconds': 'expirationSeconds' + } + + def __init__(self, audiences=None, bound_object_ref=None, expiration_seconds=None, local_vars_configuration=None): # noqa: E501 + """V1TokenRequestSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._audiences = None + self._bound_object_ref = None + self._expiration_seconds = None + self.discriminator = None + + self.audiences = audiences + if bound_object_ref is not None: + self.bound_object_ref = bound_object_ref + if expiration_seconds is not None: + self.expiration_seconds = expiration_seconds + + @property + def audiences(self): + """Gets the audiences of this V1TokenRequestSpec. # noqa: E501 + + Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. # noqa: E501 + + :return: The audiences of this V1TokenRequestSpec. # noqa: E501 + :rtype: list[str] + """ + return self._audiences + + @audiences.setter + def audiences(self, audiences): + """Sets the audiences of this V1TokenRequestSpec. + + Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. # noqa: E501 + + :param audiences: The audiences of this V1TokenRequestSpec. # noqa: E501 + :type: list[str] + """ + if self.local_vars_configuration.client_side_validation and audiences is None: # noqa: E501 + raise ValueError("Invalid value for `audiences`, must not be `None`") # noqa: E501 + + self._audiences = audiences + + @property + def bound_object_ref(self): + """Gets the bound_object_ref of this V1TokenRequestSpec. # noqa: E501 + + + :return: The bound_object_ref of this V1TokenRequestSpec. # noqa: E501 + :rtype: V1BoundObjectReference + """ + return self._bound_object_ref + + @bound_object_ref.setter + def bound_object_ref(self, bound_object_ref): + """Sets the bound_object_ref of this V1TokenRequestSpec. + + + :param bound_object_ref: The bound_object_ref of this V1TokenRequestSpec. # noqa: E501 + :type: V1BoundObjectReference + """ + + self._bound_object_ref = bound_object_ref + + @property + def expiration_seconds(self): + """Gets the expiration_seconds of this V1TokenRequestSpec. # noqa: E501 + + ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response. # noqa: E501 + + :return: The expiration_seconds of this V1TokenRequestSpec. # noqa: E501 + :rtype: int + """ + return self._expiration_seconds + + @expiration_seconds.setter + def expiration_seconds(self, expiration_seconds): + """Sets the expiration_seconds of this V1TokenRequestSpec. + + ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response. # noqa: E501 + + :param expiration_seconds: The expiration_seconds of this V1TokenRequestSpec. # noqa: E501 + :type: int + """ + + self._expiration_seconds = expiration_seconds + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TokenRequestSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TokenRequestSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_status.py new file mode 100644 index 0000000000000000000000000000000000000000..9ea3c745a2e150bfcf9d215e676d03e1fd727df5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_request_status.py @@ -0,0 +1,152 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TokenRequestStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'expiration_timestamp': 'datetime', + 'token': 'str' + } + + attribute_map = { + 'expiration_timestamp': 'expirationTimestamp', + 'token': 'token' + } + + def __init__(self, expiration_timestamp=None, token=None, local_vars_configuration=None): # noqa: E501 + """V1TokenRequestStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._expiration_timestamp = None + self._token = None + self.discriminator = None + + self.expiration_timestamp = expiration_timestamp + self.token = token + + @property + def expiration_timestamp(self): + """Gets the expiration_timestamp of this V1TokenRequestStatus. # noqa: E501 + + ExpirationTimestamp is the time of expiration of the returned token. # noqa: E501 + + :return: The expiration_timestamp of this V1TokenRequestStatus. # noqa: E501 + :rtype: datetime + """ + return self._expiration_timestamp + + @expiration_timestamp.setter + def expiration_timestamp(self, expiration_timestamp): + """Sets the expiration_timestamp of this V1TokenRequestStatus. + + ExpirationTimestamp is the time of expiration of the returned token. # noqa: E501 + + :param expiration_timestamp: The expiration_timestamp of this V1TokenRequestStatus. # noqa: E501 + :type: datetime + """ + if self.local_vars_configuration.client_side_validation and expiration_timestamp is None: # noqa: E501 + raise ValueError("Invalid value for `expiration_timestamp`, must not be `None`") # noqa: E501 + + self._expiration_timestamp = expiration_timestamp + + @property + def token(self): + """Gets the token of this V1TokenRequestStatus. # noqa: E501 + + Token is the opaque bearer token. # noqa: E501 + + :return: The token of this V1TokenRequestStatus. # noqa: E501 + :rtype: str + """ + return self._token + + @token.setter + def token(self, token): + """Sets the token of this V1TokenRequestStatus. + + Token is the opaque bearer token. # noqa: E501 + + :param token: The token of this V1TokenRequestStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and token is None: # noqa: E501 + raise ValueError("Invalid value for `token`, must not be `None`") # noqa: E501 + + self._token = token + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TokenRequestStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TokenRequestStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review.py new file mode 100644 index 0000000000000000000000000000000000000000..fc80ee40136b72273742eb6ce0fbf79445c144ef --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review.py @@ -0,0 +1,229 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TokenReview(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'spec': 'V1TokenReviewSpec', + 'status': 'V1TokenReviewStatus' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'spec': 'spec', + 'status': 'status' + } + + def __init__(self, api_version=None, kind=None, metadata=None, spec=None, status=None, local_vars_configuration=None): # noqa: E501 + """V1TokenReview - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._spec = None + self._status = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + self.spec = spec + if status is not None: + self.status = status + + @property + def api_version(self): + """Gets the api_version of this V1TokenReview. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1TokenReview. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1TokenReview. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1TokenReview. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V1TokenReview. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1TokenReview. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1TokenReview. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1TokenReview. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1TokenReview. # noqa: E501 + + + :return: The metadata of this V1TokenReview. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1TokenReview. + + + :param metadata: The metadata of this V1TokenReview. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def spec(self): + """Gets the spec of this V1TokenReview. # noqa: E501 + + + :return: The spec of this V1TokenReview. # noqa: E501 + :rtype: V1TokenReviewSpec + """ + return self._spec + + @spec.setter + def spec(self, spec): + """Sets the spec of this V1TokenReview. + + + :param spec: The spec of this V1TokenReview. # noqa: E501 + :type: V1TokenReviewSpec + """ + if self.local_vars_configuration.client_side_validation and spec is None: # noqa: E501 + raise ValueError("Invalid value for `spec`, must not be `None`") # noqa: E501 + + self._spec = spec + + @property + def status(self): + """Gets the status of this V1TokenReview. # noqa: E501 + + + :return: The status of this V1TokenReview. # noqa: E501 + :rtype: V1TokenReviewStatus + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this V1TokenReview. + + + :param status: The status of this V1TokenReview. # noqa: E501 + :type: V1TokenReviewStatus + """ + + self._status = status + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TokenReview): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TokenReview): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..921cab4170a7808b878b5b8e7bd59d96c0c1065c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_spec.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TokenReviewSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'audiences': 'list[str]', + 'token': 'str' + } + + attribute_map = { + 'audiences': 'audiences', + 'token': 'token' + } + + def __init__(self, audiences=None, token=None, local_vars_configuration=None): # noqa: E501 + """V1TokenReviewSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._audiences = None + self._token = None + self.discriminator = None + + if audiences is not None: + self.audiences = audiences + if token is not None: + self.token = token + + @property + def audiences(self): + """Gets the audiences of this V1TokenReviewSpec. # noqa: E501 + + Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. # noqa: E501 + + :return: The audiences of this V1TokenReviewSpec. # noqa: E501 + :rtype: list[str] + """ + return self._audiences + + @audiences.setter + def audiences(self, audiences): + """Sets the audiences of this V1TokenReviewSpec. + + Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. # noqa: E501 + + :param audiences: The audiences of this V1TokenReviewSpec. # noqa: E501 + :type: list[str] + """ + + self._audiences = audiences + + @property + def token(self): + """Gets the token of this V1TokenReviewSpec. # noqa: E501 + + Token is the opaque bearer token. # noqa: E501 + + :return: The token of this V1TokenReviewSpec. # noqa: E501 + :rtype: str + """ + return self._token + + @token.setter + def token(self, token): + """Sets the token of this V1TokenReviewSpec. + + Token is the opaque bearer token. # noqa: E501 + + :param token: The token of this V1TokenReviewSpec. # noqa: E501 + :type: str + """ + + self._token = token + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TokenReviewSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TokenReviewSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_status.py new file mode 100644 index 0000000000000000000000000000000000000000..f733f5e0a3851df341f7c06a6cfcab774a7bb75d --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_token_review_status.py @@ -0,0 +1,204 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TokenReviewStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'audiences': 'list[str]', + 'authenticated': 'bool', + 'error': 'str', + 'user': 'V1UserInfo' + } + + attribute_map = { + 'audiences': 'audiences', + 'authenticated': 'authenticated', + 'error': 'error', + 'user': 'user' + } + + def __init__(self, audiences=None, authenticated=None, error=None, user=None, local_vars_configuration=None): # noqa: E501 + """V1TokenReviewStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._audiences = None + self._authenticated = None + self._error = None + self._user = None + self.discriminator = None + + if audiences is not None: + self.audiences = audiences + if authenticated is not None: + self.authenticated = authenticated + if error is not None: + self.error = error + if user is not None: + self.user = user + + @property + def audiences(self): + """Gets the audiences of this V1TokenReviewStatus. # noqa: E501 + + Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is \"true\", the token is valid against the audience of the Kubernetes API server. # noqa: E501 + + :return: The audiences of this V1TokenReviewStatus. # noqa: E501 + :rtype: list[str] + """ + return self._audiences + + @audiences.setter + def audiences(self, audiences): + """Sets the audiences of this V1TokenReviewStatus. + + Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is \"true\", the token is valid against the audience of the Kubernetes API server. # noqa: E501 + + :param audiences: The audiences of this V1TokenReviewStatus. # noqa: E501 + :type: list[str] + """ + + self._audiences = audiences + + @property + def authenticated(self): + """Gets the authenticated of this V1TokenReviewStatus. # noqa: E501 + + Authenticated indicates that the token was associated with a known user. # noqa: E501 + + :return: The authenticated of this V1TokenReviewStatus. # noqa: E501 + :rtype: bool + """ + return self._authenticated + + @authenticated.setter + def authenticated(self, authenticated): + """Sets the authenticated of this V1TokenReviewStatus. + + Authenticated indicates that the token was associated with a known user. # noqa: E501 + + :param authenticated: The authenticated of this V1TokenReviewStatus. # noqa: E501 + :type: bool + """ + + self._authenticated = authenticated + + @property + def error(self): + """Gets the error of this V1TokenReviewStatus. # noqa: E501 + + Error indicates that the token couldn't be checked # noqa: E501 + + :return: The error of this V1TokenReviewStatus. # noqa: E501 + :rtype: str + """ + return self._error + + @error.setter + def error(self, error): + """Sets the error of this V1TokenReviewStatus. + + Error indicates that the token couldn't be checked # noqa: E501 + + :param error: The error of this V1TokenReviewStatus. # noqa: E501 + :type: str + """ + + self._error = error + + @property + def user(self): + """Gets the user of this V1TokenReviewStatus. # noqa: E501 + + + :return: The user of this V1TokenReviewStatus. # noqa: E501 + :rtype: V1UserInfo + """ + return self._user + + @user.setter + def user(self, user): + """Sets the user of this V1TokenReviewStatus. + + + :param user: The user of this V1TokenReviewStatus. # noqa: E501 + :type: V1UserInfo + """ + + self._user = user + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TokenReviewStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TokenReviewStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_toleration.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_toleration.py new file mode 100644 index 0000000000000000000000000000000000000000..642e833dd1c3832adc703c382651d77a9ab5ab79 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_toleration.py @@ -0,0 +1,234 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Toleration(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'effect': 'str', + 'key': 'str', + 'operator': 'str', + 'toleration_seconds': 'int', + 'value': 'str' + } + + attribute_map = { + 'effect': 'effect', + 'key': 'key', + 'operator': 'operator', + 'toleration_seconds': 'tolerationSeconds', + 'value': 'value' + } + + def __init__(self, effect=None, key=None, operator=None, toleration_seconds=None, value=None, local_vars_configuration=None): # noqa: E501 + """V1Toleration - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._effect = None + self._key = None + self._operator = None + self._toleration_seconds = None + self._value = None + self.discriminator = None + + if effect is not None: + self.effect = effect + if key is not None: + self.key = key + if operator is not None: + self.operator = operator + if toleration_seconds is not None: + self.toleration_seconds = toleration_seconds + if value is not None: + self.value = value + + @property + def effect(self): + """Gets the effect of this V1Toleration. # noqa: E501 + + Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. # noqa: E501 + + :return: The effect of this V1Toleration. # noqa: E501 + :rtype: str + """ + return self._effect + + @effect.setter + def effect(self, effect): + """Sets the effect of this V1Toleration. + + Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. # noqa: E501 + + :param effect: The effect of this V1Toleration. # noqa: E501 + :type: str + """ + + self._effect = effect + + @property + def key(self): + """Gets the key of this V1Toleration. # noqa: E501 + + Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. # noqa: E501 + + :return: The key of this V1Toleration. # noqa: E501 + :rtype: str + """ + return self._key + + @key.setter + def key(self, key): + """Sets the key of this V1Toleration. + + Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. # noqa: E501 + + :param key: The key of this V1Toleration. # noqa: E501 + :type: str + """ + + self._key = key + + @property + def operator(self): + """Gets the operator of this V1Toleration. # noqa: E501 + + Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). # noqa: E501 + + :return: The operator of this V1Toleration. # noqa: E501 + :rtype: str + """ + return self._operator + + @operator.setter + def operator(self, operator): + """Sets the operator of this V1Toleration. + + Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). # noqa: E501 + + :param operator: The operator of this V1Toleration. # noqa: E501 + :type: str + """ + + self._operator = operator + + @property + def toleration_seconds(self): + """Gets the toleration_seconds of this V1Toleration. # noqa: E501 + + TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. # noqa: E501 + + :return: The toleration_seconds of this V1Toleration. # noqa: E501 + :rtype: int + """ + return self._toleration_seconds + + @toleration_seconds.setter + def toleration_seconds(self, toleration_seconds): + """Sets the toleration_seconds of this V1Toleration. + + TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. # noqa: E501 + + :param toleration_seconds: The toleration_seconds of this V1Toleration. # noqa: E501 + :type: int + """ + + self._toleration_seconds = toleration_seconds + + @property + def value(self): + """Gets the value of this V1Toleration. # noqa: E501 + + Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. # noqa: E501 + + :return: The value of this V1Toleration. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V1Toleration. + + Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. # noqa: E501 + + :param value: The value of this V1Toleration. # noqa: E501 + :type: str + """ + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Toleration): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Toleration): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_label_requirement.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_label_requirement.py new file mode 100644 index 0000000000000000000000000000000000000000..4733fc0472226455125c1beba5045c2cd13f9730 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_label_requirement.py @@ -0,0 +1,152 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TopologySelectorLabelRequirement(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'key': 'str', + 'values': 'list[str]' + } + + attribute_map = { + 'key': 'key', + 'values': 'values' + } + + def __init__(self, key=None, values=None, local_vars_configuration=None): # noqa: E501 + """V1TopologySelectorLabelRequirement - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._key = None + self._values = None + self.discriminator = None + + self.key = key + self.values = values + + @property + def key(self): + """Gets the key of this V1TopologySelectorLabelRequirement. # noqa: E501 + + The label key that the selector applies to. # noqa: E501 + + :return: The key of this V1TopologySelectorLabelRequirement. # noqa: E501 + :rtype: str + """ + return self._key + + @key.setter + def key(self, key): + """Sets the key of this V1TopologySelectorLabelRequirement. + + The label key that the selector applies to. # noqa: E501 + + :param key: The key of this V1TopologySelectorLabelRequirement. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and key is None: # noqa: E501 + raise ValueError("Invalid value for `key`, must not be `None`") # noqa: E501 + + self._key = key + + @property + def values(self): + """Gets the values of this V1TopologySelectorLabelRequirement. # noqa: E501 + + An array of string values. One value must match the label to be selected. Each entry in Values is ORed. # noqa: E501 + + :return: The values of this V1TopologySelectorLabelRequirement. # noqa: E501 + :rtype: list[str] + """ + return self._values + + @values.setter + def values(self, values): + """Sets the values of this V1TopologySelectorLabelRequirement. + + An array of string values. One value must match the label to be selected. Each entry in Values is ORed. # noqa: E501 + + :param values: The values of this V1TopologySelectorLabelRequirement. # noqa: E501 + :type: list[str] + """ + if self.local_vars_configuration.client_side_validation and values is None: # noqa: E501 + raise ValueError("Invalid value for `values`, must not be `None`") # noqa: E501 + + self._values = values + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TopologySelectorLabelRequirement): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TopologySelectorLabelRequirement): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_term.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_term.py new file mode 100644 index 0000000000000000000000000000000000000000..b22f3fc810c27689a558dc0999f878cc1ada301c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_selector_term.py @@ -0,0 +1,122 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TopologySelectorTerm(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'match_label_expressions': 'list[V1TopologySelectorLabelRequirement]' + } + + attribute_map = { + 'match_label_expressions': 'matchLabelExpressions' + } + + def __init__(self, match_label_expressions=None, local_vars_configuration=None): # noqa: E501 + """V1TopologySelectorTerm - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._match_label_expressions = None + self.discriminator = None + + if match_label_expressions is not None: + self.match_label_expressions = match_label_expressions + + @property + def match_label_expressions(self): + """Gets the match_label_expressions of this V1TopologySelectorTerm. # noqa: E501 + + A list of topology selector requirements by labels. # noqa: E501 + + :return: The match_label_expressions of this V1TopologySelectorTerm. # noqa: E501 + :rtype: list[V1TopologySelectorLabelRequirement] + """ + return self._match_label_expressions + + @match_label_expressions.setter + def match_label_expressions(self, match_label_expressions): + """Sets the match_label_expressions of this V1TopologySelectorTerm. + + A list of topology selector requirements by labels. # noqa: E501 + + :param match_label_expressions: The match_label_expressions of this V1TopologySelectorTerm. # noqa: E501 + :type: list[V1TopologySelectorLabelRequirement] + """ + + self._match_label_expressions = match_label_expressions + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TopologySelectorTerm): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TopologySelectorTerm): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_spread_constraint.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_spread_constraint.py new file mode 100644 index 0000000000000000000000000000000000000000..ea3de4cdbab01b69cbac630d6542731eccff4515 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_topology_spread_constraint.py @@ -0,0 +1,319 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TopologySpreadConstraint(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'label_selector': 'V1LabelSelector', + 'match_label_keys': 'list[str]', + 'max_skew': 'int', + 'min_domains': 'int', + 'node_affinity_policy': 'str', + 'node_taints_policy': 'str', + 'topology_key': 'str', + 'when_unsatisfiable': 'str' + } + + attribute_map = { + 'label_selector': 'labelSelector', + 'match_label_keys': 'matchLabelKeys', + 'max_skew': 'maxSkew', + 'min_domains': 'minDomains', + 'node_affinity_policy': 'nodeAffinityPolicy', + 'node_taints_policy': 'nodeTaintsPolicy', + 'topology_key': 'topologyKey', + 'when_unsatisfiable': 'whenUnsatisfiable' + } + + def __init__(self, label_selector=None, match_label_keys=None, max_skew=None, min_domains=None, node_affinity_policy=None, node_taints_policy=None, topology_key=None, when_unsatisfiable=None, local_vars_configuration=None): # noqa: E501 + """V1TopologySpreadConstraint - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._label_selector = None + self._match_label_keys = None + self._max_skew = None + self._min_domains = None + self._node_affinity_policy = None + self._node_taints_policy = None + self._topology_key = None + self._when_unsatisfiable = None + self.discriminator = None + + if label_selector is not None: + self.label_selector = label_selector + if match_label_keys is not None: + self.match_label_keys = match_label_keys + self.max_skew = max_skew + if min_domains is not None: + self.min_domains = min_domains + if node_affinity_policy is not None: + self.node_affinity_policy = node_affinity_policy + if node_taints_policy is not None: + self.node_taints_policy = node_taints_policy + self.topology_key = topology_key + self.when_unsatisfiable = when_unsatisfiable + + @property + def label_selector(self): + """Gets the label_selector of this V1TopologySpreadConstraint. # noqa: E501 + + + :return: The label_selector of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: V1LabelSelector + """ + return self._label_selector + + @label_selector.setter + def label_selector(self, label_selector): + """Sets the label_selector of this V1TopologySpreadConstraint. + + + :param label_selector: The label_selector of this V1TopologySpreadConstraint. # noqa: E501 + :type: V1LabelSelector + """ + + self._label_selector = label_selector + + @property + def match_label_keys(self): + """Gets the match_label_keys of this V1TopologySpreadConstraint. # noqa: E501 + + MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector. This is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default). # noqa: E501 + + :return: The match_label_keys of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: list[str] + """ + return self._match_label_keys + + @match_label_keys.setter + def match_label_keys(self, match_label_keys): + """Sets the match_label_keys of this V1TopologySpreadConstraint. + + MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector. This is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default). # noqa: E501 + + :param match_label_keys: The match_label_keys of this V1TopologySpreadConstraint. # noqa: E501 + :type: list[str] + """ + + self._match_label_keys = match_label_keys + + @property + def max_skew(self): + """Gets the max_skew of this V1TopologySpreadConstraint. # noqa: E501 + + MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed. # noqa: E501 + + :return: The max_skew of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: int + """ + return self._max_skew + + @max_skew.setter + def max_skew(self, max_skew): + """Sets the max_skew of this V1TopologySpreadConstraint. + + MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed. # noqa: E501 + + :param max_skew: The max_skew of this V1TopologySpreadConstraint. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and max_skew is None: # noqa: E501 + raise ValueError("Invalid value for `max_skew`, must not be `None`") # noqa: E501 + + self._max_skew = max_skew + + @property + def min_domains(self): + """Gets the min_domains of this V1TopologySpreadConstraint. # noqa: E501 + + MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. # noqa: E501 + + :return: The min_domains of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: int + """ + return self._min_domains + + @min_domains.setter + def min_domains(self, min_domains): + """Sets the min_domains of this V1TopologySpreadConstraint. + + MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. # noqa: E501 + + :param min_domains: The min_domains of this V1TopologySpreadConstraint. # noqa: E501 + :type: int + """ + + self._min_domains = min_domains + + @property + def node_affinity_policy(self): + """Gets the node_affinity_policy of this V1TopologySpreadConstraint. # noqa: E501 + + NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. If this value is nil, the behavior is equivalent to the Honor policy. # noqa: E501 + + :return: The node_affinity_policy of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: str + """ + return self._node_affinity_policy + + @node_affinity_policy.setter + def node_affinity_policy(self, node_affinity_policy): + """Sets the node_affinity_policy of this V1TopologySpreadConstraint. + + NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. If this value is nil, the behavior is equivalent to the Honor policy. # noqa: E501 + + :param node_affinity_policy: The node_affinity_policy of this V1TopologySpreadConstraint. # noqa: E501 + :type: str + """ + + self._node_affinity_policy = node_affinity_policy + + @property + def node_taints_policy(self): + """Gets the node_taints_policy of this V1TopologySpreadConstraint. # noqa: E501 + + NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. If this value is nil, the behavior is equivalent to the Ignore policy. # noqa: E501 + + :return: The node_taints_policy of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: str + """ + return self._node_taints_policy + + @node_taints_policy.setter + def node_taints_policy(self, node_taints_policy): + """Sets the node_taints_policy of this V1TopologySpreadConstraint. + + NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. If this value is nil, the behavior is equivalent to the Ignore policy. # noqa: E501 + + :param node_taints_policy: The node_taints_policy of this V1TopologySpreadConstraint. # noqa: E501 + :type: str + """ + + self._node_taints_policy = node_taints_policy + + @property + def topology_key(self): + """Gets the topology_key of this V1TopologySpreadConstraint. # noqa: E501 + + TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field. # noqa: E501 + + :return: The topology_key of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: str + """ + return self._topology_key + + @topology_key.setter + def topology_key(self, topology_key): + """Sets the topology_key of this V1TopologySpreadConstraint. + + TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field. # noqa: E501 + + :param topology_key: The topology_key of this V1TopologySpreadConstraint. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and topology_key is None: # noqa: E501 + raise ValueError("Invalid value for `topology_key`, must not be `None`") # noqa: E501 + + self._topology_key = topology_key + + @property + def when_unsatisfiable(self): + """Gets the when_unsatisfiable of this V1TopologySpreadConstraint. # noqa: E501 + + WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field. # noqa: E501 + + :return: The when_unsatisfiable of this V1TopologySpreadConstraint. # noqa: E501 + :rtype: str + """ + return self._when_unsatisfiable + + @when_unsatisfiable.setter + def when_unsatisfiable(self, when_unsatisfiable): + """Sets the when_unsatisfiable of this V1TopologySpreadConstraint. + + WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field. # noqa: E501 + + :param when_unsatisfiable: The when_unsatisfiable of this V1TopologySpreadConstraint. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and when_unsatisfiable is None: # noqa: E501 + raise ValueError("Invalid value for `when_unsatisfiable`, must not be `None`") # noqa: E501 + + self._when_unsatisfiable = when_unsatisfiable + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TopologySpreadConstraint): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TopologySpreadConstraint): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_type_checking.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_type_checking.py new file mode 100644 index 0000000000000000000000000000000000000000..5459b611f8a9b6b2206c7de3a4a7c10ded7704b6 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_type_checking.py @@ -0,0 +1,122 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TypeChecking(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'expression_warnings': 'list[V1ExpressionWarning]' + } + + attribute_map = { + 'expression_warnings': 'expressionWarnings' + } + + def __init__(self, expression_warnings=None, local_vars_configuration=None): # noqa: E501 + """V1TypeChecking - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._expression_warnings = None + self.discriminator = None + + if expression_warnings is not None: + self.expression_warnings = expression_warnings + + @property + def expression_warnings(self): + """Gets the expression_warnings of this V1TypeChecking. # noqa: E501 + + The type checking warnings for each expression. # noqa: E501 + + :return: The expression_warnings of this V1TypeChecking. # noqa: E501 + :rtype: list[V1ExpressionWarning] + """ + return self._expression_warnings + + @expression_warnings.setter + def expression_warnings(self, expression_warnings): + """Sets the expression_warnings of this V1TypeChecking. + + The type checking warnings for each expression. # noqa: E501 + + :param expression_warnings: The expression_warnings of this V1TypeChecking. # noqa: E501 + :type: list[V1ExpressionWarning] + """ + + self._expression_warnings = expression_warnings + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TypeChecking): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TypeChecking): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_local_object_reference.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_local_object_reference.py new file mode 100644 index 0000000000000000000000000000000000000000..62fe1d254339d8c709655d27ac0ca4d336c000fc --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_local_object_reference.py @@ -0,0 +1,180 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TypedLocalObjectReference(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_group': 'str', + 'kind': 'str', + 'name': 'str' + } + + attribute_map = { + 'api_group': 'apiGroup', + 'kind': 'kind', + 'name': 'name' + } + + def __init__(self, api_group=None, kind=None, name=None, local_vars_configuration=None): # noqa: E501 + """V1TypedLocalObjectReference - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_group = None + self._kind = None + self._name = None + self.discriminator = None + + if api_group is not None: + self.api_group = api_group + self.kind = kind + self.name = name + + @property + def api_group(self): + """Gets the api_group of this V1TypedLocalObjectReference. # noqa: E501 + + APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. # noqa: E501 + + :return: The api_group of this V1TypedLocalObjectReference. # noqa: E501 + :rtype: str + """ + return self._api_group + + @api_group.setter + def api_group(self, api_group): + """Sets the api_group of this V1TypedLocalObjectReference. + + APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. # noqa: E501 + + :param api_group: The api_group of this V1TypedLocalObjectReference. # noqa: E501 + :type: str + """ + + self._api_group = api_group + + @property + def kind(self): + """Gets the kind of this V1TypedLocalObjectReference. # noqa: E501 + + Kind is the type of resource being referenced # noqa: E501 + + :return: The kind of this V1TypedLocalObjectReference. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1TypedLocalObjectReference. + + Kind is the type of resource being referenced # noqa: E501 + + :param kind: The kind of this V1TypedLocalObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and kind is None: # noqa: E501 + raise ValueError("Invalid value for `kind`, must not be `None`") # noqa: E501 + + self._kind = kind + + @property + def name(self): + """Gets the name of this V1TypedLocalObjectReference. # noqa: E501 + + Name is the name of resource being referenced # noqa: E501 + + :return: The name of this V1TypedLocalObjectReference. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1TypedLocalObjectReference. + + Name is the name of resource being referenced # noqa: E501 + + :param name: The name of this V1TypedLocalObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TypedLocalObjectReference): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TypedLocalObjectReference): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_object_reference.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_object_reference.py new file mode 100644 index 0000000000000000000000000000000000000000..7f354227b4bfca4d0199086a746d697b36995863 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_typed_object_reference.py @@ -0,0 +1,208 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1TypedObjectReference(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_group': 'str', + 'kind': 'str', + 'name': 'str', + 'namespace': 'str' + } + + attribute_map = { + 'api_group': 'apiGroup', + 'kind': 'kind', + 'name': 'name', + 'namespace': 'namespace' + } + + def __init__(self, api_group=None, kind=None, name=None, namespace=None, local_vars_configuration=None): # noqa: E501 + """V1TypedObjectReference - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_group = None + self._kind = None + self._name = None + self._namespace = None + self.discriminator = None + + if api_group is not None: + self.api_group = api_group + self.kind = kind + self.name = name + if namespace is not None: + self.namespace = namespace + + @property + def api_group(self): + """Gets the api_group of this V1TypedObjectReference. # noqa: E501 + + APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. # noqa: E501 + + :return: The api_group of this V1TypedObjectReference. # noqa: E501 + :rtype: str + """ + return self._api_group + + @api_group.setter + def api_group(self, api_group): + """Sets the api_group of this V1TypedObjectReference. + + APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. # noqa: E501 + + :param api_group: The api_group of this V1TypedObjectReference. # noqa: E501 + :type: str + """ + + self._api_group = api_group + + @property + def kind(self): + """Gets the kind of this V1TypedObjectReference. # noqa: E501 + + Kind is the type of resource being referenced # noqa: E501 + + :return: The kind of this V1TypedObjectReference. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1TypedObjectReference. + + Kind is the type of resource being referenced # noqa: E501 + + :param kind: The kind of this V1TypedObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and kind is None: # noqa: E501 + raise ValueError("Invalid value for `kind`, must not be `None`") # noqa: E501 + + self._kind = kind + + @property + def name(self): + """Gets the name of this V1TypedObjectReference. # noqa: E501 + + Name is the name of resource being referenced # noqa: E501 + + :return: The name of this V1TypedObjectReference. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1TypedObjectReference. + + Name is the name of resource being referenced # noqa: E501 + + :param name: The name of this V1TypedObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def namespace(self): + """Gets the namespace of this V1TypedObjectReference. # noqa: E501 + + Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. # noqa: E501 + + :return: The namespace of this V1TypedObjectReference. # noqa: E501 + :rtype: str + """ + return self._namespace + + @namespace.setter + def namespace(self, namespace): + """Sets the namespace of this V1TypedObjectReference. + + Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. # noqa: E501 + + :param namespace: The namespace of this V1TypedObjectReference. # noqa: E501 + :type: str + """ + + self._namespace = namespace + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1TypedObjectReference): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1TypedObjectReference): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_uncounted_terminated_pods.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_uncounted_terminated_pods.py new file mode 100644 index 0000000000000000000000000000000000000000..b3a5d057af5ac2c82c7b7ea009794c36cc04e531 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_uncounted_terminated_pods.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1UncountedTerminatedPods(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'failed': 'list[str]', + 'succeeded': 'list[str]' + } + + attribute_map = { + 'failed': 'failed', + 'succeeded': 'succeeded' + } + + def __init__(self, failed=None, succeeded=None, local_vars_configuration=None): # noqa: E501 + """V1UncountedTerminatedPods - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._failed = None + self._succeeded = None + self.discriminator = None + + if failed is not None: + self.failed = failed + if succeeded is not None: + self.succeeded = succeeded + + @property + def failed(self): + """Gets the failed of this V1UncountedTerminatedPods. # noqa: E501 + + failed holds UIDs of failed Pods. # noqa: E501 + + :return: The failed of this V1UncountedTerminatedPods. # noqa: E501 + :rtype: list[str] + """ + return self._failed + + @failed.setter + def failed(self, failed): + """Sets the failed of this V1UncountedTerminatedPods. + + failed holds UIDs of failed Pods. # noqa: E501 + + :param failed: The failed of this V1UncountedTerminatedPods. # noqa: E501 + :type: list[str] + """ + + self._failed = failed + + @property + def succeeded(self): + """Gets the succeeded of this V1UncountedTerminatedPods. # noqa: E501 + + succeeded holds UIDs of succeeded Pods. # noqa: E501 + + :return: The succeeded of this V1UncountedTerminatedPods. # noqa: E501 + :rtype: list[str] + """ + return self._succeeded + + @succeeded.setter + def succeeded(self, succeeded): + """Sets the succeeded of this V1UncountedTerminatedPods. + + succeeded holds UIDs of succeeded Pods. # noqa: E501 + + :param succeeded: The succeeded of this V1UncountedTerminatedPods. # noqa: E501 + :type: list[str] + """ + + self._succeeded = succeeded + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1UncountedTerminatedPods): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1UncountedTerminatedPods): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_info.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_info.py new file mode 100644 index 0000000000000000000000000000000000000000..929180d509b683d370e23dcffb039672568bed80 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_info.py @@ -0,0 +1,206 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1UserInfo(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'extra': 'dict(str, list[str])', + 'groups': 'list[str]', + 'uid': 'str', + 'username': 'str' + } + + attribute_map = { + 'extra': 'extra', + 'groups': 'groups', + 'uid': 'uid', + 'username': 'username' + } + + def __init__(self, extra=None, groups=None, uid=None, username=None, local_vars_configuration=None): # noqa: E501 + """V1UserInfo - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._extra = None + self._groups = None + self._uid = None + self._username = None + self.discriminator = None + + if extra is not None: + self.extra = extra + if groups is not None: + self.groups = groups + if uid is not None: + self.uid = uid + if username is not None: + self.username = username + + @property + def extra(self): + """Gets the extra of this V1UserInfo. # noqa: E501 + + Any additional information provided by the authenticator. # noqa: E501 + + :return: The extra of this V1UserInfo. # noqa: E501 + :rtype: dict(str, list[str]) + """ + return self._extra + + @extra.setter + def extra(self, extra): + """Sets the extra of this V1UserInfo. + + Any additional information provided by the authenticator. # noqa: E501 + + :param extra: The extra of this V1UserInfo. # noqa: E501 + :type: dict(str, list[str]) + """ + + self._extra = extra + + @property + def groups(self): + """Gets the groups of this V1UserInfo. # noqa: E501 + + The names of groups this user is a part of. # noqa: E501 + + :return: The groups of this V1UserInfo. # noqa: E501 + :rtype: list[str] + """ + return self._groups + + @groups.setter + def groups(self, groups): + """Sets the groups of this V1UserInfo. + + The names of groups this user is a part of. # noqa: E501 + + :param groups: The groups of this V1UserInfo. # noqa: E501 + :type: list[str] + """ + + self._groups = groups + + @property + def uid(self): + """Gets the uid of this V1UserInfo. # noqa: E501 + + A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. # noqa: E501 + + :return: The uid of this V1UserInfo. # noqa: E501 + :rtype: str + """ + return self._uid + + @uid.setter + def uid(self, uid): + """Sets the uid of this V1UserInfo. + + A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. # noqa: E501 + + :param uid: The uid of this V1UserInfo. # noqa: E501 + :type: str + """ + + self._uid = uid + + @property + def username(self): + """Gets the username of this V1UserInfo. # noqa: E501 + + The name that uniquely identifies this user among all active users. # noqa: E501 + + :return: The username of this V1UserInfo. # noqa: E501 + :rtype: str + """ + return self._username + + @username.setter + def username(self, username): + """Sets the username of this V1UserInfo. + + The name that uniquely identifies this user among all active users. # noqa: E501 + + :param username: The username of this V1UserInfo. # noqa: E501 + :type: str + """ + + self._username = username + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1UserInfo): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1UserInfo): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_subject.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_subject.py new file mode 100644 index 0000000000000000000000000000000000000000..720c9d6f79b18baec2c16e280e452dd82f39991b --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_user_subject.py @@ -0,0 +1,123 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1UserSubject(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'name': 'str' + } + + attribute_map = { + 'name': 'name' + } + + def __init__(self, name=None, local_vars_configuration=None): # noqa: E501 + """V1UserSubject - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._name = None + self.discriminator = None + + self.name = name + + @property + def name(self): + """Gets the name of this V1UserSubject. # noqa: E501 + + `name` is the username that matches, or \"*\" to match all usernames. Required. # noqa: E501 + + :return: The name of this V1UserSubject. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1UserSubject. + + `name` is the username that matches, or \"*\" to match all usernames. Required. # noqa: E501 + + :param name: The name of this V1UserSubject. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1UserSubject): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1UserSubject): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..8c9c4b3ea539206d046cb1eb3e4ed6ec5c1b606b --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy.py @@ -0,0 +1,228 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicy(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'spec': 'V1ValidatingAdmissionPolicySpec', + 'status': 'V1ValidatingAdmissionPolicyStatus' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'spec': 'spec', + 'status': 'status' + } + + def __init__(self, api_version=None, kind=None, metadata=None, spec=None, status=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicy - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._spec = None + self._status = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + if spec is not None: + self.spec = spec + if status is not None: + self.status = status + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingAdmissionPolicy. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingAdmissionPolicy. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingAdmissionPolicy. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingAdmissionPolicy. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V1ValidatingAdmissionPolicy. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingAdmissionPolicy. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingAdmissionPolicy. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingAdmissionPolicy. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingAdmissionPolicy. # noqa: E501 + + + :return: The metadata of this V1ValidatingAdmissionPolicy. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingAdmissionPolicy. + + + :param metadata: The metadata of this V1ValidatingAdmissionPolicy. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def spec(self): + """Gets the spec of this V1ValidatingAdmissionPolicy. # noqa: E501 + + + :return: The spec of this V1ValidatingAdmissionPolicy. # noqa: E501 + :rtype: V1ValidatingAdmissionPolicySpec + """ + return self._spec + + @spec.setter + def spec(self, spec): + """Sets the spec of this V1ValidatingAdmissionPolicy. + + + :param spec: The spec of this V1ValidatingAdmissionPolicy. # noqa: E501 + :type: V1ValidatingAdmissionPolicySpec + """ + + self._spec = spec + + @property + def status(self): + """Gets the status of this V1ValidatingAdmissionPolicy. # noqa: E501 + + + :return: The status of this V1ValidatingAdmissionPolicy. # noqa: E501 + :rtype: V1ValidatingAdmissionPolicyStatus + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this V1ValidatingAdmissionPolicy. + + + :param status: The status of this V1ValidatingAdmissionPolicy. # noqa: E501 + :type: V1ValidatingAdmissionPolicyStatus + """ + + self._status = status + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicy): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicy): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding.py new file mode 100644 index 0000000000000000000000000000000000000000..f8d0599d0b6e81f7325f6aa3c504efcc81ae7a3b --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding.py @@ -0,0 +1,202 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicyBinding(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'spec': 'V1ValidatingAdmissionPolicyBindingSpec' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'spec': 'spec' + } + + def __init__(self, api_version=None, kind=None, metadata=None, spec=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicyBinding - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._spec = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + if spec is not None: + self.spec = spec + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingAdmissionPolicyBinding. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingAdmissionPolicyBinding. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + + + :return: The metadata of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingAdmissionPolicyBinding. + + + :param metadata: The metadata of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def spec(self): + """Gets the spec of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + + + :return: The spec of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :rtype: V1ValidatingAdmissionPolicyBindingSpec + """ + return self._spec + + @spec.setter + def spec(self, spec): + """Sets the spec of this V1ValidatingAdmissionPolicyBinding. + + + :param spec: The spec of this V1ValidatingAdmissionPolicyBinding. # noqa: E501 + :type: V1ValidatingAdmissionPolicyBindingSpec + """ + + self._spec = spec + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBinding): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBinding): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_list.py new file mode 100644 index 0000000000000000000000000000000000000000..f38cafb9baa41ba5ae628007fd92053edd54010c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicyBindingList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V1ValidatingAdmissionPolicyBinding]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicyBindingList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingAdmissionPolicyBindingList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + + List of PolicyBinding. # noqa: E501 + + :return: The items of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :rtype: list[V1ValidatingAdmissionPolicyBinding] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V1ValidatingAdmissionPolicyBindingList. + + List of PolicyBinding. # noqa: E501 + + :param items: The items of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :type: list[V1ValidatingAdmissionPolicyBinding] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingAdmissionPolicyBindingList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + + + :return: The metadata of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingAdmissionPolicyBindingList. + + + :param metadata: The metadata of this V1ValidatingAdmissionPolicyBindingList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBindingList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBindingList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..ad2bd0fb6dde479266561197600b14d8ee3aac2a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_binding_spec.py @@ -0,0 +1,202 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicyBindingSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'match_resources': 'V1MatchResources', + 'param_ref': 'V1ParamRef', + 'policy_name': 'str', + 'validation_actions': 'list[str]' + } + + attribute_map = { + 'match_resources': 'matchResources', + 'param_ref': 'paramRef', + 'policy_name': 'policyName', + 'validation_actions': 'validationActions' + } + + def __init__(self, match_resources=None, param_ref=None, policy_name=None, validation_actions=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicyBindingSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._match_resources = None + self._param_ref = None + self._policy_name = None + self._validation_actions = None + self.discriminator = None + + if match_resources is not None: + self.match_resources = match_resources + if param_ref is not None: + self.param_ref = param_ref + if policy_name is not None: + self.policy_name = policy_name + if validation_actions is not None: + self.validation_actions = validation_actions + + @property + def match_resources(self): + """Gets the match_resources of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + + + :return: The match_resources of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :rtype: V1MatchResources + """ + return self._match_resources + + @match_resources.setter + def match_resources(self, match_resources): + """Sets the match_resources of this V1ValidatingAdmissionPolicyBindingSpec. + + + :param match_resources: The match_resources of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :type: V1MatchResources + """ + + self._match_resources = match_resources + + @property + def param_ref(self): + """Gets the param_ref of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + + + :return: The param_ref of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :rtype: V1ParamRef + """ + return self._param_ref + + @param_ref.setter + def param_ref(self, param_ref): + """Sets the param_ref of this V1ValidatingAdmissionPolicyBindingSpec. + + + :param param_ref: The param_ref of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :type: V1ParamRef + """ + + self._param_ref = param_ref + + @property + def policy_name(self): + """Gets the policy_name of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + + PolicyName references a ValidatingAdmissionPolicy name which the ValidatingAdmissionPolicyBinding binds to. If the referenced resource does not exist, this binding is considered invalid and will be ignored Required. # noqa: E501 + + :return: The policy_name of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :rtype: str + """ + return self._policy_name + + @policy_name.setter + def policy_name(self, policy_name): + """Sets the policy_name of this V1ValidatingAdmissionPolicyBindingSpec. + + PolicyName references a ValidatingAdmissionPolicy name which the ValidatingAdmissionPolicyBinding binds to. If the referenced resource does not exist, this binding is considered invalid and will be ignored Required. # noqa: E501 + + :param policy_name: The policy_name of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :type: str + """ + + self._policy_name = policy_name + + @property + def validation_actions(self): + """Gets the validation_actions of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + + validationActions declares how Validations of the referenced ValidatingAdmissionPolicy are enforced. If a validation evaluates to false it is always enforced according to these actions. Failures defined by the ValidatingAdmissionPolicy's FailurePolicy are enforced according to these actions only if the FailurePolicy is set to Fail, otherwise the failures are ignored. This includes compilation errors, runtime errors and misconfigurations of the policy. validationActions is declared as a set of action values. Order does not matter. validationActions may not contain duplicates of the same action. The supported actions values are: \"Deny\" specifies that a validation failure results in a denied request. \"Warn\" specifies that a validation failure is reported to the request client in HTTP Warning headers, with a warning code of 299. Warnings can be sent both for allowed or denied admission responses. \"Audit\" specifies that a validation failure is included in the published audit event for the request. The audit event will contain a `validation.policy.admission.k8s.io/validation_failure` audit annotation with a value containing the details of the validation failures, formatted as a JSON list of objects, each with the following fields: - message: The validation failure message string - policy: The resource name of the ValidatingAdmissionPolicy - binding: The resource name of the ValidatingAdmissionPolicyBinding - expressionIndex: The index of the failed validations in the ValidatingAdmissionPolicy - validationActions: The enforcement actions enacted for the validation failure Example audit annotation: `\"validation.policy.admission.k8s.io/validation_failure\": \"[{\\\"message\\\": \\\"Invalid value\\\", {\\\"policy\\\": \\\"policy.example.com\\\", {\\\"binding\\\": \\\"policybinding.example.com\\\", {\\\"expressionIndex\\\": \\\"1\\\", {\\\"validationActions\\\": [\\\"Audit\\\"]}]\"` Clients should expect to handle additional values by ignoring any values not recognized. \"Deny\" and \"Warn\" may not be used together since this combination needlessly duplicates the validation failure both in the API response body and the HTTP warning headers. Required. # noqa: E501 + + :return: The validation_actions of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :rtype: list[str] + """ + return self._validation_actions + + @validation_actions.setter + def validation_actions(self, validation_actions): + """Sets the validation_actions of this V1ValidatingAdmissionPolicyBindingSpec. + + validationActions declares how Validations of the referenced ValidatingAdmissionPolicy are enforced. If a validation evaluates to false it is always enforced according to these actions. Failures defined by the ValidatingAdmissionPolicy's FailurePolicy are enforced according to these actions only if the FailurePolicy is set to Fail, otherwise the failures are ignored. This includes compilation errors, runtime errors and misconfigurations of the policy. validationActions is declared as a set of action values. Order does not matter. validationActions may not contain duplicates of the same action. The supported actions values are: \"Deny\" specifies that a validation failure results in a denied request. \"Warn\" specifies that a validation failure is reported to the request client in HTTP Warning headers, with a warning code of 299. Warnings can be sent both for allowed or denied admission responses. \"Audit\" specifies that a validation failure is included in the published audit event for the request. The audit event will contain a `validation.policy.admission.k8s.io/validation_failure` audit annotation with a value containing the details of the validation failures, formatted as a JSON list of objects, each with the following fields: - message: The validation failure message string - policy: The resource name of the ValidatingAdmissionPolicy - binding: The resource name of the ValidatingAdmissionPolicyBinding - expressionIndex: The index of the failed validations in the ValidatingAdmissionPolicy - validationActions: The enforcement actions enacted for the validation failure Example audit annotation: `\"validation.policy.admission.k8s.io/validation_failure\": \"[{\\\"message\\\": \\\"Invalid value\\\", {\\\"policy\\\": \\\"policy.example.com\\\", {\\\"binding\\\": \\\"policybinding.example.com\\\", {\\\"expressionIndex\\\": \\\"1\\\", {\\\"validationActions\\\": [\\\"Audit\\\"]}]\"` Clients should expect to handle additional values by ignoring any values not recognized. \"Deny\" and \"Warn\" may not be used together since this combination needlessly duplicates the validation failure both in the API response body and the HTTP warning headers. Required. # noqa: E501 + + :param validation_actions: The validation_actions of this V1ValidatingAdmissionPolicyBindingSpec. # noqa: E501 + :type: list[str] + """ + + self._validation_actions = validation_actions + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBindingSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyBindingSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_list.py new file mode 100644 index 0000000000000000000000000000000000000000..0ed0091de121d50ee4ed58d816cc39b11b098ccb --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicyList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V1ValidatingAdmissionPolicy]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicyList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingAdmissionPolicyList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingAdmissionPolicyList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V1ValidatingAdmissionPolicyList. # noqa: E501 + + List of ValidatingAdmissionPolicy. # noqa: E501 + + :return: The items of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :rtype: list[V1ValidatingAdmissionPolicy] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V1ValidatingAdmissionPolicyList. + + List of ValidatingAdmissionPolicy. # noqa: E501 + + :param items: The items of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :type: list[V1ValidatingAdmissionPolicy] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V1ValidatingAdmissionPolicyList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingAdmissionPolicyList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingAdmissionPolicyList. # noqa: E501 + + + :return: The metadata of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingAdmissionPolicyList. + + + :param metadata: The metadata of this V1ValidatingAdmissionPolicyList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..df7060d90ded2f2f76822d2da65087da5f499370 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_spec.py @@ -0,0 +1,286 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicySpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'audit_annotations': 'list[V1AuditAnnotation]', + 'failure_policy': 'str', + 'match_conditions': 'list[V1MatchCondition]', + 'match_constraints': 'V1MatchResources', + 'param_kind': 'V1ParamKind', + 'validations': 'list[V1Validation]', + 'variables': 'list[V1Variable]' + } + + attribute_map = { + 'audit_annotations': 'auditAnnotations', + 'failure_policy': 'failurePolicy', + 'match_conditions': 'matchConditions', + 'match_constraints': 'matchConstraints', + 'param_kind': 'paramKind', + 'validations': 'validations', + 'variables': 'variables' + } + + def __init__(self, audit_annotations=None, failure_policy=None, match_conditions=None, match_constraints=None, param_kind=None, validations=None, variables=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicySpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._audit_annotations = None + self._failure_policy = None + self._match_conditions = None + self._match_constraints = None + self._param_kind = None + self._validations = None + self._variables = None + self.discriminator = None + + if audit_annotations is not None: + self.audit_annotations = audit_annotations + if failure_policy is not None: + self.failure_policy = failure_policy + if match_conditions is not None: + self.match_conditions = match_conditions + if match_constraints is not None: + self.match_constraints = match_constraints + if param_kind is not None: + self.param_kind = param_kind + if validations is not None: + self.validations = validations + if variables is not None: + self.variables = variables + + @property + def audit_annotations(self): + """Gets the audit_annotations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. # noqa: E501 + + :return: The audit_annotations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: list[V1AuditAnnotation] + """ + return self._audit_annotations + + @audit_annotations.setter + def audit_annotations(self, audit_annotations): + """Sets the audit_annotations of this V1ValidatingAdmissionPolicySpec. + + auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. # noqa: E501 + + :param audit_annotations: The audit_annotations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: list[V1AuditAnnotation] + """ + + self._audit_annotations = audit_annotations + + @property + def failure_policy(self): + """Gets the failure_policy of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + failurePolicy defines how to handle failures for the admission policy. Failures can occur from CEL expression parse errors, type check errors, runtime errors and invalid or mis-configured policy definitions or bindings. A policy is invalid if spec.paramKind refers to a non-existent Kind. A binding is invalid if spec.paramRef.name refers to a non-existent resource. failurePolicy does not define how validations that evaluate to false are handled. When failurePolicy is set to Fail, ValidatingAdmissionPolicyBinding validationActions define how failures are enforced. Allowed values are Ignore or Fail. Defaults to Fail. # noqa: E501 + + :return: The failure_policy of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: str + """ + return self._failure_policy + + @failure_policy.setter + def failure_policy(self, failure_policy): + """Sets the failure_policy of this V1ValidatingAdmissionPolicySpec. + + failurePolicy defines how to handle failures for the admission policy. Failures can occur from CEL expression parse errors, type check errors, runtime errors and invalid or mis-configured policy definitions or bindings. A policy is invalid if spec.paramKind refers to a non-existent Kind. A binding is invalid if spec.paramRef.name refers to a non-existent resource. failurePolicy does not define how validations that evaluate to false are handled. When failurePolicy is set to Fail, ValidatingAdmissionPolicyBinding validationActions define how failures are enforced. Allowed values are Ignore or Fail. Defaults to Fail. # noqa: E501 + + :param failure_policy: The failure_policy of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: str + """ + + self._failure_policy = failure_policy + + @property + def match_conditions(self): + """Gets the match_conditions of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + MatchConditions is a list of conditions that must be met for a request to be validated. Match conditions filter requests that have already been matched by the rules, namespaceSelector, and objectSelector. An empty list of matchConditions matches all requests. There are a maximum of 64 match conditions allowed. If a parameter object is provided, it can be accessed via the `params` handle in the same manner as validation expressions. The exact matching logic is (in order): 1. If ANY matchCondition evaluates to FALSE, the policy is skipped. 2. If ALL matchConditions evaluate to TRUE, the policy is evaluated. 3. If any matchCondition evaluates to an error (but none are FALSE): - If failurePolicy=Fail, reject the request - If failurePolicy=Ignore, the policy is skipped # noqa: E501 + + :return: The match_conditions of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: list[V1MatchCondition] + """ + return self._match_conditions + + @match_conditions.setter + def match_conditions(self, match_conditions): + """Sets the match_conditions of this V1ValidatingAdmissionPolicySpec. + + MatchConditions is a list of conditions that must be met for a request to be validated. Match conditions filter requests that have already been matched by the rules, namespaceSelector, and objectSelector. An empty list of matchConditions matches all requests. There are a maximum of 64 match conditions allowed. If a parameter object is provided, it can be accessed via the `params` handle in the same manner as validation expressions. The exact matching logic is (in order): 1. If ANY matchCondition evaluates to FALSE, the policy is skipped. 2. If ALL matchConditions evaluate to TRUE, the policy is evaluated. 3. If any matchCondition evaluates to an error (but none are FALSE): - If failurePolicy=Fail, reject the request - If failurePolicy=Ignore, the policy is skipped # noqa: E501 + + :param match_conditions: The match_conditions of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: list[V1MatchCondition] + """ + + self._match_conditions = match_conditions + + @property + def match_constraints(self): + """Gets the match_constraints of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + + :return: The match_constraints of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: V1MatchResources + """ + return self._match_constraints + + @match_constraints.setter + def match_constraints(self, match_constraints): + """Sets the match_constraints of this V1ValidatingAdmissionPolicySpec. + + + :param match_constraints: The match_constraints of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: V1MatchResources + """ + + self._match_constraints = match_constraints + + @property + def param_kind(self): + """Gets the param_kind of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + + :return: The param_kind of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: V1ParamKind + """ + return self._param_kind + + @param_kind.setter + def param_kind(self, param_kind): + """Sets the param_kind of this V1ValidatingAdmissionPolicySpec. + + + :param param_kind: The param_kind of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: V1ParamKind + """ + + self._param_kind = param_kind + + @property + def validations(self): + """Gets the validations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + Validations contain CEL expressions which is used to apply the validation. Validations and AuditAnnotations may not both be empty; a minimum of one Validations or AuditAnnotations is required. # noqa: E501 + + :return: The validations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: list[V1Validation] + """ + return self._validations + + @validations.setter + def validations(self, validations): + """Sets the validations of this V1ValidatingAdmissionPolicySpec. + + Validations contain CEL expressions which is used to apply the validation. Validations and AuditAnnotations may not both be empty; a minimum of one Validations or AuditAnnotations is required. # noqa: E501 + + :param validations: The validations of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: list[V1Validation] + """ + + self._validations = validations + + @property + def variables(self): + """Gets the variables of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + + Variables contain definitions of variables that can be used in composition of other expressions. Each variable is defined as a named CEL expression. The variables defined here will be available under `variables` in other expressions of the policy except MatchConditions because MatchConditions are evaluated before the rest of the policy. The expression of a variable can refer to other variables defined earlier in the list but not those after. Thus, Variables must be sorted by the order of first appearance and acyclic. # noqa: E501 + + :return: The variables of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :rtype: list[V1Variable] + """ + return self._variables + + @variables.setter + def variables(self, variables): + """Sets the variables of this V1ValidatingAdmissionPolicySpec. + + Variables contain definitions of variables that can be used in composition of other expressions. Each variable is defined as a named CEL expression. The variables defined here will be available under `variables` in other expressions of the policy except MatchConditions because MatchConditions are evaluated before the rest of the policy. The expression of a variable can refer to other variables defined earlier in the list but not those after. Thus, Variables must be sorted by the order of first appearance and acyclic. # noqa: E501 + + :param variables: The variables of this V1ValidatingAdmissionPolicySpec. # noqa: E501 + :type: list[V1Variable] + """ + + self._variables = variables + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicySpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicySpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_status.py new file mode 100644 index 0000000000000000000000000000000000000000..29a9f1a01d0e1b5d5f1cb76a0828839f8ed64dc0 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_admission_policy_status.py @@ -0,0 +1,176 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingAdmissionPolicyStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'conditions': 'list[V1Condition]', + 'observed_generation': 'int', + 'type_checking': 'V1TypeChecking' + } + + attribute_map = { + 'conditions': 'conditions', + 'observed_generation': 'observedGeneration', + 'type_checking': 'typeChecking' + } + + def __init__(self, conditions=None, observed_generation=None, type_checking=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingAdmissionPolicyStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._conditions = None + self._observed_generation = None + self._type_checking = None + self.discriminator = None + + if conditions is not None: + self.conditions = conditions + if observed_generation is not None: + self.observed_generation = observed_generation + if type_checking is not None: + self.type_checking = type_checking + + @property + def conditions(self): + """Gets the conditions of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + + The conditions represent the latest available observations of a policy's current state. # noqa: E501 + + :return: The conditions of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :rtype: list[V1Condition] + """ + return self._conditions + + @conditions.setter + def conditions(self, conditions): + """Sets the conditions of this V1ValidatingAdmissionPolicyStatus. + + The conditions represent the latest available observations of a policy's current state. # noqa: E501 + + :param conditions: The conditions of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :type: list[V1Condition] + """ + + self._conditions = conditions + + @property + def observed_generation(self): + """Gets the observed_generation of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + + The generation observed by the controller. # noqa: E501 + + :return: The observed_generation of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :rtype: int + """ + return self._observed_generation + + @observed_generation.setter + def observed_generation(self, observed_generation): + """Sets the observed_generation of this V1ValidatingAdmissionPolicyStatus. + + The generation observed by the controller. # noqa: E501 + + :param observed_generation: The observed_generation of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :type: int + """ + + self._observed_generation = observed_generation + + @property + def type_checking(self): + """Gets the type_checking of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + + + :return: The type_checking of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :rtype: V1TypeChecking + """ + return self._type_checking + + @type_checking.setter + def type_checking(self, type_checking): + """Sets the type_checking of this V1ValidatingAdmissionPolicyStatus. + + + :param type_checking: The type_checking of this V1ValidatingAdmissionPolicyStatus. # noqa: E501 + :type: V1TypeChecking + """ + + self._type_checking = type_checking + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingAdmissionPolicyStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook.py new file mode 100644 index 0000000000000000000000000000000000000000..bc11ece36e611ee3b401d28ec80205bfa07b4d3e --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook.py @@ -0,0 +1,400 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingWebhook(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'admission_review_versions': 'list[str]', + 'client_config': 'AdmissionregistrationV1WebhookClientConfig', + 'failure_policy': 'str', + 'match_conditions': 'list[V1MatchCondition]', + 'match_policy': 'str', + 'name': 'str', + 'namespace_selector': 'V1LabelSelector', + 'object_selector': 'V1LabelSelector', + 'rules': 'list[V1RuleWithOperations]', + 'side_effects': 'str', + 'timeout_seconds': 'int' + } + + attribute_map = { + 'admission_review_versions': 'admissionReviewVersions', + 'client_config': 'clientConfig', + 'failure_policy': 'failurePolicy', + 'match_conditions': 'matchConditions', + 'match_policy': 'matchPolicy', + 'name': 'name', + 'namespace_selector': 'namespaceSelector', + 'object_selector': 'objectSelector', + 'rules': 'rules', + 'side_effects': 'sideEffects', + 'timeout_seconds': 'timeoutSeconds' + } + + def __init__(self, admission_review_versions=None, client_config=None, failure_policy=None, match_conditions=None, match_policy=None, name=None, namespace_selector=None, object_selector=None, rules=None, side_effects=None, timeout_seconds=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingWebhook - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._admission_review_versions = None + self._client_config = None + self._failure_policy = None + self._match_conditions = None + self._match_policy = None + self._name = None + self._namespace_selector = None + self._object_selector = None + self._rules = None + self._side_effects = None + self._timeout_seconds = None + self.discriminator = None + + self.admission_review_versions = admission_review_versions + self.client_config = client_config + if failure_policy is not None: + self.failure_policy = failure_policy + if match_conditions is not None: + self.match_conditions = match_conditions + if match_policy is not None: + self.match_policy = match_policy + self.name = name + if namespace_selector is not None: + self.namespace_selector = namespace_selector + if object_selector is not None: + self.object_selector = object_selector + if rules is not None: + self.rules = rules + self.side_effects = side_effects + if timeout_seconds is not None: + self.timeout_seconds = timeout_seconds + + @property + def admission_review_versions(self): + """Gets the admission_review_versions of this V1ValidatingWebhook. # noqa: E501 + + AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. # noqa: E501 + + :return: The admission_review_versions of this V1ValidatingWebhook. # noqa: E501 + :rtype: list[str] + """ + return self._admission_review_versions + + @admission_review_versions.setter + def admission_review_versions(self, admission_review_versions): + """Sets the admission_review_versions of this V1ValidatingWebhook. + + AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. # noqa: E501 + + :param admission_review_versions: The admission_review_versions of this V1ValidatingWebhook. # noqa: E501 + :type: list[str] + """ + if self.local_vars_configuration.client_side_validation and admission_review_versions is None: # noqa: E501 + raise ValueError("Invalid value for `admission_review_versions`, must not be `None`") # noqa: E501 + + self._admission_review_versions = admission_review_versions + + @property + def client_config(self): + """Gets the client_config of this V1ValidatingWebhook. # noqa: E501 + + + :return: The client_config of this V1ValidatingWebhook. # noqa: E501 + :rtype: AdmissionregistrationV1WebhookClientConfig + """ + return self._client_config + + @client_config.setter + def client_config(self, client_config): + """Sets the client_config of this V1ValidatingWebhook. + + + :param client_config: The client_config of this V1ValidatingWebhook. # noqa: E501 + :type: AdmissionregistrationV1WebhookClientConfig + """ + if self.local_vars_configuration.client_side_validation and client_config is None: # noqa: E501 + raise ValueError("Invalid value for `client_config`, must not be `None`") # noqa: E501 + + self._client_config = client_config + + @property + def failure_policy(self): + """Gets the failure_policy of this V1ValidatingWebhook. # noqa: E501 + + FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. # noqa: E501 + + :return: The failure_policy of this V1ValidatingWebhook. # noqa: E501 + :rtype: str + """ + return self._failure_policy + + @failure_policy.setter + def failure_policy(self, failure_policy): + """Sets the failure_policy of this V1ValidatingWebhook. + + FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. # noqa: E501 + + :param failure_policy: The failure_policy of this V1ValidatingWebhook. # noqa: E501 + :type: str + """ + + self._failure_policy = failure_policy + + @property + def match_conditions(self): + """Gets the match_conditions of this V1ValidatingWebhook. # noqa: E501 + + MatchConditions is a list of conditions that must be met for a request to be sent to this webhook. Match conditions filter requests that have already been matched by the rules, namespaceSelector, and objectSelector. An empty list of matchConditions matches all requests. There are a maximum of 64 match conditions allowed. The exact matching logic is (in order): 1. If ANY matchCondition evaluates to FALSE, the webhook is skipped. 2. If ALL matchConditions evaluate to TRUE, the webhook is called. 3. If any matchCondition evaluates to an error (but none are FALSE): - If failurePolicy=Fail, reject the request - If failurePolicy=Ignore, the error is ignored and the webhook is skipped # noqa: E501 + + :return: The match_conditions of this V1ValidatingWebhook. # noqa: E501 + :rtype: list[V1MatchCondition] + """ + return self._match_conditions + + @match_conditions.setter + def match_conditions(self, match_conditions): + """Sets the match_conditions of this V1ValidatingWebhook. + + MatchConditions is a list of conditions that must be met for a request to be sent to this webhook. Match conditions filter requests that have already been matched by the rules, namespaceSelector, and objectSelector. An empty list of matchConditions matches all requests. There are a maximum of 64 match conditions allowed. The exact matching logic is (in order): 1. If ANY matchCondition evaluates to FALSE, the webhook is skipped. 2. If ALL matchConditions evaluate to TRUE, the webhook is called. 3. If any matchCondition evaluates to an error (but none are FALSE): - If failurePolicy=Fail, reject the request - If failurePolicy=Ignore, the error is ignored and the webhook is skipped # noqa: E501 + + :param match_conditions: The match_conditions of this V1ValidatingWebhook. # noqa: E501 + :type: list[V1MatchCondition] + """ + + self._match_conditions = match_conditions + + @property + def match_policy(self): + """Gets the match_policy of this V1ValidatingWebhook. # noqa: E501 + + matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Equivalent\" # noqa: E501 + + :return: The match_policy of this V1ValidatingWebhook. # noqa: E501 + :rtype: str + """ + return self._match_policy + + @match_policy.setter + def match_policy(self, match_policy): + """Sets the match_policy of this V1ValidatingWebhook. + + matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Equivalent\" # noqa: E501 + + :param match_policy: The match_policy of this V1ValidatingWebhook. # noqa: E501 + :type: str + """ + + self._match_policy = match_policy + + @property + def name(self): + """Gets the name of this V1ValidatingWebhook. # noqa: E501 + + The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. # noqa: E501 + + :return: The name of this V1ValidatingWebhook. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1ValidatingWebhook. + + The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. # noqa: E501 + + :param name: The name of this V1ValidatingWebhook. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def namespace_selector(self): + """Gets the namespace_selector of this V1ValidatingWebhook. # noqa: E501 + + + :return: The namespace_selector of this V1ValidatingWebhook. # noqa: E501 + :rtype: V1LabelSelector + """ + return self._namespace_selector + + @namespace_selector.setter + def namespace_selector(self, namespace_selector): + """Sets the namespace_selector of this V1ValidatingWebhook. + + + :param namespace_selector: The namespace_selector of this V1ValidatingWebhook. # noqa: E501 + :type: V1LabelSelector + """ + + self._namespace_selector = namespace_selector + + @property + def object_selector(self): + """Gets the object_selector of this V1ValidatingWebhook. # noqa: E501 + + + :return: The object_selector of this V1ValidatingWebhook. # noqa: E501 + :rtype: V1LabelSelector + """ + return self._object_selector + + @object_selector.setter + def object_selector(self, object_selector): + """Sets the object_selector of this V1ValidatingWebhook. + + + :param object_selector: The object_selector of this V1ValidatingWebhook. # noqa: E501 + :type: V1LabelSelector + """ + + self._object_selector = object_selector + + @property + def rules(self): + """Gets the rules of this V1ValidatingWebhook. # noqa: E501 + + Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. # noqa: E501 + + :return: The rules of this V1ValidatingWebhook. # noqa: E501 + :rtype: list[V1RuleWithOperations] + """ + return self._rules + + @rules.setter + def rules(self, rules): + """Sets the rules of this V1ValidatingWebhook. + + Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. # noqa: E501 + + :param rules: The rules of this V1ValidatingWebhook. # noqa: E501 + :type: list[V1RuleWithOperations] + """ + + self._rules = rules + + @property + def side_effects(self): + """Gets the side_effects of this V1ValidatingWebhook. # noqa: E501 + + SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission chain and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. # noqa: E501 + + :return: The side_effects of this V1ValidatingWebhook. # noqa: E501 + :rtype: str + """ + return self._side_effects + + @side_effects.setter + def side_effects(self, side_effects): + """Sets the side_effects of this V1ValidatingWebhook. + + SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission chain and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. # noqa: E501 + + :param side_effects: The side_effects of this V1ValidatingWebhook. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and side_effects is None: # noqa: E501 + raise ValueError("Invalid value for `side_effects`, must not be `None`") # noqa: E501 + + self._side_effects = side_effects + + @property + def timeout_seconds(self): + """Gets the timeout_seconds of this V1ValidatingWebhook. # noqa: E501 + + TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. # noqa: E501 + + :return: The timeout_seconds of this V1ValidatingWebhook. # noqa: E501 + :rtype: int + """ + return self._timeout_seconds + + @timeout_seconds.setter + def timeout_seconds(self, timeout_seconds): + """Sets the timeout_seconds of this V1ValidatingWebhook. + + TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. # noqa: E501 + + :param timeout_seconds: The timeout_seconds of this V1ValidatingWebhook. # noqa: E501 + :type: int + """ + + self._timeout_seconds = timeout_seconds + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingWebhook): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingWebhook): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration.py new file mode 100644 index 0000000000000000000000000000000000000000..b037306503cc2df5ae99a9d1a31d5a34ef4f36b1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration.py @@ -0,0 +1,204 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingWebhookConfiguration(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'webhooks': 'list[V1ValidatingWebhook]' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'webhooks': 'webhooks' + } + + def __init__(self, api_version=None, kind=None, metadata=None, webhooks=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingWebhookConfiguration - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._webhooks = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + if webhooks is not None: + self.webhooks = webhooks + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingWebhookConfiguration. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingWebhookConfiguration. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingWebhookConfiguration. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingWebhookConfiguration. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V1ValidatingWebhookConfiguration. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingWebhookConfiguration. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingWebhookConfiguration. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingWebhookConfiguration. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingWebhookConfiguration. # noqa: E501 + + + :return: The metadata of this V1ValidatingWebhookConfiguration. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingWebhookConfiguration. + + + :param metadata: The metadata of this V1ValidatingWebhookConfiguration. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def webhooks(self): + """Gets the webhooks of this V1ValidatingWebhookConfiguration. # noqa: E501 + + Webhooks is a list of webhooks and the affected resources and operations. # noqa: E501 + + :return: The webhooks of this V1ValidatingWebhookConfiguration. # noqa: E501 + :rtype: list[V1ValidatingWebhook] + """ + return self._webhooks + + @webhooks.setter + def webhooks(self, webhooks): + """Sets the webhooks of this V1ValidatingWebhookConfiguration. + + Webhooks is a list of webhooks and the affected resources and operations. # noqa: E501 + + :param webhooks: The webhooks of this V1ValidatingWebhookConfiguration. # noqa: E501 + :type: list[V1ValidatingWebhook] + """ + + self._webhooks = webhooks + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingWebhookConfiguration): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingWebhookConfiguration): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration_list.py new file mode 100644 index 0000000000000000000000000000000000000000..e36bf67d44b787f009dfc1b04fd4f3be79a734ff --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validating_webhook_configuration_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidatingWebhookConfigurationList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V1ValidatingWebhookConfiguration]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V1ValidatingWebhookConfigurationList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V1ValidatingWebhookConfigurationList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1ValidatingWebhookConfigurationList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V1ValidatingWebhookConfigurationList. # noqa: E501 + + List of ValidatingWebhookConfiguration. # noqa: E501 + + :return: The items of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :rtype: list[V1ValidatingWebhookConfiguration] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V1ValidatingWebhookConfigurationList. + + List of ValidatingWebhookConfiguration. # noqa: E501 + + :param items: The items of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :type: list[V1ValidatingWebhookConfiguration] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V1ValidatingWebhookConfigurationList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1ValidatingWebhookConfigurationList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1ValidatingWebhookConfigurationList. # noqa: E501 + + + :return: The metadata of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1ValidatingWebhookConfigurationList. + + + :param metadata: The metadata of this V1ValidatingWebhookConfigurationList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidatingWebhookConfigurationList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidatingWebhookConfigurationList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation.py new file mode 100644 index 0000000000000000000000000000000000000000..48de8eed237f84ddcaf6b474eaac0bf02ab74649 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation.py @@ -0,0 +1,207 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Validation(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'expression': 'str', + 'message': 'str', + 'message_expression': 'str', + 'reason': 'str' + } + + attribute_map = { + 'expression': 'expression', + 'message': 'message', + 'message_expression': 'messageExpression', + 'reason': 'reason' + } + + def __init__(self, expression=None, message=None, message_expression=None, reason=None, local_vars_configuration=None): # noqa: E501 + """V1Validation - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._expression = None + self._message = None + self._message_expression = None + self._reason = None + self.discriminator = None + + self.expression = expression + if message is not None: + self.message = message + if message_expression is not None: + self.message_expression = message_expression + if reason is not None: + self.reason = reason + + @property + def expression(self): + """Gets the expression of this V1Validation. # noqa: E501 + + Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. For example, a variable named 'foo' can be accessed as 'variables.foo'. - 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. See https://pkg.go.dev/k8s.io/apiserver/pkg/cel/library#Authz - 'authorizer.requestResource' - A CEL ResourceCheck constructed from the 'authorizer' and configured with the request resource. The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object. No other metadata properties are accessible. Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\", \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\". Examples: - Expression accessing a property named \"namespace\": {\"Expression\": \"object.__namespace__ > 0\"} - Expression accessing a property named \"x-prop\": {\"Expression\": \"object.x__dash__prop > 0\"} - Expression accessing a property named \"redact__d\": {\"Expression\": \"object.redact__underscores__d > 0\"} Equality on arrays with list type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and non-intersecting elements in `Y` are appended, retaining their partial order. - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with non-intersecting keys are appended, retaining their partial order. Required. # noqa: E501 + + :return: The expression of this V1Validation. # noqa: E501 + :rtype: str + """ + return self._expression + + @expression.setter + def expression(self, expression): + """Sets the expression of this V1Validation. + + Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. For example, a variable named 'foo' can be accessed as 'variables.foo'. - 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. See https://pkg.go.dev/k8s.io/apiserver/pkg/cel/library#Authz - 'authorizer.requestResource' - A CEL ResourceCheck constructed from the 'authorizer' and configured with the request resource. The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object. No other metadata properties are accessible. Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\", \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\". Examples: - Expression accessing a property named \"namespace\": {\"Expression\": \"object.__namespace__ > 0\"} - Expression accessing a property named \"x-prop\": {\"Expression\": \"object.x__dash__prop > 0\"} - Expression accessing a property named \"redact__d\": {\"Expression\": \"object.redact__underscores__d > 0\"} Equality on arrays with list type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and non-intersecting elements in `Y` are appended, retaining their partial order. - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with non-intersecting keys are appended, retaining their partial order. Required. # noqa: E501 + + :param expression: The expression of this V1Validation. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and expression is None: # noqa: E501 + raise ValueError("Invalid value for `expression`, must not be `None`") # noqa: E501 + + self._expression = expression + + @property + def message(self): + """Gets the message of this V1Validation. # noqa: E501 + + Message represents the message displayed when validation fails. The message is required if the Expression contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\" If the Expression contains line breaks. Message is required. The message must not contain line breaks. If unset, the message is \"failed Expression: {Expression}\". # noqa: E501 + + :return: The message of this V1Validation. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this V1Validation. + + Message represents the message displayed when validation fails. The message is required if the Expression contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\" If the Expression contains line breaks. Message is required. The message must not contain line breaks. If unset, the message is \"failed Expression: {Expression}\". # noqa: E501 + + :param message: The message of this V1Validation. # noqa: E501 + :type: str + """ + + self._message = message + + @property + def message_expression(self): + """Gets the message_expression of this V1Validation. # noqa: E501 + + messageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a validation, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the `expression` except for 'authorizer' and 'authorizer.requestResource'. Example: \"object.x must be less than max (\"+string(params.max)+\")\" # noqa: E501 + + :return: The message_expression of this V1Validation. # noqa: E501 + :rtype: str + """ + return self._message_expression + + @message_expression.setter + def message_expression(self, message_expression): + """Sets the message_expression of this V1Validation. + + messageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a validation, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the `expression` except for 'authorizer' and 'authorizer.requestResource'. Example: \"object.x must be less than max (\"+string(params.max)+\")\" # noqa: E501 + + :param message_expression: The message_expression of this V1Validation. # noqa: E501 + :type: str + """ + + self._message_expression = message_expression + + @property + def reason(self): + """Gets the reason of this V1Validation. # noqa: E501 + + Reason represents a machine-readable description of why this validation failed. If this is the first validation in the list to fail, this reason, as well as the corresponding HTTP response code, are used in the HTTP response to the client. The currently supported reasons are: \"Unauthorized\", \"Forbidden\", \"Invalid\", \"RequestEntityTooLarge\". If not set, StatusReasonInvalid is used in the response to the client. # noqa: E501 + + :return: The reason of this V1Validation. # noqa: E501 + :rtype: str + """ + return self._reason + + @reason.setter + def reason(self, reason): + """Sets the reason of this V1Validation. + + Reason represents a machine-readable description of why this validation failed. If this is the first validation in the list to fail, this reason, as well as the corresponding HTTP response code, are used in the HTTP response to the client. The currently supported reasons are: \"Unauthorized\", \"Forbidden\", \"Invalid\", \"RequestEntityTooLarge\". If not set, StatusReasonInvalid is used in the response to the client. # noqa: E501 + + :param reason: The reason of this V1Validation. # noqa: E501 + :type: str + """ + + self._reason = reason + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Validation): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Validation): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation_rule.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation_rule.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4daca4167248e4aac29d25a31774dfbeade1d1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_validation_rule.py @@ -0,0 +1,263 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1ValidationRule(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'field_path': 'str', + 'message': 'str', + 'message_expression': 'str', + 'optional_old_self': 'bool', + 'reason': 'str', + 'rule': 'str' + } + + attribute_map = { + 'field_path': 'fieldPath', + 'message': 'message', + 'message_expression': 'messageExpression', + 'optional_old_self': 'optionalOldSelf', + 'reason': 'reason', + 'rule': 'rule' + } + + def __init__(self, field_path=None, message=None, message_expression=None, optional_old_self=None, reason=None, rule=None, local_vars_configuration=None): # noqa: E501 + """V1ValidationRule - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._field_path = None + self._message = None + self._message_expression = None + self._optional_old_self = None + self._reason = None + self._rule = None + self.discriminator = None + + if field_path is not None: + self.field_path = field_path + if message is not None: + self.message = message + if message_expression is not None: + self.message_expression = message_expression + if optional_old_self is not None: + self.optional_old_self = optional_old_self + if reason is not None: + self.reason = reason + self.rule = rule + + @property + def field_path(self): + """Gets the field_path of this V1ValidationRule. # noqa: E501 + + fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']` # noqa: E501 + + :return: The field_path of this V1ValidationRule. # noqa: E501 + :rtype: str + """ + return self._field_path + + @field_path.setter + def field_path(self, field_path): + """Sets the field_path of this V1ValidationRule. + + fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']` # noqa: E501 + + :param field_path: The field_path of this V1ValidationRule. # noqa: E501 + :type: str + """ + + self._field_path = field_path + + @property + def message(self): + """Gets the message of this V1ValidationRule. # noqa: E501 + + Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\" # noqa: E501 + + :return: The message of this V1ValidationRule. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this V1ValidationRule. + + Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\" # noqa: E501 + + :param message: The message of this V1ValidationRule. # noqa: E501 + :type: str + """ + + self._message = message + + @property + def message_expression(self): + """Gets the message_expression of this V1ValidationRule. # noqa: E501 + + MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a rule, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the rule; the only difference is the return type. Example: \"x must be less than max (\"+string(self.max)+\")\" # noqa: E501 + + :return: The message_expression of this V1ValidationRule. # noqa: E501 + :rtype: str + """ + return self._message_expression + + @message_expression.setter + def message_expression(self, message_expression): + """Sets the message_expression of this V1ValidationRule. + + MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a rule, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the rule; the only difference is the return type. Example: \"x must be less than max (\"+string(self.max)+\")\" # noqa: E501 + + :param message_expression: The message_expression of this V1ValidationRule. # noqa: E501 + :type: str + """ + + self._message_expression = message_expression + + @property + def optional_old_self(self): + """Gets the optional_old_self of this V1ValidationRule. # noqa: E501 + + optionalOldSelf is used to opt a transition rule into evaluation even when the object is first created, or if the old object is missing the value. When enabled `oldSelf` will be a CEL optional whose value will be `None` if there is no old value, or when the object is initially created. You may check for presence of oldSelf using `oldSelf.hasValue()` and unwrap it after checking using `oldSelf.value()`. Check the CEL documentation for Optional types for more information: https://pkg.go.dev/github.com/google/cel-go/cel#OptionalTypes May not be set unless `oldSelf` is used in `rule`. # noqa: E501 + + :return: The optional_old_self of this V1ValidationRule. # noqa: E501 + :rtype: bool + """ + return self._optional_old_self + + @optional_old_self.setter + def optional_old_self(self, optional_old_self): + """Sets the optional_old_self of this V1ValidationRule. + + optionalOldSelf is used to opt a transition rule into evaluation even when the object is first created, or if the old object is missing the value. When enabled `oldSelf` will be a CEL optional whose value will be `None` if there is no old value, or when the object is initially created. You may check for presence of oldSelf using `oldSelf.hasValue()` and unwrap it after checking using `oldSelf.value()`. Check the CEL documentation for Optional types for more information: https://pkg.go.dev/github.com/google/cel-go/cel#OptionalTypes May not be set unless `oldSelf` is used in `rule`. # noqa: E501 + + :param optional_old_self: The optional_old_self of this V1ValidationRule. # noqa: E501 + :type: bool + """ + + self._optional_old_self = optional_old_self + + @property + def reason(self): + """Gets the reason of this V1ValidationRule. # noqa: E501 + + reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule. The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule. The currently supported reasons are: \"FieldValueInvalid\", \"FieldValueForbidden\", \"FieldValueRequired\", \"FieldValueDuplicate\". If not set, default to use \"FieldValueInvalid\". All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid. # noqa: E501 + + :return: The reason of this V1ValidationRule. # noqa: E501 + :rtype: str + """ + return self._reason + + @reason.setter + def reason(self, reason): + """Sets the reason of this V1ValidationRule. + + reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule. The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule. The currently supported reasons are: \"FieldValueInvalid\", \"FieldValueForbidden\", \"FieldValueRequired\", \"FieldValueDuplicate\". If not set, default to use \"FieldValueInvalid\". All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid. # noqa: E501 + + :param reason: The reason of this V1ValidationRule. # noqa: E501 + :type: str + """ + + self._reason = reason + + @property + def rule(self): + """Gets the rule of this V1ValidationRule. # noqa: E501 + + Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {\"rule\": \"self.status.actual <= self.spec.maxDesired\"} If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {\"rule\": \"self.components['Widget'].priority < 10\"} - Rule scoped to a list of integers: {\"rule\": \"self.values.all(value, value >= 0 && value < 100)\"} - Rule scoped to a string value: {\"rule\": \"self.startsWith('kube')\"} The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an \"unknown type\". An \"unknown type\" is recursively defined as: - A schema with no type and x-kubernetes-preserve-unknown-fields set to true - An array where the items schema is of an \"unknown type\" - An object where the additionalProperties schema is of an \"unknown type\" Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\", \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\". Examples: - Rule accessing a property named \"namespace\": {\"rule\": \"self.__namespace__ > 0\"} - Rule accessing a property named \"x-prop\": {\"rule\": \"self.x__dash__prop > 0\"} - Rule accessing a property named \"redact__d\": {\"rule\": \"self.redact__underscores__d > 0\"} Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and non-intersecting elements in `Y` are appended, retaining their partial order. - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with non-intersecting keys are appended, retaining their partial order. If `rule` makes use of the `oldSelf` variable it is implicitly a `transition rule`. By default, the `oldSelf` variable is the same type as `self`. When `optionalOldSelf` is true, the `oldSelf` variable is a CEL optional variable whose value() is the same type as `self`. See the documentation for the `optionalOldSelf` field for details. Transition rules by default are applied only on UPDATE requests and are skipped if an old value could not be found. You can opt a transition rule into unconditional evaluation by setting `optionalOldSelf` to true. # noqa: E501 + + :return: The rule of this V1ValidationRule. # noqa: E501 + :rtype: str + """ + return self._rule + + @rule.setter + def rule(self, rule): + """Sets the rule of this V1ValidationRule. + + Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {\"rule\": \"self.status.actual <= self.spec.maxDesired\"} If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {\"rule\": \"self.components['Widget'].priority < 10\"} - Rule scoped to a list of integers: {\"rule\": \"self.values.all(value, value >= 0 && value < 100)\"} - Rule scoped to a string value: {\"rule\": \"self.startsWith('kube')\"} The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an \"unknown type\". An \"unknown type\" is recursively defined as: - A schema with no type and x-kubernetes-preserve-unknown-fields set to true - An array where the items schema is of an \"unknown type\" - An object where the additionalProperties schema is of an \"unknown type\" Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\", \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\". Examples: - Rule accessing a property named \"namespace\": {\"rule\": \"self.__namespace__ > 0\"} - Rule accessing a property named \"x-prop\": {\"rule\": \"self.x__dash__prop > 0\"} - Rule accessing a property named \"redact__d\": {\"rule\": \"self.redact__underscores__d > 0\"} Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and non-intersecting elements in `Y` are appended, retaining their partial order. - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with non-intersecting keys are appended, retaining their partial order. If `rule` makes use of the `oldSelf` variable it is implicitly a `transition rule`. By default, the `oldSelf` variable is the same type as `self`. When `optionalOldSelf` is true, the `oldSelf` variable is a CEL optional variable whose value() is the same type as `self`. See the documentation for the `optionalOldSelf` field for details. Transition rules by default are applied only on UPDATE requests and are skipped if an old value could not be found. You can opt a transition rule into unconditional evaluation by setting `optionalOldSelf` to true. # noqa: E501 + + :param rule: The rule of this V1ValidationRule. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and rule is None: # noqa: E501 + raise ValueError("Invalid value for `rule`, must not be `None`") # noqa: E501 + + self._rule = rule + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1ValidationRule): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1ValidationRule): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_variable.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_variable.py new file mode 100644 index 0000000000000000000000000000000000000000..6ddfb4a00d45945b9530f5cf36681a7006581683 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_variable.py @@ -0,0 +1,152 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Variable(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'expression': 'str', + 'name': 'str' + } + + attribute_map = { + 'expression': 'expression', + 'name': 'name' + } + + def __init__(self, expression=None, name=None, local_vars_configuration=None): # noqa: E501 + """V1Variable - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._expression = None + self._name = None + self.discriminator = None + + self.expression = expression + self.name = name + + @property + def expression(self): + """Gets the expression of this V1Variable. # noqa: E501 + + Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. # noqa: E501 + + :return: The expression of this V1Variable. # noqa: E501 + :rtype: str + """ + return self._expression + + @expression.setter + def expression(self, expression): + """Sets the expression of this V1Variable. + + Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. # noqa: E501 + + :param expression: The expression of this V1Variable. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and expression is None: # noqa: E501 + raise ValueError("Invalid value for `expression`, must not be `None`") # noqa: E501 + + self._expression = expression + + @property + def name(self): + """Gets the name of this V1Variable. # noqa: E501 + + Name is the name of the variable. The name must be a valid CEL identifier and unique among all variables. The variable can be accessed in other expressions through `variables` For example, if name is \"foo\", the variable will be available as `variables.foo` # noqa: E501 + + :return: The name of this V1Variable. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1Variable. + + Name is the name of the variable. The name must be a valid CEL identifier and unique among all variables. The variable can be accessed in other expressions through `variables` For example, if name is \"foo\", the variable will be available as `variables.foo` # noqa: E501 + + :param name: The name of this V1Variable. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Variable): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Variable): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume.py new file mode 100644 index 0000000000000000000000000000000000000000..8af48f23cfedbc5b29dfa37a94490b545ddc05b5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume.py @@ -0,0 +1,903 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1Volume(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'aws_elastic_block_store': 'V1AWSElasticBlockStoreVolumeSource', + 'azure_disk': 'V1AzureDiskVolumeSource', + 'azure_file': 'V1AzureFileVolumeSource', + 'cephfs': 'V1CephFSVolumeSource', + 'cinder': 'V1CinderVolumeSource', + 'config_map': 'V1ConfigMapVolumeSource', + 'csi': 'V1CSIVolumeSource', + 'downward_api': 'V1DownwardAPIVolumeSource', + 'empty_dir': 'V1EmptyDirVolumeSource', + 'ephemeral': 'V1EphemeralVolumeSource', + 'fc': 'V1FCVolumeSource', + 'flex_volume': 'V1FlexVolumeSource', + 'flocker': 'V1FlockerVolumeSource', + 'gce_persistent_disk': 'V1GCEPersistentDiskVolumeSource', + 'git_repo': 'V1GitRepoVolumeSource', + 'glusterfs': 'V1GlusterfsVolumeSource', + 'host_path': 'V1HostPathVolumeSource', + 'image': 'V1ImageVolumeSource', + 'iscsi': 'V1ISCSIVolumeSource', + 'name': 'str', + 'nfs': 'V1NFSVolumeSource', + 'persistent_volume_claim': 'V1PersistentVolumeClaimVolumeSource', + 'photon_persistent_disk': 'V1PhotonPersistentDiskVolumeSource', + 'portworx_volume': 'V1PortworxVolumeSource', + 'projected': 'V1ProjectedVolumeSource', + 'quobyte': 'V1QuobyteVolumeSource', + 'rbd': 'V1RBDVolumeSource', + 'scale_io': 'V1ScaleIOVolumeSource', + 'secret': 'V1SecretVolumeSource', + 'storageos': 'V1StorageOSVolumeSource', + 'vsphere_volume': 'V1VsphereVirtualDiskVolumeSource' + } + + attribute_map = { + 'aws_elastic_block_store': 'awsElasticBlockStore', + 'azure_disk': 'azureDisk', + 'azure_file': 'azureFile', + 'cephfs': 'cephfs', + 'cinder': 'cinder', + 'config_map': 'configMap', + 'csi': 'csi', + 'downward_api': 'downwardAPI', + 'empty_dir': 'emptyDir', + 'ephemeral': 'ephemeral', + 'fc': 'fc', + 'flex_volume': 'flexVolume', + 'flocker': 'flocker', + 'gce_persistent_disk': 'gcePersistentDisk', + 'git_repo': 'gitRepo', + 'glusterfs': 'glusterfs', + 'host_path': 'hostPath', + 'image': 'image', + 'iscsi': 'iscsi', + 'name': 'name', + 'nfs': 'nfs', + 'persistent_volume_claim': 'persistentVolumeClaim', + 'photon_persistent_disk': 'photonPersistentDisk', + 'portworx_volume': 'portworxVolume', + 'projected': 'projected', + 'quobyte': 'quobyte', + 'rbd': 'rbd', + 'scale_io': 'scaleIO', + 'secret': 'secret', + 'storageos': 'storageos', + 'vsphere_volume': 'vsphereVolume' + } + + def __init__(self, aws_elastic_block_store=None, azure_disk=None, azure_file=None, cephfs=None, cinder=None, config_map=None, csi=None, downward_api=None, empty_dir=None, ephemeral=None, fc=None, flex_volume=None, flocker=None, gce_persistent_disk=None, git_repo=None, glusterfs=None, host_path=None, image=None, iscsi=None, name=None, nfs=None, persistent_volume_claim=None, photon_persistent_disk=None, portworx_volume=None, projected=None, quobyte=None, rbd=None, scale_io=None, secret=None, storageos=None, vsphere_volume=None, local_vars_configuration=None): # noqa: E501 + """V1Volume - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._aws_elastic_block_store = None + self._azure_disk = None + self._azure_file = None + self._cephfs = None + self._cinder = None + self._config_map = None + self._csi = None + self._downward_api = None + self._empty_dir = None + self._ephemeral = None + self._fc = None + self._flex_volume = None + self._flocker = None + self._gce_persistent_disk = None + self._git_repo = None + self._glusterfs = None + self._host_path = None + self._image = None + self._iscsi = None + self._name = None + self._nfs = None + self._persistent_volume_claim = None + self._photon_persistent_disk = None + self._portworx_volume = None + self._projected = None + self._quobyte = None + self._rbd = None + self._scale_io = None + self._secret = None + self._storageos = None + self._vsphere_volume = None + self.discriminator = None + + if aws_elastic_block_store is not None: + self.aws_elastic_block_store = aws_elastic_block_store + if azure_disk is not None: + self.azure_disk = azure_disk + if azure_file is not None: + self.azure_file = azure_file + if cephfs is not None: + self.cephfs = cephfs + if cinder is not None: + self.cinder = cinder + if config_map is not None: + self.config_map = config_map + if csi is not None: + self.csi = csi + if downward_api is not None: + self.downward_api = downward_api + if empty_dir is not None: + self.empty_dir = empty_dir + if ephemeral is not None: + self.ephemeral = ephemeral + if fc is not None: + self.fc = fc + if flex_volume is not None: + self.flex_volume = flex_volume + if flocker is not None: + self.flocker = flocker + if gce_persistent_disk is not None: + self.gce_persistent_disk = gce_persistent_disk + if git_repo is not None: + self.git_repo = git_repo + if glusterfs is not None: + self.glusterfs = glusterfs + if host_path is not None: + self.host_path = host_path + if image is not None: + self.image = image + if iscsi is not None: + self.iscsi = iscsi + self.name = name + if nfs is not None: + self.nfs = nfs + if persistent_volume_claim is not None: + self.persistent_volume_claim = persistent_volume_claim + if photon_persistent_disk is not None: + self.photon_persistent_disk = photon_persistent_disk + if portworx_volume is not None: + self.portworx_volume = portworx_volume + if projected is not None: + self.projected = projected + if quobyte is not None: + self.quobyte = quobyte + if rbd is not None: + self.rbd = rbd + if scale_io is not None: + self.scale_io = scale_io + if secret is not None: + self.secret = secret + if storageos is not None: + self.storageos = storageos + if vsphere_volume is not None: + self.vsphere_volume = vsphere_volume + + @property + def aws_elastic_block_store(self): + """Gets the aws_elastic_block_store of this V1Volume. # noqa: E501 + + + :return: The aws_elastic_block_store of this V1Volume. # noqa: E501 + :rtype: V1AWSElasticBlockStoreVolumeSource + """ + return self._aws_elastic_block_store + + @aws_elastic_block_store.setter + def aws_elastic_block_store(self, aws_elastic_block_store): + """Sets the aws_elastic_block_store of this V1Volume. + + + :param aws_elastic_block_store: The aws_elastic_block_store of this V1Volume. # noqa: E501 + :type: V1AWSElasticBlockStoreVolumeSource + """ + + self._aws_elastic_block_store = aws_elastic_block_store + + @property + def azure_disk(self): + """Gets the azure_disk of this V1Volume. # noqa: E501 + + + :return: The azure_disk of this V1Volume. # noqa: E501 + :rtype: V1AzureDiskVolumeSource + """ + return self._azure_disk + + @azure_disk.setter + def azure_disk(self, azure_disk): + """Sets the azure_disk of this V1Volume. + + + :param azure_disk: The azure_disk of this V1Volume. # noqa: E501 + :type: V1AzureDiskVolumeSource + """ + + self._azure_disk = azure_disk + + @property + def azure_file(self): + """Gets the azure_file of this V1Volume. # noqa: E501 + + + :return: The azure_file of this V1Volume. # noqa: E501 + :rtype: V1AzureFileVolumeSource + """ + return self._azure_file + + @azure_file.setter + def azure_file(self, azure_file): + """Sets the azure_file of this V1Volume. + + + :param azure_file: The azure_file of this V1Volume. # noqa: E501 + :type: V1AzureFileVolumeSource + """ + + self._azure_file = azure_file + + @property + def cephfs(self): + """Gets the cephfs of this V1Volume. # noqa: E501 + + + :return: The cephfs of this V1Volume. # noqa: E501 + :rtype: V1CephFSVolumeSource + """ + return self._cephfs + + @cephfs.setter + def cephfs(self, cephfs): + """Sets the cephfs of this V1Volume. + + + :param cephfs: The cephfs of this V1Volume. # noqa: E501 + :type: V1CephFSVolumeSource + """ + + self._cephfs = cephfs + + @property + def cinder(self): + """Gets the cinder of this V1Volume. # noqa: E501 + + + :return: The cinder of this V1Volume. # noqa: E501 + :rtype: V1CinderVolumeSource + """ + return self._cinder + + @cinder.setter + def cinder(self, cinder): + """Sets the cinder of this V1Volume. + + + :param cinder: The cinder of this V1Volume. # noqa: E501 + :type: V1CinderVolumeSource + """ + + self._cinder = cinder + + @property + def config_map(self): + """Gets the config_map of this V1Volume. # noqa: E501 + + + :return: The config_map of this V1Volume. # noqa: E501 + :rtype: V1ConfigMapVolumeSource + """ + return self._config_map + + @config_map.setter + def config_map(self, config_map): + """Sets the config_map of this V1Volume. + + + :param config_map: The config_map of this V1Volume. # noqa: E501 + :type: V1ConfigMapVolumeSource + """ + + self._config_map = config_map + + @property + def csi(self): + """Gets the csi of this V1Volume. # noqa: E501 + + + :return: The csi of this V1Volume. # noqa: E501 + :rtype: V1CSIVolumeSource + """ + return self._csi + + @csi.setter + def csi(self, csi): + """Sets the csi of this V1Volume. + + + :param csi: The csi of this V1Volume. # noqa: E501 + :type: V1CSIVolumeSource + """ + + self._csi = csi + + @property + def downward_api(self): + """Gets the downward_api of this V1Volume. # noqa: E501 + + + :return: The downward_api of this V1Volume. # noqa: E501 + :rtype: V1DownwardAPIVolumeSource + """ + return self._downward_api + + @downward_api.setter + def downward_api(self, downward_api): + """Sets the downward_api of this V1Volume. + + + :param downward_api: The downward_api of this V1Volume. # noqa: E501 + :type: V1DownwardAPIVolumeSource + """ + + self._downward_api = downward_api + + @property + def empty_dir(self): + """Gets the empty_dir of this V1Volume. # noqa: E501 + + + :return: The empty_dir of this V1Volume. # noqa: E501 + :rtype: V1EmptyDirVolumeSource + """ + return self._empty_dir + + @empty_dir.setter + def empty_dir(self, empty_dir): + """Sets the empty_dir of this V1Volume. + + + :param empty_dir: The empty_dir of this V1Volume. # noqa: E501 + :type: V1EmptyDirVolumeSource + """ + + self._empty_dir = empty_dir + + @property + def ephemeral(self): + """Gets the ephemeral of this V1Volume. # noqa: E501 + + + :return: The ephemeral of this V1Volume. # noqa: E501 + :rtype: V1EphemeralVolumeSource + """ + return self._ephemeral + + @ephemeral.setter + def ephemeral(self, ephemeral): + """Sets the ephemeral of this V1Volume. + + + :param ephemeral: The ephemeral of this V1Volume. # noqa: E501 + :type: V1EphemeralVolumeSource + """ + + self._ephemeral = ephemeral + + @property + def fc(self): + """Gets the fc of this V1Volume. # noqa: E501 + + + :return: The fc of this V1Volume. # noqa: E501 + :rtype: V1FCVolumeSource + """ + return self._fc + + @fc.setter + def fc(self, fc): + """Sets the fc of this V1Volume. + + + :param fc: The fc of this V1Volume. # noqa: E501 + :type: V1FCVolumeSource + """ + + self._fc = fc + + @property + def flex_volume(self): + """Gets the flex_volume of this V1Volume. # noqa: E501 + + + :return: The flex_volume of this V1Volume. # noqa: E501 + :rtype: V1FlexVolumeSource + """ + return self._flex_volume + + @flex_volume.setter + def flex_volume(self, flex_volume): + """Sets the flex_volume of this V1Volume. + + + :param flex_volume: The flex_volume of this V1Volume. # noqa: E501 + :type: V1FlexVolumeSource + """ + + self._flex_volume = flex_volume + + @property + def flocker(self): + """Gets the flocker of this V1Volume. # noqa: E501 + + + :return: The flocker of this V1Volume. # noqa: E501 + :rtype: V1FlockerVolumeSource + """ + return self._flocker + + @flocker.setter + def flocker(self, flocker): + """Sets the flocker of this V1Volume. + + + :param flocker: The flocker of this V1Volume. # noqa: E501 + :type: V1FlockerVolumeSource + """ + + self._flocker = flocker + + @property + def gce_persistent_disk(self): + """Gets the gce_persistent_disk of this V1Volume. # noqa: E501 + + + :return: The gce_persistent_disk of this V1Volume. # noqa: E501 + :rtype: V1GCEPersistentDiskVolumeSource + """ + return self._gce_persistent_disk + + @gce_persistent_disk.setter + def gce_persistent_disk(self, gce_persistent_disk): + """Sets the gce_persistent_disk of this V1Volume. + + + :param gce_persistent_disk: The gce_persistent_disk of this V1Volume. # noqa: E501 + :type: V1GCEPersistentDiskVolumeSource + """ + + self._gce_persistent_disk = gce_persistent_disk + + @property + def git_repo(self): + """Gets the git_repo of this V1Volume. # noqa: E501 + + + :return: The git_repo of this V1Volume. # noqa: E501 + :rtype: V1GitRepoVolumeSource + """ + return self._git_repo + + @git_repo.setter + def git_repo(self, git_repo): + """Sets the git_repo of this V1Volume. + + + :param git_repo: The git_repo of this V1Volume. # noqa: E501 + :type: V1GitRepoVolumeSource + """ + + self._git_repo = git_repo + + @property + def glusterfs(self): + """Gets the glusterfs of this V1Volume. # noqa: E501 + + + :return: The glusterfs of this V1Volume. # noqa: E501 + :rtype: V1GlusterfsVolumeSource + """ + return self._glusterfs + + @glusterfs.setter + def glusterfs(self, glusterfs): + """Sets the glusterfs of this V1Volume. + + + :param glusterfs: The glusterfs of this V1Volume. # noqa: E501 + :type: V1GlusterfsVolumeSource + """ + + self._glusterfs = glusterfs + + @property + def host_path(self): + """Gets the host_path of this V1Volume. # noqa: E501 + + + :return: The host_path of this V1Volume. # noqa: E501 + :rtype: V1HostPathVolumeSource + """ + return self._host_path + + @host_path.setter + def host_path(self, host_path): + """Sets the host_path of this V1Volume. + + + :param host_path: The host_path of this V1Volume. # noqa: E501 + :type: V1HostPathVolumeSource + """ + + self._host_path = host_path + + @property + def image(self): + """Gets the image of this V1Volume. # noqa: E501 + + + :return: The image of this V1Volume. # noqa: E501 + :rtype: V1ImageVolumeSource + """ + return self._image + + @image.setter + def image(self, image): + """Sets the image of this V1Volume. + + + :param image: The image of this V1Volume. # noqa: E501 + :type: V1ImageVolumeSource + """ + + self._image = image + + @property + def iscsi(self): + """Gets the iscsi of this V1Volume. # noqa: E501 + + + :return: The iscsi of this V1Volume. # noqa: E501 + :rtype: V1ISCSIVolumeSource + """ + return self._iscsi + + @iscsi.setter + def iscsi(self, iscsi): + """Sets the iscsi of this V1Volume. + + + :param iscsi: The iscsi of this V1Volume. # noqa: E501 + :type: V1ISCSIVolumeSource + """ + + self._iscsi = iscsi + + @property + def name(self): + """Gets the name of this V1Volume. # noqa: E501 + + name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names # noqa: E501 + + :return: The name of this V1Volume. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1Volume. + + name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names # noqa: E501 + + :param name: The name of this V1Volume. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def nfs(self): + """Gets the nfs of this V1Volume. # noqa: E501 + + + :return: The nfs of this V1Volume. # noqa: E501 + :rtype: V1NFSVolumeSource + """ + return self._nfs + + @nfs.setter + def nfs(self, nfs): + """Sets the nfs of this V1Volume. + + + :param nfs: The nfs of this V1Volume. # noqa: E501 + :type: V1NFSVolumeSource + """ + + self._nfs = nfs + + @property + def persistent_volume_claim(self): + """Gets the persistent_volume_claim of this V1Volume. # noqa: E501 + + + :return: The persistent_volume_claim of this V1Volume. # noqa: E501 + :rtype: V1PersistentVolumeClaimVolumeSource + """ + return self._persistent_volume_claim + + @persistent_volume_claim.setter + def persistent_volume_claim(self, persistent_volume_claim): + """Sets the persistent_volume_claim of this V1Volume. + + + :param persistent_volume_claim: The persistent_volume_claim of this V1Volume. # noqa: E501 + :type: V1PersistentVolumeClaimVolumeSource + """ + + self._persistent_volume_claim = persistent_volume_claim + + @property + def photon_persistent_disk(self): + """Gets the photon_persistent_disk of this V1Volume. # noqa: E501 + + + :return: The photon_persistent_disk of this V1Volume. # noqa: E501 + :rtype: V1PhotonPersistentDiskVolumeSource + """ + return self._photon_persistent_disk + + @photon_persistent_disk.setter + def photon_persistent_disk(self, photon_persistent_disk): + """Sets the photon_persistent_disk of this V1Volume. + + + :param photon_persistent_disk: The photon_persistent_disk of this V1Volume. # noqa: E501 + :type: V1PhotonPersistentDiskVolumeSource + """ + + self._photon_persistent_disk = photon_persistent_disk + + @property + def portworx_volume(self): + """Gets the portworx_volume of this V1Volume. # noqa: E501 + + + :return: The portworx_volume of this V1Volume. # noqa: E501 + :rtype: V1PortworxVolumeSource + """ + return self._portworx_volume + + @portworx_volume.setter + def portworx_volume(self, portworx_volume): + """Sets the portworx_volume of this V1Volume. + + + :param portworx_volume: The portworx_volume of this V1Volume. # noqa: E501 + :type: V1PortworxVolumeSource + """ + + self._portworx_volume = portworx_volume + + @property + def projected(self): + """Gets the projected of this V1Volume. # noqa: E501 + + + :return: The projected of this V1Volume. # noqa: E501 + :rtype: V1ProjectedVolumeSource + """ + return self._projected + + @projected.setter + def projected(self, projected): + """Sets the projected of this V1Volume. + + + :param projected: The projected of this V1Volume. # noqa: E501 + :type: V1ProjectedVolumeSource + """ + + self._projected = projected + + @property + def quobyte(self): + """Gets the quobyte of this V1Volume. # noqa: E501 + + + :return: The quobyte of this V1Volume. # noqa: E501 + :rtype: V1QuobyteVolumeSource + """ + return self._quobyte + + @quobyte.setter + def quobyte(self, quobyte): + """Sets the quobyte of this V1Volume. + + + :param quobyte: The quobyte of this V1Volume. # noqa: E501 + :type: V1QuobyteVolumeSource + """ + + self._quobyte = quobyte + + @property + def rbd(self): + """Gets the rbd of this V1Volume. # noqa: E501 + + + :return: The rbd of this V1Volume. # noqa: E501 + :rtype: V1RBDVolumeSource + """ + return self._rbd + + @rbd.setter + def rbd(self, rbd): + """Sets the rbd of this V1Volume. + + + :param rbd: The rbd of this V1Volume. # noqa: E501 + :type: V1RBDVolumeSource + """ + + self._rbd = rbd + + @property + def scale_io(self): + """Gets the scale_io of this V1Volume. # noqa: E501 + + + :return: The scale_io of this V1Volume. # noqa: E501 + :rtype: V1ScaleIOVolumeSource + """ + return self._scale_io + + @scale_io.setter + def scale_io(self, scale_io): + """Sets the scale_io of this V1Volume. + + + :param scale_io: The scale_io of this V1Volume. # noqa: E501 + :type: V1ScaleIOVolumeSource + """ + + self._scale_io = scale_io + + @property + def secret(self): + """Gets the secret of this V1Volume. # noqa: E501 + + + :return: The secret of this V1Volume. # noqa: E501 + :rtype: V1SecretVolumeSource + """ + return self._secret + + @secret.setter + def secret(self, secret): + """Sets the secret of this V1Volume. + + + :param secret: The secret of this V1Volume. # noqa: E501 + :type: V1SecretVolumeSource + """ + + self._secret = secret + + @property + def storageos(self): + """Gets the storageos of this V1Volume. # noqa: E501 + + + :return: The storageos of this V1Volume. # noqa: E501 + :rtype: V1StorageOSVolumeSource + """ + return self._storageos + + @storageos.setter + def storageos(self, storageos): + """Sets the storageos of this V1Volume. + + + :param storageos: The storageos of this V1Volume. # noqa: E501 + :type: V1StorageOSVolumeSource + """ + + self._storageos = storageos + + @property + def vsphere_volume(self): + """Gets the vsphere_volume of this V1Volume. # noqa: E501 + + + :return: The vsphere_volume of this V1Volume. # noqa: E501 + :rtype: V1VsphereVirtualDiskVolumeSource + """ + return self._vsphere_volume + + @vsphere_volume.setter + def vsphere_volume(self, vsphere_volume): + """Sets the vsphere_volume of this V1Volume. + + + :param vsphere_volume: The vsphere_volume of this V1Volume. # noqa: E501 + :type: V1VsphereVirtualDiskVolumeSource + """ + + self._vsphere_volume = vsphere_volume + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1Volume): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1Volume): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment.py new file mode 100644 index 0000000000000000000000000000000000000000..aba46889a69a87a5f5da781cfd29af555bbea97d --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment.py @@ -0,0 +1,229 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttachment(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'spec': 'V1VolumeAttachmentSpec', + 'status': 'V1VolumeAttachmentStatus' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'spec': 'spec', + 'status': 'status' + } + + def __init__(self, api_version=None, kind=None, metadata=None, spec=None, status=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttachment - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._spec = None + self._status = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + self.spec = spec + if status is not None: + self.status = status + + @property + def api_version(self): + """Gets the api_version of this V1VolumeAttachment. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1VolumeAttachment. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1VolumeAttachment. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1VolumeAttachment. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V1VolumeAttachment. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1VolumeAttachment. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1VolumeAttachment. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1VolumeAttachment. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1VolumeAttachment. # noqa: E501 + + + :return: The metadata of this V1VolumeAttachment. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1VolumeAttachment. + + + :param metadata: The metadata of this V1VolumeAttachment. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def spec(self): + """Gets the spec of this V1VolumeAttachment. # noqa: E501 + + + :return: The spec of this V1VolumeAttachment. # noqa: E501 + :rtype: V1VolumeAttachmentSpec + """ + return self._spec + + @spec.setter + def spec(self, spec): + """Sets the spec of this V1VolumeAttachment. + + + :param spec: The spec of this V1VolumeAttachment. # noqa: E501 + :type: V1VolumeAttachmentSpec + """ + if self.local_vars_configuration.client_side_validation and spec is None: # noqa: E501 + raise ValueError("Invalid value for `spec`, must not be `None`") # noqa: E501 + + self._spec = spec + + @property + def status(self): + """Gets the status of this V1VolumeAttachment. # noqa: E501 + + + :return: The status of this V1VolumeAttachment. # noqa: E501 + :rtype: V1VolumeAttachmentStatus + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this V1VolumeAttachment. + + + :param status: The status of this V1VolumeAttachment. # noqa: E501 + :type: V1VolumeAttachmentStatus + """ + + self._status = status + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttachment): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttachment): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_list.py new file mode 100644 index 0000000000000000000000000000000000000000..d200e09a9941452e6b478f1f45ee1c07c628a81a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttachmentList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V1VolumeAttachment]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttachmentList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V1VolumeAttachmentList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1VolumeAttachmentList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1VolumeAttachmentList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1VolumeAttachmentList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V1VolumeAttachmentList. # noqa: E501 + + items is the list of VolumeAttachments # noqa: E501 + + :return: The items of this V1VolumeAttachmentList. # noqa: E501 + :rtype: list[V1VolumeAttachment] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V1VolumeAttachmentList. + + items is the list of VolumeAttachments # noqa: E501 + + :param items: The items of this V1VolumeAttachmentList. # noqa: E501 + :type: list[V1VolumeAttachment] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V1VolumeAttachmentList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1VolumeAttachmentList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1VolumeAttachmentList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1VolumeAttachmentList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1VolumeAttachmentList. # noqa: E501 + + + :return: The metadata of this V1VolumeAttachmentList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1VolumeAttachmentList. + + + :param metadata: The metadata of this V1VolumeAttachmentList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttachmentList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttachmentList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_source.py new file mode 100644 index 0000000000000000000000000000000000000000..810a6f71b8a723b34077e9b2a27349121d3dd63c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_source.py @@ -0,0 +1,148 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttachmentSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'inline_volume_spec': 'V1PersistentVolumeSpec', + 'persistent_volume_name': 'str' + } + + attribute_map = { + 'inline_volume_spec': 'inlineVolumeSpec', + 'persistent_volume_name': 'persistentVolumeName' + } + + def __init__(self, inline_volume_spec=None, persistent_volume_name=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttachmentSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._inline_volume_spec = None + self._persistent_volume_name = None + self.discriminator = None + + if inline_volume_spec is not None: + self.inline_volume_spec = inline_volume_spec + if persistent_volume_name is not None: + self.persistent_volume_name = persistent_volume_name + + @property + def inline_volume_spec(self): + """Gets the inline_volume_spec of this V1VolumeAttachmentSource. # noqa: E501 + + + :return: The inline_volume_spec of this V1VolumeAttachmentSource. # noqa: E501 + :rtype: V1PersistentVolumeSpec + """ + return self._inline_volume_spec + + @inline_volume_spec.setter + def inline_volume_spec(self, inline_volume_spec): + """Sets the inline_volume_spec of this V1VolumeAttachmentSource. + + + :param inline_volume_spec: The inline_volume_spec of this V1VolumeAttachmentSource. # noqa: E501 + :type: V1PersistentVolumeSpec + """ + + self._inline_volume_spec = inline_volume_spec + + @property + def persistent_volume_name(self): + """Gets the persistent_volume_name of this V1VolumeAttachmentSource. # noqa: E501 + + persistentVolumeName represents the name of the persistent volume to attach. # noqa: E501 + + :return: The persistent_volume_name of this V1VolumeAttachmentSource. # noqa: E501 + :rtype: str + """ + return self._persistent_volume_name + + @persistent_volume_name.setter + def persistent_volume_name(self, persistent_volume_name): + """Sets the persistent_volume_name of this V1VolumeAttachmentSource. + + persistentVolumeName represents the name of the persistent volume to attach. # noqa: E501 + + :param persistent_volume_name: The persistent_volume_name of this V1VolumeAttachmentSource. # noqa: E501 + :type: str + """ + + self._persistent_volume_name = persistent_volume_name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttachmentSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttachmentSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..c08a44c7127b71fc68a8c8d546a4b43086d974b0 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_spec.py @@ -0,0 +1,179 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttachmentSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'attacher': 'str', + 'node_name': 'str', + 'source': 'V1VolumeAttachmentSource' + } + + attribute_map = { + 'attacher': 'attacher', + 'node_name': 'nodeName', + 'source': 'source' + } + + def __init__(self, attacher=None, node_name=None, source=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttachmentSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._attacher = None + self._node_name = None + self._source = None + self.discriminator = None + + self.attacher = attacher + self.node_name = node_name + self.source = source + + @property + def attacher(self): + """Gets the attacher of this V1VolumeAttachmentSpec. # noqa: E501 + + attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). # noqa: E501 + + :return: The attacher of this V1VolumeAttachmentSpec. # noqa: E501 + :rtype: str + """ + return self._attacher + + @attacher.setter + def attacher(self, attacher): + """Sets the attacher of this V1VolumeAttachmentSpec. + + attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). # noqa: E501 + + :param attacher: The attacher of this V1VolumeAttachmentSpec. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and attacher is None: # noqa: E501 + raise ValueError("Invalid value for `attacher`, must not be `None`") # noqa: E501 + + self._attacher = attacher + + @property + def node_name(self): + """Gets the node_name of this V1VolumeAttachmentSpec. # noqa: E501 + + nodeName represents the node that the volume should be attached to. # noqa: E501 + + :return: The node_name of this V1VolumeAttachmentSpec. # noqa: E501 + :rtype: str + """ + return self._node_name + + @node_name.setter + def node_name(self, node_name): + """Sets the node_name of this V1VolumeAttachmentSpec. + + nodeName represents the node that the volume should be attached to. # noqa: E501 + + :param node_name: The node_name of this V1VolumeAttachmentSpec. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and node_name is None: # noqa: E501 + raise ValueError("Invalid value for `node_name`, must not be `None`") # noqa: E501 + + self._node_name = node_name + + @property + def source(self): + """Gets the source of this V1VolumeAttachmentSpec. # noqa: E501 + + + :return: The source of this V1VolumeAttachmentSpec. # noqa: E501 + :rtype: V1VolumeAttachmentSource + """ + return self._source + + @source.setter + def source(self, source): + """Sets the source of this V1VolumeAttachmentSpec. + + + :param source: The source of this V1VolumeAttachmentSpec. # noqa: E501 + :type: V1VolumeAttachmentSource + """ + if self.local_vars_configuration.client_side_validation and source is None: # noqa: E501 + raise ValueError("Invalid value for `source`, must not be `None`") # noqa: E501 + + self._source = source + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttachmentSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttachmentSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_status.py new file mode 100644 index 0000000000000000000000000000000000000000..9daa0650fb35193af4e0590b0967309b0d87b754 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attachment_status.py @@ -0,0 +1,203 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttachmentStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'attach_error': 'V1VolumeError', + 'attached': 'bool', + 'attachment_metadata': 'dict(str, str)', + 'detach_error': 'V1VolumeError' + } + + attribute_map = { + 'attach_error': 'attachError', + 'attached': 'attached', + 'attachment_metadata': 'attachmentMetadata', + 'detach_error': 'detachError' + } + + def __init__(self, attach_error=None, attached=None, attachment_metadata=None, detach_error=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttachmentStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._attach_error = None + self._attached = None + self._attachment_metadata = None + self._detach_error = None + self.discriminator = None + + if attach_error is not None: + self.attach_error = attach_error + self.attached = attached + if attachment_metadata is not None: + self.attachment_metadata = attachment_metadata + if detach_error is not None: + self.detach_error = detach_error + + @property + def attach_error(self): + """Gets the attach_error of this V1VolumeAttachmentStatus. # noqa: E501 + + + :return: The attach_error of this V1VolumeAttachmentStatus. # noqa: E501 + :rtype: V1VolumeError + """ + return self._attach_error + + @attach_error.setter + def attach_error(self, attach_error): + """Sets the attach_error of this V1VolumeAttachmentStatus. + + + :param attach_error: The attach_error of this V1VolumeAttachmentStatus. # noqa: E501 + :type: V1VolumeError + """ + + self._attach_error = attach_error + + @property + def attached(self): + """Gets the attached of this V1VolumeAttachmentStatus. # noqa: E501 + + attached indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. # noqa: E501 + + :return: The attached of this V1VolumeAttachmentStatus. # noqa: E501 + :rtype: bool + """ + return self._attached + + @attached.setter + def attached(self, attached): + """Sets the attached of this V1VolumeAttachmentStatus. + + attached indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. # noqa: E501 + + :param attached: The attached of this V1VolumeAttachmentStatus. # noqa: E501 + :type: bool + """ + if self.local_vars_configuration.client_side_validation and attached is None: # noqa: E501 + raise ValueError("Invalid value for `attached`, must not be `None`") # noqa: E501 + + self._attached = attached + + @property + def attachment_metadata(self): + """Gets the attachment_metadata of this V1VolumeAttachmentStatus. # noqa: E501 + + attachmentMetadata is populated with any information returned by the attach operation, upon successful attach, that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. # noqa: E501 + + :return: The attachment_metadata of this V1VolumeAttachmentStatus. # noqa: E501 + :rtype: dict(str, str) + """ + return self._attachment_metadata + + @attachment_metadata.setter + def attachment_metadata(self, attachment_metadata): + """Sets the attachment_metadata of this V1VolumeAttachmentStatus. + + attachmentMetadata is populated with any information returned by the attach operation, upon successful attach, that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. # noqa: E501 + + :param attachment_metadata: The attachment_metadata of this V1VolumeAttachmentStatus. # noqa: E501 + :type: dict(str, str) + """ + + self._attachment_metadata = attachment_metadata + + @property + def detach_error(self): + """Gets the detach_error of this V1VolumeAttachmentStatus. # noqa: E501 + + + :return: The detach_error of this V1VolumeAttachmentStatus. # noqa: E501 + :rtype: V1VolumeError + """ + return self._detach_error + + @detach_error.setter + def detach_error(self, detach_error): + """Sets the detach_error of this V1VolumeAttachmentStatus. + + + :param detach_error: The detach_error of this V1VolumeAttachmentStatus. # noqa: E501 + :type: V1VolumeError + """ + + self._detach_error = detach_error + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttachmentStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttachmentStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class.py new file mode 100644 index 0000000000000000000000000000000000000000..aa28e9484014aeac8748709459e1fe267c0e1131 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class.py @@ -0,0 +1,233 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttributesClass(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'driver_name': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'parameters': 'dict(str, str)' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'driver_name': 'driverName', + 'kind': 'kind', + 'metadata': 'metadata', + 'parameters': 'parameters' + } + + def __init__(self, api_version=None, driver_name=None, kind=None, metadata=None, parameters=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttributesClass - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._driver_name = None + self._kind = None + self._metadata = None + self._parameters = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.driver_name = driver_name + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + if parameters is not None: + self.parameters = parameters + + @property + def api_version(self): + """Gets the api_version of this V1VolumeAttributesClass. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1VolumeAttributesClass. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1VolumeAttributesClass. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1VolumeAttributesClass. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def driver_name(self): + """Gets the driver_name of this V1VolumeAttributesClass. # noqa: E501 + + Name of the CSI driver This field is immutable. # noqa: E501 + + :return: The driver_name of this V1VolumeAttributesClass. # noqa: E501 + :rtype: str + """ + return self._driver_name + + @driver_name.setter + def driver_name(self, driver_name): + """Sets the driver_name of this V1VolumeAttributesClass. + + Name of the CSI driver This field is immutable. # noqa: E501 + + :param driver_name: The driver_name of this V1VolumeAttributesClass. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and driver_name is None: # noqa: E501 + raise ValueError("Invalid value for `driver_name`, must not be `None`") # noqa: E501 + + self._driver_name = driver_name + + @property + def kind(self): + """Gets the kind of this V1VolumeAttributesClass. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1VolumeAttributesClass. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1VolumeAttributesClass. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1VolumeAttributesClass. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1VolumeAttributesClass. # noqa: E501 + + + :return: The metadata of this V1VolumeAttributesClass. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1VolumeAttributesClass. + + + :param metadata: The metadata of this V1VolumeAttributesClass. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def parameters(self): + """Gets the parameters of this V1VolumeAttributesClass. # noqa: E501 + + parameters hold volume attributes defined by the CSI driver. These values are opaque to the Kubernetes and are passed directly to the CSI driver. The underlying storage provider supports changing these attributes on an existing volume, however the parameters field itself is immutable. To invoke a volume update, a new VolumeAttributesClass should be created with new parameters, and the PersistentVolumeClaim should be updated to reference the new VolumeAttributesClass. This field is required and must contain at least one key/value pair. The keys cannot be empty, and the maximum number of parameters is 512, with a cumulative max size of 256K. If the CSI driver rejects invalid parameters, the target PersistentVolumeClaim will be set to an \"Infeasible\" state in the modifyVolumeStatus field. # noqa: E501 + + :return: The parameters of this V1VolumeAttributesClass. # noqa: E501 + :rtype: dict(str, str) + """ + return self._parameters + + @parameters.setter + def parameters(self, parameters): + """Sets the parameters of this V1VolumeAttributesClass. + + parameters hold volume attributes defined by the CSI driver. These values are opaque to the Kubernetes and are passed directly to the CSI driver. The underlying storage provider supports changing these attributes on an existing volume, however the parameters field itself is immutable. To invoke a volume update, a new VolumeAttributesClass should be created with new parameters, and the PersistentVolumeClaim should be updated to reference the new VolumeAttributesClass. This field is required and must contain at least one key/value pair. The keys cannot be empty, and the maximum number of parameters is 512, with a cumulative max size of 256K. If the CSI driver rejects invalid parameters, the target PersistentVolumeClaim will be set to an \"Infeasible\" state in the modifyVolumeStatus field. # noqa: E501 + + :param parameters: The parameters of this V1VolumeAttributesClass. # noqa: E501 + :type: dict(str, str) + """ + + self._parameters = parameters + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttributesClass): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttributesClass): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class_list.py new file mode 100644 index 0000000000000000000000000000000000000000..f07391e2d9e4b540d096e13814b7b87bca98e9db --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_attributes_class_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeAttributesClassList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V1VolumeAttributesClass]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeAttributesClassList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V1VolumeAttributesClassList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V1VolumeAttributesClassList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V1VolumeAttributesClassList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V1VolumeAttributesClassList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V1VolumeAttributesClassList. # noqa: E501 + + items is the list of VolumeAttributesClass objects. # noqa: E501 + + :return: The items of this V1VolumeAttributesClassList. # noqa: E501 + :rtype: list[V1VolumeAttributesClass] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V1VolumeAttributesClassList. + + items is the list of VolumeAttributesClass objects. # noqa: E501 + + :param items: The items of this V1VolumeAttributesClassList. # noqa: E501 + :type: list[V1VolumeAttributesClass] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V1VolumeAttributesClassList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V1VolumeAttributesClassList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V1VolumeAttributesClassList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V1VolumeAttributesClassList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V1VolumeAttributesClassList. # noqa: E501 + + + :return: The metadata of this V1VolumeAttributesClassList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V1VolumeAttributesClassList. + + + :param metadata: The metadata of this V1VolumeAttributesClassList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeAttributesClassList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeAttributesClassList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_device.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_device.py new file mode 100644 index 0000000000000000000000000000000000000000..d137f9dd2258bcb6b8c5e074e07787422c2e6e80 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_device.py @@ -0,0 +1,152 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeDevice(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'device_path': 'str', + 'name': 'str' + } + + attribute_map = { + 'device_path': 'devicePath', + 'name': 'name' + } + + def __init__(self, device_path=None, name=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeDevice - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._device_path = None + self._name = None + self.discriminator = None + + self.device_path = device_path + self.name = name + + @property + def device_path(self): + """Gets the device_path of this V1VolumeDevice. # noqa: E501 + + devicePath is the path inside of the container that the device will be mapped to. # noqa: E501 + + :return: The device_path of this V1VolumeDevice. # noqa: E501 + :rtype: str + """ + return self._device_path + + @device_path.setter + def device_path(self, device_path): + """Sets the device_path of this V1VolumeDevice. + + devicePath is the path inside of the container that the device will be mapped to. # noqa: E501 + + :param device_path: The device_path of this V1VolumeDevice. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and device_path is None: # noqa: E501 + raise ValueError("Invalid value for `device_path`, must not be `None`") # noqa: E501 + + self._device_path = device_path + + @property + def name(self): + """Gets the name of this V1VolumeDevice. # noqa: E501 + + name must match the name of a persistentVolumeClaim in the pod # noqa: E501 + + :return: The name of this V1VolumeDevice. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1VolumeDevice. + + name must match the name of a persistentVolumeClaim in the pod # noqa: E501 + + :param name: The name of this V1VolumeDevice. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeDevice): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeDevice): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_error.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_error.py new file mode 100644 index 0000000000000000000000000000000000000000..831799b893e9b4950dcb3655d0f5eae361f93949 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_error.py @@ -0,0 +1,178 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeError(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'error_code': 'int', + 'message': 'str', + 'time': 'datetime' + } + + attribute_map = { + 'error_code': 'errorCode', + 'message': 'message', + 'time': 'time' + } + + def __init__(self, error_code=None, message=None, time=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeError - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._error_code = None + self._message = None + self._time = None + self.discriminator = None + + if error_code is not None: + self.error_code = error_code + if message is not None: + self.message = message + if time is not None: + self.time = time + + @property + def error_code(self): + """Gets the error_code of this V1VolumeError. # noqa: E501 + + errorCode is a numeric gRPC code representing the error encountered during Attach or Detach operations. This is an optional, beta field that requires the MutableCSINodeAllocatableCount feature gate being enabled to be set. # noqa: E501 + + :return: The error_code of this V1VolumeError. # noqa: E501 + :rtype: int + """ + return self._error_code + + @error_code.setter + def error_code(self, error_code): + """Sets the error_code of this V1VolumeError. + + errorCode is a numeric gRPC code representing the error encountered during Attach or Detach operations. This is an optional, beta field that requires the MutableCSINodeAllocatableCount feature gate being enabled to be set. # noqa: E501 + + :param error_code: The error_code of this V1VolumeError. # noqa: E501 + :type: int + """ + + self._error_code = error_code + + @property + def message(self): + """Gets the message of this V1VolumeError. # noqa: E501 + + message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. # noqa: E501 + + :return: The message of this V1VolumeError. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this V1VolumeError. + + message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. # noqa: E501 + + :param message: The message of this V1VolumeError. # noqa: E501 + :type: str + """ + + self._message = message + + @property + def time(self): + """Gets the time of this V1VolumeError. # noqa: E501 + + time represents the time the error was encountered. # noqa: E501 + + :return: The time of this V1VolumeError. # noqa: E501 + :rtype: datetime + """ + return self._time + + @time.setter + def time(self, time): + """Sets the time of this V1VolumeError. + + time represents the time the error was encountered. # noqa: E501 + + :param time: The time of this V1VolumeError. # noqa: E501 + :type: datetime + """ + + self._time = time + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeError): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeError): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount.py new file mode 100644 index 0000000000000000000000000000000000000000..a228cd74341d85d870d835135cc8ae68178291ea --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount.py @@ -0,0 +1,292 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeMount(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'mount_path': 'str', + 'mount_propagation': 'str', + 'name': 'str', + 'read_only': 'bool', + 'recursive_read_only': 'str', + 'sub_path': 'str', + 'sub_path_expr': 'str' + } + + attribute_map = { + 'mount_path': 'mountPath', + 'mount_propagation': 'mountPropagation', + 'name': 'name', + 'read_only': 'readOnly', + 'recursive_read_only': 'recursiveReadOnly', + 'sub_path': 'subPath', + 'sub_path_expr': 'subPathExpr' + } + + def __init__(self, mount_path=None, mount_propagation=None, name=None, read_only=None, recursive_read_only=None, sub_path=None, sub_path_expr=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeMount - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._mount_path = None + self._mount_propagation = None + self._name = None + self._read_only = None + self._recursive_read_only = None + self._sub_path = None + self._sub_path_expr = None + self.discriminator = None + + self.mount_path = mount_path + if mount_propagation is not None: + self.mount_propagation = mount_propagation + self.name = name + if read_only is not None: + self.read_only = read_only + if recursive_read_only is not None: + self.recursive_read_only = recursive_read_only + if sub_path is not None: + self.sub_path = sub_path + if sub_path_expr is not None: + self.sub_path_expr = sub_path_expr + + @property + def mount_path(self): + """Gets the mount_path of this V1VolumeMount. # noqa: E501 + + Path within the container at which the volume should be mounted. Must not contain ':'. # noqa: E501 + + :return: The mount_path of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._mount_path + + @mount_path.setter + def mount_path(self, mount_path): + """Sets the mount_path of this V1VolumeMount. + + Path within the container at which the volume should be mounted. Must not contain ':'. # noqa: E501 + + :param mount_path: The mount_path of this V1VolumeMount. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and mount_path is None: # noqa: E501 + raise ValueError("Invalid value for `mount_path`, must not be `None`") # noqa: E501 + + self._mount_path = mount_path + + @property + def mount_propagation(self): + """Gets the mount_propagation of this V1VolumeMount. # noqa: E501 + + mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None). # noqa: E501 + + :return: The mount_propagation of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._mount_propagation + + @mount_propagation.setter + def mount_propagation(self, mount_propagation): + """Sets the mount_propagation of this V1VolumeMount. + + mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None). # noqa: E501 + + :param mount_propagation: The mount_propagation of this V1VolumeMount. # noqa: E501 + :type: str + """ + + self._mount_propagation = mount_propagation + + @property + def name(self): + """Gets the name of this V1VolumeMount. # noqa: E501 + + This must match the Name of a Volume. # noqa: E501 + + :return: The name of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1VolumeMount. + + This must match the Name of a Volume. # noqa: E501 + + :param name: The name of this V1VolumeMount. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def read_only(self): + """Gets the read_only of this V1VolumeMount. # noqa: E501 + + Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. # noqa: E501 + + :return: The read_only of this V1VolumeMount. # noqa: E501 + :rtype: bool + """ + return self._read_only + + @read_only.setter + def read_only(self, read_only): + """Sets the read_only of this V1VolumeMount. + + Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. # noqa: E501 + + :param read_only: The read_only of this V1VolumeMount. # noqa: E501 + :type: bool + """ + + self._read_only = read_only + + @property + def recursive_read_only(self): + """Gets the recursive_read_only of this V1VolumeMount. # noqa: E501 + + RecursiveReadOnly specifies whether read-only mounts should be handled recursively. If ReadOnly is false, this field has no meaning and must be unspecified. If ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason. If this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None). If this field is not specified, it is treated as an equivalent of Disabled. # noqa: E501 + + :return: The recursive_read_only of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._recursive_read_only + + @recursive_read_only.setter + def recursive_read_only(self, recursive_read_only): + """Sets the recursive_read_only of this V1VolumeMount. + + RecursiveReadOnly specifies whether read-only mounts should be handled recursively. If ReadOnly is false, this field has no meaning and must be unspecified. If ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason. If this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None). If this field is not specified, it is treated as an equivalent of Disabled. # noqa: E501 + + :param recursive_read_only: The recursive_read_only of this V1VolumeMount. # noqa: E501 + :type: str + """ + + self._recursive_read_only = recursive_read_only + + @property + def sub_path(self): + """Gets the sub_path of this V1VolumeMount. # noqa: E501 + + Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root). # noqa: E501 + + :return: The sub_path of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._sub_path + + @sub_path.setter + def sub_path(self, sub_path): + """Sets the sub_path of this V1VolumeMount. + + Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root). # noqa: E501 + + :param sub_path: The sub_path of this V1VolumeMount. # noqa: E501 + :type: str + """ + + self._sub_path = sub_path + + @property + def sub_path_expr(self): + """Gets the sub_path_expr of this V1VolumeMount. # noqa: E501 + + Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive. # noqa: E501 + + :return: The sub_path_expr of this V1VolumeMount. # noqa: E501 + :rtype: str + """ + return self._sub_path_expr + + @sub_path_expr.setter + def sub_path_expr(self, sub_path_expr): + """Sets the sub_path_expr of this V1VolumeMount. + + Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive. # noqa: E501 + + :param sub_path_expr: The sub_path_expr of this V1VolumeMount. # noqa: E501 + :type: str + """ + + self._sub_path_expr = sub_path_expr + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeMount): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeMount): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount_status.py new file mode 100644 index 0000000000000000000000000000000000000000..21c1c6fa3b393291b3fc20c0ab8f4a6a66ca4f72 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_mount_status.py @@ -0,0 +1,208 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeMountStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'mount_path': 'str', + 'name': 'str', + 'read_only': 'bool', + 'recursive_read_only': 'str' + } + + attribute_map = { + 'mount_path': 'mountPath', + 'name': 'name', + 'read_only': 'readOnly', + 'recursive_read_only': 'recursiveReadOnly' + } + + def __init__(self, mount_path=None, name=None, read_only=None, recursive_read_only=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeMountStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._mount_path = None + self._name = None + self._read_only = None + self._recursive_read_only = None + self.discriminator = None + + self.mount_path = mount_path + self.name = name + if read_only is not None: + self.read_only = read_only + if recursive_read_only is not None: + self.recursive_read_only = recursive_read_only + + @property + def mount_path(self): + """Gets the mount_path of this V1VolumeMountStatus. # noqa: E501 + + MountPath corresponds to the original VolumeMount. # noqa: E501 + + :return: The mount_path of this V1VolumeMountStatus. # noqa: E501 + :rtype: str + """ + return self._mount_path + + @mount_path.setter + def mount_path(self, mount_path): + """Sets the mount_path of this V1VolumeMountStatus. + + MountPath corresponds to the original VolumeMount. # noqa: E501 + + :param mount_path: The mount_path of this V1VolumeMountStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and mount_path is None: # noqa: E501 + raise ValueError("Invalid value for `mount_path`, must not be `None`") # noqa: E501 + + self._mount_path = mount_path + + @property + def name(self): + """Gets the name of this V1VolumeMountStatus. # noqa: E501 + + Name corresponds to the name of the original VolumeMount. # noqa: E501 + + :return: The name of this V1VolumeMountStatus. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1VolumeMountStatus. + + Name corresponds to the name of the original VolumeMount. # noqa: E501 + + :param name: The name of this V1VolumeMountStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def read_only(self): + """Gets the read_only of this V1VolumeMountStatus. # noqa: E501 + + ReadOnly corresponds to the original VolumeMount. # noqa: E501 + + :return: The read_only of this V1VolumeMountStatus. # noqa: E501 + :rtype: bool + """ + return self._read_only + + @read_only.setter + def read_only(self, read_only): + """Sets the read_only of this V1VolumeMountStatus. + + ReadOnly corresponds to the original VolumeMount. # noqa: E501 + + :param read_only: The read_only of this V1VolumeMountStatus. # noqa: E501 + :type: bool + """ + + self._read_only = read_only + + @property + def recursive_read_only(self): + """Gets the recursive_read_only of this V1VolumeMountStatus. # noqa: E501 + + RecursiveReadOnly must be set to Disabled, Enabled, or unspecified (for non-readonly mounts). An IfPossible value in the original VolumeMount must be translated to Disabled or Enabled, depending on the mount result. # noqa: E501 + + :return: The recursive_read_only of this V1VolumeMountStatus. # noqa: E501 + :rtype: str + """ + return self._recursive_read_only + + @recursive_read_only.setter + def recursive_read_only(self, recursive_read_only): + """Sets the recursive_read_only of this V1VolumeMountStatus. + + RecursiveReadOnly must be set to Disabled, Enabled, or unspecified (for non-readonly mounts). An IfPossible value in the original VolumeMount must be translated to Disabled or Enabled, depending on the mount result. # noqa: E501 + + :param recursive_read_only: The recursive_read_only of this V1VolumeMountStatus. # noqa: E501 + :type: str + """ + + self._recursive_read_only = recursive_read_only + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeMountStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeMountStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_affinity.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_affinity.py new file mode 100644 index 0000000000000000000000000000000000000000..0658779be92af258276d54cc8310e93ee3952011 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_affinity.py @@ -0,0 +1,120 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeNodeAffinity(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'required': 'V1NodeSelector' + } + + attribute_map = { + 'required': 'required' + } + + def __init__(self, required=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeNodeAffinity - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._required = None + self.discriminator = None + + if required is not None: + self.required = required + + @property + def required(self): + """Gets the required of this V1VolumeNodeAffinity. # noqa: E501 + + + :return: The required of this V1VolumeNodeAffinity. # noqa: E501 + :rtype: V1NodeSelector + """ + return self._required + + @required.setter + def required(self, required): + """Sets the required of this V1VolumeNodeAffinity. + + + :param required: The required of this V1VolumeNodeAffinity. # noqa: E501 + :type: V1NodeSelector + """ + + self._required = required + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeNodeAffinity): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeNodeAffinity): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_resources.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_resources.py new file mode 100644 index 0000000000000000000000000000000000000000..d7e39b4254021121d35a348cb24231f0aba74b6f --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_node_resources.py @@ -0,0 +1,122 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeNodeResources(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'count': 'int' + } + + attribute_map = { + 'count': 'count' + } + + def __init__(self, count=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeNodeResources - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._count = None + self.discriminator = None + + if count is not None: + self.count = count + + @property + def count(self): + """Gets the count of this V1VolumeNodeResources. # noqa: E501 + + count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded. # noqa: E501 + + :return: The count of this V1VolumeNodeResources. # noqa: E501 + :rtype: int + """ + return self._count + + @count.setter + def count(self, count): + """Sets the count of this V1VolumeNodeResources. + + count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded. # noqa: E501 + + :param count: The count of this V1VolumeNodeResources. # noqa: E501 + :type: int + """ + + self._count = count + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeNodeResources): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeNodeResources): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_projection.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_projection.py new file mode 100644 index 0000000000000000000000000000000000000000..b42590ed5084ede76bb97b3b7f8417f64feab849 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_projection.py @@ -0,0 +1,250 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeProjection(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'cluster_trust_bundle': 'V1ClusterTrustBundleProjection', + 'config_map': 'V1ConfigMapProjection', + 'downward_api': 'V1DownwardAPIProjection', + 'pod_certificate': 'V1PodCertificateProjection', + 'secret': 'V1SecretProjection', + 'service_account_token': 'V1ServiceAccountTokenProjection' + } + + attribute_map = { + 'cluster_trust_bundle': 'clusterTrustBundle', + 'config_map': 'configMap', + 'downward_api': 'downwardAPI', + 'pod_certificate': 'podCertificate', + 'secret': 'secret', + 'service_account_token': 'serviceAccountToken' + } + + def __init__(self, cluster_trust_bundle=None, config_map=None, downward_api=None, pod_certificate=None, secret=None, service_account_token=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeProjection - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._cluster_trust_bundle = None + self._config_map = None + self._downward_api = None + self._pod_certificate = None + self._secret = None + self._service_account_token = None + self.discriminator = None + + if cluster_trust_bundle is not None: + self.cluster_trust_bundle = cluster_trust_bundle + if config_map is not None: + self.config_map = config_map + if downward_api is not None: + self.downward_api = downward_api + if pod_certificate is not None: + self.pod_certificate = pod_certificate + if secret is not None: + self.secret = secret + if service_account_token is not None: + self.service_account_token = service_account_token + + @property + def cluster_trust_bundle(self): + """Gets the cluster_trust_bundle of this V1VolumeProjection. # noqa: E501 + + + :return: The cluster_trust_bundle of this V1VolumeProjection. # noqa: E501 + :rtype: V1ClusterTrustBundleProjection + """ + return self._cluster_trust_bundle + + @cluster_trust_bundle.setter + def cluster_trust_bundle(self, cluster_trust_bundle): + """Sets the cluster_trust_bundle of this V1VolumeProjection. + + + :param cluster_trust_bundle: The cluster_trust_bundle of this V1VolumeProjection. # noqa: E501 + :type: V1ClusterTrustBundleProjection + """ + + self._cluster_trust_bundle = cluster_trust_bundle + + @property + def config_map(self): + """Gets the config_map of this V1VolumeProjection. # noqa: E501 + + + :return: The config_map of this V1VolumeProjection. # noqa: E501 + :rtype: V1ConfigMapProjection + """ + return self._config_map + + @config_map.setter + def config_map(self, config_map): + """Sets the config_map of this V1VolumeProjection. + + + :param config_map: The config_map of this V1VolumeProjection. # noqa: E501 + :type: V1ConfigMapProjection + """ + + self._config_map = config_map + + @property + def downward_api(self): + """Gets the downward_api of this V1VolumeProjection. # noqa: E501 + + + :return: The downward_api of this V1VolumeProjection. # noqa: E501 + :rtype: V1DownwardAPIProjection + """ + return self._downward_api + + @downward_api.setter + def downward_api(self, downward_api): + """Sets the downward_api of this V1VolumeProjection. + + + :param downward_api: The downward_api of this V1VolumeProjection. # noqa: E501 + :type: V1DownwardAPIProjection + """ + + self._downward_api = downward_api + + @property + def pod_certificate(self): + """Gets the pod_certificate of this V1VolumeProjection. # noqa: E501 + + + :return: The pod_certificate of this V1VolumeProjection. # noqa: E501 + :rtype: V1PodCertificateProjection + """ + return self._pod_certificate + + @pod_certificate.setter + def pod_certificate(self, pod_certificate): + """Sets the pod_certificate of this V1VolumeProjection. + + + :param pod_certificate: The pod_certificate of this V1VolumeProjection. # noqa: E501 + :type: V1PodCertificateProjection + """ + + self._pod_certificate = pod_certificate + + @property + def secret(self): + """Gets the secret of this V1VolumeProjection. # noqa: E501 + + + :return: The secret of this V1VolumeProjection. # noqa: E501 + :rtype: V1SecretProjection + """ + return self._secret + + @secret.setter + def secret(self, secret): + """Sets the secret of this V1VolumeProjection. + + + :param secret: The secret of this V1VolumeProjection. # noqa: E501 + :type: V1SecretProjection + """ + + self._secret = secret + + @property + def service_account_token(self): + """Gets the service_account_token of this V1VolumeProjection. # noqa: E501 + + + :return: The service_account_token of this V1VolumeProjection. # noqa: E501 + :rtype: V1ServiceAccountTokenProjection + """ + return self._service_account_token + + @service_account_token.setter + def service_account_token(self, service_account_token): + """Sets the service_account_token of this V1VolumeProjection. + + + :param service_account_token: The service_account_token of this V1VolumeProjection. # noqa: E501 + :type: V1ServiceAccountTokenProjection + """ + + self._service_account_token = service_account_token + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeProjection): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeProjection): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_resource_requirements.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_resource_requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..fd7f8d543d387d2c3c28dc2e906c19684462c047 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_volume_resource_requirements.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VolumeResourceRequirements(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'limits': 'dict(str, str)', + 'requests': 'dict(str, str)' + } + + attribute_map = { + 'limits': 'limits', + 'requests': 'requests' + } + + def __init__(self, limits=None, requests=None, local_vars_configuration=None): # noqa: E501 + """V1VolumeResourceRequirements - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._limits = None + self._requests = None + self.discriminator = None + + if limits is not None: + self.limits = limits + if requests is not None: + self.requests = requests + + @property + def limits(self): + """Gets the limits of this V1VolumeResourceRequirements. # noqa: E501 + + Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ # noqa: E501 + + :return: The limits of this V1VolumeResourceRequirements. # noqa: E501 + :rtype: dict(str, str) + """ + return self._limits + + @limits.setter + def limits(self, limits): + """Sets the limits of this V1VolumeResourceRequirements. + + Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ # noqa: E501 + + :param limits: The limits of this V1VolumeResourceRequirements. # noqa: E501 + :type: dict(str, str) + """ + + self._limits = limits + + @property + def requests(self): + """Gets the requests of this V1VolumeResourceRequirements. # noqa: E501 + + Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ # noqa: E501 + + :return: The requests of this V1VolumeResourceRequirements. # noqa: E501 + :rtype: dict(str, str) + """ + return self._requests + + @requests.setter + def requests(self, requests): + """Sets the requests of this V1VolumeResourceRequirements. + + Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ # noqa: E501 + + :param requests: The requests of this V1VolumeResourceRequirements. # noqa: E501 + :type: dict(str, str) + """ + + self._requests = requests + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VolumeResourceRequirements): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VolumeResourceRequirements): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_vsphere_virtual_disk_volume_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_vsphere_virtual_disk_volume_source.py new file mode 100644 index 0000000000000000000000000000000000000000..e0a85bb17dff68ac21dfbc6880840b275e1d95da --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_vsphere_virtual_disk_volume_source.py @@ -0,0 +1,207 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1VsphereVirtualDiskVolumeSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'fs_type': 'str', + 'storage_policy_id': 'str', + 'storage_policy_name': 'str', + 'volume_path': 'str' + } + + attribute_map = { + 'fs_type': 'fsType', + 'storage_policy_id': 'storagePolicyID', + 'storage_policy_name': 'storagePolicyName', + 'volume_path': 'volumePath' + } + + def __init__(self, fs_type=None, storage_policy_id=None, storage_policy_name=None, volume_path=None, local_vars_configuration=None): # noqa: E501 + """V1VsphereVirtualDiskVolumeSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._fs_type = None + self._storage_policy_id = None + self._storage_policy_name = None + self._volume_path = None + self.discriminator = None + + if fs_type is not None: + self.fs_type = fs_type + if storage_policy_id is not None: + self.storage_policy_id = storage_policy_id + if storage_policy_name is not None: + self.storage_policy_name = storage_policy_name + self.volume_path = volume_path + + @property + def fs_type(self): + """Gets the fs_type of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + + fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. # noqa: E501 + + :return: The fs_type of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :rtype: str + """ + return self._fs_type + + @fs_type.setter + def fs_type(self, fs_type): + """Sets the fs_type of this V1VsphereVirtualDiskVolumeSource. + + fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. # noqa: E501 + + :param fs_type: The fs_type of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :type: str + """ + + self._fs_type = fs_type + + @property + def storage_policy_id(self): + """Gets the storage_policy_id of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + + storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. # noqa: E501 + + :return: The storage_policy_id of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :rtype: str + """ + return self._storage_policy_id + + @storage_policy_id.setter + def storage_policy_id(self, storage_policy_id): + """Sets the storage_policy_id of this V1VsphereVirtualDiskVolumeSource. + + storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. # noqa: E501 + + :param storage_policy_id: The storage_policy_id of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :type: str + """ + + self._storage_policy_id = storage_policy_id + + @property + def storage_policy_name(self): + """Gets the storage_policy_name of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + + storagePolicyName is the storage Policy Based Management (SPBM) profile name. # noqa: E501 + + :return: The storage_policy_name of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :rtype: str + """ + return self._storage_policy_name + + @storage_policy_name.setter + def storage_policy_name(self, storage_policy_name): + """Sets the storage_policy_name of this V1VsphereVirtualDiskVolumeSource. + + storagePolicyName is the storage Policy Based Management (SPBM) profile name. # noqa: E501 + + :param storage_policy_name: The storage_policy_name of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :type: str + """ + + self._storage_policy_name = storage_policy_name + + @property + def volume_path(self): + """Gets the volume_path of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + + volumePath is the path that identifies vSphere volume vmdk # noqa: E501 + + :return: The volume_path of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :rtype: str + """ + return self._volume_path + + @volume_path.setter + def volume_path(self, volume_path): + """Sets the volume_path of this V1VsphereVirtualDiskVolumeSource. + + volumePath is the path that identifies vSphere volume vmdk # noqa: E501 + + :param volume_path: The volume_path of this V1VsphereVirtualDiskVolumeSource. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and volume_path is None: # noqa: E501 + raise ValueError("Invalid value for `volume_path`, must not be `None`") # noqa: E501 + + self._volume_path = volume_path + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1VsphereVirtualDiskVolumeSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1VsphereVirtualDiskVolumeSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_watch_event.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_watch_event.py new file mode 100644 index 0000000000000000000000000000000000000000..14bcaeba13e15ee68e238e863a43f18c5204043d --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_watch_event.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1WatchEvent(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'object': 'object', + 'type': 'str' + } + + attribute_map = { + 'object': 'object', + 'type': 'type' + } + + def __init__(self, object=None, type=None, local_vars_configuration=None): # noqa: E501 + """V1WatchEvent - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._object = None + self._type = None + self.discriminator = None + + self.object = object + self.type = type + + @property + def object(self): + """Gets the object of this V1WatchEvent. # noqa: E501 + + Object is: * If Type is Added or Modified: the new state of the object. * If Type is Deleted: the state of the object immediately before deletion. * If Type is Error: *Status is recommended; other types may make sense depending on context. # noqa: E501 + + :return: The object of this V1WatchEvent. # noqa: E501 + :rtype: object + """ + return self._object + + @object.setter + def object(self, object): + """Sets the object of this V1WatchEvent. + + Object is: * If Type is Added or Modified: the new state of the object. * If Type is Deleted: the state of the object immediately before deletion. * If Type is Error: *Status is recommended; other types may make sense depending on context. # noqa: E501 + + :param object: The object of this V1WatchEvent. # noqa: E501 + :type: object + """ + if self.local_vars_configuration.client_side_validation and object is None: # noqa: E501 + raise ValueError("Invalid value for `object`, must not be `None`") # noqa: E501 + + self._object = object + + @property + def type(self): + """Gets the type of this V1WatchEvent. # noqa: E501 + + + :return: The type of this V1WatchEvent. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V1WatchEvent. + + + :param type: The type of this V1WatchEvent. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1WatchEvent): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1WatchEvent): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_webhook_conversion.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_webhook_conversion.py new file mode 100644 index 0000000000000000000000000000000000000000..bdc6530c81b8782df66618fe32b8927ca073b88c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_webhook_conversion.py @@ -0,0 +1,149 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1WebhookConversion(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'client_config': 'ApiextensionsV1WebhookClientConfig', + 'conversion_review_versions': 'list[str]' + } + + attribute_map = { + 'client_config': 'clientConfig', + 'conversion_review_versions': 'conversionReviewVersions' + } + + def __init__(self, client_config=None, conversion_review_versions=None, local_vars_configuration=None): # noqa: E501 + """V1WebhookConversion - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._client_config = None + self._conversion_review_versions = None + self.discriminator = None + + if client_config is not None: + self.client_config = client_config + self.conversion_review_versions = conversion_review_versions + + @property + def client_config(self): + """Gets the client_config of this V1WebhookConversion. # noqa: E501 + + + :return: The client_config of this V1WebhookConversion. # noqa: E501 + :rtype: ApiextensionsV1WebhookClientConfig + """ + return self._client_config + + @client_config.setter + def client_config(self, client_config): + """Sets the client_config of this V1WebhookConversion. + + + :param client_config: The client_config of this V1WebhookConversion. # noqa: E501 + :type: ApiextensionsV1WebhookClientConfig + """ + + self._client_config = client_config + + @property + def conversion_review_versions(self): + """Gets the conversion_review_versions of this V1WebhookConversion. # noqa: E501 + + conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. # noqa: E501 + + :return: The conversion_review_versions of this V1WebhookConversion. # noqa: E501 + :rtype: list[str] + """ + return self._conversion_review_versions + + @conversion_review_versions.setter + def conversion_review_versions(self, conversion_review_versions): + """Sets the conversion_review_versions of this V1WebhookConversion. + + conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. # noqa: E501 + + :param conversion_review_versions: The conversion_review_versions of this V1WebhookConversion. # noqa: E501 + :type: list[str] + """ + if self.local_vars_configuration.client_side_validation and conversion_review_versions is None: # noqa: E501 + raise ValueError("Invalid value for `conversion_review_versions`, must not be `None`") # noqa: E501 + + self._conversion_review_versions = conversion_review_versions + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1WebhookConversion): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1WebhookConversion): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_weighted_pod_affinity_term.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_weighted_pod_affinity_term.py new file mode 100644 index 0000000000000000000000000000000000000000..58214a69b449f6d3640a45d4a912e19bbfe74ba1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_weighted_pod_affinity_term.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1WeightedPodAffinityTerm(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'pod_affinity_term': 'V1PodAffinityTerm', + 'weight': 'int' + } + + attribute_map = { + 'pod_affinity_term': 'podAffinityTerm', + 'weight': 'weight' + } + + def __init__(self, pod_affinity_term=None, weight=None, local_vars_configuration=None): # noqa: E501 + """V1WeightedPodAffinityTerm - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._pod_affinity_term = None + self._weight = None + self.discriminator = None + + self.pod_affinity_term = pod_affinity_term + self.weight = weight + + @property + def pod_affinity_term(self): + """Gets the pod_affinity_term of this V1WeightedPodAffinityTerm. # noqa: E501 + + + :return: The pod_affinity_term of this V1WeightedPodAffinityTerm. # noqa: E501 + :rtype: V1PodAffinityTerm + """ + return self._pod_affinity_term + + @pod_affinity_term.setter + def pod_affinity_term(self, pod_affinity_term): + """Sets the pod_affinity_term of this V1WeightedPodAffinityTerm. + + + :param pod_affinity_term: The pod_affinity_term of this V1WeightedPodAffinityTerm. # noqa: E501 + :type: V1PodAffinityTerm + """ + if self.local_vars_configuration.client_side_validation and pod_affinity_term is None: # noqa: E501 + raise ValueError("Invalid value for `pod_affinity_term`, must not be `None`") # noqa: E501 + + self._pod_affinity_term = pod_affinity_term + + @property + def weight(self): + """Gets the weight of this V1WeightedPodAffinityTerm. # noqa: E501 + + weight associated with matching the corresponding podAffinityTerm, in the range 1-100. # noqa: E501 + + :return: The weight of this V1WeightedPodAffinityTerm. # noqa: E501 + :rtype: int + """ + return self._weight + + @weight.setter + def weight(self, weight): + """Sets the weight of this V1WeightedPodAffinityTerm. + + weight associated with matching the corresponding podAffinityTerm, in the range 1-100. # noqa: E501 + + :param weight: The weight of this V1WeightedPodAffinityTerm. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and weight is None: # noqa: E501 + raise ValueError("Invalid value for `weight`, must not be `None`") # noqa: E501 + + self._weight = weight + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1WeightedPodAffinityTerm): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1WeightedPodAffinityTerm): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_windows_security_context_options.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_windows_security_context_options.py new file mode 100644 index 0000000000000000000000000000000000000000..2bc8c932231a67adcdbb1694046f3417cca03a8a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_windows_security_context_options.py @@ -0,0 +1,206 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1WindowsSecurityContextOptions(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'gmsa_credential_spec': 'str', + 'gmsa_credential_spec_name': 'str', + 'host_process': 'bool', + 'run_as_user_name': 'str' + } + + attribute_map = { + 'gmsa_credential_spec': 'gmsaCredentialSpec', + 'gmsa_credential_spec_name': 'gmsaCredentialSpecName', + 'host_process': 'hostProcess', + 'run_as_user_name': 'runAsUserName' + } + + def __init__(self, gmsa_credential_spec=None, gmsa_credential_spec_name=None, host_process=None, run_as_user_name=None, local_vars_configuration=None): # noqa: E501 + """V1WindowsSecurityContextOptions - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._gmsa_credential_spec = None + self._gmsa_credential_spec_name = None + self._host_process = None + self._run_as_user_name = None + self.discriminator = None + + if gmsa_credential_spec is not None: + self.gmsa_credential_spec = gmsa_credential_spec + if gmsa_credential_spec_name is not None: + self.gmsa_credential_spec_name = gmsa_credential_spec_name + if host_process is not None: + self.host_process = host_process + if run_as_user_name is not None: + self.run_as_user_name = run_as_user_name + + @property + def gmsa_credential_spec(self): + """Gets the gmsa_credential_spec of this V1WindowsSecurityContextOptions. # noqa: E501 + + GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. # noqa: E501 + + :return: The gmsa_credential_spec of this V1WindowsSecurityContextOptions. # noqa: E501 + :rtype: str + """ + return self._gmsa_credential_spec + + @gmsa_credential_spec.setter + def gmsa_credential_spec(self, gmsa_credential_spec): + """Sets the gmsa_credential_spec of this V1WindowsSecurityContextOptions. + + GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. # noqa: E501 + + :param gmsa_credential_spec: The gmsa_credential_spec of this V1WindowsSecurityContextOptions. # noqa: E501 + :type: str + """ + + self._gmsa_credential_spec = gmsa_credential_spec + + @property + def gmsa_credential_spec_name(self): + """Gets the gmsa_credential_spec_name of this V1WindowsSecurityContextOptions. # noqa: E501 + + GMSACredentialSpecName is the name of the GMSA credential spec to use. # noqa: E501 + + :return: The gmsa_credential_spec_name of this V1WindowsSecurityContextOptions. # noqa: E501 + :rtype: str + """ + return self._gmsa_credential_spec_name + + @gmsa_credential_spec_name.setter + def gmsa_credential_spec_name(self, gmsa_credential_spec_name): + """Sets the gmsa_credential_spec_name of this V1WindowsSecurityContextOptions. + + GMSACredentialSpecName is the name of the GMSA credential spec to use. # noqa: E501 + + :param gmsa_credential_spec_name: The gmsa_credential_spec_name of this V1WindowsSecurityContextOptions. # noqa: E501 + :type: str + """ + + self._gmsa_credential_spec_name = gmsa_credential_spec_name + + @property + def host_process(self): + """Gets the host_process of this V1WindowsSecurityContextOptions. # noqa: E501 + + HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. # noqa: E501 + + :return: The host_process of this V1WindowsSecurityContextOptions. # noqa: E501 + :rtype: bool + """ + return self._host_process + + @host_process.setter + def host_process(self, host_process): + """Sets the host_process of this V1WindowsSecurityContextOptions. + + HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. # noqa: E501 + + :param host_process: The host_process of this V1WindowsSecurityContextOptions. # noqa: E501 + :type: bool + """ + + self._host_process = host_process + + @property + def run_as_user_name(self): + """Gets the run_as_user_name of this V1WindowsSecurityContextOptions. # noqa: E501 + + The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. # noqa: E501 + + :return: The run_as_user_name of this V1WindowsSecurityContextOptions. # noqa: E501 + :rtype: str + """ + return self._run_as_user_name + + @run_as_user_name.setter + def run_as_user_name(self, run_as_user_name): + """Sets the run_as_user_name of this V1WindowsSecurityContextOptions. + + The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. # noqa: E501 + + :param run_as_user_name: The run_as_user_name of this V1WindowsSecurityContextOptions. # noqa: E501 + :type: str + """ + + self._run_as_user_name = run_as_user_name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1WindowsSecurityContextOptions): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1WindowsSecurityContextOptions): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_workload_reference.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_workload_reference.py new file mode 100644 index 0000000000000000000000000000000000000000..e3015a0a090fa52543310ddd64800b5a9219da0e --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v1_workload_reference.py @@ -0,0 +1,180 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V1WorkloadReference(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'name': 'str', + 'pod_group': 'str', + 'pod_group_replica_key': 'str' + } + + attribute_map = { + 'name': 'name', + 'pod_group': 'podGroup', + 'pod_group_replica_key': 'podGroupReplicaKey' + } + + def __init__(self, name=None, pod_group=None, pod_group_replica_key=None, local_vars_configuration=None): # noqa: E501 + """V1WorkloadReference - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._name = None + self._pod_group = None + self._pod_group_replica_key = None + self.discriminator = None + + self.name = name + self.pod_group = pod_group + if pod_group_replica_key is not None: + self.pod_group_replica_key = pod_group_replica_key + + @property + def name(self): + """Gets the name of this V1WorkloadReference. # noqa: E501 + + Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain. # noqa: E501 + + :return: The name of this V1WorkloadReference. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V1WorkloadReference. + + Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain. # noqa: E501 + + :param name: The name of this V1WorkloadReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def pod_group(self): + """Gets the pod_group of this V1WorkloadReference. # noqa: E501 + + PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label. # noqa: E501 + + :return: The pod_group of this V1WorkloadReference. # noqa: E501 + :rtype: str + """ + return self._pod_group + + @pod_group.setter + def pod_group(self, pod_group): + """Sets the pod_group of this V1WorkloadReference. + + PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label. # noqa: E501 + + :param pod_group: The pod_group of this V1WorkloadReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and pod_group is None: # noqa: E501 + raise ValueError("Invalid value for `pod_group`, must not be `None`") # noqa: E501 + + self._pod_group = pod_group + + @property + def pod_group_replica_key(self): + """Gets the pod_group_replica_key of this V1WorkloadReference. # noqa: E501 + + PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label. # noqa: E501 + + :return: The pod_group_replica_key of this V1WorkloadReference. # noqa: E501 + :rtype: str + """ + return self._pod_group_replica_key + + @pod_group_replica_key.setter + def pod_group_replica_key(self, pod_group_replica_key): + """Sets the pod_group_replica_key of this V1WorkloadReference. + + PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label. # noqa: E501 + + :param pod_group_replica_key: The pod_group_replica_key of this V1WorkloadReference. # noqa: E501 + :type: str + """ + + self._pod_group_replica_key = pod_group_replica_key + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1WorkloadReference): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V1WorkloadReference): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_source.py new file mode 100644 index 0000000000000000000000000000000000000000..16c026e340bf4b2a332d5b0063b6251a8cb49016 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_source.py @@ -0,0 +1,179 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ContainerResourceMetricSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'container': 'str', + 'name': 'str', + 'target': 'V2MetricTarget' + } + + attribute_map = { + 'container': 'container', + 'name': 'name', + 'target': 'target' + } + + def __init__(self, container=None, name=None, target=None, local_vars_configuration=None): # noqa: E501 + """V2ContainerResourceMetricSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._container = None + self._name = None + self._target = None + self.discriminator = None + + self.container = container + self.name = name + self.target = target + + @property + def container(self): + """Gets the container of this V2ContainerResourceMetricSource. # noqa: E501 + + container is the name of the container in the pods of the scaling target # noqa: E501 + + :return: The container of this V2ContainerResourceMetricSource. # noqa: E501 + :rtype: str + """ + return self._container + + @container.setter + def container(self, container): + """Sets the container of this V2ContainerResourceMetricSource. + + container is the name of the container in the pods of the scaling target # noqa: E501 + + :param container: The container of this V2ContainerResourceMetricSource. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and container is None: # noqa: E501 + raise ValueError("Invalid value for `container`, must not be `None`") # noqa: E501 + + self._container = container + + @property + def name(self): + """Gets the name of this V2ContainerResourceMetricSource. # noqa: E501 + + name is the name of the resource in question. # noqa: E501 + + :return: The name of this V2ContainerResourceMetricSource. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2ContainerResourceMetricSource. + + name is the name of the resource in question. # noqa: E501 + + :param name: The name of this V2ContainerResourceMetricSource. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def target(self): + """Gets the target of this V2ContainerResourceMetricSource. # noqa: E501 + + + :return: The target of this V2ContainerResourceMetricSource. # noqa: E501 + :rtype: V2MetricTarget + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this V2ContainerResourceMetricSource. + + + :param target: The target of this V2ContainerResourceMetricSource. # noqa: E501 + :type: V2MetricTarget + """ + if self.local_vars_configuration.client_side_validation and target is None: # noqa: E501 + raise ValueError("Invalid value for `target`, must not be `None`") # noqa: E501 + + self._target = target + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ContainerResourceMetricSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ContainerResourceMetricSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..6ec03dcc54ad10895ab9faab93bdfb45a0118d66 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_container_resource_metric_status.py @@ -0,0 +1,179 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ContainerResourceMetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'container': 'str', + 'current': 'V2MetricValueStatus', + 'name': 'str' + } + + attribute_map = { + 'container': 'container', + 'current': 'current', + 'name': 'name' + } + + def __init__(self, container=None, current=None, name=None, local_vars_configuration=None): # noqa: E501 + """V2ContainerResourceMetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._container = None + self._current = None + self._name = None + self.discriminator = None + + self.container = container + self.current = current + self.name = name + + @property + def container(self): + """Gets the container of this V2ContainerResourceMetricStatus. # noqa: E501 + + container is the name of the container in the pods of the scaling target # noqa: E501 + + :return: The container of this V2ContainerResourceMetricStatus. # noqa: E501 + :rtype: str + """ + return self._container + + @container.setter + def container(self, container): + """Sets the container of this V2ContainerResourceMetricStatus. + + container is the name of the container in the pods of the scaling target # noqa: E501 + + :param container: The container of this V2ContainerResourceMetricStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and container is None: # noqa: E501 + raise ValueError("Invalid value for `container`, must not be `None`") # noqa: E501 + + self._container = container + + @property + def current(self): + """Gets the current of this V2ContainerResourceMetricStatus. # noqa: E501 + + + :return: The current of this V2ContainerResourceMetricStatus. # noqa: E501 + :rtype: V2MetricValueStatus + """ + return self._current + + @current.setter + def current(self, current): + """Sets the current of this V2ContainerResourceMetricStatus. + + + :param current: The current of this V2ContainerResourceMetricStatus. # noqa: E501 + :type: V2MetricValueStatus + """ + if self.local_vars_configuration.client_side_validation and current is None: # noqa: E501 + raise ValueError("Invalid value for `current`, must not be `None`") # noqa: E501 + + self._current = current + + @property + def name(self): + """Gets the name of this V2ContainerResourceMetricStatus. # noqa: E501 + + name is the name of the resource in question. # noqa: E501 + + :return: The name of this V2ContainerResourceMetricStatus. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2ContainerResourceMetricStatus. + + name is the name of the resource in question. # noqa: E501 + + :param name: The name of this V2ContainerResourceMetricStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ContainerResourceMetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ContainerResourceMetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_cross_version_object_reference.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_cross_version_object_reference.py new file mode 100644 index 0000000000000000000000000000000000000000..84ee8043fa57550c67c2e8d85202fc733f594f48 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_cross_version_object_reference.py @@ -0,0 +1,180 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2CrossVersionObjectReference(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'name': 'str' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'name': 'name' + } + + def __init__(self, api_version=None, kind=None, name=None, local_vars_configuration=None): # noqa: E501 + """V2CrossVersionObjectReference - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._name = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.kind = kind + self.name = name + + @property + def api_version(self): + """Gets the api_version of this V2CrossVersionObjectReference. # noqa: E501 + + apiVersion is the API version of the referent # noqa: E501 + + :return: The api_version of this V2CrossVersionObjectReference. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V2CrossVersionObjectReference. + + apiVersion is the API version of the referent # noqa: E501 + + :param api_version: The api_version of this V2CrossVersionObjectReference. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V2CrossVersionObjectReference. # noqa: E501 + + kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V2CrossVersionObjectReference. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V2CrossVersionObjectReference. + + kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V2CrossVersionObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and kind is None: # noqa: E501 + raise ValueError("Invalid value for `kind`, must not be `None`") # noqa: E501 + + self._kind = kind + + @property + def name(self): + """Gets the name of this V2CrossVersionObjectReference. # noqa: E501 + + name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names # noqa: E501 + + :return: The name of this V2CrossVersionObjectReference. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2CrossVersionObjectReference. + + name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names # noqa: E501 + + :param name: The name of this V2CrossVersionObjectReference. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2CrossVersionObjectReference): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2CrossVersionObjectReference): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_source.py new file mode 100644 index 0000000000000000000000000000000000000000..eafb9ce0c31df42d886bc6b6087022bc43c5ea87 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_source.py @@ -0,0 +1,148 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ExternalMetricSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'metric': 'V2MetricIdentifier', + 'target': 'V2MetricTarget' + } + + attribute_map = { + 'metric': 'metric', + 'target': 'target' + } + + def __init__(self, metric=None, target=None, local_vars_configuration=None): # noqa: E501 + """V2ExternalMetricSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._metric = None + self._target = None + self.discriminator = None + + self.metric = metric + self.target = target + + @property + def metric(self): + """Gets the metric of this V2ExternalMetricSource. # noqa: E501 + + + :return: The metric of this V2ExternalMetricSource. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2ExternalMetricSource. + + + :param metric: The metric of this V2ExternalMetricSource. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + @property + def target(self): + """Gets the target of this V2ExternalMetricSource. # noqa: E501 + + + :return: The target of this V2ExternalMetricSource. # noqa: E501 + :rtype: V2MetricTarget + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this V2ExternalMetricSource. + + + :param target: The target of this V2ExternalMetricSource. # noqa: E501 + :type: V2MetricTarget + """ + if self.local_vars_configuration.client_side_validation and target is None: # noqa: E501 + raise ValueError("Invalid value for `target`, must not be `None`") # noqa: E501 + + self._target = target + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ExternalMetricSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ExternalMetricSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..4e3acc7d8bb55fbbf0e330d5f9d8eb0112cce54a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_external_metric_status.py @@ -0,0 +1,148 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ExternalMetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'current': 'V2MetricValueStatus', + 'metric': 'V2MetricIdentifier' + } + + attribute_map = { + 'current': 'current', + 'metric': 'metric' + } + + def __init__(self, current=None, metric=None, local_vars_configuration=None): # noqa: E501 + """V2ExternalMetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._current = None + self._metric = None + self.discriminator = None + + self.current = current + self.metric = metric + + @property + def current(self): + """Gets the current of this V2ExternalMetricStatus. # noqa: E501 + + + :return: The current of this V2ExternalMetricStatus. # noqa: E501 + :rtype: V2MetricValueStatus + """ + return self._current + + @current.setter + def current(self, current): + """Sets the current of this V2ExternalMetricStatus. + + + :param current: The current of this V2ExternalMetricStatus. # noqa: E501 + :type: V2MetricValueStatus + """ + if self.local_vars_configuration.client_side_validation and current is None: # noqa: E501 + raise ValueError("Invalid value for `current`, must not be `None`") # noqa: E501 + + self._current = current + + @property + def metric(self): + """Gets the metric of this V2ExternalMetricStatus. # noqa: E501 + + + :return: The metric of this V2ExternalMetricStatus. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2ExternalMetricStatus. + + + :param metric: The metric of this V2ExternalMetricStatus. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ExternalMetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ExternalMetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler.py new file mode 100644 index 0000000000000000000000000000000000000000..3104dcd226e31d8fa454ea8ba2b482dfbd8464a3 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler.py @@ -0,0 +1,228 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscaler(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'kind': 'str', + 'metadata': 'V1ObjectMeta', + 'spec': 'V2HorizontalPodAutoscalerSpec', + 'status': 'V2HorizontalPodAutoscalerStatus' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'kind': 'kind', + 'metadata': 'metadata', + 'spec': 'spec', + 'status': 'status' + } + + def __init__(self, api_version=None, kind=None, metadata=None, spec=None, status=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscaler - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._kind = None + self._metadata = None + self._spec = None + self._status = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + if spec is not None: + self.spec = spec + if status is not None: + self.status = status + + @property + def api_version(self): + """Gets the api_version of this V2HorizontalPodAutoscaler. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V2HorizontalPodAutoscaler. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V2HorizontalPodAutoscaler. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V2HorizontalPodAutoscaler. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def kind(self): + """Gets the kind of this V2HorizontalPodAutoscaler. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V2HorizontalPodAutoscaler. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V2HorizontalPodAutoscaler. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V2HorizontalPodAutoscaler. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V2HorizontalPodAutoscaler. # noqa: E501 + + + :return: The metadata of this V2HorizontalPodAutoscaler. # noqa: E501 + :rtype: V1ObjectMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V2HorizontalPodAutoscaler. + + + :param metadata: The metadata of this V2HorizontalPodAutoscaler. # noqa: E501 + :type: V1ObjectMeta + """ + + self._metadata = metadata + + @property + def spec(self): + """Gets the spec of this V2HorizontalPodAutoscaler. # noqa: E501 + + + :return: The spec of this V2HorizontalPodAutoscaler. # noqa: E501 + :rtype: V2HorizontalPodAutoscalerSpec + """ + return self._spec + + @spec.setter + def spec(self, spec): + """Sets the spec of this V2HorizontalPodAutoscaler. + + + :param spec: The spec of this V2HorizontalPodAutoscaler. # noqa: E501 + :type: V2HorizontalPodAutoscalerSpec + """ + + self._spec = spec + + @property + def status(self): + """Gets the status of this V2HorizontalPodAutoscaler. # noqa: E501 + + + :return: The status of this V2HorizontalPodAutoscaler. # noqa: E501 + :rtype: V2HorizontalPodAutoscalerStatus + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this V2HorizontalPodAutoscaler. + + + :param status: The status of this V2HorizontalPodAutoscaler. # noqa: E501 + :type: V2HorizontalPodAutoscalerStatus + """ + + self._status = status + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscaler): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscaler): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_behavior.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_behavior.py new file mode 100644 index 0000000000000000000000000000000000000000..768d62d41014d046793989ad691354fc2ab53cac --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_behavior.py @@ -0,0 +1,146 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscalerBehavior(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'scale_down': 'V2HPAScalingRules', + 'scale_up': 'V2HPAScalingRules' + } + + attribute_map = { + 'scale_down': 'scaleDown', + 'scale_up': 'scaleUp' + } + + def __init__(self, scale_down=None, scale_up=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscalerBehavior - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._scale_down = None + self._scale_up = None + self.discriminator = None + + if scale_down is not None: + self.scale_down = scale_down + if scale_up is not None: + self.scale_up = scale_up + + @property + def scale_down(self): + """Gets the scale_down of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + + + :return: The scale_down of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + :rtype: V2HPAScalingRules + """ + return self._scale_down + + @scale_down.setter + def scale_down(self, scale_down): + """Sets the scale_down of this V2HorizontalPodAutoscalerBehavior. + + + :param scale_down: The scale_down of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + :type: V2HPAScalingRules + """ + + self._scale_down = scale_down + + @property + def scale_up(self): + """Gets the scale_up of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + + + :return: The scale_up of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + :rtype: V2HPAScalingRules + """ + return self._scale_up + + @scale_up.setter + def scale_up(self, scale_up): + """Sets the scale_up of this V2HorizontalPodAutoscalerBehavior. + + + :param scale_up: The scale_up of this V2HorizontalPodAutoscalerBehavior. # noqa: E501 + :type: V2HPAScalingRules + """ + + self._scale_up = scale_up + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscalerBehavior): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscalerBehavior): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_condition.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_condition.py new file mode 100644 index 0000000000000000000000000000000000000000..16b02b22dc3a7b1217c747d4e7ad375e31d64491 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_condition.py @@ -0,0 +1,236 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscalerCondition(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'last_transition_time': 'datetime', + 'message': 'str', + 'reason': 'str', + 'status': 'str', + 'type': 'str' + } + + attribute_map = { + 'last_transition_time': 'lastTransitionTime', + 'message': 'message', + 'reason': 'reason', + 'status': 'status', + 'type': 'type' + } + + def __init__(self, last_transition_time=None, message=None, reason=None, status=None, type=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscalerCondition - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._last_transition_time = None + self._message = None + self._reason = None + self._status = None + self._type = None + self.discriminator = None + + if last_transition_time is not None: + self.last_transition_time = last_transition_time + if message is not None: + self.message = message + if reason is not None: + self.reason = reason + self.status = status + self.type = type + + @property + def last_transition_time(self): + """Gets the last_transition_time of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + + lastTransitionTime is the last time the condition transitioned from one status to another # noqa: E501 + + :return: The last_transition_time of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :rtype: datetime + """ + return self._last_transition_time + + @last_transition_time.setter + def last_transition_time(self, last_transition_time): + """Sets the last_transition_time of this V2HorizontalPodAutoscalerCondition. + + lastTransitionTime is the last time the condition transitioned from one status to another # noqa: E501 + + :param last_transition_time: The last_transition_time of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :type: datetime + """ + + self._last_transition_time = last_transition_time + + @property + def message(self): + """Gets the message of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + + message is a human-readable explanation containing details about the transition # noqa: E501 + + :return: The message of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this V2HorizontalPodAutoscalerCondition. + + message is a human-readable explanation containing details about the transition # noqa: E501 + + :param message: The message of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :type: str + """ + + self._message = message + + @property + def reason(self): + """Gets the reason of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + + reason is the reason for the condition's last transition. # noqa: E501 + + :return: The reason of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :rtype: str + """ + return self._reason + + @reason.setter + def reason(self, reason): + """Sets the reason of this V2HorizontalPodAutoscalerCondition. + + reason is the reason for the condition's last transition. # noqa: E501 + + :param reason: The reason of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :type: str + """ + + self._reason = reason + + @property + def status(self): + """Gets the status of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + + status is the status of the condition (True, False, Unknown) # noqa: E501 + + :return: The status of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :rtype: str + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this V2HorizontalPodAutoscalerCondition. + + status is the status of the condition (True, False, Unknown) # noqa: E501 + + :param status: The status of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and status is None: # noqa: E501 + raise ValueError("Invalid value for `status`, must not be `None`") # noqa: E501 + + self._status = status + + @property + def type(self): + """Gets the type of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + + type describes the current condition # noqa: E501 + + :return: The type of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V2HorizontalPodAutoscalerCondition. + + type describes the current condition # noqa: E501 + + :param type: The type of this V2HorizontalPodAutoscalerCondition. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscalerCondition): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscalerCondition): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_list.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_list.py new file mode 100644 index 0000000000000000000000000000000000000000..c0c13051cd9e2ff52bf348aacc3f823abadb3c9d --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_list.py @@ -0,0 +1,205 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscalerList(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'api_version': 'str', + 'items': 'list[V2HorizontalPodAutoscaler]', + 'kind': 'str', + 'metadata': 'V1ListMeta' + } + + attribute_map = { + 'api_version': 'apiVersion', + 'items': 'items', + 'kind': 'kind', + 'metadata': 'metadata' + } + + def __init__(self, api_version=None, items=None, kind=None, metadata=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscalerList - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._api_version = None + self._items = None + self._kind = None + self._metadata = None + self.discriminator = None + + if api_version is not None: + self.api_version = api_version + self.items = items + if kind is not None: + self.kind = kind + if metadata is not None: + self.metadata = metadata + + @property + def api_version(self): + """Gets the api_version of this V2HorizontalPodAutoscalerList. # noqa: E501 + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :return: The api_version of this V2HorizontalPodAutoscalerList. # noqa: E501 + :rtype: str + """ + return self._api_version + + @api_version.setter + def api_version(self, api_version): + """Sets the api_version of this V2HorizontalPodAutoscalerList. + + APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources # noqa: E501 + + :param api_version: The api_version of this V2HorizontalPodAutoscalerList. # noqa: E501 + :type: str + """ + + self._api_version = api_version + + @property + def items(self): + """Gets the items of this V2HorizontalPodAutoscalerList. # noqa: E501 + + items is the list of horizontal pod autoscaler objects. # noqa: E501 + + :return: The items of this V2HorizontalPodAutoscalerList. # noqa: E501 + :rtype: list[V2HorizontalPodAutoscaler] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this V2HorizontalPodAutoscalerList. + + items is the list of horizontal pod autoscaler objects. # noqa: E501 + + :param items: The items of this V2HorizontalPodAutoscalerList. # noqa: E501 + :type: list[V2HorizontalPodAutoscaler] + """ + if self.local_vars_configuration.client_side_validation and items is None: # noqa: E501 + raise ValueError("Invalid value for `items`, must not be `None`") # noqa: E501 + + self._items = items + + @property + def kind(self): + """Gets the kind of this V2HorizontalPodAutoscalerList. # noqa: E501 + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :return: The kind of this V2HorizontalPodAutoscalerList. # noqa: E501 + :rtype: str + """ + return self._kind + + @kind.setter + def kind(self, kind): + """Sets the kind of this V2HorizontalPodAutoscalerList. + + Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds # noqa: E501 + + :param kind: The kind of this V2HorizontalPodAutoscalerList. # noqa: E501 + :type: str + """ + + self._kind = kind + + @property + def metadata(self): + """Gets the metadata of this V2HorizontalPodAutoscalerList. # noqa: E501 + + + :return: The metadata of this V2HorizontalPodAutoscalerList. # noqa: E501 + :rtype: V1ListMeta + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this V2HorizontalPodAutoscalerList. + + + :param metadata: The metadata of this V2HorizontalPodAutoscalerList. # noqa: E501 + :type: V1ListMeta + """ + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscalerList): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscalerList): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..ce276634c4519a3c5a7fd71d35825231aec4ee50 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_spec.py @@ -0,0 +1,232 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscalerSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'behavior': 'V2HorizontalPodAutoscalerBehavior', + 'max_replicas': 'int', + 'metrics': 'list[V2MetricSpec]', + 'min_replicas': 'int', + 'scale_target_ref': 'V2CrossVersionObjectReference' + } + + attribute_map = { + 'behavior': 'behavior', + 'max_replicas': 'maxReplicas', + 'metrics': 'metrics', + 'min_replicas': 'minReplicas', + 'scale_target_ref': 'scaleTargetRef' + } + + def __init__(self, behavior=None, max_replicas=None, metrics=None, min_replicas=None, scale_target_ref=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscalerSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._behavior = None + self._max_replicas = None + self._metrics = None + self._min_replicas = None + self._scale_target_ref = None + self.discriminator = None + + if behavior is not None: + self.behavior = behavior + self.max_replicas = max_replicas + if metrics is not None: + self.metrics = metrics + if min_replicas is not None: + self.min_replicas = min_replicas + self.scale_target_ref = scale_target_ref + + @property + def behavior(self): + """Gets the behavior of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + + + :return: The behavior of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :rtype: V2HorizontalPodAutoscalerBehavior + """ + return self._behavior + + @behavior.setter + def behavior(self, behavior): + """Sets the behavior of this V2HorizontalPodAutoscalerSpec. + + + :param behavior: The behavior of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :type: V2HorizontalPodAutoscalerBehavior + """ + + self._behavior = behavior + + @property + def max_replicas(self): + """Gets the max_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + + maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. # noqa: E501 + + :return: The max_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :rtype: int + """ + return self._max_replicas + + @max_replicas.setter + def max_replicas(self, max_replicas): + """Sets the max_replicas of this V2HorizontalPodAutoscalerSpec. + + maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. # noqa: E501 + + :param max_replicas: The max_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and max_replicas is None: # noqa: E501 + raise ValueError("Invalid value for `max_replicas`, must not be `None`") # noqa: E501 + + self._max_replicas = max_replicas + + @property + def metrics(self): + """Gets the metrics of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + + metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization. # noqa: E501 + + :return: The metrics of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :rtype: list[V2MetricSpec] + """ + return self._metrics + + @metrics.setter + def metrics(self, metrics): + """Sets the metrics of this V2HorizontalPodAutoscalerSpec. + + metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization. # noqa: E501 + + :param metrics: The metrics of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :type: list[V2MetricSpec] + """ + + self._metrics = metrics + + @property + def min_replicas(self): + """Gets the min_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + + minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. # noqa: E501 + + :return: The min_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :rtype: int + """ + return self._min_replicas + + @min_replicas.setter + def min_replicas(self, min_replicas): + """Sets the min_replicas of this V2HorizontalPodAutoscalerSpec. + + minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. # noqa: E501 + + :param min_replicas: The min_replicas of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :type: int + """ + + self._min_replicas = min_replicas + + @property + def scale_target_ref(self): + """Gets the scale_target_ref of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + + + :return: The scale_target_ref of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :rtype: V2CrossVersionObjectReference + """ + return self._scale_target_ref + + @scale_target_ref.setter + def scale_target_ref(self, scale_target_ref): + """Sets the scale_target_ref of this V2HorizontalPodAutoscalerSpec. + + + :param scale_target_ref: The scale_target_ref of this V2HorizontalPodAutoscalerSpec. # noqa: E501 + :type: V2CrossVersionObjectReference + """ + if self.local_vars_configuration.client_side_validation and scale_target_ref is None: # noqa: E501 + raise ValueError("Invalid value for `scale_target_ref`, must not be `None`") # noqa: E501 + + self._scale_target_ref = scale_target_ref + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscalerSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscalerSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_status.py new file mode 100644 index 0000000000000000000000000000000000000000..4efabdec8e69915e55497a37d164d52f72ace17a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_horizontal_pod_autoscaler_status.py @@ -0,0 +1,263 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HorizontalPodAutoscalerStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'conditions': 'list[V2HorizontalPodAutoscalerCondition]', + 'current_metrics': 'list[V2MetricStatus]', + 'current_replicas': 'int', + 'desired_replicas': 'int', + 'last_scale_time': 'datetime', + 'observed_generation': 'int' + } + + attribute_map = { + 'conditions': 'conditions', + 'current_metrics': 'currentMetrics', + 'current_replicas': 'currentReplicas', + 'desired_replicas': 'desiredReplicas', + 'last_scale_time': 'lastScaleTime', + 'observed_generation': 'observedGeneration' + } + + def __init__(self, conditions=None, current_metrics=None, current_replicas=None, desired_replicas=None, last_scale_time=None, observed_generation=None, local_vars_configuration=None): # noqa: E501 + """V2HorizontalPodAutoscalerStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._conditions = None + self._current_metrics = None + self._current_replicas = None + self._desired_replicas = None + self._last_scale_time = None + self._observed_generation = None + self.discriminator = None + + if conditions is not None: + self.conditions = conditions + if current_metrics is not None: + self.current_metrics = current_metrics + if current_replicas is not None: + self.current_replicas = current_replicas + self.desired_replicas = desired_replicas + if last_scale_time is not None: + self.last_scale_time = last_scale_time + if observed_generation is not None: + self.observed_generation = observed_generation + + @property + def conditions(self): + """Gets the conditions of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. # noqa: E501 + + :return: The conditions of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: list[V2HorizontalPodAutoscalerCondition] + """ + return self._conditions + + @conditions.setter + def conditions(self, conditions): + """Sets the conditions of this V2HorizontalPodAutoscalerStatus. + + conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. # noqa: E501 + + :param conditions: The conditions of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: list[V2HorizontalPodAutoscalerCondition] + """ + + self._conditions = conditions + + @property + def current_metrics(self): + """Gets the current_metrics of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + currentMetrics is the last read state of the metrics used by this autoscaler. # noqa: E501 + + :return: The current_metrics of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: list[V2MetricStatus] + """ + return self._current_metrics + + @current_metrics.setter + def current_metrics(self, current_metrics): + """Sets the current_metrics of this V2HorizontalPodAutoscalerStatus. + + currentMetrics is the last read state of the metrics used by this autoscaler. # noqa: E501 + + :param current_metrics: The current_metrics of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: list[V2MetricStatus] + """ + + self._current_metrics = current_metrics + + @property + def current_replicas(self): + """Gets the current_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler. # noqa: E501 + + :return: The current_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: int + """ + return self._current_replicas + + @current_replicas.setter + def current_replicas(self, current_replicas): + """Sets the current_replicas of this V2HorizontalPodAutoscalerStatus. + + currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler. # noqa: E501 + + :param current_replicas: The current_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: int + """ + + self._current_replicas = current_replicas + + @property + def desired_replicas(self): + """Gets the desired_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler. # noqa: E501 + + :return: The desired_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: int + """ + return self._desired_replicas + + @desired_replicas.setter + def desired_replicas(self, desired_replicas): + """Sets the desired_replicas of this V2HorizontalPodAutoscalerStatus. + + desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler. # noqa: E501 + + :param desired_replicas: The desired_replicas of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and desired_replicas is None: # noqa: E501 + raise ValueError("Invalid value for `desired_replicas`, must not be `None`") # noqa: E501 + + self._desired_replicas = desired_replicas + + @property + def last_scale_time(self): + """Gets the last_scale_time of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, used by the autoscaler to control how often the number of pods is changed. # noqa: E501 + + :return: The last_scale_time of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: datetime + """ + return self._last_scale_time + + @last_scale_time.setter + def last_scale_time(self, last_scale_time): + """Sets the last_scale_time of this V2HorizontalPodAutoscalerStatus. + + lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, used by the autoscaler to control how often the number of pods is changed. # noqa: E501 + + :param last_scale_time: The last_scale_time of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: datetime + """ + + self._last_scale_time = last_scale_time + + @property + def observed_generation(self): + """Gets the observed_generation of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + + observedGeneration is the most recent generation observed by this autoscaler. # noqa: E501 + + :return: The observed_generation of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :rtype: int + """ + return self._observed_generation + + @observed_generation.setter + def observed_generation(self, observed_generation): + """Sets the observed_generation of this V2HorizontalPodAutoscalerStatus. + + observedGeneration is the most recent generation observed by this autoscaler. # noqa: E501 + + :param observed_generation: The observed_generation of this V2HorizontalPodAutoscalerStatus. # noqa: E501 + :type: int + """ + + self._observed_generation = observed_generation + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HorizontalPodAutoscalerStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HorizontalPodAutoscalerStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_policy.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..d8eae5e41a88a20882b576a56e8f55b2e309a187 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_policy.py @@ -0,0 +1,181 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HPAScalingPolicy(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'period_seconds': 'int', + 'type': 'str', + 'value': 'int' + } + + attribute_map = { + 'period_seconds': 'periodSeconds', + 'type': 'type', + 'value': 'value' + } + + def __init__(self, period_seconds=None, type=None, value=None, local_vars_configuration=None): # noqa: E501 + """V2HPAScalingPolicy - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._period_seconds = None + self._type = None + self._value = None + self.discriminator = None + + self.period_seconds = period_seconds + self.type = type + self.value = value + + @property + def period_seconds(self): + """Gets the period_seconds of this V2HPAScalingPolicy. # noqa: E501 + + periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). # noqa: E501 + + :return: The period_seconds of this V2HPAScalingPolicy. # noqa: E501 + :rtype: int + """ + return self._period_seconds + + @period_seconds.setter + def period_seconds(self, period_seconds): + """Sets the period_seconds of this V2HPAScalingPolicy. + + periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). # noqa: E501 + + :param period_seconds: The period_seconds of this V2HPAScalingPolicy. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and period_seconds is None: # noqa: E501 + raise ValueError("Invalid value for `period_seconds`, must not be `None`") # noqa: E501 + + self._period_seconds = period_seconds + + @property + def type(self): + """Gets the type of this V2HPAScalingPolicy. # noqa: E501 + + type is used to specify the scaling policy. # noqa: E501 + + :return: The type of this V2HPAScalingPolicy. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V2HPAScalingPolicy. + + type is used to specify the scaling policy. # noqa: E501 + + :param type: The type of this V2HPAScalingPolicy. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + @property + def value(self): + """Gets the value of this V2HPAScalingPolicy. # noqa: E501 + + value contains the amount of change which is permitted by the policy. It must be greater than zero # noqa: E501 + + :return: The value of this V2HPAScalingPolicy. # noqa: E501 + :rtype: int + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V2HPAScalingPolicy. + + value contains the amount of change which is permitted by the policy. It must be greater than zero # noqa: E501 + + :param value: The value of this V2HPAScalingPolicy. # noqa: E501 + :type: int + """ + if self.local_vars_configuration.client_side_validation and value is None: # noqa: E501 + raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501 + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HPAScalingPolicy): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HPAScalingPolicy): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_rules.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_rules.py new file mode 100644 index 0000000000000000000000000000000000000000..e49b51e607e6be96c31b67ef4bea8804b6f2fd46 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_hpa_scaling_rules.py @@ -0,0 +1,206 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2HPAScalingRules(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'policies': 'list[V2HPAScalingPolicy]', + 'select_policy': 'str', + 'stabilization_window_seconds': 'int', + 'tolerance': 'str' + } + + attribute_map = { + 'policies': 'policies', + 'select_policy': 'selectPolicy', + 'stabilization_window_seconds': 'stabilizationWindowSeconds', + 'tolerance': 'tolerance' + } + + def __init__(self, policies=None, select_policy=None, stabilization_window_seconds=None, tolerance=None, local_vars_configuration=None): # noqa: E501 + """V2HPAScalingRules - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._policies = None + self._select_policy = None + self._stabilization_window_seconds = None + self._tolerance = None + self.discriminator = None + + if policies is not None: + self.policies = policies + if select_policy is not None: + self.select_policy = select_policy + if stabilization_window_seconds is not None: + self.stabilization_window_seconds = stabilization_window_seconds + if tolerance is not None: + self.tolerance = tolerance + + @property + def policies(self): + """Gets the policies of this V2HPAScalingRules. # noqa: E501 + + policies is a list of potential scaling polices which can be used during scaling. If not set, use the default values: - For scale up: allow doubling the number of pods, or an absolute change of 4 pods in a 15s window. - For scale down: allow all pods to be removed in a 15s window. # noqa: E501 + + :return: The policies of this V2HPAScalingRules. # noqa: E501 + :rtype: list[V2HPAScalingPolicy] + """ + return self._policies + + @policies.setter + def policies(self, policies): + """Sets the policies of this V2HPAScalingRules. + + policies is a list of potential scaling polices which can be used during scaling. If not set, use the default values: - For scale up: allow doubling the number of pods, or an absolute change of 4 pods in a 15s window. - For scale down: allow all pods to be removed in a 15s window. # noqa: E501 + + :param policies: The policies of this V2HPAScalingRules. # noqa: E501 + :type: list[V2HPAScalingPolicy] + """ + + self._policies = policies + + @property + def select_policy(self): + """Gets the select_policy of this V2HPAScalingRules. # noqa: E501 + + selectPolicy is used to specify which policy should be used. If not set, the default value Max is used. # noqa: E501 + + :return: The select_policy of this V2HPAScalingRules. # noqa: E501 + :rtype: str + """ + return self._select_policy + + @select_policy.setter + def select_policy(self, select_policy): + """Sets the select_policy of this V2HPAScalingRules. + + selectPolicy is used to specify which policy should be used. If not set, the default value Max is used. # noqa: E501 + + :param select_policy: The select_policy of this V2HPAScalingRules. # noqa: E501 + :type: str + """ + + self._select_policy = select_policy + + @property + def stabilization_window_seconds(self): + """Gets the stabilization_window_seconds of this V2HPAScalingRules. # noqa: E501 + + stabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long). # noqa: E501 + + :return: The stabilization_window_seconds of this V2HPAScalingRules. # noqa: E501 + :rtype: int + """ + return self._stabilization_window_seconds + + @stabilization_window_seconds.setter + def stabilization_window_seconds(self, stabilization_window_seconds): + """Sets the stabilization_window_seconds of this V2HPAScalingRules. + + stabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long). # noqa: E501 + + :param stabilization_window_seconds: The stabilization_window_seconds of this V2HPAScalingRules. # noqa: E501 + :type: int + """ + + self._stabilization_window_seconds = stabilization_window_seconds + + @property + def tolerance(self): + """Gets the tolerance of this V2HPAScalingRules. # noqa: E501 + + tolerance is the tolerance on the ratio between the current and desired metric value under which no updates are made to the desired number of replicas (e.g. 0.01 for 1%). Must be greater than or equal to zero. If not set, the default cluster-wide tolerance is applied (by default 10%). For example, if autoscaling is configured with a memory consumption target of 100Mi, and scale-down and scale-up tolerances of 5% and 1% respectively, scaling will be triggered when the actual consumption falls below 95Mi or exceeds 101Mi. This is an beta field and requires the HPAConfigurableTolerance feature gate to be enabled. # noqa: E501 + + :return: The tolerance of this V2HPAScalingRules. # noqa: E501 + :rtype: str + """ + return self._tolerance + + @tolerance.setter + def tolerance(self, tolerance): + """Sets the tolerance of this V2HPAScalingRules. + + tolerance is the tolerance on the ratio between the current and desired metric value under which no updates are made to the desired number of replicas (e.g. 0.01 for 1%). Must be greater than or equal to zero. If not set, the default cluster-wide tolerance is applied (by default 10%). For example, if autoscaling is configured with a memory consumption target of 100Mi, and scale-down and scale-up tolerances of 5% and 1% respectively, scaling will be triggered when the actual consumption falls below 95Mi or exceeds 101Mi. This is an beta field and requires the HPAConfigurableTolerance feature gate to be enabled. # noqa: E501 + + :param tolerance: The tolerance of this V2HPAScalingRules. # noqa: E501 + :type: str + """ + + self._tolerance = tolerance + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2HPAScalingRules): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2HPAScalingRules): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_identifier.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_identifier.py new file mode 100644 index 0000000000000000000000000000000000000000..c76ceabea5f33c49759f7e30e763a80a46e0ff8e --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_identifier.py @@ -0,0 +1,149 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2MetricIdentifier(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'name': 'str', + 'selector': 'V1LabelSelector' + } + + attribute_map = { + 'name': 'name', + 'selector': 'selector' + } + + def __init__(self, name=None, selector=None, local_vars_configuration=None): # noqa: E501 + """V2MetricIdentifier - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._name = None + self._selector = None + self.discriminator = None + + self.name = name + if selector is not None: + self.selector = selector + + @property + def name(self): + """Gets the name of this V2MetricIdentifier. # noqa: E501 + + name is the name of the given metric # noqa: E501 + + :return: The name of this V2MetricIdentifier. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2MetricIdentifier. + + name is the name of the given metric # noqa: E501 + + :param name: The name of this V2MetricIdentifier. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def selector(self): + """Gets the selector of this V2MetricIdentifier. # noqa: E501 + + + :return: The selector of this V2MetricIdentifier. # noqa: E501 + :rtype: V1LabelSelector + """ + return self._selector + + @selector.setter + def selector(self, selector): + """Sets the selector of this V2MetricIdentifier. + + + :param selector: The selector of this V2MetricIdentifier. # noqa: E501 + :type: V1LabelSelector + """ + + self._selector = selector + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2MetricIdentifier): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2MetricIdentifier): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_spec.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..cc13fd64e22d5c04c4d0b8aeb55a8f48a4216c2c --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_spec.py @@ -0,0 +1,253 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2MetricSpec(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'container_resource': 'V2ContainerResourceMetricSource', + 'external': 'V2ExternalMetricSource', + 'object': 'V2ObjectMetricSource', + 'pods': 'V2PodsMetricSource', + 'resource': 'V2ResourceMetricSource', + 'type': 'str' + } + + attribute_map = { + 'container_resource': 'containerResource', + 'external': 'external', + 'object': 'object', + 'pods': 'pods', + 'resource': 'resource', + 'type': 'type' + } + + def __init__(self, container_resource=None, external=None, object=None, pods=None, resource=None, type=None, local_vars_configuration=None): # noqa: E501 + """V2MetricSpec - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._container_resource = None + self._external = None + self._object = None + self._pods = None + self._resource = None + self._type = None + self.discriminator = None + + if container_resource is not None: + self.container_resource = container_resource + if external is not None: + self.external = external + if object is not None: + self.object = object + if pods is not None: + self.pods = pods + if resource is not None: + self.resource = resource + self.type = type + + @property + def container_resource(self): + """Gets the container_resource of this V2MetricSpec. # noqa: E501 + + + :return: The container_resource of this V2MetricSpec. # noqa: E501 + :rtype: V2ContainerResourceMetricSource + """ + return self._container_resource + + @container_resource.setter + def container_resource(self, container_resource): + """Sets the container_resource of this V2MetricSpec. + + + :param container_resource: The container_resource of this V2MetricSpec. # noqa: E501 + :type: V2ContainerResourceMetricSource + """ + + self._container_resource = container_resource + + @property + def external(self): + """Gets the external of this V2MetricSpec. # noqa: E501 + + + :return: The external of this V2MetricSpec. # noqa: E501 + :rtype: V2ExternalMetricSource + """ + return self._external + + @external.setter + def external(self, external): + """Sets the external of this V2MetricSpec. + + + :param external: The external of this V2MetricSpec. # noqa: E501 + :type: V2ExternalMetricSource + """ + + self._external = external + + @property + def object(self): + """Gets the object of this V2MetricSpec. # noqa: E501 + + + :return: The object of this V2MetricSpec. # noqa: E501 + :rtype: V2ObjectMetricSource + """ + return self._object + + @object.setter + def object(self, object): + """Sets the object of this V2MetricSpec. + + + :param object: The object of this V2MetricSpec. # noqa: E501 + :type: V2ObjectMetricSource + """ + + self._object = object + + @property + def pods(self): + """Gets the pods of this V2MetricSpec. # noqa: E501 + + + :return: The pods of this V2MetricSpec. # noqa: E501 + :rtype: V2PodsMetricSource + """ + return self._pods + + @pods.setter + def pods(self, pods): + """Sets the pods of this V2MetricSpec. + + + :param pods: The pods of this V2MetricSpec. # noqa: E501 + :type: V2PodsMetricSource + """ + + self._pods = pods + + @property + def resource(self): + """Gets the resource of this V2MetricSpec. # noqa: E501 + + + :return: The resource of this V2MetricSpec. # noqa: E501 + :rtype: V2ResourceMetricSource + """ + return self._resource + + @resource.setter + def resource(self, resource): + """Sets the resource of this V2MetricSpec. + + + :param resource: The resource of this V2MetricSpec. # noqa: E501 + :type: V2ResourceMetricSource + """ + + self._resource = resource + + @property + def type(self): + """Gets the type of this V2MetricSpec. # noqa: E501 + + type is the type of metric source. It should be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. # noqa: E501 + + :return: The type of this V2MetricSpec. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V2MetricSpec. + + type is the type of metric source. It should be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. # noqa: E501 + + :param type: The type of this V2MetricSpec. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2MetricSpec): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2MetricSpec): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..019dc10098b0058447c1bc2f841c4e924e433b6d --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_status.py @@ -0,0 +1,253 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2MetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'container_resource': 'V2ContainerResourceMetricStatus', + 'external': 'V2ExternalMetricStatus', + 'object': 'V2ObjectMetricStatus', + 'pods': 'V2PodsMetricStatus', + 'resource': 'V2ResourceMetricStatus', + 'type': 'str' + } + + attribute_map = { + 'container_resource': 'containerResource', + 'external': 'external', + 'object': 'object', + 'pods': 'pods', + 'resource': 'resource', + 'type': 'type' + } + + def __init__(self, container_resource=None, external=None, object=None, pods=None, resource=None, type=None, local_vars_configuration=None): # noqa: E501 + """V2MetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._container_resource = None + self._external = None + self._object = None + self._pods = None + self._resource = None + self._type = None + self.discriminator = None + + if container_resource is not None: + self.container_resource = container_resource + if external is not None: + self.external = external + if object is not None: + self.object = object + if pods is not None: + self.pods = pods + if resource is not None: + self.resource = resource + self.type = type + + @property + def container_resource(self): + """Gets the container_resource of this V2MetricStatus. # noqa: E501 + + + :return: The container_resource of this V2MetricStatus. # noqa: E501 + :rtype: V2ContainerResourceMetricStatus + """ + return self._container_resource + + @container_resource.setter + def container_resource(self, container_resource): + """Sets the container_resource of this V2MetricStatus. + + + :param container_resource: The container_resource of this V2MetricStatus. # noqa: E501 + :type: V2ContainerResourceMetricStatus + """ + + self._container_resource = container_resource + + @property + def external(self): + """Gets the external of this V2MetricStatus. # noqa: E501 + + + :return: The external of this V2MetricStatus. # noqa: E501 + :rtype: V2ExternalMetricStatus + """ + return self._external + + @external.setter + def external(self, external): + """Sets the external of this V2MetricStatus. + + + :param external: The external of this V2MetricStatus. # noqa: E501 + :type: V2ExternalMetricStatus + """ + + self._external = external + + @property + def object(self): + """Gets the object of this V2MetricStatus. # noqa: E501 + + + :return: The object of this V2MetricStatus. # noqa: E501 + :rtype: V2ObjectMetricStatus + """ + return self._object + + @object.setter + def object(self, object): + """Sets the object of this V2MetricStatus. + + + :param object: The object of this V2MetricStatus. # noqa: E501 + :type: V2ObjectMetricStatus + """ + + self._object = object + + @property + def pods(self): + """Gets the pods of this V2MetricStatus. # noqa: E501 + + + :return: The pods of this V2MetricStatus. # noqa: E501 + :rtype: V2PodsMetricStatus + """ + return self._pods + + @pods.setter + def pods(self, pods): + """Sets the pods of this V2MetricStatus. + + + :param pods: The pods of this V2MetricStatus. # noqa: E501 + :type: V2PodsMetricStatus + """ + + self._pods = pods + + @property + def resource(self): + """Gets the resource of this V2MetricStatus. # noqa: E501 + + + :return: The resource of this V2MetricStatus. # noqa: E501 + :rtype: V2ResourceMetricStatus + """ + return self._resource + + @resource.setter + def resource(self, resource): + """Sets the resource of this V2MetricStatus. + + + :param resource: The resource of this V2MetricStatus. # noqa: E501 + :type: V2ResourceMetricStatus + """ + + self._resource = resource + + @property + def type(self): + """Gets the type of this V2MetricStatus. # noqa: E501 + + type is the type of metric source. It will be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. # noqa: E501 + + :return: The type of this V2MetricStatus. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V2MetricStatus. + + type is the type of metric source. It will be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. # noqa: E501 + + :param type: The type of this V2MetricStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2MetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2MetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_target.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_target.py new file mode 100644 index 0000000000000000000000000000000000000000..0ffb63df18cdd7320cd221a45f56425909c8fc59 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_target.py @@ -0,0 +1,207 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2MetricTarget(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'average_utilization': 'int', + 'average_value': 'str', + 'type': 'str', + 'value': 'str' + } + + attribute_map = { + 'average_utilization': 'averageUtilization', + 'average_value': 'averageValue', + 'type': 'type', + 'value': 'value' + } + + def __init__(self, average_utilization=None, average_value=None, type=None, value=None, local_vars_configuration=None): # noqa: E501 + """V2MetricTarget - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._average_utilization = None + self._average_value = None + self._type = None + self._value = None + self.discriminator = None + + if average_utilization is not None: + self.average_utilization = average_utilization + if average_value is not None: + self.average_value = average_value + self.type = type + if value is not None: + self.value = value + + @property + def average_utilization(self): + """Gets the average_utilization of this V2MetricTarget. # noqa: E501 + + averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type # noqa: E501 + + :return: The average_utilization of this V2MetricTarget. # noqa: E501 + :rtype: int + """ + return self._average_utilization + + @average_utilization.setter + def average_utilization(self, average_utilization): + """Sets the average_utilization of this V2MetricTarget. + + averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type # noqa: E501 + + :param average_utilization: The average_utilization of this V2MetricTarget. # noqa: E501 + :type: int + """ + + self._average_utilization = average_utilization + + @property + def average_value(self): + """Gets the average_value of this V2MetricTarget. # noqa: E501 + + averageValue is the target value of the average of the metric across all relevant pods (as a quantity) # noqa: E501 + + :return: The average_value of this V2MetricTarget. # noqa: E501 + :rtype: str + """ + return self._average_value + + @average_value.setter + def average_value(self, average_value): + """Sets the average_value of this V2MetricTarget. + + averageValue is the target value of the average of the metric across all relevant pods (as a quantity) # noqa: E501 + + :param average_value: The average_value of this V2MetricTarget. # noqa: E501 + :type: str + """ + + self._average_value = average_value + + @property + def type(self): + """Gets the type of this V2MetricTarget. # noqa: E501 + + type represents whether the metric type is Utilization, Value, or AverageValue # noqa: E501 + + :return: The type of this V2MetricTarget. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V2MetricTarget. + + type represents whether the metric type is Utilization, Value, or AverageValue # noqa: E501 + + :param type: The type of this V2MetricTarget. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and type is None: # noqa: E501 + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + @property + def value(self): + """Gets the value of this V2MetricTarget. # noqa: E501 + + value is the target value of the metric (as a quantity). # noqa: E501 + + :return: The value of this V2MetricTarget. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V2MetricTarget. + + value is the target value of the metric (as a quantity). # noqa: E501 + + :param value: The value of this V2MetricTarget. # noqa: E501 + :type: str + """ + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2MetricTarget): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2MetricTarget): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_value_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_value_status.py new file mode 100644 index 0000000000000000000000000000000000000000..da307d6f813bc023729492cb3842354c78d3169a --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_metric_value_status.py @@ -0,0 +1,178 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2MetricValueStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'average_utilization': 'int', + 'average_value': 'str', + 'value': 'str' + } + + attribute_map = { + 'average_utilization': 'averageUtilization', + 'average_value': 'averageValue', + 'value': 'value' + } + + def __init__(self, average_utilization=None, average_value=None, value=None, local_vars_configuration=None): # noqa: E501 + """V2MetricValueStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._average_utilization = None + self._average_value = None + self._value = None + self.discriminator = None + + if average_utilization is not None: + self.average_utilization = average_utilization + if average_value is not None: + self.average_value = average_value + if value is not None: + self.value = value + + @property + def average_utilization(self): + """Gets the average_utilization of this V2MetricValueStatus. # noqa: E501 + + currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. # noqa: E501 + + :return: The average_utilization of this V2MetricValueStatus. # noqa: E501 + :rtype: int + """ + return self._average_utilization + + @average_utilization.setter + def average_utilization(self, average_utilization): + """Sets the average_utilization of this V2MetricValueStatus. + + currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. # noqa: E501 + + :param average_utilization: The average_utilization of this V2MetricValueStatus. # noqa: E501 + :type: int + """ + + self._average_utilization = average_utilization + + @property + def average_value(self): + """Gets the average_value of this V2MetricValueStatus. # noqa: E501 + + averageValue is the current value of the average of the metric across all relevant pods (as a quantity) # noqa: E501 + + :return: The average_value of this V2MetricValueStatus. # noqa: E501 + :rtype: str + """ + return self._average_value + + @average_value.setter + def average_value(self, average_value): + """Sets the average_value of this V2MetricValueStatus. + + averageValue is the current value of the average of the metric across all relevant pods (as a quantity) # noqa: E501 + + :param average_value: The average_value of this V2MetricValueStatus. # noqa: E501 + :type: str + """ + + self._average_value = average_value + + @property + def value(self): + """Gets the value of this V2MetricValueStatus. # noqa: E501 + + value is the current value of the metric (as a quantity). # noqa: E501 + + :return: The value of this V2MetricValueStatus. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this V2MetricValueStatus. + + value is the current value of the metric (as a quantity). # noqa: E501 + + :param value: The value of this V2MetricValueStatus. # noqa: E501 + :type: str + """ + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2MetricValueStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2MetricValueStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_source.py new file mode 100644 index 0000000000000000000000000000000000000000..d48f9b007a2580f2f01a4f785e5b32ef66b70119 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_source.py @@ -0,0 +1,175 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ObjectMetricSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'described_object': 'V2CrossVersionObjectReference', + 'metric': 'V2MetricIdentifier', + 'target': 'V2MetricTarget' + } + + attribute_map = { + 'described_object': 'describedObject', + 'metric': 'metric', + 'target': 'target' + } + + def __init__(self, described_object=None, metric=None, target=None, local_vars_configuration=None): # noqa: E501 + """V2ObjectMetricSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._described_object = None + self._metric = None + self._target = None + self.discriminator = None + + self.described_object = described_object + self.metric = metric + self.target = target + + @property + def described_object(self): + """Gets the described_object of this V2ObjectMetricSource. # noqa: E501 + + + :return: The described_object of this V2ObjectMetricSource. # noqa: E501 + :rtype: V2CrossVersionObjectReference + """ + return self._described_object + + @described_object.setter + def described_object(self, described_object): + """Sets the described_object of this V2ObjectMetricSource. + + + :param described_object: The described_object of this V2ObjectMetricSource. # noqa: E501 + :type: V2CrossVersionObjectReference + """ + if self.local_vars_configuration.client_side_validation and described_object is None: # noqa: E501 + raise ValueError("Invalid value for `described_object`, must not be `None`") # noqa: E501 + + self._described_object = described_object + + @property + def metric(self): + """Gets the metric of this V2ObjectMetricSource. # noqa: E501 + + + :return: The metric of this V2ObjectMetricSource. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2ObjectMetricSource. + + + :param metric: The metric of this V2ObjectMetricSource. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + @property + def target(self): + """Gets the target of this V2ObjectMetricSource. # noqa: E501 + + + :return: The target of this V2ObjectMetricSource. # noqa: E501 + :rtype: V2MetricTarget + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this V2ObjectMetricSource. + + + :param target: The target of this V2ObjectMetricSource. # noqa: E501 + :type: V2MetricTarget + """ + if self.local_vars_configuration.client_side_validation and target is None: # noqa: E501 + raise ValueError("Invalid value for `target`, must not be `None`") # noqa: E501 + + self._target = target + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ObjectMetricSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ObjectMetricSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..fdbc5ecc1c9a7ed31a52075e446dff2c2d6e5cb7 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_object_metric_status.py @@ -0,0 +1,175 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ObjectMetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'current': 'V2MetricValueStatus', + 'described_object': 'V2CrossVersionObjectReference', + 'metric': 'V2MetricIdentifier' + } + + attribute_map = { + 'current': 'current', + 'described_object': 'describedObject', + 'metric': 'metric' + } + + def __init__(self, current=None, described_object=None, metric=None, local_vars_configuration=None): # noqa: E501 + """V2ObjectMetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._current = None + self._described_object = None + self._metric = None + self.discriminator = None + + self.current = current + self.described_object = described_object + self.metric = metric + + @property + def current(self): + """Gets the current of this V2ObjectMetricStatus. # noqa: E501 + + + :return: The current of this V2ObjectMetricStatus. # noqa: E501 + :rtype: V2MetricValueStatus + """ + return self._current + + @current.setter + def current(self, current): + """Sets the current of this V2ObjectMetricStatus. + + + :param current: The current of this V2ObjectMetricStatus. # noqa: E501 + :type: V2MetricValueStatus + """ + if self.local_vars_configuration.client_side_validation and current is None: # noqa: E501 + raise ValueError("Invalid value for `current`, must not be `None`") # noqa: E501 + + self._current = current + + @property + def described_object(self): + """Gets the described_object of this V2ObjectMetricStatus. # noqa: E501 + + + :return: The described_object of this V2ObjectMetricStatus. # noqa: E501 + :rtype: V2CrossVersionObjectReference + """ + return self._described_object + + @described_object.setter + def described_object(self, described_object): + """Sets the described_object of this V2ObjectMetricStatus. + + + :param described_object: The described_object of this V2ObjectMetricStatus. # noqa: E501 + :type: V2CrossVersionObjectReference + """ + if self.local_vars_configuration.client_side_validation and described_object is None: # noqa: E501 + raise ValueError("Invalid value for `described_object`, must not be `None`") # noqa: E501 + + self._described_object = described_object + + @property + def metric(self): + """Gets the metric of this V2ObjectMetricStatus. # noqa: E501 + + + :return: The metric of this V2ObjectMetricStatus. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2ObjectMetricStatus. + + + :param metric: The metric of this V2ObjectMetricStatus. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ObjectMetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ObjectMetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_source.py new file mode 100644 index 0000000000000000000000000000000000000000..d461588d4298add32688834e85cd69ee09d00da4 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_source.py @@ -0,0 +1,148 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2PodsMetricSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'metric': 'V2MetricIdentifier', + 'target': 'V2MetricTarget' + } + + attribute_map = { + 'metric': 'metric', + 'target': 'target' + } + + def __init__(self, metric=None, target=None, local_vars_configuration=None): # noqa: E501 + """V2PodsMetricSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._metric = None + self._target = None + self.discriminator = None + + self.metric = metric + self.target = target + + @property + def metric(self): + """Gets the metric of this V2PodsMetricSource. # noqa: E501 + + + :return: The metric of this V2PodsMetricSource. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2PodsMetricSource. + + + :param metric: The metric of this V2PodsMetricSource. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + @property + def target(self): + """Gets the target of this V2PodsMetricSource. # noqa: E501 + + + :return: The target of this V2PodsMetricSource. # noqa: E501 + :rtype: V2MetricTarget + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this V2PodsMetricSource. + + + :param target: The target of this V2PodsMetricSource. # noqa: E501 + :type: V2MetricTarget + """ + if self.local_vars_configuration.client_side_validation and target is None: # noqa: E501 + raise ValueError("Invalid value for `target`, must not be `None`") # noqa: E501 + + self._target = target + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2PodsMetricSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2PodsMetricSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..f616765b1d6853f120a582058f6426042b72e956 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_pods_metric_status.py @@ -0,0 +1,148 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2PodsMetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'current': 'V2MetricValueStatus', + 'metric': 'V2MetricIdentifier' + } + + attribute_map = { + 'current': 'current', + 'metric': 'metric' + } + + def __init__(self, current=None, metric=None, local_vars_configuration=None): # noqa: E501 + """V2PodsMetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._current = None + self._metric = None + self.discriminator = None + + self.current = current + self.metric = metric + + @property + def current(self): + """Gets the current of this V2PodsMetricStatus. # noqa: E501 + + + :return: The current of this V2PodsMetricStatus. # noqa: E501 + :rtype: V2MetricValueStatus + """ + return self._current + + @current.setter + def current(self, current): + """Sets the current of this V2PodsMetricStatus. + + + :param current: The current of this V2PodsMetricStatus. # noqa: E501 + :type: V2MetricValueStatus + """ + if self.local_vars_configuration.client_side_validation and current is None: # noqa: E501 + raise ValueError("Invalid value for `current`, must not be `None`") # noqa: E501 + + self._current = current + + @property + def metric(self): + """Gets the metric of this V2PodsMetricStatus. # noqa: E501 + + + :return: The metric of this V2PodsMetricStatus. # noqa: E501 + :rtype: V2MetricIdentifier + """ + return self._metric + + @metric.setter + def metric(self, metric): + """Sets the metric of this V2PodsMetricStatus. + + + :param metric: The metric of this V2PodsMetricStatus. # noqa: E501 + :type: V2MetricIdentifier + """ + if self.local_vars_configuration.client_side_validation and metric is None: # noqa: E501 + raise ValueError("Invalid value for `metric`, must not be `None`") # noqa: E501 + + self._metric = metric + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2PodsMetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2PodsMetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_source.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_source.py new file mode 100644 index 0000000000000000000000000000000000000000..216e98ab86d8e2ce98525a7ebee3ea918db36778 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_source.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ResourceMetricSource(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'name': 'str', + 'target': 'V2MetricTarget' + } + + attribute_map = { + 'name': 'name', + 'target': 'target' + } + + def __init__(self, name=None, target=None, local_vars_configuration=None): # noqa: E501 + """V2ResourceMetricSource - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._name = None + self._target = None + self.discriminator = None + + self.name = name + self.target = target + + @property + def name(self): + """Gets the name of this V2ResourceMetricSource. # noqa: E501 + + name is the name of the resource in question. # noqa: E501 + + :return: The name of this V2ResourceMetricSource. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2ResourceMetricSource. + + name is the name of the resource in question. # noqa: E501 + + :param name: The name of this V2ResourceMetricSource. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def target(self): + """Gets the target of this V2ResourceMetricSource. # noqa: E501 + + + :return: The target of this V2ResourceMetricSource. # noqa: E501 + :rtype: V2MetricTarget + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this V2ResourceMetricSource. + + + :param target: The target of this V2ResourceMetricSource. # noqa: E501 + :type: V2MetricTarget + """ + if self.local_vars_configuration.client_side_validation and target is None: # noqa: E501 + raise ValueError("Invalid value for `target`, must not be `None`") # noqa: E501 + + self._target = target + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ResourceMetricSource): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ResourceMetricSource): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_status.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_status.py new file mode 100644 index 0000000000000000000000000000000000000000..cccd709d5149f2d922bc9f460eb4fa7e32bf60fb --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/v2_resource_metric_status.py @@ -0,0 +1,150 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class V2ResourceMetricStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'current': 'V2MetricValueStatus', + 'name': 'str' + } + + attribute_map = { + 'current': 'current', + 'name': 'name' + } + + def __init__(self, current=None, name=None, local_vars_configuration=None): # noqa: E501 + """V2ResourceMetricStatus - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._current = None + self._name = None + self.discriminator = None + + self.current = current + self.name = name + + @property + def current(self): + """Gets the current of this V2ResourceMetricStatus. # noqa: E501 + + + :return: The current of this V2ResourceMetricStatus. # noqa: E501 + :rtype: V2MetricValueStatus + """ + return self._current + + @current.setter + def current(self, current): + """Sets the current of this V2ResourceMetricStatus. + + + :param current: The current of this V2ResourceMetricStatus. # noqa: E501 + :type: V2MetricValueStatus + """ + if self.local_vars_configuration.client_side_validation and current is None: # noqa: E501 + raise ValueError("Invalid value for `current`, must not be `None`") # noqa: E501 + + self._current = current + + @property + def name(self): + """Gets the name of this V2ResourceMetricStatus. # noqa: E501 + + name is the name of the resource in question. # noqa: E501 + + :return: The name of this V2ResourceMetricStatus. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this V2ResourceMetricStatus. + + name is the name of the resource in question. # noqa: E501 + + :param name: The name of this V2ResourceMetricStatus. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501 + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V2ResourceMetricStatus): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, V2ResourceMetricStatus): + return True + + return self.to_dict() != other.to_dict() diff --git a/python/user_packages/Python313/site-packages/kubernetes/client/models/version_info.py b/python/user_packages/Python313/site-packages/kubernetes/client/models/version_info.py new file mode 100644 index 0000000000000000000000000000000000000000..3109bf9838bfaed50e8aa190a57dea738664d679 --- /dev/null +++ b/python/user_packages/Python313/site-packages/kubernetes/client/models/version_info.py @@ -0,0 +1,453 @@ +# coding: utf-8 + +""" + Kubernetes + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 + + The version of the OpenAPI document: release-1.35 + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client.configuration import Configuration + + +class VersionInfo(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'build_date': 'str', + 'compiler': 'str', + 'emulation_major': 'str', + 'emulation_minor': 'str', + 'git_commit': 'str', + 'git_tree_state': 'str', + 'git_version': 'str', + 'go_version': 'str', + 'major': 'str', + 'min_compatibility_major': 'str', + 'min_compatibility_minor': 'str', + 'minor': 'str', + 'platform': 'str' + } + + attribute_map = { + 'build_date': 'buildDate', + 'compiler': 'compiler', + 'emulation_major': 'emulationMajor', + 'emulation_minor': 'emulationMinor', + 'git_commit': 'gitCommit', + 'git_tree_state': 'gitTreeState', + 'git_version': 'gitVersion', + 'go_version': 'goVersion', + 'major': 'major', + 'min_compatibility_major': 'minCompatibilityMajor', + 'min_compatibility_minor': 'minCompatibilityMinor', + 'minor': 'minor', + 'platform': 'platform' + } + + def __init__(self, build_date=None, compiler=None, emulation_major=None, emulation_minor=None, git_commit=None, git_tree_state=None, git_version=None, go_version=None, major=None, min_compatibility_major=None, min_compatibility_minor=None, minor=None, platform=None, local_vars_configuration=None): # noqa: E501 + """VersionInfo - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration + + self._build_date = None + self._compiler = None + self._emulation_major = None + self._emulation_minor = None + self._git_commit = None + self._git_tree_state = None + self._git_version = None + self._go_version = None + self._major = None + self._min_compatibility_major = None + self._min_compatibility_minor = None + self._minor = None + self._platform = None + self.discriminator = None + + self.build_date = build_date + self.compiler = compiler + if emulation_major is not None: + self.emulation_major = emulation_major + if emulation_minor is not None: + self.emulation_minor = emulation_minor + self.git_commit = git_commit + self.git_tree_state = git_tree_state + self.git_version = git_version + self.go_version = go_version + self.major = major + if min_compatibility_major is not None: + self.min_compatibility_major = min_compatibility_major + if min_compatibility_minor is not None: + self.min_compatibility_minor = min_compatibility_minor + self.minor = minor + self.platform = platform + + @property + def build_date(self): + """Gets the build_date of this VersionInfo. # noqa: E501 + + + :return: The build_date of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._build_date + + @build_date.setter + def build_date(self, build_date): + """Sets the build_date of this VersionInfo. + + + :param build_date: The build_date of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and build_date is None: # noqa: E501 + raise ValueError("Invalid value for `build_date`, must not be `None`") # noqa: E501 + + self._build_date = build_date + + @property + def compiler(self): + """Gets the compiler of this VersionInfo. # noqa: E501 + + + :return: The compiler of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._compiler + + @compiler.setter + def compiler(self, compiler): + """Sets the compiler of this VersionInfo. + + + :param compiler: The compiler of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and compiler is None: # noqa: E501 + raise ValueError("Invalid value for `compiler`, must not be `None`") # noqa: E501 + + self._compiler = compiler + + @property + def emulation_major(self): + """Gets the emulation_major of this VersionInfo. # noqa: E501 + + EmulationMajor is the major version of the emulation version # noqa: E501 + + :return: The emulation_major of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._emulation_major + + @emulation_major.setter + def emulation_major(self, emulation_major): + """Sets the emulation_major of this VersionInfo. + + EmulationMajor is the major version of the emulation version # noqa: E501 + + :param emulation_major: The emulation_major of this VersionInfo. # noqa: E501 + :type: str + """ + + self._emulation_major = emulation_major + + @property + def emulation_minor(self): + """Gets the emulation_minor of this VersionInfo. # noqa: E501 + + EmulationMinor is the minor version of the emulation version # noqa: E501 + + :return: The emulation_minor of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._emulation_minor + + @emulation_minor.setter + def emulation_minor(self, emulation_minor): + """Sets the emulation_minor of this VersionInfo. + + EmulationMinor is the minor version of the emulation version # noqa: E501 + + :param emulation_minor: The emulation_minor of this VersionInfo. # noqa: E501 + :type: str + """ + + self._emulation_minor = emulation_minor + + @property + def git_commit(self): + """Gets the git_commit of this VersionInfo. # noqa: E501 + + + :return: The git_commit of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._git_commit + + @git_commit.setter + def git_commit(self, git_commit): + """Sets the git_commit of this VersionInfo. + + + :param git_commit: The git_commit of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and git_commit is None: # noqa: E501 + raise ValueError("Invalid value for `git_commit`, must not be `None`") # noqa: E501 + + self._git_commit = git_commit + + @property + def git_tree_state(self): + """Gets the git_tree_state of this VersionInfo. # noqa: E501 + + + :return: The git_tree_state of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._git_tree_state + + @git_tree_state.setter + def git_tree_state(self, git_tree_state): + """Sets the git_tree_state of this VersionInfo. + + + :param git_tree_state: The git_tree_state of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and git_tree_state is None: # noqa: E501 + raise ValueError("Invalid value for `git_tree_state`, must not be `None`") # noqa: E501 + + self._git_tree_state = git_tree_state + + @property + def git_version(self): + """Gets the git_version of this VersionInfo. # noqa: E501 + + + :return: The git_version of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._git_version + + @git_version.setter + def git_version(self, git_version): + """Sets the git_version of this VersionInfo. + + + :param git_version: The git_version of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and git_version is None: # noqa: E501 + raise ValueError("Invalid value for `git_version`, must not be `None`") # noqa: E501 + + self._git_version = git_version + + @property + def go_version(self): + """Gets the go_version of this VersionInfo. # noqa: E501 + + + :return: The go_version of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._go_version + + @go_version.setter + def go_version(self, go_version): + """Sets the go_version of this VersionInfo. + + + :param go_version: The go_version of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and go_version is None: # noqa: E501 + raise ValueError("Invalid value for `go_version`, must not be `None`") # noqa: E501 + + self._go_version = go_version + + @property + def major(self): + """Gets the major of this VersionInfo. # noqa: E501 + + Major is the major version of the binary version # noqa: E501 + + :return: The major of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._major + + @major.setter + def major(self, major): + """Sets the major of this VersionInfo. + + Major is the major version of the binary version # noqa: E501 + + :param major: The major of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and major is None: # noqa: E501 + raise ValueError("Invalid value for `major`, must not be `None`") # noqa: E501 + + self._major = major + + @property + def min_compatibility_major(self): + """Gets the min_compatibility_major of this VersionInfo. # noqa: E501 + + MinCompatibilityMajor is the major version of the minimum compatibility version # noqa: E501 + + :return: The min_compatibility_major of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._min_compatibility_major + + @min_compatibility_major.setter + def min_compatibility_major(self, min_compatibility_major): + """Sets the min_compatibility_major of this VersionInfo. + + MinCompatibilityMajor is the major version of the minimum compatibility version # noqa: E501 + + :param min_compatibility_major: The min_compatibility_major of this VersionInfo. # noqa: E501 + :type: str + """ + + self._min_compatibility_major = min_compatibility_major + + @property + def min_compatibility_minor(self): + """Gets the min_compatibility_minor of this VersionInfo. # noqa: E501 + + MinCompatibilityMinor is the minor version of the minimum compatibility version # noqa: E501 + + :return: The min_compatibility_minor of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._min_compatibility_minor + + @min_compatibility_minor.setter + def min_compatibility_minor(self, min_compatibility_minor): + """Sets the min_compatibility_minor of this VersionInfo. + + MinCompatibilityMinor is the minor version of the minimum compatibility version # noqa: E501 + + :param min_compatibility_minor: The min_compatibility_minor of this VersionInfo. # noqa: E501 + :type: str + """ + + self._min_compatibility_minor = min_compatibility_minor + + @property + def minor(self): + """Gets the minor of this VersionInfo. # noqa: E501 + + Minor is the minor version of the binary version # noqa: E501 + + :return: The minor of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._minor + + @minor.setter + def minor(self, minor): + """Sets the minor of this VersionInfo. + + Minor is the minor version of the binary version # noqa: E501 + + :param minor: The minor of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and minor is None: # noqa: E501 + raise ValueError("Invalid value for `minor`, must not be `None`") # noqa: E501 + + self._minor = minor + + @property + def platform(self): + """Gets the platform of this VersionInfo. # noqa: E501 + + + :return: The platform of this VersionInfo. # noqa: E501 + :rtype: str + """ + return self._platform + + @platform.setter + def platform(self, platform): + """Sets the platform of this VersionInfo. + + + :param platform: The platform of this VersionInfo. # noqa: E501 + :type: str + """ + if self.local_vars_configuration.client_side_validation and platform is None: # noqa: E501 + raise ValueError("Invalid value for `platform`, must not be `None`") # noqa: E501 + + self._platform = platform + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, VersionInfo): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, VersionInfo): + return True + + return self.to_dict() != other.to_dict()