forked from wikimedia/pywikibot
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathpwb.py
executable file
·366 lines (299 loc) · 12.2 KB
/
pwb.py
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Wrapper script to invoke pywikibot-based scripts.
Run scripts with pywikibot in directory mode using::
python pwb.py <pwb options> <name_of_script> <options>
This wrapper script uses the package directory to store all user files,
will fix up search paths so the package does not need to be installed, etc.
Currently `<pwb options>` are global options. This can be used for tests
to set the default site (see T216825)::
python pwb.py -lang:de bot_tests -v
"""
# (C) Pywikibot team, 2012-2021
#
# Distributed under the terms of the MIT license.
#
# ## KEEP PYTHON 2 SUPPORT FOR THIS SCRIPT ## #
from __future__ import print_function
import os
import sys
import types
from difflib import get_close_matches
from importlib import import_module
from time import sleep
from warnings import warn
pwb = None
# The following snippet was developed by Ned Batchelder (and others)
# for coverage [1], with Python 3 support [2] added later,
# and is available under the BSD license (see [3])
# [1]
# https://bitbucket.org/ned/coveragepy/src/b5abcee50dbe/coverage/execfile.py
# [2]
# https://bitbucket.org/ned/coveragepy/src/fd5363090034/coverage/execfile.py
# [3]
# https://bitbucket.org/ned/coveragepy/src/2c5fb3a8b81c/setup.py?at=default#cl-31
def run_python_file(filename, argv, argvu, package=None):
"""Run a python file as if it were the main program on the command line.
`filename` is the path to the file to execute, it need not be a .py file.
`args` is the argument array to present as sys.argv, as unicode strings.
"""
# Create a module to serve as __main__
old_main_mod = sys.modules['__main__']
main_mod = types.ModuleType('__main__')
sys.modules['__main__'] = main_mod
main_mod.__file__ = filename
main_mod.__builtins__ = sys.modules['builtins']
if package:
main_mod.__package__ = package
# Set sys.argv and the first path element properly.
old_argv = sys.argv
old_argvu = pwb.argvu
sys.argv = argv
pwb.argvu = argvu
sys.path.insert(0, os.path.dirname(filename))
try:
with open(filename, 'rb') as f:
source = f.read()
exec(compile(source, filename, 'exec', dont_inherit=True),
main_mod.__dict__)
finally:
# Restore the old __main__
sys.modules['__main__'] = old_main_mod
# Restore the old argv and path
sys.argv = old_argv
sys.path.pop(0)
pwb.argvu = old_argvu
# end of snippet from coverage
def abspath(path):
"""Convert path to absolute path, with uppercase drive letter on win32."""
path = os.path.abspath(path)
if path[0] != '/':
# normalise Windows drive letter
path = path[0].upper() + path[1:]
return path
def handle_args(pwb_py, *args):
"""Handle args and get filename.
@return: filename, script args, local args for pwb.py
@rtype: tuple
"""
fname = None
index = 0
for arg in args:
if arg.startswith('-'):
index += 1
else:
fname = arg
if not fname.endswith('.py'):
fname += '.py'
break
return fname, list(args[index + int(bool(fname)):]), args[:index]
def _print_requirements(requirements, script, variant):
"""Print pip command to install requirements."""
if not requirements:
return
if len(requirements) > 1:
format_string = '\nPackages necessary for {} are {}.'
else:
format_string = '\nA package necessary for {} is {}.'
print(format_string.format(script or 'pywikibot', variant))
print('Please update required module{} with:\n\n'
.format('s' if len(requirements) > 1 else ''))
for requirement in requirements:
print(' pip install "{}"\n'
.format(str(requirement).partition(';')[0]))
def check_modules(script=None):
"""Check whether mandatory modules are present.
This also checks Python version when importing deptendencies from setup.py
@param script: The script name to be checked for dependencies
@type script: str or None
@return: True if all dependencies are installed
@rtype: bool
@raise RuntimeError: wrong Python version found in setup.py
"""
import pkg_resources
if script:
from setup import script_deps
dependencies = script_deps.get(Path(script).name, [])
else:
from setup import dependencies
missing_requirements = []
version_conflicts = []
for requirement in pkg_resources.parse_requirements(dependencies):
if requirement.marker is None \
or pkg_resources.evaluate_marker(str(requirement.marker)):
try:
pkg_resources.resource_exists(requirement, requirement.name)
except pkg_resources.DistributionNotFound as e:
missing_requirements.append(requirement)
print(e)
except pkg_resources.VersionConflict as e:
version_conflicts.append(requirement)
print(e)
del pkg_resources
del dependencies
_print_requirements(missing_requirements, script, 'missing')
_print_requirements(version_conflicts, script, 'outdated')
if version_conflicts and not missing_requirements:
print('\nYou may continue on your own risk; type CTRL-C to stop.')
try:
sleep(5)
except KeyboardInterrupt:
return False
return not missing_requirements
try:
if not check_modules():
raise RuntimeError('') # no further output needed
except RuntimeError as e: # setup.py may also raise RuntimeError
sys.exit(e)
from pathlib import Path # noqa: E402
filename, script_args, global_args = handle_args(*sys.argv)
# Search for user-config.py before creating one.
# If successful, user-config.py already exists in one of the candidate
# directories. See config.py for details on search order.
# Use env var to communicate to config.py pwb.py location (bug T74918).
_pwb_dir = os.path.split(__file__)[0]
os.environ['PYWIKIBOT_DIR_PWB'] = _pwb_dir
try:
import pywikibot as pwb
except RuntimeError:
os.environ['PYWIKIBOT_NO_USER_CONFIG'] = '2'
import pywikibot as pwb
# user-config.py to be created
if filename is not None and not (filename.startswith('generate_')
or filename == 'version.py'):
print("NOTE: 'user-config.py' was not found!")
print('Please follow the prompts to create it:')
run_python_file(os.path.join(_pwb_dir, 'generate_user_files.py'),
['generate_user_files.py'],
['generate_user_files.py'])
# because we have loaded pywikibot without user-config.py loaded,
# we need to re-start the entire process. Ask the user to do so.
print('Now, you have to re-execute the command to start your script.')
sys.exit(1)
except ImportError as e: # raised in textlib
sys.exit(e)
def find_alternates(filename, script_paths):
"""Search for similar filenames in the given script paths."""
from pywikibot import config, input_choice, output
from pywikibot.bot import QuitKeyboardInterrupt, ShowingListOption
from pywikibot.tools.formatter import color_format
assert config.pwb_close_matches > 0, \
'config.pwb_close_matches must be greater than 0'
assert 0.0 < config.pwb_cut_off < 1.0, \
'config.pwb_cut_off must be a float in range [0, 1]'
print('ERROR: {} not found! Misspelling?'.format(filename),
file=sys.stderr)
scripts = {}
script_paths = [['.']] + script_paths # add current directory
for path in script_paths:
for script_name in os.listdir(os.path.join(*path)):
# remove .py for better matching
name, _, suffix = script_name.rpartition('.')
if suffix == 'py' and not name.startswith('__'):
scripts[name] = os.path.join(*(path + [script_name]))
filename = filename[:-3]
similar_scripts = get_close_matches(filename, scripts,
config.pwb_close_matches,
config.pwb_cut_off)
if not similar_scripts:
return None
if len(similar_scripts) == 1:
script = similar_scripts[0]
wait_time = config.pwb_autostart_waittime
output(color_format(
'NOTE: Starting the most similar script '
'{lightyellow}{0}.py{default}\n'
' in {1} seconds; type CTRL-C to stop.',
script, wait_time))
try:
sleep(wait_time) # Wait a bit to let it be cancelled
except KeyboardInterrupt:
return None
else:
msg = '\nThe most similar scripts are:'
alternatives = ShowingListOption(similar_scripts, pre=msg, post='')
try:
prefix, script = input_choice('Which script to be run:',
alternatives, default='1')
except QuitKeyboardInterrupt:
return None
print()
return scripts[script]
def find_filename(filename):
"""Search for the filename in the given script paths."""
from pywikibot import config
script_paths = ['scripts.userscripts',
'scripts',
'scripts.maintenance']
if config.user_script_paths:
if isinstance(config.user_script_paths, list):
script_paths = config.user_script_paths + script_paths
else:
warn("'user_script_paths' must be a list,\n"
'found: {}. Ignoring this setting.'
.format(type(config.user_script_paths)))
path_list = []
for file_package in script_paths:
package = file_package.split('.')
paths = package + [filename]
testpath = os.path.join(_pwb_dir, *paths)
if os.path.exists(testpath):
filename = testpath
break
path_list.append(package)
else:
filename = find_alternates(filename, path_list)
return filename
def main():
"""Command line entry point."""
global filename
if global_args: # don't use sys.argv
unknown_args = pwb.handle_args(global_args)
if unknown_args:
print('ERROR: unknown pwb.py argument{}: {}\n'
.format('' if len(unknown_args) == 1 else 's',
', '.join(unknown_args)))
return False
if not filename:
return False
file_package = None
argvu = pwb.argvu[1:]
if not os.path.exists(filename):
filename = find_filename(filename)
if filename is None:
return True
# When both pwb.py and the filename to run are within the current
# working directory:
# a) set __package__ as if called using python -m scripts.blah.foo
# b) set __file__ to be relative, so it can be relative in backtraces,
# and __file__ *appears* to be an unstable path to load data from.
# This is a rough (and quick!) emulation of 'package name' detection.
# a much more detailed implementation is in coverage's find_module.
# https://bitbucket.org/ned/coveragepy/src/default/coverage/execfile.py
cwd = abspath(os.getcwd())
absolute_path = abspath(os.path.dirname(sys.argv[0]))
if absolute_path == cwd:
absolute_filename = abspath(filename)[:len(cwd)]
if absolute_filename == cwd:
relative_filename = os.path.relpath(filename)
# remove the filename, and use '.' instead of path separator.
file_package = os.path.dirname(
relative_filename).replace(os.sep, '.')
filename = os.path.join(os.curdir, relative_filename)
if file_package and file_package not in sys.modules:
try:
import_module(file_package)
except ImportError as e:
warn('Parent module {} not found: {}'
.format(file_package, e), ImportWarning)
help_option = any(arg.startswith('-help:') or arg == '-help'
for arg in script_args)
if check_modules(filename) or help_option:
run_python_file(filename,
[filename] + script_args,
[Path(filename).stem] + argvu[1:],
file_package)
return True
if __name__ == '__main__':
if not main():
print(__doc__)