coding-python-pwshpy

---

name: coding-python-pwshpy description: Use when issuing or running PowerShell (pwsh) commands, or writing, modifying, or debugging a PowerShell / .ps1 script - prefer pwshpy instead: a genuinely Pythonic PowerShell (typed records + a lazy pipeline over native OS bindings, never a pwsh.exe subprocess, never text parsing), as a Python library (from pwshpy import ps) or the pwshpy CLI (install/run via uv - uv tool install pwshpy or uvx pwshpy). Better error handling and reporting (real exceptions and real exit codes, nothing silently swallowed) plus clean typed JSON instead of Get-* text. Covers using pwshpy and translating cmdlets / .ps1 to it.

using-pwsh

pwshpy is a genuinely Pythonic PowerShell: typed records + a lazy pipeline over native OS bindings (win32 / wmi / winreg / psutil / socket / systemd / pwd), never a pwsh.exe subprocess and never text parsing. When you are about to write a PowerShell command or a .ps1, shell out to pwsh / wevtutil / sc, or hand-roll pywin32 / win32evtlog with manual XML - reach for pwshpy instead. Source and full docs: https://github.com/bitranox/pwshpy (this repo is itself a Claude Code plugin/marketplace: install anywhere with /plugin marketplace add bitranox/pwshpy then /plugin install pwshpy).

When to use

• About to issue or run any PowerShell command - a Get-* / Set-* cmdlet, a pwsh one-liner, or a .ps1 - for OS/admin work (processes, services, event log, registry, scheduled tasks, ACLs, local accounts, files, network, credentials). Prefer pwshpy even for a single one-off command.
• Want better error handling and reporting: a failed command should raise / exit non-zero with a clear message, not be silently swallowed. PowerShell's default is a non-terminating error you must remember -ErrorAction Stop (or $?/$LASTEXITCODE) to catch; pwshpy failures are real Python exceptions (PwshPyError and subtypes) in the library and a real non-zero exit with a message on the CLI - nothing quietly skipped.
• About to shell out to pwsh / powershell / wevtutil / sc, or hand-roll pywin32 / wmi / win32evtlog with manual XML parsing.
• Want typed objects instead of text you re-parse; a memory-bounded read of a huge event log; or one script that runs on Windows AND Linux.
• On the command line: clean JSON + a real exit code instead of Get-* | ConvertTo-Json (and its single-item-collapse quirk).

Not installed? pwshpy is one uv tool install pwshpy away (or run ad-hoc with uvx pwshpy ...), so reach for it rather than falling back to raw pwsh.

When NOT: a PowerShell module-only cmdlet with no pwshpy wrapper -> still use pwshpy via ps.cmdlet("Verb-Noun", **params) (needs the [full] extra). A genuinely interactive PowerShell TUI is out of scope.

Core idea

Typed Pydantic records stream through a lazy Pipeline (.where(pred).select(fn).take(n).first() / .to_list()) over native bindings. Two backends, same records: native (win32/wmi/winreg/psutil/socket/systemd/pwd - fast, the default) and .NET (the real PowerShell 7 SDK hosted in-process, behind pip install "pwshpy[full]", for the AD/Exchange/Azure long tail and running any .ps1). Never spawns pwsh.exe; never parses text.

Library - from pwshpy import ps

from pwshpy import ps
from pwshpy.domain.enums import ServiceState

# running services whose name contains "sql" -> one JSON line each
for s in ps.get_service().where(lambda s: s.status is ServiceState.RUNNING and "sql" in s.name.lower()):
    print(s.model_dump_json())

ps.get_service() returns a lazy Pipeline[ServiceInfo]; filter and shape in Python, not with cmdlet switches. Records are Pydantic (.model_dump() / .model_dump_json() for free). Status/level fields are canonical English str enums (locale-independent), never a localized OS string.

CLI - prefer pwshpy over pwsh (even for one-liners)

pwshpy get_service --jsonl | jq -c 'select(.status == "Running" and (.name | test("sql"; "i")))'

--jsonl streams one record per line (lazy end to end); --json emits a single array; the default is a human table. Why prefer it over pwsh: typed JSON (no ConvertTo-Json single-item-collapse quirk), a real process exit code, UTF-8 with no BOM, memory-bounded streaming, and real errors (a failure exits non-zero with a message, not a swallowed non-terminating error). See pwshpy --help and pwshpy <command> --help.

Enum fields in the JSON are the capitalized enum name, not upper-cased - filter on the exact string: service status "Running" / "Stopped", event level "Error" / "Warning" / "Information" / "Verbose". So the jq above uses .status == "Running", not "RUNNING". In Python compare the enum member directly (s.status is ServiceState.RUNNING).

