Debian Codegraph @

Tools/freeze/freeze.py

raw
1 #! /usr/bin/env python3
2
3 """Freeze a Python script into a binary.
4
5 usage: freeze [options...] script [module]...
6
7 Options:
8 -p prefix: This is the prefix used when you ran ``make install''
9 in the Python build directory.
10 (If you never ran this, freeze won't work.)
11 The default is whatever sys.prefix evaluates to.
12 It can also be the top directory of the Python source
13 tree; then -P must point to the build tree.
14
15 -P exec_prefix: Like -p but this is the 'exec_prefix', used to
16 install objects etc. The default is whatever sys.exec_prefix
17 evaluates to, or the -p argument if given.
18 If -p points to the Python source tree, -P must point
19 to the build tree, if different.
20
21 -e extension: A directory containing additional .o files that
22 may be used to resolve modules. This directory
23 should also have a Setup file describing the .o files.
24 On Windows, the name of a .INI file describing one
25 or more extensions is passed.
26 More than one -e option may be given.
27
28 -o dir: Directory where the output files are created; default '.'.
29
30 -m: Additional arguments are module names instead of filenames.
31
32 -a package=dir: Additional directories to be added to the package's
33 __path__. Used to simulate directories added by the
34 package at runtime (eg, by OpenGL and win32com).
35 More than one -a option may be given for each package.
36
37 -l file: Pass the file to the linker (windows only)
38
39 -d: Debugging mode for the module finder.
40
41 -q: Make the module finder totally quiet.
42
43 -h: Print this help message.
44
45 -x module Exclude the specified module. It will still be imported
46 by the frozen binary if it exists on the host system.
47
48 -X module Like -x, except the module can never be imported by
49 the frozen binary.
50
51 -E: Freeze will fail if any modules can't be found (that
52 were not excluded using -x or -X).
53
54 -i filename: Include a file with additional command line options. Used
55 to prevent command lines growing beyond the capabilities of
56 the shell/OS. All arguments specified in filename
57 are read and the -i option replaced with the parsed
58 params (note - quoting args in this file is NOT supported)
59
60 -s subsystem: Specify the subsystem (For Windows only.);
61 'console' (default), 'windows', 'service' or 'com_dll'
62
63 -w: Toggle Windows (NT or 95) behavior.
64 (For debugging only -- on a win32 platform, win32 behavior
65 is automatic.)
66
67 -r prefix=f: Replace path prefix.
68 Replace prefix with f in the source path references
69 contained in the resulting binary.
70
71 Arguments:
72
73 script: The Python script to be executed by the resulting binary.
74
75 module ...: Additional Python modules (referenced by pathname)
76 that will be included in the resulting binary. These
77 may be .py or .pyc files. If -m is specified, these are
78 module names that are search in the path instead.
79
80 NOTES:
81
82 In order to use freeze successfully, you must have built Python and
83 installed it ("make install").
84
85 The script should not use modules provided only as shared libraries;
86 if it does, the resulting binary is not self-contained.
87 """
88
89
90 # Import standard modules
91
92 import modulefinder
93 import getopt
94 import os
95 import sys
96 import sysconfig
97
98
99 # Import the freeze-private modules
100
101 import checkextensions
102 import makeconfig
103 import makefreeze
104 import makemakefile
105 import parsesetup
106 import bkfile
107
108
109 # Main program
110
111 def main():
112 # overridable context
113 prefix = None # settable with -p option
114 exec_prefix = None # settable with -P option
115 extensions = []
116 exclude = [] # settable with -x option
117 addn_link = [] # settable with -l, but only honored under Windows.
118 path = sys.path[:]
119 modargs = 0
120 debug = 1
121 odir = ''
122 win = sys.platform[:3] == 'win'
123 replace_paths = [] # settable with -r option
124 error_if_any_missing = 0
125
126 # default the exclude list for each platform
127 if win: exclude = exclude + [
128 'dos', 'dospath', 'mac', 'macfs', 'MACFS', 'posix', ]
129
130 fail_import = exclude[:]
131
132 # output files
133 frozen_c = 'frozen.c'
134 config_c = 'config.c'
135 target = 'a.out' # normally derived from script name
136 makefile = 'Makefile'
137 subsystem = 'console'
138
139 if sys.platform == "darwin" and sysconfig.get_config_var("PYTHONFRAMEWORK"):
140 print(f"{sys.argv[0]} cannot be used with framework builds of Python", file=sys.stderr)
141 sys.exit(1)
142
143
144 # parse command line by first replacing any "-i" options with the
145 # file contents.
146 pos = 1
147 while pos < len(sys.argv)-1:
148 # last option can not be "-i", so this ensures "pos+1" is in range!
149 if sys.argv[pos] == '-i':
150 try:
151 with open(sys.argv[pos+1]) as infp:
152 options = infp.read().split()
153 except IOError as why:
154 usage("File name '%s' specified with the -i option "
155 "can not be read - %s" % (sys.argv[pos+1], why) )
156 # Replace the '-i' and the filename with the read params.
157 sys.argv[pos:pos+2] = options
158 pos = pos + len(options) - 1 # Skip the name and the included args.
159 pos = pos + 1
160
161 # Now parse the command line with the extras inserted.
162 try:
163 opts, args = getopt.getopt(sys.argv[1:], 'r:a:dEe:hmo:p:P:qs:wX:x:l:')
164 except getopt.error as msg:
165 usage('getopt error: ' + str(msg))
166
167 # process option arguments
168 for o, a in opts:
169 if o == '-h':
170 print(__doc__)
171 return
172 if o == '-d':
173 debug = debug + 1
174 if o == '-e':
175 extensions.append(a)
176 if o == '-m':
177 modargs = 1
178 if o == '-o':
179 odir = a
180 if o == '-p':
181 prefix = a
182 if o == '-P':
183 exec_prefix = a
184 if o == '-q':
185 debug = 0
186 if o == '-w':
187 win = not win
188 if o == '-s':
189 if not win:
190 usage("-s subsystem option only on Windows")
191 subsystem = a
192 if o == '-x':
193 exclude.append(a)
194 if o == '-X':
195 exclude.append(a)
196 fail_import.append(a)
197 if o == '-E':
198 error_if_any_missing = 1
199 if o == '-l':
200 addn_link.append(a)
201 if o == '-a':
202 modulefinder.AddPackagePath(*a.split("=", 2))
203 if o == '-r':
204 f,r = a.split("=", 2)
205 replace_paths.append( (f,r) )
206
207 # modules that are imported by the Python runtime
208 implicits = []
209 for module in ('site', 'warnings', 'encodings.utf_8', 'encodings.latin_1'):
210 if module not in exclude:
211 implicits.append(module)
212
213 # default prefix and exec_prefix
214 if not exec_prefix:
215 if prefix:
216 exec_prefix = prefix
217 else:
218 exec_prefix = sys.exec_prefix
219 if not prefix:
220 prefix = sys.prefix
221
222 # determine whether -p points to the Python source tree
223 ishome = os.path.exists(os.path.join(prefix, 'Python', 'ceval.c'))
224
225 # locations derived from options
226 version = '%d.%d' % sys.version_info[:2]
227 if hasattr(sys, 'abiflags'):
228 flagged_version = version + sys.abiflags
229 else:
230 flagged_version = version
231 if win:
232 extensions_c = 'frozen_extensions.c'
233 if ishome:
234 print("(Using Python source directory)")
235 configdir = exec_prefix
236 incldir = os.path.join(prefix, 'Include')
237 config_h_dir = exec_prefix
238 config_c_in = os.path.join(prefix, 'Modules', 'config.c.in')
239 frozenmain_c = os.path.join(prefix, 'Python', 'frozenmain.c')
240 makefile_in = os.path.join(exec_prefix, 'Makefile')
241 if win:
242 frozendllmain_c = os.path.join(exec_prefix, 'Pc\\frozen_dllmain.c')
243 else:
244 configdir = sysconfig.get_config_var('LIBPL')
245 incldir = os.path.join(prefix, 'include', 'python%s' % flagged_version)
246 config_h_dir = os.path.join(exec_prefix, 'include',
247 'python%s' % flagged_version)
248 config_c_in = os.path.join(configdir, 'config.c.in')
249 frozenmain_c = os.path.join(configdir, 'frozenmain.c')
250 makefile_in = os.path.join(configdir, 'Makefile')
251 frozendllmain_c = os.path.join(configdir, 'frozen_dllmain.c')
252 libdir = sysconfig.get_config_var('LIBDIR')
253 supp_sources = []
254 defines = []
255 includes = ['-I' + incldir, '-I' + config_h_dir]
256
257 # sanity check of directories and files
258 check_dirs = [prefix, exec_prefix, configdir, incldir]
259 if not win:
260 # These are not directories on Windows.
261 check_dirs = check_dirs + extensions
262 for dir in check_dirs:
263 if not os.path.exists(dir):
264 usage('needed directory %s not found' % dir)
265 if not os.path.isdir(dir):
266 usage('%s: not a directory' % dir)
267 if win:
268 files = supp_sources + extensions # extensions are files on Windows.
269 else:
270 files = [config_c_in, makefile_in] + supp_sources
271 for file in supp_sources:
272 if not os.path.exists(file):
273 usage('needed file %s not found' % file)
274 if not os.path.isfile(file):
275 usage('%s: not a plain file' % file)
276 if not win:
277 for dir in extensions:
278 setup = os.path.join(dir, 'Setup')
279 if not os.path.exists(setup):
280 usage('needed file %s not found' % setup)
281 if not os.path.isfile(setup):
282 usage('%s: not a plain file' % setup)
283
284 # check that enough arguments are passed
285 if not args:
286 usage('at least one filename argument required')
287
288 # check that file arguments exist
289 for arg in args:
290 if arg == '-m':
291 break
292 # if user specified -m on the command line before _any_
293 # file names, then nothing should be checked (as the
294 # very first file should be a module name)
295 if modargs:
296 break
297 if not os.path.exists(arg):
298 usage('argument %s not found' % arg)
299 if not os.path.isfile(arg):
300 usage('%s: not a plain file' % arg)
301
302 # process non-option arguments
303 scriptfile = args[0]
304 modules = args[1:]
305
306 # derive target name from script name
307 base = os.path.basename(scriptfile)
308 base, ext = os.path.splitext(base)
309 if base:
310 if base != scriptfile:
311 target = base
312 else:
313 target = base + '.bin'
314
315 # handle -o option
316 base_frozen_c = frozen_c
317 base_config_c = config_c
318 base_target = target
319 if odir and not os.path.isdir(odir):
320 try:
321 os.mkdir(odir)
322 print("Created output directory", odir)
323 except OSError as msg:
324 usage('%s: mkdir failed (%s)' % (odir, str(msg)))
325 base = ''
326 if odir:
327 base = os.path.join(odir, '')
328 frozen_c = os.path.join(odir, frozen_c)
329 config_c = os.path.join(odir, config_c)
330 target = os.path.join(odir, target)
331 makefile = os.path.join(odir, makefile)
332 if win: extensions_c = os.path.join(odir, extensions_c)
333
334 # Handle special entry point requirements
335 # (on Windows, some frozen programs do not use __main__, but
336 # import the module directly. Eg, DLLs, Services, etc
337 custom_entry_point = None # Currently only used on Windows
338 python_entry_is_main = 1 # Is the entry point called __main__?
339 # handle -s option on Windows
340 if win:
341 import winmakemakefile
342 try:
343 custom_entry_point, python_entry_is_main = \
344 winmakemakefile.get_custom_entry_point(subsystem)
345 except ValueError as why:
346 usage(why)
347
348
349 # Actual work starts here...
350
351 # collect all modules of the program
352 dir = os.path.dirname(scriptfile)
353 path[0] = dir
354 mf = modulefinder.ModuleFinder(path, debug, exclude, replace_paths)
355
356 if win and subsystem=='service':
357 # If a Windows service, then add the "built-in" module.
358 mod = mf.add_module("servicemanager")
359 mod.__file__="dummy.pyd" # really built-in to the resulting EXE
360
361 for mod in implicits:
362 mf.import_hook(mod)
363 for mod in modules:
364 if mod == '-m':
365 modargs = 1
366 continue
367 if modargs:
368 if mod[-2:] == '.*':
369 mf.import_hook(mod[:-2], None, ["*"])
370 else:
371 mf.import_hook(mod)
372 else:
373 mf.load_file(mod)
374
375 # Add the main script as either __main__, or the actual module name.
376 if python_entry_is_main:
377 mf.run_script(scriptfile)
378 else:
379 mf.load_file(scriptfile)
380
381 if debug > 0:
382 mf.report()
383 print()
384 dict = mf.modules
385
386 if error_if_any_missing:
387 missing = mf.any_missing()
388 if missing:
389 sys.exit("There are some missing modules: %r" % missing)
390
391 # generate output for frozen modules
392 files = makefreeze.makefreeze(base, dict, debug, custom_entry_point,
393 fail_import)
394
395 # look for unfrozen modules (builtin and of unknown origin)
396 builtins = []
397 unknown = []
398 mods = sorted(dict.keys())
399 for mod in mods:
400 if dict[mod].__code__:
401 continue
402 if not dict[mod].__file__:
403 builtins.append(mod)
404 else:
405 unknown.append(mod)
406
407 # search for unknown modules in extensions directories (not on Windows)
408 addfiles = []
409 frozen_extensions = [] # Windows list of modules.
410 if unknown or (not win and builtins):
411 if not win:
412 addfiles, addmods = \
413 checkextensions.checkextensions(unknown+builtins,
414 extensions)
415 for mod in addmods:
416 if mod in unknown:
417 unknown.remove(mod)
418 builtins.append(mod)
419 else:
420 # Do the windows thang...
421 import checkextensions_win32
422 # Get a list of CExtension instances, each describing a module
423 # (including its source files)
424 frozen_extensions = checkextensions_win32.checkextensions(
425 unknown, extensions, prefix)
426 for mod in frozen_extensions:
427 unknown.remove(mod.name)
428
429 # report unknown modules
430 if unknown:
431 sys.stderr.write('Warning: unknown modules remain: %s\n' %
432 ' '.join(unknown))
433
434 # windows gets different treatment
435 if win:
436 # Taking a shortcut here...
437 import winmakemakefile, checkextensions_win32
438 checkextensions_win32.write_extension_table(extensions_c,
439 frozen_extensions)
440 # Create a module definition for the bootstrap C code.
441 xtras = [frozenmain_c, os.path.basename(frozen_c),
442 frozendllmain_c, os.path.basename(extensions_c)] + files
443 maindefn = checkextensions_win32.CExtension( '__main__', xtras )
444 frozen_extensions.append( maindefn )
445 with open(makefile, 'w') as outfp:
446 winmakemakefile.makemakefile(outfp,
447 locals(),
448 frozen_extensions,
449 os.path.basename(target))
450 return
451
452 # generate config.c and Makefile
453 builtins.sort()
454 with open(config_c_in) as infp, bkfile.open(config_c, 'w') as outfp:
455 makeconfig.makeconfig(infp, outfp, builtins)
456
457 cflags = ['$(OPT)']
458 cppflags = defines + includes
459 libs = [os.path.join(libdir, '$(LDLIBRARY)')]
460
461 somevars = {}
462 if os.path.exists(makefile_in):
463 makevars = parsesetup.getmakevars(makefile_in)
464 for key in makevars:
465 somevars[key] = makevars[key]
466
467 somevars['CFLAGS'] = ' '.join(cflags) # override
468 somevars['CPPFLAGS'] = ' '.join(cppflags) # override
469 files = [base_config_c, base_frozen_c] + \
470 files + supp_sources + addfiles + libs + \
471 ['$(MODLIBS)', '$(LIBS)', '$(SYSLIBS)']
472
473 with bkfile.open(makefile, 'w') as outfp:
474 makemakefile.makemakefile(outfp, somevars, files, base_target)
475
476 # Done!
477
478 if odir:
479 print('Now run "make" in', odir, end=' ')
480 print('to build the target:', base_target)
481 else:
482 print('Now run "make" to build the target:', base_target)
483
484
485 # Print usage message and exit
486
487 def usage(msg):
488 sys.stdout = sys.stderr
489 print("Error:", msg)
490 print("Use ``%s -h'' for help" % sys.argv[0])
491 sys.exit(2)
492
493
494 main()