winrt-Windows.System.Threading.Core 3.2.1__tar.gz → 4!10.0.28000.2957__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- winrt_windows_system_threading_core-4!10.0.28000.2957/.gitignore +5 -0
- winrt_windows_system_threading_core-4!10.0.28000.2957/LICENSE +22 -0
- winrt_windows_system_threading_core-4!10.0.28000.2957/PKG-INFO +45 -0
- winrt_windows_system_threading_core-4!10.0.28000.2957/README.md +17 -0
- winrt_windows_system_threading_core-4!10.0.28000.2957/pyproject.toml +57 -0
- winrt_windows_system_threading_core-4!10.0.28000.2957/winrt/windows/system/threading/core/__init__.py +18 -0
- winrt_windows_system_threading_core-3.2.1/winrt/_winrt_windows_system_threading_core.pyi → winrt_windows_system_threading_core-4!10.0.28000.2957/winrt/windows/system/threading/core/__init__.pyi +26 -13
- winrt_windows_system_threading_core-4!10.0.28000.2957/winrt/windows/system/threading/core/_table.pywinrt.txt +92 -0
- winrt_windows_system_threading_core-3.2.1/PKG-INFO +0 -26
- winrt_windows_system_threading_core-3.2.1/README.md +0 -7
- winrt_windows_system_threading_core-3.2.1/all-requirements.txt +0 -4
- winrt_windows_system_threading_core-3.2.1/py.Windows.System.Threading.Core.cpp +0 -591
- winrt_windows_system_threading_core-3.2.1/pyproject.toml +0 -47
- winrt_windows_system_threading_core-3.2.1/pywinrt-version.txt +0 -1
- winrt_windows_system_threading_core-3.2.1/requirements.txt +0 -3
- winrt_windows_system_threading_core-3.2.1/setup.cfg +0 -4
- winrt_windows_system_threading_core-3.2.1/setup.py +0 -33
- winrt_windows_system_threading_core-3.2.1/winrt/windows/system/threading/core/__init__.py +0 -18
- winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/PKG-INFO +0 -26
- winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/SOURCES.txt +0 -15
- winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/dependency_links.txt +0 -1
- winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/requires.txt +0 -5
- winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/top_level.txt +0 -1
- {winrt_windows_system_threading_core-3.2.1 → winrt_windows_system_threading_core-4!10.0.28000.2957}/winrt/windows/system/threading/core/py.typed +0 -0
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
4
|
+
Copyright (c) 2021-2026 David Lechner <david@pybricks.com>
|
|
5
|
+
|
|
6
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
7
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
8
|
+
in the Software without restriction, including without limitation the rights
|
|
9
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
10
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
11
|
+
furnished to do so, subject to the following conditions:
|
|
12
|
+
|
|
13
|
+
The above copyright notice and this permission notice shall be included in all
|
|
14
|
+
copies or substantial portions of the Software.
|
|
15
|
+
|
|
16
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
17
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
18
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
19
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
20
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
21
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
22
|
+
SOFTWARE
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
Metadata-Version: 2.5
|
|
2
|
+
Name: winrt-Windows.System.Threading.Core
|
|
3
|
+
Version: 4!10.0.28000.2957
|
|
4
|
+
Summary: PyWinRT projection of the Windows.System.Threading.Core namespace
|
|
5
|
+
Project-URL: Documentation, https://pywinrt.readthedocs.io
|
|
6
|
+
Project-URL: Repository, https://github.com/pywinrt/pywinrt
|
|
7
|
+
Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/projection/winrt/CHANGELOG.md
|
|
8
|
+
License-Expression: MIT
|
|
9
|
+
License-File: LICENSE
|
|
10
|
+
Classifier: Intended Audience :: Developers
|
|
11
|
+
Classifier: Operating System :: Microsoft :: Windows
|
|
12
|
+
Classifier: Programming Language :: Python :: 3
|
|
13
|
+
Classifier: Programming Language :: Python :: 3.11
|
|
14
|
+
Classifier: Programming Language :: Python :: 3.12
|
|
15
|
+
Classifier: Programming Language :: Python :: 3.13
|
|
16
|
+
Classifier: Programming Language :: Python :: 3.14
|
|
17
|
+
Classifier: Programming Language :: Python :: 3.15
|
|
18
|
+
Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
|
|
19
|
+
Classifier: Programming Language :: Python :: Implementation :: CPython
|
|
20
|
+
Classifier: Typing :: Typed
|
|
21
|
+
Requires-Python: >=3.11
|
|
22
|
+
Requires-Dist: winrt-runtime<5,>=4.0.0
|
|
23
|
+
Requires-Dist: winrt-windows-foundation>=4!10.0.28000.2957
|
|
24
|
+
Provides-Extra: all
|
|
25
|
+
Requires-Dist: winrt-windows-foundation[all]>=4!10.0.28000.2957; extra == 'all'
|
|
26
|
+
Requires-Dist: winrt-windows-system-threading[all]>=4!10.0.28000.2957; extra == 'all'
|
|
27
|
+
Description-Content-Type: text/markdown
|
|
28
|
+
|
|
29
|
+
<!-- warning: Please don't edit this file. It was automatically generated. -->
|
|
30
|
+
|
|
31
|
+
# winrt-Windows.System.Threading.Core
|
|
32
|
+
|
|
33
|
+
Windows Runtime (WinRT) APIs for the `Windows.System.Threading.Core` namespace.
|
|
34
|
+
|
|
35
|
+
This package provides the `winrt.windows.system.threading.core` module.
|
|
36
|
+
|
|
37
|
+
The WinRT APIs in it are those of version 10.0.28000.2957 of the
|
|
38
|
+
`Microsoft.Windows.SDK.CPP` NuGet package.
|
|
39
|
+
|
|
40
|
+
```
|
|
41
|
+
pip install winrt-Windows.System.Threading.Core
|
|
42
|
+
```
|
|
43
|
+
|
|
44
|
+
Other WinRT namespaces are packages of their own, so install the package of
|
|
45
|
+
each namespace your code imports from.
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
<!-- warning: Please don't edit this file. It was automatically generated. -->
|
|
2
|
+
|
|
3
|
+
# winrt-Windows.System.Threading.Core
|
|
4
|
+
|
|
5
|
+
Windows Runtime (WinRT) APIs for the `Windows.System.Threading.Core` namespace.
|
|
6
|
+
|
|
7
|
+
This package provides the `winrt.windows.system.threading.core` module.
|
|
8
|
+
|
|
9
|
+
The WinRT APIs in it are those of version 10.0.28000.2957 of the
|
|
10
|
+
`Microsoft.Windows.SDK.CPP` NuGet package.
|
|
11
|
+
|
|
12
|
+
```
|
|
13
|
+
pip install winrt-Windows.System.Threading.Core
|
|
14
|
+
```
|
|
15
|
+
|
|
16
|
+
Other WinRT namespaces are packages of their own, so install the package of
|
|
17
|
+
each namespace your code imports from.
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
# WARNING: Please don't edit this file. It was automatically generated.
|
|
2
|
+
|
|
3
|
+
[build-system]
|
|
4
|
+
requires = ["hatchling", "winrt-table-compiler>=4.0.0,<5"]
|
|
5
|
+
build-backend = "hatchling.build"
|
|
6
|
+
|
|
7
|
+
[project]
|
|
8
|
+
name = "winrt-Windows.System.Threading.Core"
|
|
9
|
+
version = "4!10.0.28000.2957"
|
|
10
|
+
description = "PyWinRT projection of the Windows.System.Threading.Core namespace"
|
|
11
|
+
readme = "README.md"
|
|
12
|
+
license = "MIT"
|
|
13
|
+
license-files = ["LICENSE"]
|
|
14
|
+
classifiers = [
|
|
15
|
+
"Operating System :: Microsoft :: Windows",
|
|
16
|
+
"Programming Language :: Python :: 3",
|
|
17
|
+
"Programming Language :: Python :: 3.11",
|
|
18
|
+
"Programming Language :: Python :: 3.12",
|
|
19
|
+
"Programming Language :: Python :: 3.13",
|
|
20
|
+
"Programming Language :: Python :: 3.14",
|
|
21
|
+
"Programming Language :: Python :: 3.15",
|
|
22
|
+
"Programming Language :: Python :: Implementation :: CPython",
|
|
23
|
+
"Intended Audience :: Developers",
|
|
24
|
+
"Programming Language :: Python :: Free Threading :: 2 - Beta",
|
|
25
|
+
"Typing :: Typed",
|
|
26
|
+
]
|
|
27
|
+
requires-python = ">=3.11"
|
|
28
|
+
dependencies = [
|
|
29
|
+
"winrt-runtime>=4.0.0,<5",
|
|
30
|
+
"winrt-Windows.Foundation>=4!10.0.28000.2957",
|
|
31
|
+
]
|
|
32
|
+
|
|
33
|
+
[project.optional-dependencies]
|
|
34
|
+
all = [
|
|
35
|
+
"winrt-Windows.Foundation[all]>=4!10.0.28000.2957",
|
|
36
|
+
"winrt-Windows.System.Threading[all]>=4!10.0.28000.2957",
|
|
37
|
+
]
|
|
38
|
+
|
|
39
|
+
[project.urls]
|
|
40
|
+
Documentation = "https://pywinrt.readthedocs.io"
|
|
41
|
+
Repository = "https://github.com/pywinrt/pywinrt"
|
|
42
|
+
Changelog = "https://github.com/pywinrt/pywinrt/blob/main/projection/winrt/CHANGELOG.md"
|
|
43
|
+
|
|
44
|
+
[tool.hatch.build.targets.sdist]
|
|
45
|
+
# The text form of the table is what the source distribution carries, and the
|
|
46
|
+
# compiled form is build output wherever it turns up. Hatchling reads no
|
|
47
|
+
# .gitignore above the package, so it has to be told about the latter.
|
|
48
|
+
only-include = ["winrt", "LICENSE", "README.md"]
|
|
49
|
+
exclude = ["**/_table.pywinrt"]
|
|
50
|
+
|
|
51
|
+
[tool.hatch.build.targets.wheel]
|
|
52
|
+
packages = ["winrt"]
|
|
53
|
+
exclude = ["**/_table.pywinrt.txt"]
|
|
54
|
+
|
|
55
|
+
# winrt.table.build_hooks in winrt-table-compiler, which compiles each table
|
|
56
|
+
# the package carries and puts the result beside the __init__.py that loads it.
|
|
57
|
+
[tool.hatch.build.targets.wheel.hooks.winrt-table-compiler]
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
# WARNING: Please don't edit this file. It was generated by Python/WinRT
|
|
2
|
+
|
|
3
|
+
import typing
|
|
4
|
+
|
|
5
|
+
import winrt.runtime._internals
|
|
6
|
+
import winrt.system
|
|
7
|
+
|
|
8
|
+
winrt.runtime._internals.load_projection(__spec__)
|
|
9
|
+
|
|
10
|
+
__all__ = [
|
|
11
|
+
"PreallocatedWorkItem",
|
|
12
|
+
"SignalNotifier",
|
|
13
|
+
"SignalHandler",
|
|
14
|
+
]
|
|
15
|
+
|
|
16
|
+
winrt.runtime._internals.alias_static_method(SignalNotifier, "attach_to_event_with_timeout", "attach_to_event")
|
|
17
|
+
winrt.runtime._internals.alias_static_method(SignalNotifier, "attach_to_semaphore_with_timeout", "attach_to_semaphore")
|
|
18
|
+
SignalHandler = typing.Callable[[SignalNotifier, bool], object]
|
|
@@ -1,47 +1,60 @@
|
|
|
1
|
-
# WARNING: Please don't edit this file. It was generated by Python/WinRT
|
|
1
|
+
# WARNING: Please don't edit this file. It was generated by Python/WinRT
|
|
2
2
|
|
|
3
3
|
import datetime
|
|
4
|
-
import sys
|
|
5
|
-
import types
|
|
6
4
|
import typing
|
|
7
|
-
|
|
8
|
-
from builtins import property as _property
|
|
5
|
+
from typing_extensions import deprecated
|
|
9
6
|
|
|
10
|
-
import winrt._winrt
|
|
11
7
|
import winrt.system
|
|
12
8
|
import winrt.windows.foundation as windows_foundation
|
|
13
9
|
import winrt.windows.system.threading as windows_system_threading
|
|
14
10
|
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
11
|
+
__all__ = [
|
|
12
|
+
"PreallocatedWorkItem",
|
|
13
|
+
"SignalNotifier",
|
|
14
|
+
"SignalHandler",
|
|
15
|
+
]
|
|
18
16
|
|
|
19
17
|
@typing.final
|
|
20
18
|
class PreallocatedWorkItem(winrt.system.Object):
|
|
21
19
|
@typing.overload
|
|
22
|
-
def __new__(cls
|
|
20
|
+
def __new__(cls, handler: windows_system_threading.WorkItemHandler, /) -> typing.Self: ...
|
|
23
21
|
@typing.overload
|
|
24
|
-
def __new__(cls
|
|
22
|
+
def __new__(cls, handler: windows_system_threading.WorkItemHandler, priority: windows_system_threading.WorkItemPriority, /) -> typing.Self: ...
|
|
25
23
|
@typing.overload
|
|
26
|
-
def __new__(cls
|
|
24
|
+
def __new__(cls, handler: windows_system_threading.WorkItemHandler, priority: windows_system_threading.WorkItemPriority, options: windows_system_threading.WorkItemOptions, /) -> typing.Self: ...
|
|
27
25
|
# Windows.Foundation.IAsyncAction Windows.System.Threading.Core.PreallocatedWorkItem::RunAsync()
|
|
28
26
|
def run_async(self) -> windows_foundation.IAsyncAction: ...
|
|
29
27
|
|
|
30
28
|
@typing.final
|
|
31
|
-
class SignalNotifier_Static(winrt.
|
|
29
|
+
class SignalNotifier_Static(winrt.system.Object_Static):
|
|
30
|
+
@typing.overload
|
|
32
31
|
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToEvent(System.String,Windows.System.Threading.Core.SignalHandler)
|
|
33
32
|
def attach_to_event(cls, name: str, handler: SignalHandler, /) -> SignalNotifier: ...
|
|
33
|
+
@typing.overload
|
|
34
|
+
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToEvent(System.String,Windows.System.Threading.Core.SignalHandler,Windows.Foundation.TimeSpan)
|
|
35
|
+
def attach_to_event(cls, name: str, handler: SignalHandler, timeout: datetime.timedelta, /) -> SignalNotifier: ...
|
|
36
|
+
# Deprecated alias of attach_to_event() for pywinrt v3.x compatibility.
|
|
34
37
|
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToEvent(System.String,Windows.System.Threading.Core.SignalHandler,Windows.Foundation.TimeSpan)
|
|
38
|
+
@deprecated("Use attach_to_event() instead.")
|
|
35
39
|
def attach_to_event_with_timeout(cls, name: str, handler: SignalHandler, timeout: datetime.timedelta, /) -> SignalNotifier: ...
|
|
40
|
+
@typing.overload
|
|
36
41
|
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToSemaphore(System.String,Windows.System.Threading.Core.SignalHandler)
|
|
37
42
|
def attach_to_semaphore(cls, name: str, handler: SignalHandler, /) -> SignalNotifier: ...
|
|
43
|
+
@typing.overload
|
|
44
|
+
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToSemaphore(System.String,Windows.System.Threading.Core.SignalHandler,Windows.Foundation.TimeSpan)
|
|
45
|
+
def attach_to_semaphore(cls, name: str, handler: SignalHandler, timeout: datetime.timedelta, /) -> SignalNotifier: ...
|
|
46
|
+
# Deprecated alias of attach_to_semaphore() for pywinrt v3.x compatibility.
|
|
38
47
|
# Windows.System.Threading.Core.SignalNotifier Windows.System.Threading.Core.SignalNotifier::AttachToSemaphore(System.String,Windows.System.Threading.Core.SignalHandler,Windows.Foundation.TimeSpan)
|
|
48
|
+
@deprecated("Use attach_to_semaphore() instead.")
|
|
39
49
|
def attach_to_semaphore_with_timeout(cls, name: str, handler: SignalHandler, timeout: datetime.timedelta, /) -> SignalNotifier: ...
|
|
40
50
|
|
|
41
51
|
@typing.final
|
|
42
52
|
class SignalNotifier(winrt.system.Object, metaclass=SignalNotifier_Static):
|
|
53
|
+
def __new__(cls, _: typing.Never, /) -> typing.Self:
|
|
54
|
+
"""WinRT gives this class no constructor; an instance comes from a method or property that returns one."""
|
|
43
55
|
# System.Void Windows.System.Threading.Core.SignalNotifier::Enable()
|
|
44
56
|
def enable(self) -> None: ...
|
|
45
57
|
# System.Void Windows.System.Threading.Core.SignalNotifier::Terminate()
|
|
46
58
|
def terminate(self) -> None: ...
|
|
47
59
|
|
|
60
|
+
type SignalHandler = typing.Callable[[SignalNotifier, bool], object]
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
format 4.0
|
|
2
|
+
census 2e30db26-66c8-4551-85b9-a537376d8f99 1
|
|
3
|
+
namespace Windows.System.Threading.Core
|
|
4
|
+
|
|
5
|
+
interface Windows.System.Threading.Core.IPreallocatedWorkItem
|
|
6
|
+
guid b6daa9fc-bc5b-401a-a8b2-6e754d14daa6
|
|
7
|
+
|
|
8
|
+
interface Windows.System.Threading.Core.IPreallocatedWorkItemFactory
|
|
9
|
+
guid e3d32b45-dfea-469b-82c5-f6e3cefdeafb
|
|
10
|
+
|
|
11
|
+
interface Windows.System.Threading.Core.ISignalNotifier
|
|
12
|
+
guid 14285e06-63a7-4713-b6d9-62f64b56fb8b
|
|
13
|
+
|
|
14
|
+
interface Windows.System.Threading.Core.ISignalNotifierStatics
|
|
15
|
+
guid 1c4e4566-8400-46d3-a115-7d0c0dfc9f62
|
|
16
|
+
|
|
17
|
+
class Windows.System.Threading.Core.PreallocatedWorkItem python_type
|
|
18
|
+
py PreallocatedWorkItem
|
|
19
|
+
signature rc(Windows.System.Threading.Core.PreallocatedWorkItem;{b6daa9fc-bc5b-401a-a8b2-6e754d14daa6})
|
|
20
|
+
default Windows.System.Threading.Core.IPreallocatedWorkItem
|
|
21
|
+
requires Windows.System.Threading.Core.IPreallocatedWorkItem
|
|
22
|
+
factory Windows.System.Threading.Core.IPreallocatedWorkItemFactory
|
|
23
|
+
constructor -
|
|
24
|
+
ctor .ctor slot=6 inputs=1 outputs=1 declaring=Windows.System.Threading.Core.IPreallocatedWorkItemFactory shape=51
|
|
25
|
+
in delegate type=Windows.System.Threading.WorkItemHandler name=handler
|
|
26
|
+
out class type=Windows.System.Threading.Core.PreallocatedWorkItem return
|
|
27
|
+
ctor .ctor slot=7 inputs=2 outputs=1 declaring=Windows.System.Threading.Core.IPreallocatedWorkItemFactory shape=117
|
|
28
|
+
in delegate type=Windows.System.Threading.WorkItemHandler name=handler
|
|
29
|
+
in enum32 type=Windows.System.Threading.WorkItemPriority name=priority
|
|
30
|
+
out class type=Windows.System.Threading.Core.PreallocatedWorkItem return
|
|
31
|
+
ctor .ctor slot=8 inputs=3 outputs=1 declaring=Windows.System.Threading.Core.IPreallocatedWorkItemFactory shape=195
|
|
32
|
+
in delegate type=Windows.System.Threading.WorkItemHandler name=handler
|
|
33
|
+
in enum32 type=Windows.System.Threading.WorkItemPriority name=priority
|
|
34
|
+
in enum_u32 type=Windows.System.Threading.WorkItemOptions name=options
|
|
35
|
+
out class type=Windows.System.Threading.Core.PreallocatedWorkItem return
|
|
36
|
+
method run_async
|
|
37
|
+
method RunAsync slot=6 inputs=0 outputs=1 declaring=Windows.System.Threading.Core.IPreallocatedWorkItem shape=4
|
|
38
|
+
out interface type=Windows.Foundation.IAsyncAction return
|
|
39
|
+
|
|
40
|
+
delegate Windows.System.Threading.Core.SignalHandler python_type
|
|
41
|
+
py SignalHandler
|
|
42
|
+
guid 923c402e-4721-440e-9dda-55b6f2e07710
|
|
43
|
+
signature delegate({923c402e-4721-440e-9dda-55b6f2e07710})
|
|
44
|
+
method -
|
|
45
|
+
method Invoke slot=3 inputs=2 outputs=0 shape=51 reverse=4
|
|
46
|
+
in class type=Windows.System.Threading.Core.SignalNotifier name=signalNotifier
|
|
47
|
+
in boolean name=timedOut
|
|
48
|
+
|
|
49
|
+
class Windows.System.Threading.Core.SignalNotifier python_type
|
|
50
|
+
py SignalNotifier
|
|
51
|
+
signature rc(Windows.System.Threading.Core.SignalNotifier;{14285e06-63a7-4713-b6d9-62f64b56fb8b})
|
|
52
|
+
default Windows.System.Threading.Core.ISignalNotifier
|
|
53
|
+
requires Windows.System.Threading.Core.ISignalNotifier
|
|
54
|
+
factory Windows.System.Threading.Core.ISignalNotifierStatics
|
|
55
|
+
method attach_to_event static
|
|
56
|
+
method AttachToEvent slot=6 inputs=2 outputs=1 declaring=Windows.System.Threading.Core.ISignalNotifierStatics shape=117 static
|
|
57
|
+
in string name=name
|
|
58
|
+
in delegate type=Windows.System.Threading.Core.SignalHandler name=handler
|
|
59
|
+
out class type=Windows.System.Threading.Core.SignalNotifier return
|
|
60
|
+
method AttachToEvent slot=7 inputs=3 outputs=1 declaring=Windows.System.Threading.Core.ISignalNotifierStatics shape=200 static
|
|
61
|
+
in string name=name
|
|
62
|
+
in delegate type=Windows.System.Threading.Core.SignalHandler name=handler
|
|
63
|
+
in timespan name=timeout
|
|
64
|
+
out class type=Windows.System.Threading.Core.SignalNotifier return
|
|
65
|
+
method attach_to_semaphore static
|
|
66
|
+
method AttachToSemaphore slot=8 inputs=2 outputs=1 declaring=Windows.System.Threading.Core.ISignalNotifierStatics shape=117 static
|
|
67
|
+
in string name=name
|
|
68
|
+
in delegate type=Windows.System.Threading.Core.SignalHandler name=handler
|
|
69
|
+
out class type=Windows.System.Threading.Core.SignalNotifier return
|
|
70
|
+
method AttachToSemaphore slot=9 inputs=3 outputs=1 declaring=Windows.System.Threading.Core.ISignalNotifierStatics shape=200 static
|
|
71
|
+
in string name=name
|
|
72
|
+
in delegate type=Windows.System.Threading.Core.SignalHandler name=handler
|
|
73
|
+
in timespan name=timeout
|
|
74
|
+
out class type=Windows.System.Threading.Core.SignalNotifier return
|
|
75
|
+
method enable
|
|
76
|
+
method Enable slot=6 inputs=0 outputs=0 declaring=Windows.System.Threading.Core.ISignalNotifier shape=0
|
|
77
|
+
method terminate
|
|
78
|
+
method Terminate slot=7 inputs=0 outputs=0 declaring=Windows.System.Threading.Core.ISignalNotifier shape=0
|
|
79
|
+
|
|
80
|
+
interface Windows.Foundation.IAsyncAction external
|
|
81
|
+
py winrt.windows.foundation._IAsyncAction
|
|
82
|
+
guid 5a648006-843a-4da9-865b-9d26e5dfad7b
|
|
83
|
+
|
|
84
|
+
delegate Windows.System.Threading.WorkItemHandler external
|
|
85
|
+
py winrt.windows.system.threading.WorkItemHandler
|
|
86
|
+
guid 1d1a8b8b-fa66-414f-9cbd-b65fc99d17fa
|
|
87
|
+
|
|
88
|
+
enum Windows.System.Threading.WorkItemOptions external
|
|
89
|
+
py winrt.windows.system.threading.WorkItemOptions
|
|
90
|
+
|
|
91
|
+
enum Windows.System.Threading.WorkItemPriority external
|
|
92
|
+
py winrt.windows.system.threading.WorkItemPriority
|
|
@@ -1,26 +0,0 @@
|
|
|
1
|
-
Metadata-Version: 2.4
|
|
2
|
-
Name: winrt-Windows.System.Threading.Core
|
|
3
|
-
Version: 3.2.1
|
|
4
|
-
Summary: Python projection of Windows Runtime (WinRT) APIs
|
|
5
|
-
License-Expression: MIT
|
|
6
|
-
Project-URL: Documentation, https://pywinrt.readthedocs.io
|
|
7
|
-
Project-URL: Repository, https://github.com/pywinrt/pywinrt
|
|
8
|
-
Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
|
|
9
|
-
Classifier: Operating System :: Microsoft :: Windows
|
|
10
|
-
Classifier: Programming Language :: Python :: 3
|
|
11
|
-
Classifier: Programming Language :: Python :: Implementation :: CPython
|
|
12
|
-
Classifier: Intended Audience :: Developers
|
|
13
|
-
Requires-Python: >=3.9
|
|
14
|
-
Description-Content-Type: text/markdown
|
|
15
|
-
Requires-Dist: winrt-runtime~=3.2.1.0
|
|
16
|
-
Provides-Extra: all
|
|
17
|
-
Requires-Dist: winrt-Windows.Foundation[all]~=3.2.1.0; extra == "all"
|
|
18
|
-
Requires-Dist: winrt-Windows.System.Threading[all]~=3.2.1.0; extra == "all"
|
|
19
|
-
|
|
20
|
-
<!-- warning: Please don't edit this file. It was automatically generated. -->
|
|
21
|
-
|
|
22
|
-
# winrt-Windows.System.Threading.Core
|
|
23
|
-
|
|
24
|
-
Windows Runtime (WinRT) APIs for for the `Windows.System.Threading.Core` namespace.
|
|
25
|
-
|
|
26
|
-
This package provides the `winrt.windows.system.threading.core` module.
|
|
@@ -1,7 +0,0 @@
|
|
|
1
|
-
<!-- warning: Please don't edit this file. It was automatically generated. -->
|
|
2
|
-
|
|
3
|
-
# winrt-Windows.System.Threading.Core
|
|
4
|
-
|
|
5
|
-
Windows Runtime (WinRT) APIs for for the `Windows.System.Threading.Core` namespace.
|
|
6
|
-
|
|
7
|
-
This package provides the `winrt.windows.system.threading.core` module.
|
|
@@ -1,591 +0,0 @@
|
|
|
1
|
-
// WARNING: Please don't edit this file. It was generated by Python/WinRT v3.2.1
|
|
2
|
-
|
|
3
|
-
#include "py.Windows.System.Threading.Core.h"
|
|
4
|
-
|
|
5
|
-
namespace py::cpp::Windows::System::Threading::Core
|
|
6
|
-
{
|
|
7
|
-
// ----- PreallocatedWorkItem class --------------------
|
|
8
|
-
|
|
9
|
-
static PyObject* _new_PreallocatedWorkItem(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
|
|
10
|
-
{
|
|
11
|
-
if (kwds)
|
|
12
|
-
{
|
|
13
|
-
py::set_invalid_kwd_args_error();
|
|
14
|
-
return nullptr;
|
|
15
|
-
}
|
|
16
|
-
|
|
17
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
18
|
-
if (arg_count == 1)
|
|
19
|
-
{
|
|
20
|
-
try
|
|
21
|
-
{
|
|
22
|
-
auto param0 = py::convert_to<winrt::Windows::System::Threading::WorkItemHandler>(args, 0);
|
|
23
|
-
|
|
24
|
-
winrt::Windows::System::Threading::Core::PreallocatedWorkItem instance{param0};
|
|
25
|
-
return py::wrap(instance, type);
|
|
26
|
-
}
|
|
27
|
-
catch (...)
|
|
28
|
-
{
|
|
29
|
-
py::to_PyErr();
|
|
30
|
-
return nullptr;
|
|
31
|
-
}
|
|
32
|
-
}
|
|
33
|
-
else if (arg_count == 2)
|
|
34
|
-
{
|
|
35
|
-
try
|
|
36
|
-
{
|
|
37
|
-
auto param0 = py::convert_to<winrt::Windows::System::Threading::WorkItemHandler>(args, 0);
|
|
38
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::WorkItemPriority>(args, 1);
|
|
39
|
-
|
|
40
|
-
winrt::Windows::System::Threading::Core::PreallocatedWorkItem instance{param0, param1};
|
|
41
|
-
return py::wrap(instance, type);
|
|
42
|
-
}
|
|
43
|
-
catch (...)
|
|
44
|
-
{
|
|
45
|
-
py::to_PyErr();
|
|
46
|
-
return nullptr;
|
|
47
|
-
}
|
|
48
|
-
}
|
|
49
|
-
else if (arg_count == 3)
|
|
50
|
-
{
|
|
51
|
-
try
|
|
52
|
-
{
|
|
53
|
-
auto param0 = py::convert_to<winrt::Windows::System::Threading::WorkItemHandler>(args, 0);
|
|
54
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::WorkItemPriority>(args, 1);
|
|
55
|
-
auto param2 = py::convert_to<winrt::Windows::System::Threading::WorkItemOptions>(args, 2);
|
|
56
|
-
|
|
57
|
-
winrt::Windows::System::Threading::Core::PreallocatedWorkItem instance{param0, param1, param2};
|
|
58
|
-
return py::wrap(instance, type);
|
|
59
|
-
}
|
|
60
|
-
catch (...)
|
|
61
|
-
{
|
|
62
|
-
py::to_PyErr();
|
|
63
|
-
return nullptr;
|
|
64
|
-
}
|
|
65
|
-
}
|
|
66
|
-
else
|
|
67
|
-
{
|
|
68
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
69
|
-
return nullptr;
|
|
70
|
-
}
|
|
71
|
-
}
|
|
72
|
-
|
|
73
|
-
static void _dealloc_PreallocatedWorkItem(py::wrapper::Windows::System::Threading::Core::PreallocatedWorkItem* self) noexcept
|
|
74
|
-
{
|
|
75
|
-
auto tp = Py_TYPE(self);
|
|
76
|
-
std::destroy_at(&self->obj);
|
|
77
|
-
tp->tp_free(self);
|
|
78
|
-
Py_DECREF(tp);
|
|
79
|
-
}
|
|
80
|
-
|
|
81
|
-
static PyObject* PreallocatedWorkItem_RunAsync(py::wrapper::Windows::System::Threading::Core::PreallocatedWorkItem* self, PyObject* args) noexcept
|
|
82
|
-
{
|
|
83
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
84
|
-
|
|
85
|
-
if (arg_count == 0)
|
|
86
|
-
{
|
|
87
|
-
try
|
|
88
|
-
{
|
|
89
|
-
static std::optional<bool> is_overload_present{};
|
|
90
|
-
|
|
91
|
-
if (!is_overload_present.has_value())
|
|
92
|
-
{
|
|
93
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.PreallocatedWorkItem", L"RunAsync", 0);
|
|
94
|
-
}
|
|
95
|
-
|
|
96
|
-
if (!is_overload_present.value())
|
|
97
|
-
{
|
|
98
|
-
py::set_arg_count_version_error(0);
|
|
99
|
-
return nullptr;
|
|
100
|
-
}
|
|
101
|
-
|
|
102
|
-
return py::convert([&]()
|
|
103
|
-
{
|
|
104
|
-
auto _gil = release_gil();
|
|
105
|
-
return self->obj.RunAsync();
|
|
106
|
-
}());
|
|
107
|
-
}
|
|
108
|
-
catch (...)
|
|
109
|
-
{
|
|
110
|
-
py::to_PyErr();
|
|
111
|
-
return nullptr;
|
|
112
|
-
}
|
|
113
|
-
}
|
|
114
|
-
else
|
|
115
|
-
{
|
|
116
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
117
|
-
return nullptr;
|
|
118
|
-
}
|
|
119
|
-
}
|
|
120
|
-
|
|
121
|
-
static PyObject* _assign_array_PreallocatedWorkItem(PyObject* /*unused*/, PyObject* arg) noexcept
|
|
122
|
-
{
|
|
123
|
-
auto array = std::make_unique<py::ComArray<winrt::Windows::System::Threading::Core::PreallocatedWorkItem>>();
|
|
124
|
-
if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
|
|
125
|
-
{
|
|
126
|
-
return nullptr;
|
|
127
|
-
}
|
|
128
|
-
Py_RETURN_NONE;
|
|
129
|
-
}
|
|
130
|
-
|
|
131
|
-
static PyObject* _from_PreallocatedWorkItem(PyObject* /*unused*/, PyObject* arg) noexcept
|
|
132
|
-
{
|
|
133
|
-
try
|
|
134
|
-
{
|
|
135
|
-
auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
|
|
136
|
-
return py::convert(return_value.as<winrt::Windows::System::Threading::Core::PreallocatedWorkItem>());
|
|
137
|
-
}
|
|
138
|
-
catch (...)
|
|
139
|
-
{
|
|
140
|
-
py::to_PyErr();
|
|
141
|
-
return nullptr;
|
|
142
|
-
}
|
|
143
|
-
}
|
|
144
|
-
|
|
145
|
-
static PyMethodDef _methods_PreallocatedWorkItem[] = {
|
|
146
|
-
{ "run_async", reinterpret_cast<PyCFunction>(PreallocatedWorkItem_RunAsync), METH_VARARGS, nullptr },
|
|
147
|
-
{ "_assign_array_", _assign_array_PreallocatedWorkItem, METH_O | METH_STATIC, nullptr },
|
|
148
|
-
{ "_from", reinterpret_cast<PyCFunction>(_from_PreallocatedWorkItem), METH_O | METH_STATIC, nullptr },
|
|
149
|
-
{ }};
|
|
150
|
-
|
|
151
|
-
static PyGetSetDef _getset_PreallocatedWorkItem[] = {
|
|
152
|
-
{ }};
|
|
153
|
-
|
|
154
|
-
static PyType_Slot _type_slots_PreallocatedWorkItem[] = {
|
|
155
|
-
{ Py_tp_new, reinterpret_cast<void*>(_new_PreallocatedWorkItem) },
|
|
156
|
-
{ Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PreallocatedWorkItem) },
|
|
157
|
-
{ Py_tp_methods, reinterpret_cast<void*>(_methods_PreallocatedWorkItem) },
|
|
158
|
-
{ Py_tp_getset, reinterpret_cast<void*>(_getset_PreallocatedWorkItem) },
|
|
159
|
-
{ }};
|
|
160
|
-
|
|
161
|
-
static PyType_Spec type_spec_PreallocatedWorkItem = {
|
|
162
|
-
"winrt._winrt_windows_system_threading_core.PreallocatedWorkItem",
|
|
163
|
-
sizeof(py::wrapper::Windows::System::Threading::Core::PreallocatedWorkItem),
|
|
164
|
-
0,
|
|
165
|
-
Py_TPFLAGS_DEFAULT,
|
|
166
|
-
_type_slots_PreallocatedWorkItem};
|
|
167
|
-
|
|
168
|
-
// ----- SignalNotifier class --------------------
|
|
169
|
-
|
|
170
|
-
static PyObject* _new_SignalNotifier(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
|
|
171
|
-
{
|
|
172
|
-
static_assert(py::py_type<winrt::Windows::System::Threading::Core::SignalNotifier>::type_name);
|
|
173
|
-
py::set_invalid_activation_error(py::py_type<winrt::Windows::System::Threading::Core::SignalNotifier>::type_name);
|
|
174
|
-
return nullptr;
|
|
175
|
-
}
|
|
176
|
-
|
|
177
|
-
static void _dealloc_SignalNotifier(py::wrapper::Windows::System::Threading::Core::SignalNotifier* self) noexcept
|
|
178
|
-
{
|
|
179
|
-
auto tp = Py_TYPE(self);
|
|
180
|
-
std::destroy_at(&self->obj);
|
|
181
|
-
tp->tp_free(self);
|
|
182
|
-
Py_DECREF(tp);
|
|
183
|
-
}
|
|
184
|
-
|
|
185
|
-
static PyObject* SignalNotifier_AttachToEvent(PyObject* /*unused*/, PyObject* args) noexcept
|
|
186
|
-
{
|
|
187
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
188
|
-
|
|
189
|
-
if (arg_count == 2)
|
|
190
|
-
{
|
|
191
|
-
try
|
|
192
|
-
{
|
|
193
|
-
static std::optional<bool> is_overload_present{};
|
|
194
|
-
|
|
195
|
-
if (!is_overload_present.has_value())
|
|
196
|
-
{
|
|
197
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"AttachToEvent", 2);
|
|
198
|
-
}
|
|
199
|
-
|
|
200
|
-
if (!is_overload_present.value())
|
|
201
|
-
{
|
|
202
|
-
py::set_arg_count_version_error(2);
|
|
203
|
-
return nullptr;
|
|
204
|
-
}
|
|
205
|
-
|
|
206
|
-
auto param0 = py::convert_to<winrt::hstring>(args, 0);
|
|
207
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::Core::SignalHandler>(args, 1);
|
|
208
|
-
|
|
209
|
-
return py::convert([&]()
|
|
210
|
-
{
|
|
211
|
-
auto _gil = release_gil();
|
|
212
|
-
return winrt::Windows::System::Threading::Core::SignalNotifier::AttachToEvent(param0, param1);
|
|
213
|
-
}());
|
|
214
|
-
}
|
|
215
|
-
catch (...)
|
|
216
|
-
{
|
|
217
|
-
py::to_PyErr();
|
|
218
|
-
return nullptr;
|
|
219
|
-
}
|
|
220
|
-
}
|
|
221
|
-
else
|
|
222
|
-
{
|
|
223
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
224
|
-
return nullptr;
|
|
225
|
-
}
|
|
226
|
-
}
|
|
227
|
-
|
|
228
|
-
static PyObject* SignalNotifier_AttachToEventWithTimeout(PyObject* /*unused*/, PyObject* args) noexcept
|
|
229
|
-
{
|
|
230
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
231
|
-
|
|
232
|
-
if (arg_count == 3)
|
|
233
|
-
{
|
|
234
|
-
try
|
|
235
|
-
{
|
|
236
|
-
static std::optional<bool> is_overload_present{};
|
|
237
|
-
|
|
238
|
-
if (!is_overload_present.has_value())
|
|
239
|
-
{
|
|
240
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"AttachToEvent", 3);
|
|
241
|
-
}
|
|
242
|
-
|
|
243
|
-
if (!is_overload_present.value())
|
|
244
|
-
{
|
|
245
|
-
py::set_arg_count_version_error(3);
|
|
246
|
-
return nullptr;
|
|
247
|
-
}
|
|
248
|
-
|
|
249
|
-
auto param0 = py::convert_to<winrt::hstring>(args, 0);
|
|
250
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::Core::SignalHandler>(args, 1);
|
|
251
|
-
auto param2 = py::convert_to<winrt::Windows::Foundation::TimeSpan>(args, 2);
|
|
252
|
-
|
|
253
|
-
return py::convert([&]()
|
|
254
|
-
{
|
|
255
|
-
auto _gil = release_gil();
|
|
256
|
-
return winrt::Windows::System::Threading::Core::SignalNotifier::AttachToEvent(param0, param1, param2);
|
|
257
|
-
}());
|
|
258
|
-
}
|
|
259
|
-
catch (...)
|
|
260
|
-
{
|
|
261
|
-
py::to_PyErr();
|
|
262
|
-
return nullptr;
|
|
263
|
-
}
|
|
264
|
-
}
|
|
265
|
-
else
|
|
266
|
-
{
|
|
267
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
268
|
-
return nullptr;
|
|
269
|
-
}
|
|
270
|
-
}
|
|
271
|
-
|
|
272
|
-
static PyObject* SignalNotifier_AttachToSemaphore(PyObject* /*unused*/, PyObject* args) noexcept
|
|
273
|
-
{
|
|
274
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
275
|
-
|
|
276
|
-
if (arg_count == 2)
|
|
277
|
-
{
|
|
278
|
-
try
|
|
279
|
-
{
|
|
280
|
-
static std::optional<bool> is_overload_present{};
|
|
281
|
-
|
|
282
|
-
if (!is_overload_present.has_value())
|
|
283
|
-
{
|
|
284
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"AttachToSemaphore", 2);
|
|
285
|
-
}
|
|
286
|
-
|
|
287
|
-
if (!is_overload_present.value())
|
|
288
|
-
{
|
|
289
|
-
py::set_arg_count_version_error(2);
|
|
290
|
-
return nullptr;
|
|
291
|
-
}
|
|
292
|
-
|
|
293
|
-
auto param0 = py::convert_to<winrt::hstring>(args, 0);
|
|
294
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::Core::SignalHandler>(args, 1);
|
|
295
|
-
|
|
296
|
-
return py::convert([&]()
|
|
297
|
-
{
|
|
298
|
-
auto _gil = release_gil();
|
|
299
|
-
return winrt::Windows::System::Threading::Core::SignalNotifier::AttachToSemaphore(param0, param1);
|
|
300
|
-
}());
|
|
301
|
-
}
|
|
302
|
-
catch (...)
|
|
303
|
-
{
|
|
304
|
-
py::to_PyErr();
|
|
305
|
-
return nullptr;
|
|
306
|
-
}
|
|
307
|
-
}
|
|
308
|
-
else
|
|
309
|
-
{
|
|
310
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
311
|
-
return nullptr;
|
|
312
|
-
}
|
|
313
|
-
}
|
|
314
|
-
|
|
315
|
-
static PyObject* SignalNotifier_AttachToSemaphoreWithTimeout(PyObject* /*unused*/, PyObject* args) noexcept
|
|
316
|
-
{
|
|
317
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
318
|
-
|
|
319
|
-
if (arg_count == 3)
|
|
320
|
-
{
|
|
321
|
-
try
|
|
322
|
-
{
|
|
323
|
-
static std::optional<bool> is_overload_present{};
|
|
324
|
-
|
|
325
|
-
if (!is_overload_present.has_value())
|
|
326
|
-
{
|
|
327
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"AttachToSemaphore", 3);
|
|
328
|
-
}
|
|
329
|
-
|
|
330
|
-
if (!is_overload_present.value())
|
|
331
|
-
{
|
|
332
|
-
py::set_arg_count_version_error(3);
|
|
333
|
-
return nullptr;
|
|
334
|
-
}
|
|
335
|
-
|
|
336
|
-
auto param0 = py::convert_to<winrt::hstring>(args, 0);
|
|
337
|
-
auto param1 = py::convert_to<winrt::Windows::System::Threading::Core::SignalHandler>(args, 1);
|
|
338
|
-
auto param2 = py::convert_to<winrt::Windows::Foundation::TimeSpan>(args, 2);
|
|
339
|
-
|
|
340
|
-
return py::convert([&]()
|
|
341
|
-
{
|
|
342
|
-
auto _gil = release_gil();
|
|
343
|
-
return winrt::Windows::System::Threading::Core::SignalNotifier::AttachToSemaphore(param0, param1, param2);
|
|
344
|
-
}());
|
|
345
|
-
}
|
|
346
|
-
catch (...)
|
|
347
|
-
{
|
|
348
|
-
py::to_PyErr();
|
|
349
|
-
return nullptr;
|
|
350
|
-
}
|
|
351
|
-
}
|
|
352
|
-
else
|
|
353
|
-
{
|
|
354
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
355
|
-
return nullptr;
|
|
356
|
-
}
|
|
357
|
-
}
|
|
358
|
-
|
|
359
|
-
static PyObject* SignalNotifier_Enable(py::wrapper::Windows::System::Threading::Core::SignalNotifier* self, PyObject* args) noexcept
|
|
360
|
-
{
|
|
361
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
362
|
-
|
|
363
|
-
if (arg_count == 0)
|
|
364
|
-
{
|
|
365
|
-
try
|
|
366
|
-
{
|
|
367
|
-
static std::optional<bool> is_overload_present{};
|
|
368
|
-
|
|
369
|
-
if (!is_overload_present.has_value())
|
|
370
|
-
{
|
|
371
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"Enable", 0);
|
|
372
|
-
}
|
|
373
|
-
|
|
374
|
-
if (!is_overload_present.value())
|
|
375
|
-
{
|
|
376
|
-
py::set_arg_count_version_error(0);
|
|
377
|
-
return nullptr;
|
|
378
|
-
}
|
|
379
|
-
|
|
380
|
-
{
|
|
381
|
-
auto _gil = release_gil();
|
|
382
|
-
self->obj.Enable();
|
|
383
|
-
}
|
|
384
|
-
|
|
385
|
-
Py_RETURN_NONE;
|
|
386
|
-
}
|
|
387
|
-
catch (...)
|
|
388
|
-
{
|
|
389
|
-
py::to_PyErr();
|
|
390
|
-
return nullptr;
|
|
391
|
-
}
|
|
392
|
-
}
|
|
393
|
-
else
|
|
394
|
-
{
|
|
395
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
396
|
-
return nullptr;
|
|
397
|
-
}
|
|
398
|
-
}
|
|
399
|
-
|
|
400
|
-
static PyObject* SignalNotifier_Terminate(py::wrapper::Windows::System::Threading::Core::SignalNotifier* self, PyObject* args) noexcept
|
|
401
|
-
{
|
|
402
|
-
auto arg_count = PyTuple_GET_SIZE(args);
|
|
403
|
-
|
|
404
|
-
if (arg_count == 0)
|
|
405
|
-
{
|
|
406
|
-
try
|
|
407
|
-
{
|
|
408
|
-
static std::optional<bool> is_overload_present{};
|
|
409
|
-
|
|
410
|
-
if (!is_overload_present.has_value())
|
|
411
|
-
{
|
|
412
|
-
is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.System.Threading.Core.SignalNotifier", L"Terminate", 0);
|
|
413
|
-
}
|
|
414
|
-
|
|
415
|
-
if (!is_overload_present.value())
|
|
416
|
-
{
|
|
417
|
-
py::set_arg_count_version_error(0);
|
|
418
|
-
return nullptr;
|
|
419
|
-
}
|
|
420
|
-
|
|
421
|
-
{
|
|
422
|
-
auto _gil = release_gil();
|
|
423
|
-
self->obj.Terminate();
|
|
424
|
-
}
|
|
425
|
-
|
|
426
|
-
Py_RETURN_NONE;
|
|
427
|
-
}
|
|
428
|
-
catch (...)
|
|
429
|
-
{
|
|
430
|
-
py::to_PyErr();
|
|
431
|
-
return nullptr;
|
|
432
|
-
}
|
|
433
|
-
}
|
|
434
|
-
else
|
|
435
|
-
{
|
|
436
|
-
py::set_invalid_arg_count_error(arg_count);
|
|
437
|
-
return nullptr;
|
|
438
|
-
}
|
|
439
|
-
}
|
|
440
|
-
|
|
441
|
-
static PyObject* _assign_array_SignalNotifier(PyObject* /*unused*/, PyObject* arg) noexcept
|
|
442
|
-
{
|
|
443
|
-
auto array = std::make_unique<py::ComArray<winrt::Windows::System::Threading::Core::SignalNotifier>>();
|
|
444
|
-
if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
|
|
445
|
-
{
|
|
446
|
-
return nullptr;
|
|
447
|
-
}
|
|
448
|
-
Py_RETURN_NONE;
|
|
449
|
-
}
|
|
450
|
-
|
|
451
|
-
static PyObject* _from_SignalNotifier(PyObject* /*unused*/, PyObject* arg) noexcept
|
|
452
|
-
{
|
|
453
|
-
try
|
|
454
|
-
{
|
|
455
|
-
auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
|
|
456
|
-
return py::convert(return_value.as<winrt::Windows::System::Threading::Core::SignalNotifier>());
|
|
457
|
-
}
|
|
458
|
-
catch (...)
|
|
459
|
-
{
|
|
460
|
-
py::to_PyErr();
|
|
461
|
-
return nullptr;
|
|
462
|
-
}
|
|
463
|
-
}
|
|
464
|
-
|
|
465
|
-
static PyMethodDef _methods_SignalNotifier[] = {
|
|
466
|
-
{ "enable", reinterpret_cast<PyCFunction>(SignalNotifier_Enable), METH_VARARGS, nullptr },
|
|
467
|
-
{ "terminate", reinterpret_cast<PyCFunction>(SignalNotifier_Terminate), METH_VARARGS, nullptr },
|
|
468
|
-
{ "_assign_array_", _assign_array_SignalNotifier, METH_O | METH_STATIC, nullptr },
|
|
469
|
-
{ "_from", reinterpret_cast<PyCFunction>(_from_SignalNotifier), METH_O | METH_STATIC, nullptr },
|
|
470
|
-
{ }};
|
|
471
|
-
|
|
472
|
-
static PyGetSetDef _getset_SignalNotifier[] = {
|
|
473
|
-
{ }};
|
|
474
|
-
|
|
475
|
-
static PyType_Slot _type_slots_SignalNotifier[] = {
|
|
476
|
-
{ Py_tp_new, reinterpret_cast<void*>(_new_SignalNotifier) },
|
|
477
|
-
{ Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SignalNotifier) },
|
|
478
|
-
{ Py_tp_methods, reinterpret_cast<void*>(_methods_SignalNotifier) },
|
|
479
|
-
{ Py_tp_getset, reinterpret_cast<void*>(_getset_SignalNotifier) },
|
|
480
|
-
{ }};
|
|
481
|
-
|
|
482
|
-
static PyType_Spec type_spec_SignalNotifier = {
|
|
483
|
-
"winrt._winrt_windows_system_threading_core.SignalNotifier",
|
|
484
|
-
sizeof(py::wrapper::Windows::System::Threading::Core::SignalNotifier),
|
|
485
|
-
0,
|
|
486
|
-
Py_TPFLAGS_DEFAULT,
|
|
487
|
-
_type_slots_SignalNotifier};
|
|
488
|
-
|
|
489
|
-
static PyGetSetDef getset_SignalNotifier_Static[] = {
|
|
490
|
-
{ }};
|
|
491
|
-
|
|
492
|
-
static PyMethodDef methods_SignalNotifier_Static[] = {
|
|
493
|
-
{ "attach_to_event", reinterpret_cast<PyCFunction>(SignalNotifier_AttachToEvent), METH_VARARGS, nullptr },
|
|
494
|
-
{ "attach_to_event_with_timeout", reinterpret_cast<PyCFunction>(SignalNotifier_AttachToEventWithTimeout), METH_VARARGS, nullptr },
|
|
495
|
-
{ "attach_to_semaphore", reinterpret_cast<PyCFunction>(SignalNotifier_AttachToSemaphore), METH_VARARGS, nullptr },
|
|
496
|
-
{ "attach_to_semaphore_with_timeout", reinterpret_cast<PyCFunction>(SignalNotifier_AttachToSemaphoreWithTimeout), METH_VARARGS, nullptr },
|
|
497
|
-
{ }};
|
|
498
|
-
|
|
499
|
-
static PyType_Slot type_slots_SignalNotifier_Static[] =
|
|
500
|
-
{
|
|
501
|
-
{ Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
|
|
502
|
-
{ Py_tp_getset, reinterpret_cast<void*>(getset_SignalNotifier_Static) },
|
|
503
|
-
{ Py_tp_methods, reinterpret_cast<void*>(methods_SignalNotifier_Static) },
|
|
504
|
-
{ }
|
|
505
|
-
};
|
|
506
|
-
|
|
507
|
-
static PyType_Spec type_spec_SignalNotifier_Static = {
|
|
508
|
-
"winrt._winrt_windows_system_threading_core.SignalNotifier_Static",
|
|
509
|
-
static_cast<int>(PyType_Type.tp_basicsize),
|
|
510
|
-
static_cast<int>(PyType_Type.tp_itemsize),
|
|
511
|
-
Py_TPFLAGS_DEFAULT,
|
|
512
|
-
type_slots_SignalNotifier_Static};
|
|
513
|
-
|
|
514
|
-
// ----- Windows.System.Threading.Core Initialization --------------------
|
|
515
|
-
|
|
516
|
-
PyDoc_STRVAR(module_doc, "Windows.System.Threading.Core");
|
|
517
|
-
|
|
518
|
-
static PyModuleDef module_def = {
|
|
519
|
-
PyModuleDef_HEAD_INIT,
|
|
520
|
-
"_winrt_windows_system_threading_core",
|
|
521
|
-
module_doc,
|
|
522
|
-
0,
|
|
523
|
-
nullptr,
|
|
524
|
-
nullptr,
|
|
525
|
-
nullptr,
|
|
526
|
-
nullptr,
|
|
527
|
-
nullptr};
|
|
528
|
-
} // py::cpp::Windows::System::Threading::Core
|
|
529
|
-
|
|
530
|
-
PyMODINIT_FUNC PyInit__winrt_windows_system_threading_core(void) noexcept
|
|
531
|
-
{
|
|
532
|
-
using namespace py::cpp::Windows::System::Threading::Core;
|
|
533
|
-
|
|
534
|
-
if (py::import_winrt_runtime() == -1)
|
|
535
|
-
{
|
|
536
|
-
return nullptr;
|
|
537
|
-
}
|
|
538
|
-
|
|
539
|
-
py::pyobj_handle module{PyModule_Create(&module_def)};
|
|
540
|
-
|
|
541
|
-
if (!module)
|
|
542
|
-
{
|
|
543
|
-
return nullptr;
|
|
544
|
-
}
|
|
545
|
-
|
|
546
|
-
auto inspectable_meta_type = py::get_inspectable_meta_type();
|
|
547
|
-
if (!inspectable_meta_type)
|
|
548
|
-
{
|
|
549
|
-
return nullptr;
|
|
550
|
-
}
|
|
551
|
-
|
|
552
|
-
auto object_type = py::get_object_type();
|
|
553
|
-
if (!object_type)
|
|
554
|
-
{
|
|
555
|
-
return nullptr;
|
|
556
|
-
}
|
|
557
|
-
|
|
558
|
-
py::pyobj_handle object_bases{PyTuple_Pack(1, object_type)};
|
|
559
|
-
|
|
560
|
-
if (!object_bases)
|
|
561
|
-
{
|
|
562
|
-
return nullptr;
|
|
563
|
-
}
|
|
564
|
-
|
|
565
|
-
py::pytype_handle PreallocatedWorkItem_type{py::register_python_type(module.get(), &type_spec_PreallocatedWorkItem, object_bases.get(), inspectable_meta_type)};
|
|
566
|
-
if (!PreallocatedWorkItem_type)
|
|
567
|
-
{
|
|
568
|
-
return nullptr;
|
|
569
|
-
}
|
|
570
|
-
|
|
571
|
-
py::pyobj_handle SignalNotifier_Static_bases{PyTuple_Pack(1, reinterpret_cast<PyObject*>(inspectable_meta_type))};
|
|
572
|
-
if (!SignalNotifier_Static_bases)
|
|
573
|
-
{
|
|
574
|
-
return nullptr;
|
|
575
|
-
}
|
|
576
|
-
|
|
577
|
-
py::pyobj_handle type_SignalNotifier_Static{PyType_FromSpecWithBases(&type_spec_SignalNotifier_Static, SignalNotifier_Static_bases.get())};
|
|
578
|
-
if (!type_SignalNotifier_Static)
|
|
579
|
-
{
|
|
580
|
-
return nullptr;
|
|
581
|
-
}
|
|
582
|
-
|
|
583
|
-
py::pytype_handle SignalNotifier_type{py::register_python_type(module.get(), &type_spec_SignalNotifier, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SignalNotifier_Static.get()))};
|
|
584
|
-
if (!SignalNotifier_type)
|
|
585
|
-
{
|
|
586
|
-
return nullptr;
|
|
587
|
-
}
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
return module.detach();
|
|
591
|
-
}
|
|
@@ -1,47 +0,0 @@
|
|
|
1
|
-
# WARNING: Please don't edit this file. It was automatically generated.
|
|
2
|
-
|
|
3
|
-
[build-system]
|
|
4
|
-
requires = ["setuptools>=78", "winrt-sdk"]
|
|
5
|
-
build-backend = "setuptools.build_meta"
|
|
6
|
-
|
|
7
|
-
[project]
|
|
8
|
-
name = "winrt-Windows.System.Threading.Core"
|
|
9
|
-
description = "Python projection of Windows Runtime (WinRT) APIs"
|
|
10
|
-
readme = "README.md"
|
|
11
|
-
license = "MIT"
|
|
12
|
-
classifiers = [
|
|
13
|
-
"Operating System :: Microsoft :: Windows",
|
|
14
|
-
"Programming Language :: Python :: 3",
|
|
15
|
-
"Programming Language :: Python :: Implementation :: CPython",
|
|
16
|
-
"Intended Audience :: Developers",
|
|
17
|
-
]
|
|
18
|
-
dynamic = ["version", "dependencies", "optional-dependencies"]
|
|
19
|
-
requires-python = ">=3.9"
|
|
20
|
-
|
|
21
|
-
[project.urls]
|
|
22
|
-
# Homepage = "https://github.com/pywinrt/pywinrt"
|
|
23
|
-
Documentation = "https://pywinrt.readthedocs.io"
|
|
24
|
-
Repository = "https://github.com/pywinrt/pywinrt"
|
|
25
|
-
Changelog = "https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md"
|
|
26
|
-
|
|
27
|
-
[tool.setuptools.dynamic]
|
|
28
|
-
version = { file = "pywinrt-version.txt" }
|
|
29
|
-
dependencies = { file = "requirements.txt" }
|
|
30
|
-
optional-dependencies.all = { file = "all-requirements.txt" }
|
|
31
|
-
|
|
32
|
-
[tool.setuptools.package-data]
|
|
33
|
-
"*" = ["*.pyi", "py.typed"]
|
|
34
|
-
|
|
35
|
-
[tool.cibuildwheel]
|
|
36
|
-
# use local winrt-sdk build dependency
|
|
37
|
-
environment = { PYTHONPATH="../../winrt-sdk/src" }
|
|
38
|
-
# don't install winrt-sdk from PyPI
|
|
39
|
-
build-frontend = { name = "build[uv]", args = ["--skip-dependency-check", "--no-isolation"] }
|
|
40
|
-
before-build = "uv pip install setuptools"
|
|
41
|
-
# don't build for PyPy
|
|
42
|
-
skip = "pp*"
|
|
43
|
-
# suppress warnings about ARM64 testing
|
|
44
|
-
test-skip = "*-win_arm64"
|
|
45
|
-
|
|
46
|
-
[tool.cibuildwheel.windows]
|
|
47
|
-
archs = ["x86", "AMD64", "ARM64"]
|
|
@@ -1 +0,0 @@
|
|
|
1
|
-
3.2.1
|
|
@@ -1,33 +0,0 @@
|
|
|
1
|
-
# WARNING: Please don't edit this file. It was automatically generated.
|
|
2
|
-
|
|
3
|
-
from setuptools import Extension, setup
|
|
4
|
-
from setuptools.command.build_ext import build_ext
|
|
5
|
-
from winrt_sdk import get_include_dirs
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
class build_ext_ex(build_ext):
|
|
9
|
-
def build_extension(self, ext):
|
|
10
|
-
if self.compiler.compiler_type == "msvc":
|
|
11
|
-
ext.extra_compile_args = ["/std:c++20", "/permissive-"]
|
|
12
|
-
elif self.compiler.compiler_type == "mingw32":
|
|
13
|
-
ext.extra_compile_args = ["-std=c++20", "-D_WIN32_WINNT=_WIN32_WINNT_WIN10"]
|
|
14
|
-
# GCC 15 complains about some things that it didn't in the past
|
|
15
|
-
ext.extra_compile_args += ["-Wno-strict-aliasing", "-Wno-template-body"]
|
|
16
|
-
ext.extra_link_args = ["-loleaut32"]
|
|
17
|
-
else:
|
|
18
|
-
raise ValueError(f"Unsupported compiler: {self.compiler.compiler_type}")
|
|
19
|
-
|
|
20
|
-
build_ext.build_extension(self, ext)
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
setup(
|
|
24
|
-
cmdclass={"build_ext": build_ext_ex},
|
|
25
|
-
ext_modules=[
|
|
26
|
-
Extension(
|
|
27
|
-
"winrt._winrt_windows_system_threading_core",
|
|
28
|
-
sources=["py.Windows.System.Threading.Core.cpp"],
|
|
29
|
-
include_dirs=get_include_dirs(),
|
|
30
|
-
libraries=["windowsapp"],
|
|
31
|
-
)
|
|
32
|
-
],
|
|
33
|
-
)
|
|
@@ -1,18 +0,0 @@
|
|
|
1
|
-
# WARNING: Please don't edit this file. It was generated by Python/WinRT v3.2.1
|
|
2
|
-
|
|
3
|
-
import typing
|
|
4
|
-
import uuid as _uuid
|
|
5
|
-
|
|
6
|
-
import winrt.system
|
|
7
|
-
from winrt._winrt_windows_system_threading_core import (
|
|
8
|
-
PreallocatedWorkItem,
|
|
9
|
-
SignalNotifier,
|
|
10
|
-
)
|
|
11
|
-
|
|
12
|
-
__all__ = [
|
|
13
|
-
"PreallocatedWorkItem",
|
|
14
|
-
"SignalNotifier",
|
|
15
|
-
"SignalHandler",
|
|
16
|
-
]
|
|
17
|
-
|
|
18
|
-
SignalHandler = typing.Callable[[SignalNotifier, bool], None]
|
winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/PKG-INFO
DELETED
|
@@ -1,26 +0,0 @@
|
|
|
1
|
-
Metadata-Version: 2.4
|
|
2
|
-
Name: winrt-Windows.System.Threading.Core
|
|
3
|
-
Version: 3.2.1
|
|
4
|
-
Summary: Python projection of Windows Runtime (WinRT) APIs
|
|
5
|
-
License-Expression: MIT
|
|
6
|
-
Project-URL: Documentation, https://pywinrt.readthedocs.io
|
|
7
|
-
Project-URL: Repository, https://github.com/pywinrt/pywinrt
|
|
8
|
-
Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
|
|
9
|
-
Classifier: Operating System :: Microsoft :: Windows
|
|
10
|
-
Classifier: Programming Language :: Python :: 3
|
|
11
|
-
Classifier: Programming Language :: Python :: Implementation :: CPython
|
|
12
|
-
Classifier: Intended Audience :: Developers
|
|
13
|
-
Requires-Python: >=3.9
|
|
14
|
-
Description-Content-Type: text/markdown
|
|
15
|
-
Requires-Dist: winrt-runtime~=3.2.1.0
|
|
16
|
-
Provides-Extra: all
|
|
17
|
-
Requires-Dist: winrt-Windows.Foundation[all]~=3.2.1.0; extra == "all"
|
|
18
|
-
Requires-Dist: winrt-Windows.System.Threading[all]~=3.2.1.0; extra == "all"
|
|
19
|
-
|
|
20
|
-
<!-- warning: Please don't edit this file. It was automatically generated. -->
|
|
21
|
-
|
|
22
|
-
# winrt-Windows.System.Threading.Core
|
|
23
|
-
|
|
24
|
-
Windows Runtime (WinRT) APIs for for the `Windows.System.Threading.Core` namespace.
|
|
25
|
-
|
|
26
|
-
This package provides the `winrt.windows.system.threading.core` module.
|
winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/SOURCES.txt
DELETED
|
@@ -1,15 +0,0 @@
|
|
|
1
|
-
README.md
|
|
2
|
-
all-requirements.txt
|
|
3
|
-
py.Windows.System.Threading.Core.cpp
|
|
4
|
-
pyproject.toml
|
|
5
|
-
pywinrt-version.txt
|
|
6
|
-
requirements.txt
|
|
7
|
-
setup.py
|
|
8
|
-
winrt/_winrt_windows_system_threading_core.pyi
|
|
9
|
-
winrt/windows/system/threading/core/__init__.py
|
|
10
|
-
winrt/windows/system/threading/core/py.typed
|
|
11
|
-
winrt_Windows.System.Threading.Core.egg-info/PKG-INFO
|
|
12
|
-
winrt_Windows.System.Threading.Core.egg-info/SOURCES.txt
|
|
13
|
-
winrt_Windows.System.Threading.Core.egg-info/dependency_links.txt
|
|
14
|
-
winrt_Windows.System.Threading.Core.egg-info/requires.txt
|
|
15
|
-
winrt_Windows.System.Threading.Core.egg-info/top_level.txt
|
|
@@ -1 +0,0 @@
|
|
|
1
|
-
|
winrt_windows_system_threading_core-3.2.1/winrt_Windows.System.Threading.Core.egg-info/top_level.txt
DELETED
|
@@ -1 +0,0 @@
|
|
|
1
|
-
winrt
|