PyMemoryEditor/pyproject.toml at main · JeanExtreme002/PyMemoryEditor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
[project]
name = "PyMemoryEditor"
dynamic = ["version"]
description = "Read, write and scan process memory in a few lines of Python — Cheat Engine-style scans, pointer chains and AOB search on Windows, Linux and macOS."
authors = [
    { name = "Jean Loui Bernard Silva de Jesus", email = "contact@jeanloui.dev" },
]
license = "MIT"
readme = "README.md"
keywords = [
    "cheat-engine",
    "memory-scanner",
    "memory-editor",
    "process-memory",
    "pointer-scan",
    "aob-scan",
    "pattern-scan",
    "game-hacking",
    "reverse-engineering",
    "debugging",
    "introspection",
    "ctypes",
]

classifiers = [
    "Development Status :: 5 - Production/Stable",
    "License :: OSI Approved :: MIT License",
    "Intended Audience :: Developers",
    "Intended Audience :: Information Technology",
    "Intended Audience :: Science/Research",
    "Operating System :: Microsoft :: Windows",
    "Operating System :: POSIX :: Linux",
    "Operating System :: MacOS :: MacOS X",
    "Programming Language :: Python :: 3 :: Only",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Topic :: Scientific/Engineering",
    "Topic :: Security",
    "Topic :: System :: Monitoring",
    "Typing :: Typed",
]
requires-python = ">=3.10"
dependencies = ["psutil>=5.9,<7"]

[project.optional-dependencies]
tests = [
  "pytest",
  "pytest-xdist",
]
app = [
  "PySide6>=6.5",
]
dev = [
  "pytest",
  "pytest-xdist",
  "pytest-cov",
  "pytest-qt",
  "hypothesis",
  "flake8",
  "mypy",
  "build",
  "twine",
  "PySide6>=6.5",
]

[project.scripts]
pymemoryeditor = "PyMemoryEditor.app.application:main"

[project.urls]
Homepage = "https://github.com/JeanExtreme002/PyMemoryEditor"
Documentation = "https://pymemoryeditor.readthedocs.io"
Repository = "https://github.com/JeanExtreme002/PyMemoryEditor"
Issues = "https://github.com/JeanExtreme002/PyMemoryEditor/issues"
Changelog = "https://github.com/JeanExtreme002/PyMemoryEditor/releases"

[tool.mypy]
# The Qt app uses dynamic types and depends on the optional PySide6 GUI
# toolkit, so it isn't worth annotating strictly. Library code under
# PyMemoryEditor/ (excluding app/) is the surface that ships with
# `py.typed` and should aim for clean mypy output over time.
exclude = ["PyMemoryEditor/app/"]
ignore_missing_imports = true
# Initial pass: surface issues without immediately blocking CI. Tighten this
# over time as the pre-existing type debt gets paid down.
warn_unused_ignores = true

# Platform-specific backends use symbols that only exist on their target OS
# (`ctypes.windll`, `WINFUNCTYPE`, `WinError`, `set_last_error`, etc. on
# Windows; Mach types on macOS). mypy running on a single OS sees the others
# as undefined. The shared layer (process/, util/) is still type-checked.
[[tool.mypy.overrides]]
module = [
    "PyMemoryEditor.win32.*",
    "PyMemoryEditor.linux.*",
    "PyMemoryEditor.macos.*",
]
ignore_errors = true

[tool.hatch.version]
path = "PyMemoryEditor/__init__.py"

[tool.hatch.build.targets.wheel]
packages = ["PyMemoryEditor"]

[tool.hatch.build.targets.wheel.force-include]
"PyMemoryEditor/py.typed" = "PyMemoryEditor/py.typed"
"PyMemoryEditor/app/assets/icon.svg" = "PyMemoryEditor/app/assets/icon.svg"

# Maintainer-only tooling lives under scripts/ — keep it out of the source
# distribution (the wheel already only ships the PyMemoryEditor package).
[tool.hatch.build.targets.sdist]
exclude = ["scripts"]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

# Coverage scope: the Qt app is excluded — it's exercised manually, not by
# the automated test suite. The library code (everything else) is what we
# track regressions against.
[tool.coverage.run]
source = ["PyMemoryEditor"]
omit = ["PyMemoryEditor/app/*", "PyMemoryEditor/__main__.py"]

[tool.coverage.report]
show_missing = true
skip_empty = true

# Parallelize the suite with pytest-xdist. ``--dist=loadfile`` keeps each
# ``test_*.py`` together on a single worker (module-scoped fixtures stay
# valid), and ``-n auto`` picks one worker per available CPU. Override with
# ``pytest -n 0`` for serial debugging.
#
# Fast vs slow split:
#   pytest -m "not slow"        # ~30 s — unit/property/GUI tests only.
#   pytest                      # ~20 min — everything, including the live
#                               # self-process integration suite.
# Mark a test (or set ``pytestmark = pytest.mark.slow`` at module scope) to
# add it to the slow bucket — see tests/test_editor.py for the pattern.
[tool.pytest.ini_options]
addopts = "-n auto --dist=loadfile"
markers = [
    "slow: integration tests that read/scan the current process's whole address space (minutes, not seconds)",
]