In some cases you may want to create a true application, for instance because you want to send it off to people who may not have Python installed on their machine, or because you the application is important and you do not want changes in your Python installation like new versions to influence it.
BuildApplication
applet in the main Python folder.
BuildApplication has a similar interface as BuildApplet: you drop a script on
it and it will process it, along with an optional .rsrc
file.
What BuildApplication does, however, is very different. It parses your script,
recursively looking for all modules you use, bundles the compiled code for
all these modules in PYC resources, adds the executable machine code for the
PythonCore engine, any dynamically loaded modules you use and a main program, combines
all this into a single file and adds a few preference resources (which you
can inspect with EditPythonPrefs
, incidentally) to isolate the
new program from the existing Python installation.
Usually you do not need to worry about all this, but occasionally you may have to exercise some control over the process, for instance because your program imports modules that don't exist (which can happen if your script is multi-platform and those modules will never be used on the Mac). See the section on directives below for details. If you get strange error messages about missing modules it may also be worthwhile to run macfreeze in report mode on your program, see below.
When you start
Mac:Tools:macfreeze:macfreeze.py
you are asked for the
script file, and you can select which type of freeze to do. The first
time you should always choose report only, which will produce a
listing of modules and where they are included from in the console
window. Macfreeze actually parses all modules, so it may crash in the
process. If it does try again with a higher debug value, this should
show you where it crashes.
sys.path
early in your initialization). It is possible to
include directives to tell macfreeze to add items to the search path and
include or exclude certain modules. All your directives should be in the
main script file. Directives have the following form:
# macfreeze: command argumentThe trigger
macfreeze:
must be spelled exactly like that,
but the whitespace can be any combination of spaces and tabs. Macfreeze
understands the following directives:
path
sys.path
. The argument is a
pathname, which should probably be relative (starting with a colon) and
is interpreted relative to the folder where the script lives.
include
exclude
optional
PYC
resources. This may be useful if you have embedded Python in your own
application. The resource file generated is the same as for the CodeWarrior
generation process.
.py
removed and
build.
prepended. If the output folder does not exist yet
it is created, and a template project file and bundle resource file are
deposited there. Next, a source file macfreezeconfig.c
is
created which includes all builtin modules your script uses, and a
resource file frozenmodules.rsrc
which contains the
PYC
resources for all your Python modules.
The project expects to live in a folder one level below the Python root
folder, so the next thing you should do is move the build folder there.
It is a good idea to leave an alias with the same name in the original
location: when you run freeze again it will regenerate the
frozenmodules.rsrc
file but not the project and bundle
files. This is probably what you want: if you modify your python sources
you have to re-freeze, but you may have changed the project and bundle
files, so you don't want to regenerate them.
An alternative is to leave the build folder where it is, but then you have to adapt the search path in the project.
The project is set up to include all the standard builtin modules, but the CW linker is smart enough to exclude any object code that isn't referenced. Still, it may be worthwhile to remove any sources for modules that you are sure are not used to cut back on compilation time. You may also want to examine the various resource files (for Tcl/Tk, for instance): the loader has no way to know that these aren't used.
You may also need to add sourcefiles if your script uses non-standard
builtin modules, like anything from the Extensions
folder.
The frozenbundle.rsrc
resource file contains the bundle
information. It is almost identical to the bundle file used for applets,
with the exception that it sets the sys.path
initialization
to $(APPLICATION)
only. This means that all modules will only
be looked for in PYC resources in your application.