Metadata-Version: 2.4
Name: pywingui
Version: 6.1.58
Summary: High-performance Enterprise GUI Automation for Progress OpenEdge & Win32
Description-Content-Type: text/markdown
Requires-Dist: pywinauto>=0.6.8
Requires-Dist: pyautogui>=0.9.54
Requires-Dist: pygetwindow>=0.0.9
Requires-Dist: requests>=2.28.0
Requires-Dist: pillow>=9.0.0
Requires-Dist: cryptography>=38.0.0
Requires-Dist: opencv-python
Requires-Dist: pytesseract
Requires-Dist: pywin32
Dynamic: description
Dynamic: description-content-type
Dynamic: requires-dist
Dynamic: summary

# PyWinGUI Private Build Repository

This repository contains the private PyWinGUI implementation and release
pipeline. It is not the public customer repository.

PyWinGUI is a proprietary Windows GUI automation SDK backed by a protected
native runtime. The public repository exposes the Python API surface, while the
automation engine, control matching, OCR, AI recovery, orchestration, and
licensing logic remain private.

## Repository Roles

Private repository:

- Owns the real implementation under `pywingui/`.
- Owns licensing under `pywingui/licensing/`.
- Builds the protected native runtime with Nuitka.
- Generates the clean public repository.
- Builds and verifies the PyPI wheel.

Public repository:

- Contains public Python wrappers and type/API surface.
- Contains tests proving the public source boundary.
- Contains one protected native runtime file under `pywingui/native/`.
- Does not contain `pywingui/licensing/`.
- Does not contain private runtime Python source.

## Protected Runtime

The private runtime is compiled into:

```text
dist/runtime_pyd/pywingui_native_runtime.cp313-win_amd64.pyd
```

The public wheel includes that file at:

```text
pywingui/native/pywingui_native_runtime.cp313-win_amd64.pyd
```

The public SDK loads the runtime through `pywingui.bridge.RuntimeClient`.
Customers call normal PyWinGUI APIs; private logic stays inside the compiled
runtime.

## One-Command Local Release

Run:

```bat
release_public.bat
```

The BAT already uses:

```text
--jobs 48
```

Release stages:

1. Run private/runtime tests.
2. Compile the protected `.pyd` with Nuitka.
3. Assemble the clean public repository.
4. Run public SDK tests.
5. Build the platform wheel.
6. Install the wheel in a clean environment.
7. Load the native runtime and run `runtime.selftest`.

Expected wheel:

```text
dist/public_wheels/pywingui-<version>-cp313-cp313-win_amd64.whl
```

## Publish To PyPI

Set the PyPI token first:

```bat
set TWINE_PASSWORD=pypi-your-token
```

Then run:

```bat
release_public.bat --publish-pypi
```

Publishing only happens after tests, compile, wheel build, and clean-install
verification pass.

## Push Public Repository

To create/update the public repo locally and push it:

```bat
release_public.bat --commit --push --remote https://github.com/YOUR_ACCOUNT/pywingui.git
```

To push Git and publish PyPI in one run:

```bat
set TWINE_PASSWORD=pypi-your-token
release_public.bat --commit --push --publish-pypi --remote https://github.com/YOUR_ACCOUNT/pywingui.git
```

The generated public repo path is:

```text
C:\projects\pywingui-public
```

## Manual Commands

Run all private/runtime tests:

```bat
python -m pytest pywingui/tests tests/runtime -q
```

Build only the native runtime:

```bat
python scripts\build_runtime_pyd.py --clean --skip-tests --jobs 48
```

Assemble public repo and wheel:

```bat
python scripts\assemble_public_release.py
```

Verify a wheel in a clean environment:

```bat
python scripts\verify_public_wheel.py dist\public_wheels\pywingui-<version>-cp313-cp313-win_amd64.whl
```

## Public Boundary Rules

Do not put these in the public repository:

- `pywingui/licensing/`
- Private runtime Python source
- API keys, tokens, backend URLs, or license secrets
- Internal OCR provider implementations
- Core matching, orchestration, recovery, and automation engine logic

The public wheel must contain exactly one native runtime `.pyd` and no private
runtime `.py` files.

## License

PyWinGUI is proprietary software. All implementation rights, protected runtime
rights, licensing logic, automation logic, OCR logic, AI recovery logic, and
related trade secrets remain owned by PyWinGUI Engineering.
