././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1763780233.5890462 types_psutil-7.1.1.20251122/0000755000175100017510000000000015110223212014614 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/CHANGELOG.md0000644000175100017510000002220715110223210016426 0ustar00runnerrunner## 7.1.1.20251122 (2025-11-22) [psutil] Bump psutil to 7.1.1 ([#14873](https://github.com/python/typeshed/pull/14873)) ## 7.0.0.20251116 (2025-11-16) [psutil] Annotate few common attributes ([#15031](https://github.com/python/typeshed/pull/15031)) [psutil] Complete OSX stubs ([#15030](https://github.com/python/typeshed/pull/15030)) ## 7.0.0.20251115 (2025-11-15) [psutil] Complete Windows stubs ([#15015](https://github.com/python/typeshed/pull/15015)) ## 7.0.0.20251111 (2025-11-11) [psutil] Use Incomplete instead of Any ([#15010](https://github.com/python/typeshed/pull/15010)) ## 7.0.0.20251001 (2025-10-01) [psutil] Add `cache_clear` to `psutil.process_iter` typing ([#14803](https://github.com/python/typeshed/pull/14803)) ## 7.0.0.20250822 (2025-08-22) Add __slots__ to third-party packages using stubdefaulter ([#14619](https://github.com/python/typeshed/pull/14619)) Add missing defaults to third-party stubs ([#14617](https://github.com/python/typeshed/pull/14617)) ## 7.0.0.20250801 (2025-08-01) Split `tool.stubtest.platforms` metadata key (#13746) Co-authored-by: Avasam Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> ## 7.0.0.20250601 (2025-06-01) [psutil]: Add missing `__dir__` method to `psutil.Popen` (#14207) ## 7.0.0.20250516 (2025-05-16) Replace `Incomplete | None = None` in third party stubs (#14063) ## 7.0.0.20250401 (2025-04-01) Add `__all__` part 2 (#13719) --------- Co-authored-by: Avasam ## 7.0.0.20250218 (2025-02-18) Update psutil to 7.0.* (#13507) ## 6.1.0.20241221 (2024-12-21) Update to mypy 1.14 (#13272) ## 6.1.0.20241102 (2024-11-02) Update type for psutil.cpu_count (#12941) The function can return None: https://github.com/giampaolo/psutil/blame/567438cd3eb4334486d88ba90aa14c65755b61cd/psutil/__init__.py#L1665-L1667 ## 6.1.0.20241022 (2024-10-22) Bump psutil to 6.1.* (#12868) ## 6.0.0.20241011 (2024-10-11) update psutil.Process.parent() return type (#12767) per `psutil.Process.parent()`'s docstring, it may return `None`. https://github.com/giampaolo/psutil/blob/0a71d0e404ddaab32b5222351fd2292802e3b131/psutil/__init__.py#L574 ## 6.0.0.20240901 (2024-09-01) Fix types for psutil.cpu_* functions (#12602) ## 6.0.0.20240621 (2024-06-21) psutil: deprecate `Process.connections` (#12174) Bump psutil to 6.0.* (#12167) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> ## 5.9.5.20240516 (2024-05-16) Update dependency pyright to v1.1.363 (#11919) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: Alex Waygood ## 5.9.5.20240511 (2024-05-11) stubs: change psutil's Process.wait timeout argument to float (#11883) Fixes #11866 ## 5.9.5.20240423 (2024-04-23) Add precise values for enum members where possible (#11299) Co-authored-by: Jelle Zijlstra Co-authored-by: Alex Waygood ## 5.9.5.20240316 (2024-03-16) [psutil] add settable info property (#10275) ## 5.9.5.20240311 (2024-03-11) Use PEP 570 syntax in third party stubs (#11554) ## 5.9.5.20240205 (2024-02-05) A new shade of Black (#11362) ## 5.9.5.20240106 (2024-01-06) Update typing_extensions imports in third-party stubs (#11245) ## 5.9.5.17 (2023-10-16) psutil: updates (#10894) ## 5.9.5.16 (2023-07-20) Add an upstream_repository field to METADATA.toml (#10487) Closes: #10478 ## 5.9.5.15 (2023-06-12) psutil: import platform-specific 'pio' definitions (#10305) ## 5.9.5.14 (2023-06-12) psutil: declare return type of io_counters() (#10303) ## 5.9.5.13 (2023-06-01) [psutil] Fix cpu_percent return type when percpu is True (#10238) ## 5.9.5.12 (2023-04-20) psutil: fix stubtest (#10065) Fixes #10059 ## 5.9.5.11 (2023-03-27) Add default values for third-party stubs beginning with 'P' (#9957) ## 5.9.5.10 (2023-03-08) psutil: sconn.pid can be None (#9853) Found out about this the hard way. The code path that allows None is here: https://github.com/giampaolo/psutil/blob/2da99502238852f18f74db05304e67a01ee77005/psutil/_pslinux.py#L923 ## 5.9.5.9 (2023-02-26) Improve many `__(a)exit__` annotations (#9696) ## 5.9.5.8 (2023-02-21) Stubtest settings: change `ignore_missing_stub` default to `false` (#9779) If you're reading about this commit from an autogenerated changelog entry, this should have no user-visible impact on how the stubs are interpreted by a type checker; it's just an internal change to how typeshed's tests work. ## 5.9.5.7 (2023-02-15) Use `typing_extensions.Self` instead of `_typeshed.Self` (#9702) Bump pyright to 1.1.294; improve `psutil` stubs (#9739) Partially type psfullmem ## 5.9.5.6 (2023-01-18) Replace `Any` with `Incomplete` in many places (#9558) ## 5.9.5.5 (2022-11-13) Run stubtest for psutil on all platforms (#9169) ## 5.9.5.4 (2022-10-20) `psutil`: Fix `win_service_iter()` return type to allow iterating over its result (#8932) ## 5.9.5.3 (2022-10-19) psutil: add snicstats.flags (#8928) Fixes #8927 See https://github.com/giampaolo/psutil/commit/70eecaf44d61f2cabcd22ffb407b904242a122c9 ## 5.9.5.2 (2022-10-15) Use `Incomplete` instead of `Any` in `__getattr__` (#8903) ## 5.9.5.1 (2022-10-03) psutil: Improve types for disk_io_counters() and net_io_counters() (#8829) ## 5.9.5 (2022-08-08) psutil: improve svmem types (#8503) ## 5.9.4 (2022-08-08) psutil: types for virtual_memory (#8501) ## 5.9.3 (2022-07-30) Remove or move several `TypeAlias` declarations (#8444) ## 5.9.2 (2022-07-19) Third-party stubs: enforce CamelCase for type alias names (#8256) Co-authored-by: Jelle Zijlstra ## 5.9.1 (2022-07-04) Third-party stubs: audit more `Callable[, Any]` annotations (#8233) ## 5.9.0 (2022-07-01) [stubsabot] Bump psutil to 5.9.* (#8213) Co-authored-by: hauntsaninja <> ## 5.8.23 (2022-06-06) Always use `TypeAlias` when assigning to `Any` (#8021) ## 5.8.22 (2022-04-16) Third-party stubs: import from `collections.abc` where possible (#7637) ## 5.8.21 (2022-04-16) Use `TypeAlias` where possible for type aliases (#7630) ## 5.8.20 (2022-01-31) Upgrade black version (#7089) ## 5.8.19 (2022-01-10) Always use `_typeshed.Self`, where applicable (#6880) * Always use `_typeshed.Self`, where applicable * Revert changes to `google-cloud-ndb` (ambiguous) * Remove empty line added by script * Revert changes to `stubs/python-dateutil/dateutil/relativedelta.pyi` * Manually add a few more that the script missed * Improve `filelock` annotation Source code here: https://github.com/tox-dev/py-filelock/blob/79ec7b2826e33b982fe83b057f359448b9d966ba/src/filelock/_api.py#L207 * Improve `opentracing/scope` annotation Source code here: https://github.com/opentracing/opentracing-python/blob/3e1d357a348269ef54d67f761302fab93dbfc0f7/opentracing/scope.py#L71 * Improve `redis/client` stub Source code here: https://github.com/redis/redis-py/blob/15f315a496c3267c8cbcc6d6d9c6005ea4d4a4d5/redis/client.py#L1217 * Improve `redis/lock` annotation Source code here: https://github.com/redis/redis-py/blob/15f315a496c3267c8cbcc6d6d9c6005ea4d4a4d5/redis/lock.py#L155 * Improve `requests/models` annotation Source code here: https://github.com/psf/requests/blob/d718e753834b84018014a23d663369ac27d1ab9c/requests/models.py#L653 ## 5.8.17 (2021-12-28) Use PEP 585 syntax wherever possible (#6717) ## 5.8.16 (2021-12-23) fix typing for psutil sconn (#6669) ## 5.8.15 (2021-11-23) Reduce use of deprecated `typing` aliases (#6358) ## 5.8.14 (2021-11-08) Process.status returns a status string (#6245) Typed STATUS_* constants using Literal ## 5.8.13 (2021-10-12) Add star to all non-0.1 versions (#6146) ## 5.8.12 (2021-10-07) Add missing annotations for psutil (#6124) ## 5.8.11 (2021-10-07) Improves `psutil` (#6103) Add a few items and annotations to psutil ## 5.8.10 (2021-10-05) Add several missing type annotations to `psutil._common` (#6104) ## 5.8.9 (2021-10-05) Properly export types from psutil._compat (#6112) ## 5.8.8 (2021-09-25) Improves `Popen` types in `psutil` (#6074) ## 5.8.7 (2021-09-25) Further improvements to `psutil` (#6072) Adds types to the following functions: - `psutil.environ()` - `psutil.send_signal()` - `psutil.sensors_temperatures()` - `psutil.sensors_fans()` - `psutil.sensors_battery()` ## 5.8.6 (2021-09-24) Further annotations for the psutil module (#6066) ## 5.8.5 (2021-09-10) Annotate more NamedTuples for psutil (#6021) ## 5.8.4 (2021-09-09) Annotate several NamedTuples in psutil (#6016) Annotate more methods of psutil.Process (#6012) ## 5.8.3 (2021-09-06) Improves `psutil/_common.pyi` (#6010) * Improves `psutil/_common.pyi` In this iteration I've fixed the most obvious types and corrected several mistakes. We can go deeper in the next iteration(s). * We don't need to import `Union` * Update _common.pyi * Update _common.pyi * Update _common.pyi ## 5.8.2 (2021-09-06) Adds more missing `ContextManager` types (#6007) 1. https://github.com/giampaolo/psutil/blob/c3e63b4dd59f1724a7fa29371e53dfa7f46cbcd3/psutil/_psbsd.py#L571 2. https://github.com/giampaolo/psutil/blob/c3e63b4dd59f1724a7fa29371e53dfa7f46cbcd3/psutil/_psosx.py#L365 ## 5.8.1 (2021-09-05) Fix return type of Process.oneshot() (#6006) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/LICENSE0000644000175100017510000003056115110223210015624 0ustar00runnerrunnerThe "typeshed" project is licensed under the terms of the Apache license, as reproduced below. = = = = = Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. = = = = = Parts of typeshed are licensed under different licenses (like the MIT license), reproduced below. = = = = = The MIT License Copyright (c) 2015 Jukka Lehtosalo and contributors 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. = = = = = ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/MANIFEST.in0000644000175100017510000000002515110223210016345 0ustar00runnerrunnerinclude CHANGELOG.md ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1763780233.5890462 types_psutil-7.1.1.20251122/PKG-INFO0000644000175100017510000000326715110223212015721 0ustar00runnerrunnerMetadata-Version: 2.4 Name: types-psutil Version: 7.1.1.20251122 Summary: Typing stubs for psutil License-Expression: Apache-2.0 Project-URL: Homepage, https://github.com/python/typeshed Project-URL: GitHub, https://github.com/python/typeshed Project-URL: Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/psutil.md Project-URL: Issue tracker, https://github.com/python/typeshed/issues Project-URL: Chat, https://gitter.im/python/typing Classifier: Programming Language :: Python :: 3 Classifier: Typing :: Stubs Only Requires-Python: >=3.9 Description-Content-Type: text/markdown License-File: LICENSE Dynamic: license-file ## Typing stubs for psutil This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html) for the [`psutil`](https://github.com/giampaolo/psutil) package. It can be used by type checkers to check code that uses `psutil`. This version of `types-psutil` aims to provide accurate annotations for `psutil==7.1.1`. This package is part of the [typeshed project](https://github.com/python/typeshed). All fixes for types and metadata should be contributed there. See [the README](https://github.com/python/typeshed/blob/main/README.md) for more details. The source for this package can be found in the [`stubs/psutil`](https://github.com/python/typeshed/tree/main/stubs/psutil) directory. This package was tested with the following type checkers: * [mypy](https://github.com/python/mypy/) 1.18.2 * [pyright](https://github.com/microsoft/pyright) 1.1.407 It was generated from typeshed commit [`cc792321dd482a5336225229bf584ad51a3e85cd`](https://github.com/python/typeshed/commit/cc792321dd482a5336225229bf584ad51a3e85cd). ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/README.md0000644000175100017510000000204015110223210016065 0ustar00runnerrunner## Typing stubs for psutil This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html) for the [`psutil`](https://github.com/giampaolo/psutil) package. It can be used by type checkers to check code that uses `psutil`. This version of `types-psutil` aims to provide accurate annotations for `psutil==7.1.1`. This package is part of the [typeshed project](https://github.com/python/typeshed). All fixes for types and metadata should be contributed there. See [the README](https://github.com/python/typeshed/blob/main/README.md) for more details. The source for this package can be found in the [`stubs/psutil`](https://github.com/python/typeshed/tree/main/stubs/psutil) directory. This package was tested with the following type checkers: * [mypy](https://github.com/python/mypy/) 1.18.2 * [pyright](https://github.com/microsoft/pyright) 1.1.407 It was generated from typeshed commit [`cc792321dd482a5336225229bf584ad51a3e85cd`](https://github.com/python/typeshed/commit/cc792321dd482a5336225229bf584ad51a3e85cd).././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1763780233.588046 types_psutil-7.1.1.20251122/psutil-stubs/0000755000175100017510000000000015110223212017272 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/psutil-stubs/METADATA.toml0000644000175100017510000000021315110223210021341 0ustar00runnerrunnerversion = "7.1.1" upstream_repository = "https://github.com/giampaolo/psutil" [tool.stubtest] ci_platforms = ["darwin", "linux", "win32"] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/__init__.pyi0000644000175100017510000002355015110223174021570 0ustar00runnerrunnerimport sys from _typeshed import Incomplete from collections.abc import Callable, Iterable, Iterator from contextlib import AbstractContextManager from types import TracebackType from typing import Any, Literal, Protocol, overload, type_check_only from typing_extensions import Self, TypeAlias, deprecated from psutil._common import ( AIX as AIX, BSD as BSD, CONN_CLOSE as CONN_CLOSE, CONN_CLOSE_WAIT as CONN_CLOSE_WAIT, CONN_CLOSING as CONN_CLOSING, CONN_ESTABLISHED as CONN_ESTABLISHED, CONN_FIN_WAIT1 as CONN_FIN_WAIT1, CONN_FIN_WAIT2 as CONN_FIN_WAIT2, CONN_LAST_ACK as CONN_LAST_ACK, CONN_LISTEN as CONN_LISTEN, CONN_NONE as CONN_NONE, CONN_SYN_RECV as CONN_SYN_RECV, CONN_SYN_SENT as CONN_SYN_SENT, CONN_TIME_WAIT as CONN_TIME_WAIT, FREEBSD as FREEBSD, LINUX as LINUX, MACOS as MACOS, NETBSD as NETBSD, NIC_DUPLEX_FULL as NIC_DUPLEX_FULL, NIC_DUPLEX_HALF as NIC_DUPLEX_HALF, NIC_DUPLEX_UNKNOWN as NIC_DUPLEX_UNKNOWN, OPENBSD as OPENBSD, OSX as OSX, POSIX as POSIX, POWER_TIME_UNKNOWN as POWER_TIME_UNKNOWN, POWER_TIME_UNLIMITED as POWER_TIME_UNLIMITED, STATUS_DEAD as STATUS_DEAD, STATUS_DISK_SLEEP as STATUS_DISK_SLEEP, STATUS_IDLE as STATUS_IDLE, STATUS_LOCKED as STATUS_LOCKED, STATUS_PARKED as STATUS_PARKED, STATUS_RUNNING as STATUS_RUNNING, STATUS_SLEEPING as STATUS_SLEEPING, STATUS_STOPPED as STATUS_STOPPED, STATUS_TRACING_STOP as STATUS_TRACING_STOP, STATUS_WAITING as STATUS_WAITING, STATUS_WAKING as STATUS_WAKING, STATUS_ZOMBIE as STATUS_ZOMBIE, SUNOS as SUNOS, WINDOWS as WINDOWS, AccessDenied as AccessDenied, Error as Error, NoSuchProcess as NoSuchProcess, TimeoutExpired as TimeoutExpired, ZombieProcess as ZombieProcess, pconn, pcputimes, pctxsw, pgids, pionice, popenfile, pthread, puids, sconn, scpufreq, scpustats, sdiskio, sdiskpart, sdiskusage, sfan, shwtemp, snetio, snicaddr, snicstats, sswap, suser, ) if sys.platform == "linux": from ._pslinux import ( IOPRIO_CLASS_BE as IOPRIO_CLASS_BE, IOPRIO_CLASS_IDLE as IOPRIO_CLASS_IDLE, IOPRIO_CLASS_NONE as IOPRIO_CLASS_NONE, IOPRIO_CLASS_RT as IOPRIO_CLASS_RT, ) def sensors_temperatures(fahrenheit: bool = ...) -> dict[str, list[shwtemp]]: ... def sensors_fans() -> dict[str, list[sfan]]: ... PROCFS_PATH: str RLIMIT_AS: int RLIMIT_CORE: int RLIMIT_CPU: int RLIMIT_DATA: int RLIMIT_FSIZE: int RLIMIT_LOCKS: int RLIMIT_MEMLOCK: int RLIMIT_MSGQUEUE: int RLIMIT_NICE: int RLIMIT_NOFILE: int RLIMIT_NPROC: int RLIMIT_RSS: int RLIMIT_RTPRIO: int RLIMIT_RTTIME: int RLIMIT_SIGPENDING: int RLIMIT_STACK: int RLIM_INFINITY: int if sys.platform == "win32": from ._psutil_windows import ( ABOVE_NORMAL_PRIORITY_CLASS as ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS as BELOW_NORMAL_PRIORITY_CLASS, HIGH_PRIORITY_CLASS as HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS as IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS as NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS as REALTIME_PRIORITY_CLASS, ) from ._pswindows import ( CONN_DELETE_TCB as CONN_DELETE_TCB, IOPRIO_HIGH as IOPRIO_HIGH, IOPRIO_LOW as IOPRIO_LOW, IOPRIO_NORMAL as IOPRIO_NORMAL, IOPRIO_VERYLOW as IOPRIO_VERYLOW, win_service_get as win_service_get, win_service_iter as win_service_iter, ) if sys.platform == "linux": from ._pslinux import pfullmem, pmem, scputimes, sensors_battery as sensors_battery, svmem elif sys.platform == "darwin": from ._psosx import pfullmem, pmem, scputimes, sensors_battery as sensors_battery, svmem elif sys.platform == "win32": from ._pswindows import pfullmem, pmem, scputimes, sensors_battery as sensors_battery, svmem else: scputimes = Incomplete class pmem(Any): ... class pfullmem(Any): ... class svmem(Any): ... def sensors_battery(): ... if sys.platform == "linux": from ._pslinux import pio elif sys.platform == "win32": from ._pswindows import pio else: from ._common import pio AF_LINK: int version_info: tuple[int, int, int] __version__: str __author__: str _Status: TypeAlias = Literal[ "running", "sleeping", "disk-sleep", "stopped", "tracing-stop", "zombie", "dead", "wake-kill", "waking", "idle", "locked", "waiting", "suspended", "parked", ] class Process: def __init__(self, pid: int | None = None) -> None: ... def __eq__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... def __hash__(self) -> int: ... @property def pid(self) -> int: ... # Only present if attrs argument is passed to process_iter info: dict[str, Incomplete] def oneshot(self) -> AbstractContextManager[None]: ... def as_dict( self, attrs: list[str] | tuple[str, ...] | set[str] | frozenset[str] | None = None, ad_value=None ) -> dict[str, Incomplete]: ... def parent(self) -> Process | None: ... def parents(self) -> list[Process]: ... def is_running(self) -> bool: ... def ppid(self) -> int: ... def name(self) -> str: ... def exe(self) -> str: ... def cmdline(self) -> list[str]: ... def status(self) -> _Status: ... def username(self) -> str: ... def create_time(self) -> float: ... def cwd(self) -> str: ... def nice(self, value: int | None = None) -> int: ... if sys.platform != "win32": def uids(self) -> puids: ... def gids(self) -> pgids: ... def terminal(self) -> str: ... def num_fds(self) -> int: ... if sys.platform != "darwin": def io_counters(self) -> pio: ... def ionice(self, ioclass: int | None = None, value: int | None = None) -> pionice: ... def cpu_affinity(self, cpus: list[int] | None = None) -> list[int] | None: ... def memory_maps(self, grouped: bool = True): ... if sys.platform == "linux": def rlimit(self, resource: int, limits: tuple[int, int] | None = ...) -> tuple[int, int]: ... def cpu_num(self) -> int: ... def environ(self) -> dict[str, str]: ... if sys.platform == "win32": def num_handles(self) -> int: ... def num_ctx_switches(self) -> pctxsw: ... def num_threads(self) -> int: ... def threads(self) -> list[pthread]: ... def children(self, recursive: bool = False) -> list[Process]: ... def cpu_percent(self, interval: float | None = None) -> float: ... def cpu_times(self) -> pcputimes: ... def memory_info(self) -> pmem: ... def memory_full_info(self) -> pfullmem: ... def memory_percent(self, memtype: str = "rss") -> float: ... def open_files(self) -> list[popenfile]: ... @deprecated('use "net_connections" method instead') def connections(self, kind: str = "inet") -> list[pconn]: ... def send_signal(self, sig: int) -> None: ... def suspend(self) -> None: ... def resume(self) -> None: ... def terminate(self) -> None: ... def kill(self) -> None: ... def wait(self, timeout: float | None = None) -> int: ... def net_connections(self, kind: str = "inet") -> list[pconn]: ... class Popen(Process): def __init__(self, *args, **kwargs) -> None: ... def __enter__(self) -> Self: ... def __exit__( self, exc_type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None ) -> None: ... def __getattribute__(self, name: str) -> Any: ... def __dir__(self) -> list[str]: ... @type_check_only class _ProcessIterCallable(Protocol): def __call__( self, attrs: list[str] | tuple[str, ...] | set[str] | frozenset[str] | None = None, ad_value=None ) -> Iterator[Process]: ... def cache_clear(self) -> None: ... def pids() -> list[int]: ... def pid_exists(pid: int) -> bool: ... process_iter: _ProcessIterCallable def wait_procs( procs: Iterable[Process], timeout: float | None = None, callback: Callable[[Process], object] | None = None ) -> tuple[list[Process], list[Process]]: ... def cpu_count(logical: bool = True) -> int | None: ... @overload def cpu_freq(percpu: Literal[False] = False) -> scpufreq: ... @overload def cpu_freq(percpu: Literal[True]) -> list[scpufreq]: ... @overload def cpu_times(percpu: Literal[False] = False) -> scputimes: ... @overload def cpu_times(percpu: Literal[True]) -> list[scputimes]: ... @overload def cpu_percent(interval: float | None = None, percpu: Literal[False] = False) -> float: ... @overload def cpu_percent(interval: float | None, percpu: Literal[True]) -> list[float]: ... @overload def cpu_percent(*, percpu: Literal[True]) -> list[float]: ... @overload def cpu_times_percent(interval: float | None = None, percpu: Literal[False] = False) -> scputimes: ... @overload def cpu_times_percent(interval: float | None, percpu: Literal[True]) -> list[scputimes]: ... @overload def cpu_times_percent(*, percpu: Literal[True]) -> list[scputimes]: ... def cpu_stats() -> scpustats: ... def getloadavg() -> tuple[float, float, float]: ... def virtual_memory() -> svmem: ... def swap_memory() -> sswap: ... def disk_usage(path: str) -> sdiskusage: ... def disk_partitions(all: bool = False) -> list[sdiskpart]: ... @overload def disk_io_counters(perdisk: Literal[False] = False, nowrap: bool = True) -> sdiskio | None: ... @overload def disk_io_counters(perdisk: Literal[True], nowrap: bool = True) -> dict[str, sdiskio]: ... @overload def net_io_counters(pernic: Literal[False] = False, nowrap: bool = True) -> snetio: ... @overload def net_io_counters(pernic: Literal[True], nowrap: bool = True) -> dict[str, snetio]: ... def net_connections(kind: str = "inet") -> list[sconn]: ... def net_if_addrs() -> dict[str, list[snicaddr]]: ... def net_if_stats() -> dict[str, snicstats]: ... def boot_time() -> float: ... def users() -> list[suser]: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_common.pyi0000644000175100017510000002214115110223174021453 0ustar00runnerrunnerimport enum import io import threading from _typeshed import ConvertibleToFloat, FileDescriptorOrPath, Incomplete, StrOrBytesPath, SupportsWrite from collections.abc import Callable from socket import AF_INET6 as AF_INET6, AddressFamily, SocketKind from typing import BinaryIO, Final, NamedTuple, SupportsIndex, TypeVar, overload from typing_extensions import ParamSpec POSIX: Final[bool] WINDOWS: Final[bool] LINUX: Final[bool] MACOS: Final[bool] OSX: Final[bool] FREEBSD: Final[bool] OPENBSD: Final[bool] NETBSD: Final[bool] BSD: Final[bool] SUNOS: Final[bool] AIX: Final[bool] STATUS_RUNNING: Final = "running" STATUS_SLEEPING: Final = "sleeping" STATUS_DISK_SLEEP: Final = "disk-sleep" STATUS_STOPPED: Final = "stopped" STATUS_TRACING_STOP: Final = "tracing-stop" STATUS_ZOMBIE: Final = "zombie" STATUS_DEAD: Final = "dead" STATUS_WAKE_KILL: Final = "wake-kill" STATUS_WAKING: Final = "waking" STATUS_IDLE: Final = "idle" STATUS_LOCKED: Final = "locked" STATUS_WAITING: Final = "waiting" STATUS_SUSPENDED: Final = "suspended" STATUS_PARKED: Final = "parked" CONN_ESTABLISHED: Final = "ESTABLISHED" CONN_SYN_SENT: Final = "SYN_SENT" CONN_SYN_RECV: Final = "SYN_RECV" CONN_FIN_WAIT1: Final = "FIN_WAIT1" CONN_FIN_WAIT2: Final = "FIN_WAIT2" CONN_TIME_WAIT: Final = "TIME_WAIT" CONN_CLOSE: Final = "CLOSE" CONN_CLOSE_WAIT: Final = "CLOSE_WAIT" CONN_LAST_ACK: Final = "LAST_ACK" CONN_LISTEN: Final = "LISTEN" CONN_CLOSING: Final = "CLOSING" CONN_NONE: Final = "NONE" class NicDuplex(enum.IntEnum): NIC_DUPLEX_FULL = 2 NIC_DUPLEX_HALF = 1 NIC_DUPLEX_UNKNOWN = 0 NIC_DUPLEX_FULL: Final = NicDuplex.NIC_DUPLEX_FULL NIC_DUPLEX_HALF: Final = NicDuplex.NIC_DUPLEX_HALF NIC_DUPLEX_UNKNOWN: Final = NicDuplex.NIC_DUPLEX_UNKNOWN class BatteryTime(enum.IntEnum): POWER_TIME_UNKNOWN = -1 POWER_TIME_UNLIMITED = -2 POWER_TIME_UNKNOWN: Final = BatteryTime.POWER_TIME_UNKNOWN POWER_TIME_UNLIMITED: Final = BatteryTime.POWER_TIME_UNLIMITED ENCODING: Final[str] ENCODING_ERRS: Final[str] class sswap(NamedTuple): total: int used: int free: int percent: float sin: int sout: int class sdiskusage(NamedTuple): total: int used: int free: int percent: float class sdiskio(NamedTuple): read_count: int write_count: int read_bytes: int write_bytes: int read_time: int write_time: int class sdiskpart(NamedTuple): device: str mountpoint: str fstype: str opts: str class snetio(NamedTuple): bytes_sent: int bytes_recv: int packets_sent: int packets_recv: int errin: int errout: int dropin: int dropout: int class suser(NamedTuple): name: str terminal: str | None host: str | None started: float pid: str class sconn(NamedTuple): fd: int family: AddressFamily type: SocketKind laddr: addr | tuple[()] raddr: addr | tuple[()] status: str pid: int | None class snicaddr(NamedTuple): family: AddressFamily address: str netmask: str | None broadcast: str | None ptp: str | None class snicstats(NamedTuple): isup: bool duplex: int speed: int mtu: int flags: str class scpustats(NamedTuple): ctx_switches: int interrupts: int soft_interrupts: int syscalls: int class scpufreq(NamedTuple): current: float min: float max: float class shwtemp(NamedTuple): label: str current: float high: float | None critical: float | None class sbattery(NamedTuple): percent: int secsleft: int power_plugged: bool class sfan(NamedTuple): label: str current: int class pcputimes(NamedTuple): user: float system: float children_user: float children_system: float class popenfile(NamedTuple): path: str fd: int class pthread(NamedTuple): id: int user_time: float system_time: float class puids(NamedTuple): real: int effective: int saved: int class pgids(NamedTuple): real: int effective: int saved: int class pio(NamedTuple): read_count: int write_count: int read_bytes: int write_bytes: int class pionice(NamedTuple): ioclass: int value: int class pctxsw(NamedTuple): voluntary: int involuntary: int class pconn(NamedTuple): fd: int family: AddressFamily type: SocketKind laddr: addr raddr: addr status: str class addr(NamedTuple): ip: str port: int conn_tmap: dict[str, tuple[list[AddressFamily], list[SocketKind]]] class Error(Exception): msg: str def __init__(self, msg: str = ...) -> None: ... class NoSuchProcess(Error): pid: int name: str | None msg: str def __init__(self, pid: int, name: str | None = None, msg: str | None = None) -> None: ... class ZombieProcess(NoSuchProcess): ppid: int | None def __init__(self, pid: int, name: str | None = None, ppid: int | None = None, msg: str | None = None) -> None: ... class AccessDenied(Error): pid: int | None name: str | None msg: str def __init__(self, pid: int | None = None, name: str | None = None, msg: str | None = None) -> None: ... class TimeoutExpired(Error): seconds: float pid: int | None name: str | None msg: str def __init__(self, seconds: float, pid: int | None = None, name: str | None = None) -> None: ... _P = ParamSpec("_P") _R = TypeVar("_R") def usage_percent(used: ConvertibleToFloat, total: float, round_: SupportsIndex | None = None) -> float: ... # returned function has `cache_clear()` attribute: def memoize(fun: Callable[_P, _R]) -> Callable[_P, _R]: ... # returned function has `cache_activate(proc)` and `cache_deactivate(proc)` attributes: def memoize_when_activated(fun: Callable[_P, _R]) -> Callable[_P, _R]: ... def isfile_strict(path: StrOrBytesPath) -> bool: ... def path_exists_strict(path: StrOrBytesPath) -> bool: ... def supports_ipv6() -> bool: ... def parse_environ_block(data: str) -> dict[str, str]: ... def sockfam_to_enum(num: int) -> AddressFamily: ... def socktype_to_enum(num: int) -> SocketKind: ... @overload def conn_to_ntuple(fd: int, fam: int, type_: int, laddr, raddr, status: str, status_map, pid: int) -> sconn: ... @overload def conn_to_ntuple(fd: int, fam: int, type_: int, laddr, raddr, status: str, status_map, pid: None = None) -> pconn: ... def deprecated_method(replacement: str) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ... class _WrapNumbers: lock: threading.Lock cache: dict[Incomplete, Incomplete] reminders: dict[Incomplete, Incomplete] reminder_keys: dict[Incomplete, Incomplete] def __init__(self) -> None: ... def run(self, input_dict, name): ... def cache_clear(self, name=None) -> None: ... def cache_info(self) -> tuple[dict[Incomplete, Incomplete], dict[Incomplete, Incomplete], dict[Incomplete, Incomplete]]: ... def wrap_numbers(input_dict, name: str): ... def open_binary(fname: FileDescriptorOrPath) -> BinaryIO: ... def open_text(fname: FileDescriptorOrPath) -> io.TextIOWrapper: ... def cat(fname: FileDescriptorOrPath, fallback=..., _open=...): ... def bcat(fname: FileDescriptorOrPath, fallback=...): ... def bytes2human(n: int, format: str = "%(value).1f%(symbol)s") -> str: ... def get_procfs_path() -> str: ... def decode(s: bytes) -> str: ... def term_supports_colors(file: SupportsWrite[str] = ...) -> bool: ... def hilite(s: str, color: str | None = None, bold: bool = False) -> str: ... def print_color(s: str, color: str | None = None, bold: bool = False, file: SupportsWrite[str] = ...) -> None: ... def debug(msg: str | Exception) -> None: ... __all__ = [ # OS constants "FREEBSD", "BSD", "LINUX", "NETBSD", "OPENBSD", "MACOS", "OSX", "POSIX", "SUNOS", "WINDOWS", # connection constants "CONN_CLOSE", "CONN_CLOSE_WAIT", "CONN_CLOSING", "CONN_ESTABLISHED", "CONN_FIN_WAIT1", "CONN_FIN_WAIT2", "CONN_LAST_ACK", "CONN_LISTEN", "CONN_NONE", "CONN_SYN_RECV", "CONN_SYN_SENT", "CONN_TIME_WAIT", # net constants "NIC_DUPLEX_FULL", "NIC_DUPLEX_HALF", "NIC_DUPLEX_UNKNOWN", # process status constants "STATUS_DEAD", "STATUS_DISK_SLEEP", "STATUS_IDLE", "STATUS_LOCKED", "STATUS_RUNNING", "STATUS_SLEEPING", "STATUS_STOPPED", "STATUS_SUSPENDED", "STATUS_TRACING_STOP", "STATUS_WAITING", "STATUS_WAKE_KILL", "STATUS_WAKING", "STATUS_ZOMBIE", "STATUS_PARKED", # other constants "ENCODING", "ENCODING_ERRS", "AF_INET6", # named tuples "pconn", "pcputimes", "pctxsw", "pgids", "pio", "pionice", "popenfile", "pthread", "puids", "sconn", "scpustats", "sdiskio", "sdiskpart", "sdiskusage", "snetio", "snicaddr", "snicstats", "sswap", "suser", # utility functions "conn_tmap", "deprecated_method", "isfile_strict", "memoize", "parse_environ_block", "path_exists_strict", "usage_percent", "supports_ipv6", "sockfam_to_enum", "socktype_to_enum", "wrap_numbers", "open_text", "open_binary", "cat", "bcat", "bytes2human", "conn_to_ntuple", "debug", # shell utils "hilite", "term_supports_colors", "print_color", ] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psaix.pyi0000644000175100017510000000461315110223174021313 0ustar00runnerrunnerfrom _typeshed import Incomplete from typing import NamedTuple from psutil._common import ( NIC_DUPLEX_FULL as NIC_DUPLEX_FULL, NIC_DUPLEX_HALF as NIC_DUPLEX_HALF, NIC_DUPLEX_UNKNOWN as NIC_DUPLEX_UNKNOWN, AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, ZombieProcess as ZombieProcess, conn_to_ntuple as conn_to_ntuple, get_procfs_path as get_procfs_path, memoize_when_activated as memoize_when_activated, usage_percent as usage_percent, ) __extra__all__: Incomplete HAS_THREADS: Incomplete HAS_NET_IO_COUNTERS: Incomplete HAS_PROC_IO_COUNTERS: Incomplete PAGE_SIZE: Incomplete AF_LINK: Incomplete PROC_STATUSES: Incomplete TCP_STATUSES: Incomplete proc_info_map: Incomplete class pmem(NamedTuple): rss: Incomplete vms: Incomplete pfullmem = pmem class scputimes(NamedTuple): user: float system: float idle: float iowait: float class svmem(NamedTuple): total: Incomplete available: Incomplete percent: Incomplete used: Incomplete free: Incomplete def virtual_memory(): ... def swap_memory(): ... def cpu_times(): ... def per_cpu_times(): ... def cpu_count_logical(): ... def cpu_count_cores(): ... def cpu_stats(): ... disk_io_counters: Incomplete disk_usage: Incomplete def disk_partitions(all: bool = ...): ... net_if_addrs: Incomplete net_io_counters: Incomplete def net_connections(kind, _pid: int = ...): ... def net_if_stats(): ... def boot_time(): ... def users(): ... def pids(): ... def pid_exists(pid): ... def wrap_exceptions(fun): ... class Process: pid: Incomplete def __init__(self, pid) -> None: ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self): ... def exe(self): ... def cmdline(self): ... def environ(self): ... def create_time(self): ... def num_threads(self): ... def threads(self): ... def net_connections(self, kind: str = ...): ... def nice_get(self): ... def nice_set(self, value): ... def ppid(self): ... def uids(self): ... def gids(self): ... def cpu_times(self): ... def terminal(self): ... def cwd(self): ... def memory_info(self): ... memory_full_info: Incomplete def status(self): ... def open_files(self): ... def num_fds(self): ... def num_ctx_switches(self): ... def wait(self, timeout: Incomplete | None = ...): ... def io_counters(self): ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psbsd.pyi0000644000175100017510000001004415110223174021275 0ustar00runnerrunnerfrom _typeshed import Incomplete from contextlib import AbstractContextManager from typing import NamedTuple from psutil._common import ( FREEBSD as FREEBSD, NETBSD as NETBSD, OPENBSD as OPENBSD, AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, ZombieProcess as ZombieProcess, conn_tmap as conn_tmap, conn_to_ntuple as conn_to_ntuple, memoize as memoize, pio, usage_percent as usage_percent, ) __extra__all__: Incomplete PROC_STATUSES: Incomplete TCP_STATUSES: Incomplete PAGESIZE: Incomplete AF_LINK: Incomplete HAS_PROC_NUM_THREADS: Incomplete kinfo_proc_map: Incomplete class svmem(NamedTuple): total: int available: int percent: float used: int free: int active: int inactive: int buffers: int cached: int shared: int wired: int class scputimes(NamedTuple): user: float nice: float system: float idle: float irq: float class pmem(NamedTuple): rss: Incomplete vms: Incomplete text: Incomplete data: Incomplete stack: Incomplete pfullmem = pmem class pcputimes(NamedTuple): user: Incomplete system: Incomplete children_user: Incomplete children_system: Incomplete class pmmap_grouped(NamedTuple): path: Incomplete rss: Incomplete private: Incomplete ref_count: Incomplete shadow_count: Incomplete class pmmap_ext(NamedTuple): addr: Incomplete perms: Incomplete path: Incomplete rss: Incomplete private: Incomplete ref_count: Incomplete shadow_count: Incomplete class sdiskio(NamedTuple): read_count: Incomplete write_count: Incomplete read_bytes: Incomplete write_bytes: Incomplete read_time: Incomplete write_time: Incomplete busy_time: Incomplete def virtual_memory() -> svmem: ... def swap_memory(): ... def cpu_times(): ... def per_cpu_times(): ... def cpu_count_logical(): ... def cpu_count_cores() -> int | None: ... def cpu_stats(): ... def disk_partitions(all: bool = ...): ... disk_usage: Incomplete disk_io_counters: Incomplete net_io_counters: Incomplete net_if_addrs: Incomplete def net_if_stats(): ... def net_connections(kind): ... def sensors_battery(): ... def sensors_temperatures(): ... def cpu_freq(): ... def boot_time(): ... def users(): ... INIT_BOOT_TIME: float def adjust_proc_create_time(ctime: float) -> float: ... def pids(): ... def pid_exists(pid): ... def is_zombie(pid): ... def wrap_exceptions(fun): ... def wrap_exceptions_procfs(inst) -> AbstractContextManager[None]: ... class Process: pid: Incomplete def __init__(self, pid) -> None: ... def oneshot(self): ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self): ... def exe(self): ... def cmdline(self): ... def environ(self): ... def terminal(self): ... def ppid(self): ... def uids(self): ... def gids(self): ... def cpu_times(self): ... def cpu_num(self): ... def memory_info(self): ... memory_full_info: Incomplete def create_time(self, monotonic: bool = False) -> float: ... def num_threads(self): ... def num_ctx_switches(self): ... def threads(self): ... def net_connections(self, kind: str = ...): ... def wait(self, timeout: Incomplete | None = ...): ... def nice_get(self): ... def nice_set(self, value): ... def status(self): ... def io_counters(self) -> pio: ... def cwd(self): ... class nt_mmap_grouped(NamedTuple): path: Incomplete rss: Incomplete private: Incomplete ref_count: Incomplete shadow_count: Incomplete class nt_mmap_ext(NamedTuple): addr: Incomplete perms: Incomplete path: Incomplete rss: Incomplete private: Incomplete ref_count: Incomplete shadow_count: Incomplete def open_files(self): ... def num_fds(self): ... def cpu_affinity_get(self): ... def cpu_affinity_set(self, cpus) -> None: ... def memory_maps(self): ... def rlimit(self, resource, limits: Incomplete | None = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_pslinux.pyi0000644000175100017510000001370715110223174021675 0ustar00runnerrunnerimport enum from _typeshed import Incomplete from typing import NamedTuple from psutil._common import ( NIC_DUPLEX_FULL as NIC_DUPLEX_FULL, NIC_DUPLEX_HALF as NIC_DUPLEX_HALF, NIC_DUPLEX_UNKNOWN as NIC_DUPLEX_UNKNOWN, AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, ZombieProcess as ZombieProcess, isfile_strict as isfile_strict, parse_environ_block as parse_environ_block, path_exists_strict as path_exists_strict, supports_ipv6 as supports_ipv6, usage_percent as usage_percent, ) __extra__all__: Incomplete POWER_SUPPLY_PATH: str HAS_PROC_SMAPS: bool HAS_PROC_SMAPS_ROLLUP: bool HAS_PROC_IO_PRIORITY: Incomplete HAS_CPU_AFFINITY: Incomplete CLOCK_TICKS: Incomplete PAGESIZE: Incomplete LITTLE_ENDIAN: Incomplete UNSET: object DISK_SECTOR_SIZE: int AF_LINK: Incomplete AddressFamily: Incomplete IOPRIO_CLASS_NONE: int IOPRIO_CLASS_RT: int IOPRIO_CLASS_BE: int IOPRIO_CLASS_IDLE: int class IOPriority(enum.IntEnum): IOPRIO_CLASS_NONE = 0 IOPRIO_CLASS_RT = 1 IOPRIO_CLASS_BE = 2 IOPRIO_CLASS_IDLE = 3 PROC_STATUSES: Incomplete TCP_STATUSES: Incomplete class svmem(NamedTuple): total: int available: int percent: float used: int free: int active: int inactive: int buffers: int cached: int shared: int slab: int class sdiskio(NamedTuple): read_count: Incomplete write_count: Incomplete read_bytes: Incomplete write_bytes: Incomplete read_time: Incomplete write_time: Incomplete read_merged_count: Incomplete write_merged_count: Incomplete busy_time: Incomplete class popenfile(NamedTuple): path: Incomplete fd: Incomplete position: Incomplete mode: Incomplete flags: Incomplete class pmem(NamedTuple): rss: Incomplete vms: Incomplete shared: Incomplete text: Incomplete lib: Incomplete data: Incomplete dirty: Incomplete class pfullmem(NamedTuple): rss: Incomplete vms: Incomplete shared: Incomplete text: Incomplete lib: Incomplete data: Incomplete dirty: Incomplete uss: Incomplete pss: Incomplete swap: Incomplete class pmmap_grouped(NamedTuple): path: Incomplete rss: Incomplete size: Incomplete pss: Incomplete shared_clean: Incomplete shared_dirty: Incomplete private_clean: Incomplete private_dirty: Incomplete referenced: Incomplete anonymous: Incomplete swap: Incomplete pmmap_ext: Incomplete class pio(NamedTuple): read_count: Incomplete write_count: Incomplete read_bytes: Incomplete write_bytes: Incomplete read_chars: Incomplete write_chars: Incomplete class pcputimes(NamedTuple): user: float system: float children_user: float children_system: float iowait: float def readlink(path): ... def file_flags_to_mode(flags): ... def is_storage_device(name): ... def set_scputimes_ntuple(procfs_path) -> None: ... class scputimes(NamedTuple): # Note: scputimes has different fields depending on exactly how Linux # is setup, but we'll include the "complete" set of fields user: float nice: float system: float idle: float iowait: float irq: float softirq: float steal: float guest: float guest_nice: float def calculate_avail_vmem(mems): ... def virtual_memory() -> svmem: ... def swap_memory(): ... def cpu_times(): ... def per_cpu_times(): ... def cpu_count_logical(): ... def cpu_count_cores() -> int | None: ... def cpu_stats(): ... def cpu_freq(): ... net_if_addrs: Incomplete class _Ipv6UnsupportedError(Exception): ... class NetConnections: tmap: Incomplete def __init__(self) -> None: ... def get_proc_inodes(self, pid): ... def get_all_inodes(self): ... @staticmethod def decode_address(addr, family): ... @staticmethod def process_inet(file, family, type_, inodes, filter_pid: Incomplete | None = ...) -> None: ... @staticmethod def process_unix(file, family, inodes, filter_pid: Incomplete | None = ...) -> None: ... def retrieve(self, kind, pid: Incomplete | None = ...): ... def net_connections(kind: str = ...): ... def net_io_counters(): ... def net_if_stats(): ... disk_usage: Incomplete def disk_io_counters(perdisk: bool = ...): ... class RootFsDeviceFinder: major: Incomplete minor: Incomplete def __init__(self) -> None: ... def ask_proc_partitions(self): ... def ask_sys_dev_block(self): ... def ask_sys_class_block(self): ... def find(self): ... def disk_partitions(all: bool = ...): ... def sensors_temperatures(): ... def sensors_fans(): ... def sensors_battery(): ... def users(): ... def boot_time(): ... def pids(): ... def pid_exists(pid): ... def ppid_map(): ... def wrap_exceptions(fun): ... class Process: pid: Incomplete def __init__(self, pid) -> None: ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self): ... def exe(self): ... def cmdline(self): ... def environ(self): ... def terminal(self): ... def io_counters(self) -> pio: ... def cpu_times(self): ... def cpu_num(self): ... def wait(self, timeout: Incomplete | None = ...): ... def create_time(self, monotonic: bool = False) -> float: ... def memory_info(self): ... def memory_full_info(self): ... def memory_maps(self): ... def cwd(self): ... def num_ctx_switches(self, _ctxsw_re=...): ... def num_threads(self, _num_threads_re=...): ... def threads(self): ... def nice_get(self): ... def nice_set(self, value): ... def cpu_affinity_get(self): ... def cpu_affinity_set(self, cpus) -> None: ... def ionice_get(self): ... def ionice_set(self, ioclass, value): ... def rlimit(self, resource_, limits: Incomplete | None = ...): ... def status(self): ... def open_files(self): ... def net_connections(self, kind: str = ...): ... def num_fds(self): ... def ppid(self): ... def uids(self, _uids_re=...): ... def gids(self, _gids_re=...): ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psosx.pyi0000644000175100017510000000761615110223174021351 0ustar00runnerrunnerimport sys if sys.platform == "darwin": from collections.abc import Callable from typing import Final, NamedTuple, TypeVar from typing_extensions import ParamSpec from psutil._common import ( AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, ZombieProcess as ZombieProcess, conn_tmap as conn_tmap, conn_to_ntuple as conn_to_ntuple, debug as debug, isfile_strict as isfile_strict, memoize_when_activated as memoize_when_activated, parse_environ_block as parse_environ_block, usage_percent as usage_percent, ) from . import _common, _psposix, _psutil_osx, _psutil_posix _P = ParamSpec("_P") _R = TypeVar("_R") __extra__all__: Final[list[str]] PAGESIZE: Final[int] AF_LINK: Final[int] TCP_STATUSES: Final[dict[int, str]] PROC_STATUSES: Final[dict[int, str]] kinfo_proc_map: Final[dict[str, int]] pidtaskinfo_map: Final[dict[str, int]] class scputimes(NamedTuple): user: float nice: float system: float idle: float class svmem(NamedTuple): total: int available: int percent: float used: int free: int active: int inactive: int wired: int class pmem(NamedTuple): rss: int vms: int pfaults: int pageins: int class pfullmem(NamedTuple): rss: int vms: int pfaults: int pageins: int uss: int def virtual_memory() -> svmem: ... def swap_memory() -> _common.sswap: ... def cpu_times() -> scputimes: ... def per_cpu_times() -> list[scputimes]: ... def cpu_count_logical() -> int | None: ... def cpu_count_cores() -> int | None: ... def cpu_stats() -> _common.scpustats: ... def cpu_freq() -> list[_common.scpufreq]: ... disk_usage = _psposix.disk_usage disk_io_counters = _psutil_osx.disk_io_counters def disk_partitions(all: bool = False) -> list[_common.sdiskpart]: ... def sensors_battery() -> _common.sbattery | None: ... net_io_counters = _psutil_osx.net_io_counters net_if_addrs = _psutil_posix.net_if_addrs def net_connections(kind: str = "inet") -> list[_common.sconn]: ... def net_if_stats() -> dict[str, _common.snicstats]: ... def boot_time() -> float: ... INIT_BOOT_TIME: float def adjust_proc_create_time(ctime: float) -> float: ... def users() -> list[_common.suser]: ... def pids() -> list[int]: ... pid_exists = _psposix.pid_exists def wrap_exceptions(fun: Callable[_P, _R]) -> Callable[_P, _R]: ... def is_zombie(pid: int) -> bool: ... class Process: __slots__ = ["_cache", "_name", "_ppid", "pid"] pid: int def __init__(self, pid: int) -> None: ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self) -> str: ... def exe(self) -> str: ... def cmdline(self) -> list[str]: ... def environ(self) -> dict[str, str]: ... def ppid(self) -> int: ... def cwd(self) -> str: ... def uids(self) -> _common.puids: ... def gids(self) -> _common.puids: ... def terminal(self) -> str | None: ... def memory_info(self) -> pmem: ... def memory_full_info(self) -> pfullmem: ... def cpu_times(self) -> _common.pcputimes: ... def create_time(self, monotonic: bool = False) -> float: ... def num_ctx_switches(self) -> _common.pctxsw: ... def num_threads(self) -> int: ... def open_files(self) -> list[_common.popenfile]: ... def net_connections(self, kind: str = "inet"): ... def num_fds(self) -> int: ... def wait(self, timeout: float | None = None): ... def nice_get(self): ... def nice_set(self, value): ... def status(self) -> str: ... def threads(self) -> list[_common.pthread]: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psposix.pyi0000644000175100017510000000114415110223174021670 0ustar00runnerrunnerimport sys from _typeshed import FileDescriptorOrPath, StrOrBytesPath from ._common import sdiskusage def pid_exists(pid: int) -> bool: ... def wait_pid( pid: int, timeout: float | None = None, proc_name: str | None = None, _waitpid=..., _timer=..., _min=..., _sleep=..., _pid_exists=..., ): ... if sys.platform == "darwin": def disk_usage(path: StrOrBytesPath) -> sdiskusage: ... else: def disk_usage(path: FileDescriptorOrPath) -> sdiskusage: ... def get_terminal_map() -> dict[int, str]: ... __all__ = ["pid_exists", "wait_pid", "disk_usage", "get_terminal_map"] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_pssunos.pyi0000644000175100017510000000577315110223174021711 0ustar00runnerrunnerfrom _typeshed import Incomplete from typing import NamedTuple from psutil._common import ( AF_INET6 as AF_INET6, AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, ZombieProcess as ZombieProcess, debug as debug, get_procfs_path as get_procfs_path, isfile_strict as isfile_strict, memoize_when_activated as memoize_when_activated, sockfam_to_enum as sockfam_to_enum, socktype_to_enum as socktype_to_enum, usage_percent as usage_percent, ) __extra__all__: Incomplete PAGE_SIZE: Incomplete AF_LINK: Incomplete IS_64_BIT: Incomplete CONN_IDLE: str CONN_BOUND: str PROC_STATUSES: Incomplete TCP_STATUSES: Incomplete proc_info_map: Incomplete class scputimes(NamedTuple): user: Incomplete system: Incomplete idle: Incomplete iowait: Incomplete class pcputimes(NamedTuple): user: Incomplete system: Incomplete children_user: Incomplete children_system: Incomplete class svmem(NamedTuple): total: Incomplete available: Incomplete percent: Incomplete used: Incomplete free: Incomplete class pmem(NamedTuple): rss: Incomplete vms: Incomplete pfullmem = pmem class pmmap_grouped(NamedTuple): path: Incomplete rss: Incomplete anonymous: Incomplete locked: Incomplete pmmap_ext: Incomplete def virtual_memory(): ... def swap_memory(): ... def cpu_times(): ... def per_cpu_times(): ... def cpu_count_logical(): ... def cpu_count_cores(): ... def cpu_stats(): ... disk_io_counters: Incomplete disk_usage: Incomplete def disk_partitions(all: bool = ...): ... net_io_counters: Incomplete net_if_addrs: Incomplete def net_connections(kind, _pid: int = ...): ... def net_if_stats(): ... def boot_time(): ... def users(): ... def pids(): ... def pid_exists(pid): ... def wrap_exceptions(fun): ... class Process: pid: Incomplete def __init__(self, pid) -> None: ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self): ... def exe(self): ... def cmdline(self): ... def environ(self): ... def create_time(self): ... def num_threads(self): ... def nice_get(self): ... def nice_set(self, value): ... def ppid(self): ... def uids(self): ... def gids(self): ... def cpu_times(self): ... def cpu_num(self): ... def terminal(self): ... def cwd(self): ... def memory_info(self): ... memory_full_info: Incomplete def status(self): ... def threads(self): ... def open_files(self): ... def net_connections(self, kind: str = ...): ... class nt_mmap_grouped(NamedTuple): path: Incomplete rss: Incomplete anon: Incomplete locked: Incomplete class nt_mmap_ext(NamedTuple): addr: Incomplete perms: Incomplete path: Incomplete rss: Incomplete anon: Incomplete locked: Incomplete def memory_maps(self): ... def num_fds(self): ... def num_ctx_switches(self): ... def wait(self, timeout: Incomplete | None = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psutil_linux.pyi0000644000175100017510000000071215110223174022722 0ustar00runnerrunnerDUPLEX_FULL: int DUPLEX_HALF: int DUPLEX_UNKNOWN: int version: int def check_pid_range(pid: int, /) -> None: ... def disk_partitions(*args, **kwargs): ... def linux_sysinfo(*args, **kwargs): ... def net_if_duplex_speed(*args, **kwargs): ... def proc_cpu_affinity_get(*args, **kwargs): ... def proc_cpu_affinity_set(*args, **kwargs): ... def proc_ioprio_get(*args, **kwargs): ... def proc_ioprio_set(*args, **kwargs): ... def set_debug(*args, **kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psutil_osx.pyi0000644000175100017510000000527315110223174022403 0ustar00runnerrunnerimport sys if sys.platform == "darwin": from _typeshed import StrOrBytesPath from collections.abc import Sequence from socket import AddressFamily, SocketKind from typing import Final, TypeVar _T = TypeVar("_T") version: Final[int] SIDL: Final = 1 SRUN: Final = 2 SSLEEP: Final = 3 SSTOP: Final = 4 SZOMB: Final = 5 TCPS_CLOSED: Final = 0 TCPS_CLOSING: Final = 7 TCPS_CLOSE_WAIT: Final = 5 TCPS_LISTEN: Final = 1 TCPS_ESTABLISHED: Final = 4 TCPS_SYN_SENT: Final = 2 TCPS_SYN_RECEIVED: Final = 3 TCPS_FIN_WAIT_1: Final = 6 TCPS_FIN_WAIT_2: Final = 9 TCPS_LAST_ACK: Final = 8 TCPS_TIME_WAIT: Final = 10 PSUTIL_CONN_NONE: Final = 128 def proc_cmdline(pid: int, /) -> list[str]: ... def proc_cwd(pid: int, /) -> str: ... def proc_environ(pid: int, /) -> str: ... def proc_exe(pid: int, /) -> str: ... def proc_kinfo_oneshot(pid: int, /) -> tuple[int, int, int, int, int, int, int, float, int, str]: ... def proc_memory_uss(pid: int, /) -> int: ... def proc_name(pid: int, /) -> str: ... def proc_net_connections( pid: int, af_filter: Sequence[AddressFamily | int | None], type_filter: Sequence[SocketKind | int | None], / ) -> list[ tuple[int, int, int, tuple[str | None, int], tuple[str | None, int] | tuple[()], int] | tuple[int, int, int, str, str, int] ]: ... def proc_num_fds(pid: int, /) -> int: ... def proc_open_files(pid: int, /) -> list[tuple[str, int]]: ... def proc_pidtaskinfo_oneshot(pid: int, /) -> tuple[float, float, int, int, int, int, int, int]: ... def proc_threads(pid: int, /) -> list[tuple[int, float, float]]: ... def boot_time() -> float: ... def cpu_count_cores() -> int | None: ... def cpu_count_logical() -> int | None: ... def cpu_freq() -> tuple[int, int, int]: ... def cpu_stats() -> tuple[int, int, int, int, int]: ... def cpu_times() -> tuple[float, float, float, float]: ... def disk_io_counters() -> dict[str, tuple[int, int, int, int, int, int]]: ... def disk_partitions() -> list[tuple[str, str, str, str]]: ... def disk_usage_used(mount_point: StrOrBytesPath, default: _T, /) -> int | _T: ... def has_cpu_freq() -> bool: ... def net_io_counters() -> dict[str, tuple[int, int, int, int, int, int, int, int]]: ... def per_cpu_times() -> list[tuple[float, float, float, float]]: ... def pids() -> list[int]: ... def sensors_battery() -> tuple[int, int, int]: ... def swap_mem() -> tuple[int, int, int, int, int]: ... def virtual_mem() -> tuple[int, int, int, int, int, int]: ... def check_pid_range(pid: int, /) -> None: ... def set_debug(value: bool, /) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psutil_posix.pyi0000644000175100017510000000216415110223174022730 0ustar00runnerrunnerimport sys from _typeshed import Incomplete from typing import Final if sys.platform == "linux": RLIMIT_AS: Final[int] RLIMIT_CORE: Final[int] RLIMIT_CPU: Final[int] RLIMIT_DATA: Final[int] RLIMIT_FSIZE: Final[int] RLIMIT_LOCKS: Final[int] RLIMIT_MEMLOCK: Final[int] RLIMIT_MSGQUEUE: Final[int] RLIMIT_NICE: Final[int] RLIMIT_NOFILE: Final[int] RLIMIT_NPROC: Final[int] RLIMIT_RSS: Final[int] RLIMIT_RTPRIO: Final[int] RLIMIT_RTTIME: Final[int] RLIMIT_SIGPENDING: Final[int] RLIMIT_STACK: Final[int] RLIM_INFINITY: Final[int] def getpagesize() -> int: ... def getpriority(pid: int, /) -> int: ... def net_if_addrs() -> list[tuple[str, int, str | None, str | None, str | None, str | None]]: ... def net_if_flags(nic_name: str, /) -> list[str]: ... def net_if_is_running(nic_name: str, /) -> bool: ... def net_if_mtu(nic_name: str, /) -> int: ... if sys.platform == "darwin": AF_LINK: Final[int] def net_if_duplex_speed(nic_name: str, /) -> list[int]: ... def users() -> list[tuple[Incomplete, ...]]: ... def setpriority(pid: int, priority: int, /) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_psutil_windows.pyi0000644000175100017510000001165715110223174023267 0ustar00runnerrunnerimport sys if sys.platform == "win32": from collections.abc import Sequence from socket import AddressFamily, SocketKind from typing import Final version: Final[int] ABOVE_NORMAL_PRIORITY_CLASS: Final = 32768 BELOW_NORMAL_PRIORITY_CLASS: Final = 16384 HIGH_PRIORITY_CLASS: Final = 128 IDLE_PRIORITY_CLASS: Final = 64 NORMAL_PRIORITY_CLASS: Final = 32 REALTIME_PRIORITY_CLASS: Final = 256 MIB_TCP_STATE_CLOSED: Final = 1 MIB_TCP_STATE_CLOSING: Final = 9 MIB_TCP_STATE_CLOSE_WAIT: Final = 8 MIB_TCP_STATE_LISTEN: Final = 2 MIB_TCP_STATE_ESTAB: Final = 5 MIB_TCP_STATE_SYN_SENT: Final = 3 MIB_TCP_STATE_SYN_RCVD: Final = 4 MIB_TCP_STATE_FIN_WAIT1: Final = 6 MIB_TCP_STATE_FIN_WAIT2: Final = 7 MIB_TCP_STATE_LAST_ACK: Final = 10 MIB_TCP_STATE_TIME_WAIT: Final = 11 MIB_TCP_STATE_DELETE_TCB: Final = 12 PSUTIL_CONN_NONE: Final = 128 INFINITE: Final[int] ERROR_ACCESS_DENIED: Final = 5 ERROR_INVALID_NAME: Final = 123 ERROR_SERVICE_DOES_NOT_EXIST: Final = 1060 ERROR_PRIVILEGE_NOT_HELD: Final = 1314 WINVER: Final[int] WINDOWS_VISTA: Final = 60 WINDOWS_7: Final = 61 WINDOWS_8: Final = 62 WINDOWS_8_1: Final = 63 WINDOWS_10: Final = 100 class TimeoutAbandoned(Exception): ... class TimeoutExpired(Exception): ... def proc_cmdline(pid: int, use_peb: bool = True) -> list[str]: ... def proc_cpu_affinity_get(pid: int, /) -> int: ... def proc_cpu_affinity_set(pid: int, mask: int, /) -> None: ... def proc_cwd(pid: int, /) -> str: ... def proc_environ(pid: int, /) -> str: ... def proc_exe(pid: int, /) -> str: ... def proc_io_counters(pid: int, /) -> tuple[int, int, int, int, int, int]: ... def proc_io_priority_get(pid: int, /) -> int: ... def proc_io_priority_set(pid: int, priority: int, /) -> None: ... def proc_is_suspended(pid: int, /) -> bool: ... def proc_kill(pid: int, /) -> None: ... def proc_memory_info(pid: int, /) -> tuple[int, int, int, int, int, int, int, int, int, int]: ... def proc_memory_maps(pid: int, /) -> list[tuple[int, str, str, int]]: ... def proc_memory_uss(pid: int, /) -> int: ... def proc_num_handles(pid: int, /) -> int: ... def proc_open_files(pid: int, /) -> list[str]: ... def proc_priority_get(pid: int, /) -> int: ... def proc_priority_set(pid: int, priority: int, /) -> None: ... def proc_suspend_or_resume(pid: int, suspend: bool | None, /) -> None: ... def proc_threads(pid: int, /) -> list[tuple[int, float, float]]: ... def proc_times(pid: int, /) -> tuple[float, float, float]: ... def proc_username(pid: int, /) -> tuple[str, str]: ... def proc_wait(pid: int, timeout: int, /) -> int | None: ... def proc_info( pid: int, / ) -> tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int]: ... def uptime() -> float: ... def cpu_count_cores() -> int | None: ... def cpu_count_logical() -> int | None: ... def cpu_freq() -> tuple[int, int]: ... def cpu_stats() -> tuple[int, int, int, int]: ... def cpu_times() -> tuple[float, float, float]: ... def disk_io_counters() -> dict[str, tuple[int, int, int, int, int, int]]: ... def disk_partitions(all: bool, /) -> list[tuple[str, str, str, str]]: ... def disk_usage(path: str, /) -> tuple[int, int, int]: ... def getloadavg() -> tuple[float, float, float]: ... def getpagesize() -> int: ... def swap_percent() -> float: ... def init_loadavg_counter() -> None: ... def net_connections( pid: int, af_filter: Sequence[AddressFamily | int | None], type_filter: Sequence[SocketKind | int | None], / ) -> list[tuple[int, int, int, tuple[str | None, int], tuple[str | None, int], int, int]]: ... def net_if_addrs() -> list[tuple[str, int, str, str | None, None, None]]: ... def net_if_stats() -> dict[str, tuple[bool, int, int, int]]: ... def net_io_counters() -> dict[str, tuple[int, int, int, int, int, int, int, int]]: ... def per_cpu_times() -> list[tuple[float, float, float, float, float]]: ... def pid_exists(pid: int, /) -> bool: ... def pids() -> list[int]: ... def ppid_map() -> dict[int, int]: ... def sensors_battery() -> tuple[int, int, int, int]: ... def users() -> list[tuple[str, str | None, float]]: ... def virtual_mem() -> tuple[int, int, int, int]: ... def winservice_enumerate() -> list[tuple[str, str]]: ... def winservice_query_config(service_name: str, /) -> tuple[str, str, str, str]: ... def winservice_query_descr(service_name: str, /) -> str: ... def winservice_query_status(service_name: str, /) -> tuple[str, int] | str: ... def winservice_start(service_name: str, /) -> None: ... def winservice_stop(service_name: str, /) -> None: ... def QueryDosDevice(device_path: str, /) -> str: ... def check_pid_range(pid: int, /) -> None: ... def set_debug(value: bool, /) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780220.0 types_psutil-7.1.1.20251122/psutil-stubs/_pswindows.pyi0000644000175100017510000002027115110223174022222 0ustar00runnerrunnerimport sys if sys.platform == "win32": import enum from _typeshed import Incomplete from collections.abc import Iterable, Iterator from signal import Signals from typing import Final, Literal, NamedTuple, TypedDict, overload, type_check_only from psutil import _psutil_windows from psutil._common import ( ENCODING as ENCODING, AccessDenied as AccessDenied, NoSuchProcess as NoSuchProcess, TimeoutExpired as TimeoutExpired, conn_tmap as conn_tmap, conn_to_ntuple as conn_to_ntuple, debug as debug, isfile_strict as isfile_strict, memoize as memoize, memoize_when_activated as memoize_when_activated, parse_environ_block as parse_environ_block, usage_percent as usage_percent, ) from psutil._psutil_windows import ( ABOVE_NORMAL_PRIORITY_CLASS as ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS as BELOW_NORMAL_PRIORITY_CLASS, HIGH_PRIORITY_CLASS as HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS as IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS as NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS as REALTIME_PRIORITY_CLASS, ) from . import _common __extra__all__: Final[list[str]] CONN_DELETE_TCB: Final = "DELETE_TCB" ERROR_PARTIAL_COPY: Final = 299 PYPY: Final[bool] class AddressFamily(enum.IntEnum): AF_LINK = -1 AF_LINK: Final = AddressFamily.AF_LINK TCP_STATUSES: Final[dict[int, str]] # These noqas workaround https://github.com/astral-sh/ruff/issues/10874 class Priority(enum.IntEnum): ABOVE_NORMAL_PRIORITY_CLASS = _psutil_windows.ABOVE_NORMAL_PRIORITY_CLASS # noqa: F811 BELOW_NORMAL_PRIORITY_CLASS = _psutil_windows.BELOW_NORMAL_PRIORITY_CLASS # noqa: F811 HIGH_PRIORITY_CLASS = _psutil_windows.HIGH_PRIORITY_CLASS # noqa: F811 IDLE_PRIORITY_CLASS = _psutil_windows.IDLE_PRIORITY_CLASS # noqa: F811 NORMAL_PRIORITY_CLASS = _psutil_windows.NORMAL_PRIORITY_CLASS # noqa: F811 REALTIME_PRIORITY_CLASS = _psutil_windows.REALTIME_PRIORITY_CLASS # noqa: F811 class IOPriority(enum.IntEnum): IOPRIO_VERYLOW = 0 IOPRIO_LOW = 1 IOPRIO_NORMAL = 2 IOPRIO_HIGH = 3 IOPRIO_VERYLOW: Final = IOPriority.IOPRIO_VERYLOW IOPRIO_LOW: Final = IOPriority.IOPRIO_LOW IOPRIO_NORMAL: Final = IOPriority.IOPRIO_NORMAL IOPRIO_HIGH: Final = IOPriority.IOPRIO_HIGH pinfo_map: Final[dict[str, int]] class scputimes(NamedTuple): user: float system: float idle: float interrupt: float dpc: float class svmem(NamedTuple): total: int available: int percent: float used: int free: int class pmem(NamedTuple): rss: int vms: int num_page_faults: int peak_wset: int wset: int peak_paged_pool: int paged_pool: int peak_nonpaged_pool: int nonpaged_pool: int pagefile: int peak_pagefile: int private: int class pfullmem(NamedTuple): rss: int vms: int num_page_faults: int peak_wset: int wset: int peak_paged_pool: int paged_pool: int peak_nonpaged_pool: int nonpaged_pool: int pagefile: int peak_pagefile: int private: int uss: int class pmmap_grouped(NamedTuple): path: Incomplete rss: Incomplete class pmmap_ext(NamedTuple): addr: Incomplete perms: Incomplete path: Incomplete rss: Incomplete class pio(NamedTuple): read_count: int write_count: int read_bytes: int write_bytes: int other_count: int other_bytes: int def convert_dos_path(s: str) -> str: ... def getpagesize() -> int: ... def virtual_memory() -> svmem: ... def swap_memory() -> _common.sswap: ... disk_io_counters = _psutil_windows.disk_io_counters def disk_usage(path: str) -> _common.sdiskusage: ... def disk_partitions(all: bool) -> list[_common.sdiskpart]: ... def cpu_times() -> scputimes: ... def per_cpu_times() -> list[scputimes]: ... def cpu_count_logical() -> int | None: ... def cpu_count_cores() -> int | None: ... def cpu_stats() -> _common.scpustats: ... def cpu_freq() -> list[_common.scpufreq]: ... def getloadavg() -> tuple[float, float, float]: ... @overload def net_connections(kind: str, _pid: Literal[-1] = -1) -> list[_common.sconn]: ... @overload def net_connections(kind: str, _pid: int = -1) -> list[_common.pconn]: ... def net_if_stats() -> dict[str, _common.snicstats]: ... def net_io_counters() -> dict[str, tuple[int, int, int, int, int, int, int, int]]: ... def net_if_addrs() -> list[tuple[str, int, str, str | None, None, None]]: ... def sensors_battery() -> _common.sbattery | None: ... def boot_time() -> float: ... def users() -> list[_common.suser]: ... def win_service_iter() -> Iterator[WindowsService]: ... def win_service_get(name: str) -> WindowsService: ... @type_check_only class _WindowsServiceAttrs(TypedDict): name: str display_name: str | None description: str binpath: str username: str start_type: str status: str pid: int | None class WindowsService: def __init__(self, name: str, display_name: str | None) -> None: ... def __eq__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... def name(self) -> str: ... def display_name(self) -> str | None: ... def binpath(self) -> str: ... def username(self) -> str: ... def start_type(self) -> str: ... def pid(self) -> int: ... def status(self) -> str: ... def description(self) -> str: ... def as_dict(self) -> _WindowsServiceAttrs: ... pids = _psutil_windows.pids pid_exists = _psutil_windows.pid_exists ppid_map = _psutil_windows.ppid_map def is_permission_err(exc: OSError) -> bool: ... @overload def convert_oserror(exc: PermissionError, pid=None, name=None) -> AccessDenied: ... @overload def convert_oserror(exc: OSError, pid=None, name=None) -> AccessDenied | NoSuchProcess: ... def wrap_exceptions(fun): ... def retry_error_partial_copy(fun): ... class Process: __slots__ = ["_cache", "_name", "_ppid", "pid"] pid: int def __init__(self, pid: int) -> None: ... def oneshot_enter(self) -> None: ... def oneshot_exit(self) -> None: ... def name(self) -> str: ... def exe(self) -> str: ... def cmdline(self) -> list[str]: ... def environ(self) -> dict[str, str]: ... def ppid(self) -> int: ... def memory_info(self) -> pmem: ... def memory_full_info(self) -> pfullmem: ... def memory_maps(self) -> Iterator[tuple[str, str, str, int]]: ... def kill(self) -> None: ... def send_signal(self, sig: Literal[Signals.SIGTERM, Signals.CTRL_C_EVENT, Signals.CTRL_BREAK_EVENT]) -> None: ... def wait(self, timeout: float | None = None) -> int | None: ... def username(self) -> str: ... def create_time(self, fast_only: bool = False) -> float: ... def num_threads(self) -> int: ... def threads(self) -> list[_common.pthread]: ... def cpu_times(self) -> _common.pcputimes: ... def suspend(self) -> None: ... def resume(self) -> None: ... def cwd(self) -> str: ... def open_files(self) -> list[_common.popenfile]: ... def net_connections(self, kind: str = "inet") -> list[_common.pconn]: ... def nice_get(self) -> Priority: ... def nice_set(self, value) -> None: ... def ionice_get(self) -> IOPriority: ... def ionice_set(self, ioclass: int, value: None) -> None: ... def io_counters(self) -> pio: ... def status(self) -> Literal["stopped", "running"]: ... def cpu_affinity_get(self) -> list[int]: ... def cpu_affinity_set(self, value: Iterable[int]) -> None: ... def num_handles(self) -> int: ... def num_ctx_switches(self) -> _common.pctxsw: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/psutil-stubs/py.typed0000644000175100017510000000000015110223210020755 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/pyproject.toml0000644000175100017510000000353315110223210017532 0ustar00runnerrunner[build-system] build-backend = "setuptools.build_meta" requires = ["setuptools>=77.0.3"] [project] name = "types-psutil" version = "7.1.1.20251122" license = "Apache-2.0" license-files = ["LICENSE"] description = "Typing stubs for psutil" readme = { text = """\ ## Typing stubs for psutil This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html) for the [`psutil`](https://github.com/giampaolo/psutil) package. It can be used by type checkers to check code that uses `psutil`. This version of `types-psutil` aims to provide accurate annotations for `psutil==7.1.1`. This package is part of the [typeshed project](https://github.com/python/typeshed). All fixes for types and metadata should be contributed there. See [the README](https://github.com/python/typeshed/blob/main/README.md) for more details. The source for this package can be found in the [`stubs/psutil`](https://github.com/python/typeshed/tree/main/stubs/psutil) directory. This package was tested with the following type checkers: * [mypy](https://github.com/python/mypy/) 1.18.2 * [pyright](https://github.com/microsoft/pyright) 1.1.407 It was generated from typeshed commit [`cc792321dd482a5336225229bf584ad51a3e85cd`](https://github.com/python/typeshed/commit/cc792321dd482a5336225229bf584ad51a3e85cd). """, content-type = "text/markdown" } classifiers = [ "Programming Language :: Python :: 3", "Typing :: Stubs Only", ] requires-python = ">=3.9" dependencies = [] [project.urls] "Homepage" = "https://github.com/python/typeshed" "GitHub" = "https://github.com/python/typeshed" "Changes" = "https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/psutil.md" "Issue tracker" = "https://github.com/python/typeshed/issues" "Chat" = "https://gitter.im/python/typing" [tool.setuptools] packages = ['psutil-stubs'] include-package-data = false ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1763780233.5890462 types_psutil-7.1.1.20251122/setup.cfg0000644000175100017510000000004615110223212016435 0ustar00runnerrunner[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780232.0 types_psutil-7.1.1.20251122/setup.py0000644000175100017510000000050215110223210016321 0ustar00runnerrunner from setuptools import setup setup(package_data={'psutil-stubs': ['__init__.pyi', '_common.pyi', '_psaix.pyi', '_psbsd.pyi', '_pslinux.pyi', '_psosx.pyi', '_psposix.pyi', '_pssunos.pyi', '_psutil_linux.pyi', '_psutil_osx.pyi', '_psutil_posix.pyi', '_psutil_windows.pyi', '_pswindows.pyi', 'METADATA.toml', 'py.typed']}) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1763780233.5890462 types_psutil-7.1.1.20251122/types_psutil.egg-info/0000755000175100017510000000000015110223212021052 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780233.0 types_psutil-7.1.1.20251122/types_psutil.egg-info/PKG-INFO0000644000175100017510000000326715110223211022156 0ustar00runnerrunnerMetadata-Version: 2.4 Name: types-psutil Version: 7.1.1.20251122 Summary: Typing stubs for psutil License-Expression: Apache-2.0 Project-URL: Homepage, https://github.com/python/typeshed Project-URL: GitHub, https://github.com/python/typeshed Project-URL: Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/psutil.md Project-URL: Issue tracker, https://github.com/python/typeshed/issues Project-URL: Chat, https://gitter.im/python/typing Classifier: Programming Language :: Python :: 3 Classifier: Typing :: Stubs Only Requires-Python: >=3.9 Description-Content-Type: text/markdown License-File: LICENSE Dynamic: license-file ## Typing stubs for psutil This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html) for the [`psutil`](https://github.com/giampaolo/psutil) package. It can be used by type checkers to check code that uses `psutil`. This version of `types-psutil` aims to provide accurate annotations for `psutil==7.1.1`. This package is part of the [typeshed project](https://github.com/python/typeshed). All fixes for types and metadata should be contributed there. See [the README](https://github.com/python/typeshed/blob/main/README.md) for more details. The source for this package can be found in the [`stubs/psutil`](https://github.com/python/typeshed/tree/main/stubs/psutil) directory. This package was tested with the following type checkers: * [mypy](https://github.com/python/mypy/) 1.18.2 * [pyright](https://github.com/microsoft/pyright) 1.1.407 It was generated from typeshed commit [`cc792321dd482a5336225229bf584ad51a3e85cd`](https://github.com/python/typeshed/commit/cc792321dd482a5336225229bf584ad51a3e85cd). ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780233.0 types_psutil-7.1.1.20251122/types_psutil.egg-info/SOURCES.txt0000644000175100017510000000114415110223211022735 0ustar00runnerrunnerCHANGELOG.md LICENSE MANIFEST.in README.md pyproject.toml setup.py psutil-stubs/METADATA.toml psutil-stubs/__init__.pyi psutil-stubs/_common.pyi psutil-stubs/_psaix.pyi psutil-stubs/_psbsd.pyi psutil-stubs/_pslinux.pyi psutil-stubs/_psosx.pyi psutil-stubs/_psposix.pyi psutil-stubs/_pssunos.pyi psutil-stubs/_psutil_linux.pyi psutil-stubs/_psutil_osx.pyi psutil-stubs/_psutil_posix.pyi psutil-stubs/_psutil_windows.pyi psutil-stubs/_pswindows.pyi psutil-stubs/py.typed types_psutil.egg-info/PKG-INFO types_psutil.egg-info/SOURCES.txt types_psutil.egg-info/dependency_links.txt types_psutil.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780233.0 types_psutil-7.1.1.20251122/types_psutil.egg-info/dependency_links.txt0000644000175100017510000000000115110223211025117 0ustar00runnerrunner ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1763780233.0 types_psutil-7.1.1.20251122/types_psutil.egg-info/top_level.txt0000644000175100017510000000001515110223211023577 0ustar00runnerrunnerpsutil-stubs