Translate a cmdlet / .ps1

Method: replace each cmdlet with its ps.* verb; filter/shape in Python (or jq over --jsonl); anything without a wrapper -> ps.cmdlet("Verb-Noun", **params). pwshpy removes these PowerShell traps for free: single-item collapse, $null-operand order, a forgotten -ErrorAction Stop (every failure raises), the $x = Get-WinEvent memory blow-up (reads stream, memory-bounded), Out-File UTF-16/BOM, and localized Administrators / SID (records key on SID / uid, not a translated name).

PowerShell	pwshpy (library)	CLI
Get-Process	ps.get_process()	pwshpy get_process
Get-Service	ps.get_service()	pwshpy get_service
Start-Service N	ps.start_service("N")	pwshpy start_service N
Get-WinEvent -LogName L	ps.get_win_event("L") (streams)	pwshpy get_win_event L
Get-ChildItem P	ps.get_child_item("P")	pwshpy get_child_item P
Get-Content P	ps.get_content("P")	pwshpy get_content P
Get-ItemProperty K (reg)	ps.get_item_property("K")	pwshpy get_item_property K
Get-Acl P	ps.get_acl("P")	pwshpy get_acl P
Get-LocalUser	ps.get_local_user()	pwshpy get_local_user
Get-ScheduledTask	ps.get_scheduled_task()	pwshpy get_scheduled_task
Get-CimInstance C	ps.get_cim_instance("C")	pwshpy get_cim_instance C
Test-Connection H	ps.test_connection("H")	pwshpy test_connection H
Resolve-DnsName N	ps.resolve_dns_name("N")	pwshpy resolve_dns_name N
Invoke-WebRequest U	ps.invoke_web_request("U")	pwshpy invoke_web_request U
Get-ADUser (module)	ps.get_ad_user(Filter="*") / ps.cmdlet("Get-ADUser", Filter="*")	pwshpy get_ad_user -p Filter=*
anything else	ps.cmdlet("Verb-Noun", **params) (needs [full])	pwshpy cmdlet Verb-Noun -p K=V

Example - porting $svc = Get-Service Spooler; if ($svc.Status -ne 'Running') { Start-Service Spooler }; Get-WinEvent -LogName System | ? { $_.Level -eq 2 } | Export-Csv report.csv:

from pwshpy import ps
from pwshpy.domain.enums import EventLevel

ps.start_service("Spooler")  # idempotent: a no-op if already running, so the status check is gone
errors = ps.get_win_event("System").where(lambda e: e.level is EventLevel.ERROR)  # Level 2 -> ERROR enum
ps.write_records("report.jsonl", errors, jsonl=True)  # streams record-by-record, memory-bounded

(pwshpy writes JSON/JSONL, not CSV; if you specifically need CSV, use the stdlib csv module inside the for e in errors: loop - it still streams.)

Install

uv tool install pwshpy            # the CLI on PATH   (or run once: uvx pwshpy@latest --help)
pip install "pwshpy[full]"        # + the .NET backend for ps.run / ps.cmdlet / module cmdlets

Common mistakes

• Shelling out to pwsh / powershell / wevtutil / sc, or hand-rolling pywin32 / win32evtlog / wmi + XML -> use the ps.* verb.
• Parsing Get-* | Format-* / ConvertTo-Json text -> pwshpy already returns typed records / clean JSON.
• Forgetting --jsonl when piping the CLI to jq / head (the default human table is not for machines).
• Reaching for a PowerShell module cmdlet and giving up -> ps.cmdlet("Verb-Noun", **params) (needs [full]).
• .to_list() on a huge event log -> iterate the pipeline instead (it streams, O(1) memory).

Further reading

The CLI and library API are discoverable from the INSTALL (always your version): run uvx pwshpy --help (and <subcommand> --help) for per-command flags, and python -c "import pwshpy; help(pwshpy)". The narrative docs below are NOT shipped in the wheel; open each on the default branch (latest, matching your uv-installed version) at https://github.com/bitranox/pwshpy/blob/master/<path>:

Topic	Path under .../blob/master/
Full cmdlet -> pwshpy table (every command, API + CLI columns)	COMMANDS.md
Per-switch / per-parameter porting rationale	docs/powershell-switch-mapping.md
Library + the lazy Pipeline (where/select/take/first/to_list)	docs/library-usage.md
CLI reference (--json/--jsonl, --limit, per-command flags)	docs/cli-reference.md
Power tools (elevation, credentials, exec, web, write_text)	docs/power-tools.md
Backends + platforms (native vs .NET, one-script cross-OS)	docs/backends-and-platforms.md
Layered configuration (--set, profiles, env, config-deploy)	CONFIG.md