text:
The Office of Sustainability has partnered with local event organizers – Austin City Limits Music Festival, Circuit of The Americas LLC, and ACL Live at the Moody Theater – to create the Positive Impact on Climate and Community (PICC) program.
PICC joins the City's commitment to climate protection leadership with Austin's unique reputation as the Live Music Capital of the World. Large events and festivals in Austin involve over a million attendees annually and have a large environmental impact involving air and ground transportation, energy and water usage, food service, and material waste. By working together, the Office of Sustainability and the event organizers behind some of the largest events in the city will be able to offer a unified approach to carbon offsets to mitigate some of these impacts, while also supporting local projects that benefit the Austin community.
Now you can JOIN THE EFFORT.
Funds raised voluntarily through the Austin City Limits Music Festival will benefit the PICC program, with 50% of the dollars raised supporting Hill Country Conservancy's Violet Crown Trail Project and 50% used to purchase third-party-verified carbon offset projects in Texas through the Texas Climate & Carbon Exchange. Art Market vendors at the Austin City Limits Music Festival will designate specialty items for sale to support PICC. You can help by checking out the Art Market at this year's ACL Music Festival and making a PICC purchase – join the effort and support projects that benefit Austin.
About the Austin City Limits Music Festival: The ACL Festival takes place on 46 acres in Zilker Park – the crown jewel of Austin's public green spaces. It plays host not only to 130+ artists from across the globe, but also amazing local eats and wares, free fun for kids, green goings-on, and other cool activities to entertain you between sets.
About Hill Country Conservancy: Hill Country Conservancy (HCC) was founded in 1999 to preserve – forever – large strategic natural areas that conserve critical water features, preserve outdoor recreation opportunities, and help maintain the Hill Country's unique quality of life. HCC works every day to preserve open space in the Central Texas / Barton Springs Aquifer region – because once Hill Country land is gone, it's gone for good.
About the Violet Crown Trail: A 30 + mile hike and bike trail system that will be created in three phases to connect Lady Bird Lake, the Barton Creek Greenbelt, the Lady Bird Johnson Wildflower Center – continuing south – through public lands in Hays County. This trail will not only promote the use and enjoyment of open space, it will also provide significant economic, environmental, transportation, health, and recreational benefits to the community. The trail system will encourage walkability, enhance the visitor experience, promote environmentally friendly businesses, and offer a safe family-friendly alternative means of transportation, thus reducing traffic congestion. The trail will add a new dimension to the overall quality of life in Central Texas, as well as offer first-time public access to 6,000 acres of historic ranchlands.
About the Texas Climate & Carbon Exchange: TCCX was founded in 2011 to advance greenhouse gas reduction and offset trading programs in the United States. It provides a secure and cost effective manner for cities, corporations, utilities and individuals to buy or sell certified carbon offsets voluntarily or to meet regulatory standards via its electronic trading platform.
In the coming months ACL Live at the Moody Theater and Circuit of The Americas will be making their project selections and identifying events to fund them. Stay tuned for more details on how you can join the effort and support PICC.
Get There from Here
Towards a Best Managed City
Connect With Us


text:
|PyInstaller v1.5.1
|Giovanni Bajo & William Caban (based on Gordon McMillan's manual)
|Source URL:
|$HeadURL: https://src.develer.com/svnoss/pyinstaller/branches/1.5/doc/source/Manual.rst $
|This document has been placed in the public domain.
First, unpack the archive on your path of choice. Installer is not a Python package, so it doesn't need to go in site-packages, or have a .pth file. For the purpose of this documentation we will assume /your/path/to/pyinstaller/. You will be using a couple of scripts in the /your/path/to/pyinstaller/ directory, and these will find everything they need from their own location. For convenience, keep the paths to these scripts short (don't install in a deeply nested subdirectory).
In the /your/path/to/pyinstaller/ directory, run:
python Configure.py
This will configure PyInstaller usage based on the current system, and save some information into config.dat that would otherwise be recomputed every time.
It can be rerun at any time if your configuration changes. It must be run at least once before trying to build anything.
PyInstaller is dependant to the version of python you configure it for. In other words, you will need a separate copy of PyInstaller for each Python version you wish to work with or you'll need to rerun Configure.py every time you switch the Python version).
[For Windows COM server support, see section Windows COM Server Support]
This is the first step to do. The spec file is the description of what you want PyInstaller to do with your program. In the root directory of PyInstaller, there is a simple wizard to create simple spec files that cover all basic usages:
python Makespec.py [--onefile] yourprogram.py
By deafult, Makespec.py generates a spec file that tells PyInstaller to create a distribution directory contains the main executable and the dynamic libraries. The option --onefile specifies that you want PyInstaller to build a single file with everything inside.
Elaborating on Makespec.py, this is the supported command line:
python Makespec.py [opts] <scriptname> [<scriptname> ...]
Where allowed OPTIONS are:
|-F, --onefile
|produce a single file deployment (see below).
|-D, --onedir
|produce a single directory deployment (default).
|-K, --tk
|include TCL/TK in the deployment.
|-a, --ascii
|do not include encodings. The default (on Python versions with unicode support) is now to include all encodings.
|-d, --debug
|use debug (verbose) versions of the executables.
|-w, --windowed, --noconsole
|Use the Windows subsystem executable, which does not open the console when the program is launched. (Windows only)
|-c, --nowindowed, --console
|Use the console subsystem executable. This is the default. (Windows only)
|-s, --strip
|the executable and all shared libraries will be run through strip. Note that cygwin's strip tends to render normal Win32 dlls unusable.
|-X, --upx
|if you have UPX installed (detected by Configure), this will use it to compress your executable (and, on Windows, your dlls). See note below.
|-o DIR, --out=DIR
|create the spec file in directory. If not specified, and the current directory is Installer's root directory, an output subdirectory will be created. Otherwise the current directory is used.
|-p DIR, --paths=DIR
|set base path for import (like using PYTHONPATH). Multiple directories are allowed, separating them with the path separator (';' under Windows, ':' under Linux), or using this option multiple times.
|add file.ico to the executable's resources. (Windows only)
|add the n-th incon in file.exe to the executable's resources. (Windows only)
|-v FILE, --version=FILE
|add verfile as a version resource to the executable. (Windows only)
|-n NAME, --name=NAME
|optional name to assign to the project (from which the spec file name is generated). If omitted, the basename of the (first) script is used.
[For building with optimization on (like Python -O), see section Building Optimized]
For simple projects, the generated spec file will probably be sufficient. For more complex projects, it should be regarded as a template. The spec file is actually Python code, and modifying it should be ease. See Spec Files for details.
python Build.py specfile
A buildproject subdirectory will be created in the specfile's directory. This is a private workspace so that Build.py can act like a makefile. Any named targets will appear in the specfile's directory.
The generated files will be placed within the dist subdirectory; that's where the files you are interested in will be placed.
In most cases, this will be all you have to do. If not, see When things go wrong and be sure to read the introduction to Spec Files.
For Windows COM support execute:
python MakeCOMServer.py [OPTION] script...
This will generate a new script drivescript.py and a spec file for the script.
These options are allowed:
|Use the verbose version of the executable.
|Register the COM server(s) with the quiet flag off.
|do not include encodings (this is passed through to Makespec).
|--out <dir>
|Generate the driver script and spec file in dir.
Now Build your project on the generated spec file.
If you have the win32dbg package installed, you can use it with the generated COM server. In the driver script, set debug=1 in the registration line.
Warnings: the inprocess COM server support will not work when the client process already has Python loaded. It would be rather tricky to non-obtrusively hook into an already running Python, but the show-stopper is that the Python/C API won't let us find out which interpreter instance I should hook into. (If this is important to you, you might experiment with using apartment threading, which seems the best possibility to get this to work). To use a "frozen" COM server from a Python process, you'll have to load it as an exe:
o = win32com.client.Dispatch(progid, clsctx=pythoncom.CLSCTX_LOCAL_SERVER)
MakeCOMServer also assumes that your top level code (registration etc.) is "normal". If it's not, you will have to edit the generated script.
There are two facets to running optimized: gathering .pyo's, and setting the Py_OptimizeFlag. Installer will gather .pyo's if it is run optimized:
python -O Build.py ...
The Py_OptimizeFlag will be set if you use a ('O','','OPTION') in one of the TOCs building the EXE:
exe = EXE(pyz, a.scripts + [('O','','OPTION')], ...
See Spec Files for details.
On both Windows and Linux, UPX can give truly startling compression - the days of fitting something useful on a diskette are not gone forever! Installer has been tested with many UPX versions without problems. Just get it and install it on your PATH, then rerun configure.
For Windows, there is a problem of compatibility between UPX and executables generated by Microsoft Visual Studio .NET 2003 (or the equivalent free toolkit available for download). This is especially worrisome for users of Python 2.4+, where most extensions (and Python itself) are compiled with that compiler. This issue has been fixed in later beta versions of UPX, so you will need at least UPX 1.92 beta. Configure.py will check this for you and complain if you have an older version of UPX and you are using Python 2.4.
For Linux, a bit more discussion is in order. First, UPX is only useful on executables, not shared libs. Installer accounts for that, but to get the full benefit, you might rebuild Python with more things statically linked.
More importantly, when run finds that its sys.argv[0] does not contain a path, it will use /proc/pid/exe to find itself (if it can). This happens, for example, when executed by Apache. If it has been upx-ed, this symbolic link points to the tempfile created by the upx stub and PyInstaller will fail (please see the UPX docs for more information). So for now, at least, you can't use upx for CGI's executed by Apache. Otherwise, you can ignore the warnings in the UPX docs, since what PyInstaller opens is the executable Installer created, not the temporary upx-created executable.
A --onefile works by packing all the shared libs / dlls into the archive attached to the bootloader executable (or next to the executable in a non-elf configuration). When first started, it finds that it needs to extract these files before it can run "for real". That's because locating and loading a shared lib or linked-in dll is a system level action, not user-level. With PyInstaller v1.5.1 it always uses a temporary directory (_MEIXXXXX, where XXXXX is a random number to avoid conflicts) in the user's temp directory. It then executes itself again, setting things up so the system will be able to load the shared libs / dlls. When execution is complete, it recursively removes the entire directory it created.
The temporary directory is exported to the program's environment as os.environ['_MEIPASS2']. This can be used in case you manually modified the spec file to tell PyInstaller to add additional files (eg: data files) within the executable (see also Accessing Data Files).
This has a number of implications:
Notes for *nix users: Take notice that if the executable does a setuid root, a determined hacker could possibly (given enough tries) introduce a malicious lookalike of one of the shared libraries during the hole between when the library is extracted into the temporary directory and when it gets loaded by the execvp'd process. So maybe you shouldn't do setuid root programs using --onefile. In fact, we do not recomend the use of --onefile on setuid programs.
setuptools is a distutils extensions which provide many benefits, including the ability to distribute the extension as eggs. Together with the nifty easy_install (a tool which automatically locates, downloads and installs Python extensions), eggs are becoming more and more widespread as a way for distributing Python extensions.
eggs can be either files or directories. An egg directory is basically a standard Python package, with some additional metadata that can be used for advanced setuptools features like entry-points. An egg file is simply a ZIP file, and it works as a package as well because Python 2.3+ is able to transparently import modules stored within ZIP files.
PyInstaller supports eggs at a good level. In fact:
Improved support for eggs is planned for a future release of PyInstaller.
python ArchiveViewer.py <archivefile>
ArchiveViewer lets you examine the contents of any archive build with PyInstaller or executable (PYZ, PKG or exe). Invoke it with the target as the first arg (It has been set up as a Send-To so it shows on the context menu in Explorer). The archive can be navigated using these commands:
python bindepend.py <executable_or_dynamic_library>
bindepend will analyze the executable you pass to it, and write to stdout all its binary dependencies. This is handy to find out which DLLs are required by an executable or another DLL. This module is used by PyInstaller itself to follow the chain of dependencies of binary extensions and make sure that all of them get included in the final package.
python GrabVersion.py <executable_with_version_resource>
GrabVersion outputs text which can be eval'ed by versionInfo.py to reproduce a version resource. Invoke it with the full path name of a Windows executable (with a version resource) as the first argument. If you cut & paste (or redirect to a file), you can then edit the version information. The edited text file can be used in a version = myversion.txt option on any executable in an PyInstaller spec file.
This was done in this way because version resources are rather strange beasts, and fully understanding them is probably impossible. Some elements are optional, others required, but you could spend unbounded amounts of time figuring this out, because it's not well documented. When you view the version tab on a properties dialog, there's no straightforward relationship between how the data is displayed and the structure of the resource itself. So the easiest thing to do is find an executable that displays the kind of information you want, grab it's resource and edit it. Certainly easier than the Version resource wizard in VC++.
You can interactively track down dependencies, including getting cross-references by using mf.py, documented in section mf.py: A modulefinder Replacement
python pyinstaller.py [options] <scriptname> [ <scriptname> ...] | <specfile>
Utility pyinstaller.py is new alternative interface for using PyInstaller. It will be the default interface for using PyInstaller in next major release (PyInstaller v1.6). pyinstaller.py should simplify usage of PyInstaller by wrapping the fuctionality of scripts Configure.py, Makespec.py and Build.py.
It should accept all optios of Configure.py, Makespec.py and Build.py.
When you run Makespec.py (documented in section Create a spec file for your project), it generates a spec file for you. In fact, you can think of Makespec.py just like a wizard that lets you generate a standard spec file for most standard usages. But advanced users can learn to edit spec files to fully customize PyInstaller behaviour to their needs, giving beyond the standard settings provided by the wizard.
Spec files are in Python syntax. They are evaluated by Build.py. A simplistic spec file might look like this:
a = Analysis(['myscript.py']) pyz = PYZ(a.pure) exe = EXE(pyz, a.scripts, a.binaries, name="myapp.exe")
This creates a single file deployment with all binaries (extension modules and their dependencies) packed into the executable.
A simplistic single directory deployment might look like this:
a = Analysis(['myscript.py']) pyz = PYZ(a.pure) exe = EXE(a.scripts, pyz, name="myapp.exe", exclude_binaries=1) dist = COLLECT(exe, a.binaries, name="dist")
Note that neither of these examples are realistic. If you want to start hacking a spec file, use Makespec.py to create a basic specfile, and tweak it (if necessary) from there.
All of the classes you see above are subclasses of Build.Target. A Target acts like a rule in a makefile. It knows enough to cache its last inputs and outputs. If its inputs haven't changed, it can assume its outputs wouldn't change on recomputation. So a spec file acts much like a makefile, only rebuilding as much as needs rebuilding. This means, for example, that if you change an EXE from debug=1 to debug=0, the rebuild will be nearly instantaneous.
The high level view is that an Analysis takes a list of scripts as input, and generates three "outputs", held in attributes named scripts, pure and binaries. A PYZ (a .pyz archive) is built from the modules in pure. The EXE is built from the PYZ, the scripts and, in the case of a single-file deployment, the binaries. In a single-directory deployment, a directory is built containing a slim executable and the binaries.
Before you can do much with a spec file, you need to understand the TOC (Table Of Contents) class.
A TOC appears to be a list of tuples of the form (name, path, typecode). In fact, it's an ordered set, not a list. A TOC contains no duplicates, where uniqueness is based on name only. Furthermore, within this constraint, a TOC preserves order.
Besides the normal list methods and operations, TOC supports taking differences and intersections (and note that adding or extending is really equivalent to union). Furthermore, the operations can take a real list of tuples on the right hand side. This makes excluding modules quite easy. For a pure Python module:
pyz = PYZ(a.pure - [('badmodule', '', '')])
or for an extension module in a single-directory deployment:
dist = COLLECT(..., a.binaries - [('badmodule', '', '')], ...)
or for a single-file deployment:
exe = EXE(..., a.binaries - [('badmodule', '', '')], ...)
To add files to a TOC, you need to know about the typecodes (or the step using the TOC won't know what to do with the entry).
|An extension module.
|Python internal name.
|Full path name in build.
|A script.
|Python internal name.
|Full path name in build.
|A pure Python module (including __init__ modules).
|Python internal name.
|Full path name in build.
|A .pyz archive (archive_rt.ZlibArchive).
|Runtime name.
|Full path name in build.
|A pkg archive (carchive4.CArchive).
|Runtime name.
|Full path name in build.
|A shared library.
|Runtime name.
|Full path name in build.
|Aribitrary files.
|Runtime name.
|Full path name in build.
|A runtime runtime option (frozen into the executable).
|The option.
You can force the include of any file in much the same way you do excludes:
collect = COLLECT(a.binaries + [('readme', '/my/project/readme', 'DATA')], ...)
or even:
collect = COLLECT(a.binaries, [('readme', '/my/project/readme', 'DATA')], ...)
(that is, you can use a list of tuples in place of a TOC in most cases).
There's not much reason to use this technique for PYSOURCE, since an Analysis takes a list of scripts as input. For PYMODULEs and EXTENSIONs, the hook mechanism discussed here is better because you won't have to remember how you got it working next time.
This technique is most useful for data files (see the Tree class below for a way to build a TOC from a directory tree), and for runtime options. The options the run executables understand are:
|Verbose imports
|('v', '', 'OPTION')
|Same as Python -v ...
|Unbuffered stdio
|('u', '', 'OPTION')
|Same as Python -u ...
|W spec
|Warning option
|('W ignore', '', 'OPTION')
|Python 2.1+ only.
|Use site.py
|('s', '', 'OPTION')
|The opposite of Python's -S flag. Note that site.py must be in the executable's directory to be used.
Advanced users should note that by using set differences and intersections, it becomes possible to factor out common modules, and deploy a project containing multiple executables with minimal redundancy. You'll need some top level code in each executable to mount the common PYZ.
Analysis(scripts, pathex=None, hookspath=None, excludes=None)
An Analysis has five outputs, all TOCs accessed as attributes of the Analysis.
PYZ(toc, name=None, level=9)
Generally, you will not need to create your own PKGs, as the EXE will do it for you. This is one way to include read-only data in a single-file deployment, however. A single-file deployment including TK support will use this technique.
PKG(toc, name=None, cdict=None, exclude_binaries=0)
EXE(*args, **kws)
Possible keyword arguments:
On Windows, this provides support for doing in-process COM servers. It is not generalized. However, embedders can follow the same model to build a special purpose DLL so the Python support in their app is hidden. You will need to write your own dll, but thanks to Allan Green for refactoring the C code and making that a managable task.
COLLECT(*args, **kws)
Possible keyword arguments:
Tree(root, prefix=None, excludes=None)
A list of names to exclude. Two forms are allowed:
Since a Tree is a TOC, you can also use the exclude technique described above in the section on TOCs.
When an Analysis step runs, it produces a warnings file (named warnproject.txt) in the spec file's directory. Generally, most of these warnings are harmless. For example, os.py (which is cross-platform) works by figuring out what platform it is on, then importing (and rebinding names from) the appropriate platform-specific module. So analyzing os.py will produce a set of warnings like:
W: no module named dos (conditional import by os) W: no module named ce (conditional import by os) W: no module named os2 (conditional import by os)
Note that the analysis has detected that the import is within a conditional block (an if statement). The analysis also detects if an import within a function or class, (delayed) or at the top level. A top-level, non-conditional import failure is really a hard error. There's at least a reasonable chance that conditional and / or delayed import will be handled gracefully at runtime.
Ignorable warnings may also be produced when a class or function is declared in a package (an __init__.py module), and the import specifies package.name. In this case, the analysis can't tell if name is supposed to refer to a submodule of package.
Warnings are also produced when an __import__, exec or eval statement is encountered. The __import__ warnings should almost certainly be investigated. Both exec and eval can be used to implement import hacks, but usually their use is more benign.
Any problem detected here can be handled by hooking the analysis of the module. See Listing Hidden Imports below for how to do it.
Setting debug=1 on an EXE will cause the executable to put out progress messages (for console apps, these go to stdout; for Windows apps, these show as MessageBoxes). This can be useful if you are doing complex packaging, or your app doesn't seem to be starting, or just to learn how the runtime works.
You can also pass a -v (verbose imports) flag to the embedded Python. This can be extremely useful. I usually try it even on apparently working apps, just to make sure that I'm always getting my copies of the modules and no import has leaked out to the installed Python.
You set this (like the other runtime options) by feeding a phone TOC entry to the EXE. The easiest way to do this is to change the EXE from:
EXE(..., anal.scripts, ....)
EXE(..., anal.scripts + [('v', '', 'OPTION')], ...)
These messages will always go to stdout, so you won't see them on Windows if console=0.
When the analysis phase cannot find needed modules, it may be that the code is manipulating sys.path. The easiest thing to do in this case is tell Analysis about the new directory through the second arg to the constructor:
anal = Analysis(['somedir/myscript.py'], ['path/to/thisdir', 'path/to/thatdir'])
In this case, the Analysis will have a search path:
['somedir', 'path/to/thisdir', 'path/to/thatdir'] + sys.path
You can do the same when running Makespec.py:
Makespec.py --paths=path/to/thisdir;path/to/thatdir ...
(on *nix, use : as the path separator).
Python allows a package to extend the search path used to find modules and sub-packages through the __path__ mechanism. Normally, a package's __path__ has only one entry - the directory in which the __init__.py was found. But __init__.py is free to extend its __path__ to include other directories. For example, the win32com.shell.shell module actually resolves to win32com/win32comext/shell/shell.pyd. This is because win32com/__init__.py appends ../win32comext to its __path__.
Because the __init__.py is not actually run during an analysis, we use the same hook mechanism we use for hidden imports. A static list of names won't do, however, because the new entry on __path__ may well require computation. So hook-module.py should define a method hook(mod). The mod argument is an instance of mf.Module which has (more or less) the same attributes as a real module object. The hook function should return a mf.Module instance - perhaps a brand new one, but more likely the same one used as an arg, but mutated. See mf.py: A Modulefinder Replacement for details, and hooks/hook-win32com.py for an example.
Note that manipulations of __path__ hooked in this way apply to the analysis, and only the analysis. That is, at runtime win32com.shell is resolved the same way as win32com.anythingelse, and win32com.__path__ knows nothing of ../win32comext.
Once in awhile, that's not enough.
More bizarre situations can be accomodated with runtime hooks. These are small scripts that manipulate the environment before your main script runs, effectively providing additional top-level code to your script.
At the tail end of an analysis, the module list is examined for matches in rthooks.dat, which is the string representation of a Python dictionary. The key is the module name, and the value is a list of hook-script pathnames.
So putting an entry:
'somemodule': ['path/to/somescript.py'],
into rthooks.dat is almost the same thing as doing this:
anal = Analysis(['path/to/somescript.py', 'main.py'], ...
except that in using the hook, path/to/somescript.py will not be analyzed, (that's not a feature - we just haven't found a sane way fit the recursion into my persistence scheme).
Hooks done in this way, while they need to be careful of what they import, are free to do almost anything. One provided hook sets things up so that win32com can generate modules at runtime (to disk), and the generated modules can be found in the win32com package.
In most sophisticated apps, it becomes necessary to figure out (at runtime) whether you're running "live" or "frozen". For example, you might have a configuration file that (running "live") you locate based on a module's __file__ attribute. That won't work once the code is packaged up. You'll probably want to look for it based on sys.executable instead.
The bootloaders set sys.frozen=1 (and, for in-process COM servers, the embedding DLL sets sys.frozen='dll').
For really advanced users, you can access the iu.ImportManager as sys.importManager. See iu.py for how you might make use of this fact.
In a --onedir distribution, this is easy: pass a list of your data files (in TOC format) to the COLLECT, and they will show up in the distribution directory tree. The name in the (name, path, 'DATA') tuple can be a relative path name. Then, at runtime, you can use code like this to find the file:
os.path.join(os.path.dirname(sys.executable), relativename))
In a --onefile distribution, data files are bundled within the executable and then extracted at runtime into the work directory by the C code (which is also able to reconstruct directory trees). The work directory is best found by os.environ['_MEIPASS2']. So, you can access those files through:
os.path.join(os.environ["_MEIPASS2], relativename))
If you're using popen on Windows and want the code to work on Win9x, you'll need to distribute win9xpopen.exe with your app. On older Pythons with Win32all, this would apply to Win32pipe and win32popenWin9x.exe. (On yet older Pythons, no form of popen worked on Win9x).
The ELF executable format (Windows, Linux and some others) allows arbitrary data to be concatenated to the end of the executable without disturbing its functionality. For this reason, a CArchive's Table of Contents is at the end of the archive. The executable can open itself as a binary file name, seek to the end and 'open' the CArchive (see figure 3).
On other platforms, the archive and the executable are separate, but the archive is named executable.pkg, and expected to be in the same directory. Other than that, the process is the same.
In a single directory deployment (--onedir, which is the default), all of the binaries are already in the file system. In that case, the embedding app:
There are a couple situations which require two passes:
The first pass:
The child process executes as in One Pass Execution above (the magic environment variable is what tells it that this is pass two).
figure 3 - Self Extracting Executable
There are, of course, quite a few differences between the Windows and Unix/Linux versions. The major one is that because all of Python on Windows is in pythonXX.dll, and dynamic loading is so simple-minded, that one binary can be use with any version of Python. There's much in common, though, and that C code can be found in source/common/launch.c.
The Unix/Linux build process (which you need to run just once for any version of Python) makes use of the config information in your install (if you installed from RPM, you need the Python-development RPM). It also overrides getpath.c since we don't want it hunting around the filesystem to build sys.path.
In both cases, while one PyInstaller download can be used with any Python version, you need to have separate installations for each Python version.
You know what an archive is: a .tar file, a .jar file, a .zip file. Two kinds of archives are used here. One is equivalent to a Java .jar file - it allows Python modules to be stored efficiently and, (with some import hooks) imported directly. This is a ZlibArchive. The other (a CArchive) is equivalent to a .zip file - a general way of packing up (and optionally compressing) arbitrary blobs of data. It gets its name from the fact that it can be manipulated easily from C, as well as from Python. Both of these derive from a common base class, making it fairly easy to create new kinds of archives.
A ZlibArchive contains compressed .pyc (or .pyo) files. The Table of Contents is a marshalled dictionary, with the key (the module's name as given in an import statement) associated with a seek position and length. Because it is all marshalled Python, ZlibArchives are completely cross-platform.
A ZlibArchive hooks in with iu.py so that, with a little setup, the archived modules can be imported transparently. Even with compression at level 9, this works out to being faster than the normal import. Instead of searching sys.path, there's a lookup in the dictionary. There's no stat-ing of the .py and .pyc and no file opens (the file is already open). There's just a seek, a read and a decompress. A traceback will point to the source file the archive entry was created from (the __file__ attribute from the time the .pyc was compiled). On a user's box with no source installed, this is not terribly useful, but if they send you the traceback, at least you can make sense of it.
A CArchive contains whatever you want to stuff into it. It's very much like a .zip file. They are easy to create in Python and unpack from C code. CArchives can be appended to other files (like ELF and COFF executables, for example). To allow this, they are opened from the end, so the TOC for a CArchive is at the back, followed only by a cookie that tells you where the TOC starts and where the archive itself starts.
CArchives can also be embedded within other CArchives. The inner archive can be opened in place (without extraction).
Each TOC entry is variable length. The first field in the entry tells you the length of the entry. The last field is the name of the corresponding packed file. The name is null terminated. Compression is optional by member.
There is also a type code associated with each entry. If you're using a CArchive as a .zip file, you don't need to worry about this. The type codes are used by the self-extracting executables.
PyInstaller is mainly distributed under the GPL License but it has an exception such that you can use it to compile commercial products.
In a nutshell, the license is GPL for the source code with the exception that:
- You may use PyInstaller to compile commercial applications out of your source code.
- The resulting binaries generated by PyInstaller from your source code can be shipped with whatever license you want.
- You may modify PyInstaller for your own needs but these changes to the PyInstaller source code falls under the terms of the GPL license. In other words, any modifications to will have to be distributed under GPL.
For updated information or clarification see our FAQ at PyInstaller home page.
PyInstaller comes with binary bootloaders for most platforms, shipped in /your/path/to/pyinstaller//support/loader. If you need to build the bootloader for your own platform (either because your platform is not officially supported, or because you tweaked bootloader's source code), you can follow this guide.
On Debian/Ubuntu systems, you can run the following lines to install everything required:
sudo apt-get install build-essential python-dev
On Fedora/RHEL and derivates, you can run the following lines:
su yum groupinstall "Development Tools" yum install python-devel
On Mac OS X you can get gcc by installing Xcode. It is a suite of tools for developing software for Mac OS X. It can be also installed from your Mac OS X Install DVD. It is not necessary to install the version 4 of Xcode.
On Windows you can use MinGW (gcc for Windows) and Visual Studio C++ (msvc) compilers. Python development libraries are usually installed together with Python.
Note: There is no interdependence between the Visual Studio version used to compile the bootloader and the Visual Studio version used to compile Python. The bootloader is a self-contained static executable, that imposes no restrictions on the version of Python being used. So you can simply use any Visual Studio version you have around.
You can download and install or unpack MinGW distribution from one of the following locations:
On Windows, when using MinGW, it is needed to add PATH_TO_MINGW\bin to your system PATH. variable. In command prompt before building bootloader run for example:
set PATH=C:\MinGW\bin;%PATH%
Change to the /your/path/to/pyinstaller/ source subdirectory. Run:
pyinstaller$ cd source pyinstaller/source$ python waf configure build install
This will produce support/loader/YOUR_OS/run, support/loader/YOUR_OS/run_d, support/loader/YOUR_OS/runw and support/loader/YOUR_OS/runw_d, which are the bootloaders.
On Windows this will produce in the support/loader/YOUR_OS directory: run*.exe (bootloader for regular programs), and inprocsrvr*.dll (bootloader for in-process COM servers).
Note: If you have multiple versions of Python, the Python you use to run waf is the one whose configuration is used.
By default, the bootloaders on Linux are LSB binaries.
LSB is a set of open standards that should increase compatibility among Linux distributions. PyInstaller is able produce bootloader as LSB binary in order to increase compatibility for packaged applications among distributions.
Note: LSB version 4.0 is required for successfull building of bootloader.
On Debian- and Ubuntu-based distros, you can install LSB 4.0 tools by adding the following repository to the sources.list file:
deb http://ftp.linux-foundation.org/pub/lsb/repositories/debian lsb-4.0 main
then after having update the apt repository:
sudo apt-get update
you can install LSB 4.0:
sudo apt-get install lsb lsb-build-cc
Most other distributions contain only LSB 3.0 in their software repositories and thus LSB build tools 4.0 must be downloaded by hand. From Linux Foundation download LSB sdk 4.0 for your architecture.
Unpack it by:
tar -xvzf lsb-sdk-4.0.3-1.ia32.tar.gz
To install it run:
cd lsb-sdk ./install.sh
After having installed the LSB tools, you can follow the standard building instructions.
NOTE: if for some reason you want to avoid LSB compilation, you can do so by specifying --no-lsb on the waf command line, as follows:
pyinstaller/source$ python waf configure --no-lsb build install
This will also produce support/loader/YOUR_OS/run, support/loader/YOUR_OS/run_d, support/loader/YOUR_OS/runw and support/loader/YOUR_OS/runw_d, but they will not be LSB binaries.
Module mf is modelled after iu.
It also uses ImportDirectors and Owners to partition the import name space. Except for the fact that these return Module instances instead of real module objects, they are identical.
Instead of an ImportManager, mf has an ImportTracker managing things.
ImportTracker can be called in two ways: analyze_one(name, importername=None) or analyze_r(name, importername=None). The second method does what modulefinder does - it recursively finds all the module names that importing name would cause to appear in sys.modules. The first method is non-recursive. This is useful, because it is the only way of answering the question "Who imports name?" But since it is somewhat unrealistic (very few real imports do not involve recursion), it deserves some explanation.
When a name is imported, there are structural and dynamic effects. The dynamic effects are due to the execution of the top-level code in the module (or modules) that get imported. The structural effects have to do with whether the import is relative or absolute, and whether the name is a dotted name (if there are N dots in the name, then N+1 modules will be imported even without any code running).
The analyze_one method determines the structural effects, and defers the dynamic effects. For example, analyze_one("B.C", "A") could return ["B", "B.C"] or ["A.B", "A.B.C"] depending on whether the import turns out to be relative or absolute. In addition, ImportTracker's modules dict will have Module instances for them.
There are Module subclasses for builtins, extensions, packages and (normal) modules. Besides the normal module object attributes, they have an attribute imports. For packages and normal modules, imports is a list populated by scanning the code object (and therefor, the names in this list may be relative or absolute names - we don't know until they have been analyzed).
The highly astute will notice that there is a hole in analyze_one() here. The first thing that happens when B.C is being imported is that B is imported and it's top-level code executed. That top-level code can do various things so that when the import of B.C finally occurs, something completely different happens (from what a structural analysis would predict). But mf can handle this through it's hooks mechanism.
Like modulefinder, mf scans the byte code of a module, looking for imports. In addition, mf will pick out a module's __all__ attribute, if it is built as a list of constant names. This means that if a package declares an __all__ list as a list of names, ImportTracker will track those names if asked to analyze package.*. The code scan also notes the occurance of __import__, exec and eval, and can issue warnings when they're found.
The code scanning also keeps track (as well as it can) of the context of an import. It recognizes when imports are found at the top-level, and when they are found inside definitions (deferred imports). Within that, it also tracks whether the import is inside a condition (conditional imports).
In modulefinder, scanning the code takes the place of executing the code object. mf goes further and allows a module to be hooked (after it has been scanned, but before analyze_one is done with it). A hook is a module named hook-fullyqualifiedname in the hooks package. These modules should have one or more of the following three global names defined:
The first hook (hiddenimports) extends the list created by scanning the code. ExtensionModules, of course, don't get scanned, so this is the only way of recording any imports they do.
The second hook (attrs) exists mainly so that ImportTracker won't issue spurious warnings when the rightmost node in a dotted name turns out to be an attribute in a package module, instead of a missing submodule.
The callable hook exists for things like dynamic modification of a package's __path__ or perverse situations, like xml.__init__ replacing itself in sys.modules with _xmlplus.__init__. (It takes nine hook modules to properly trace through PyXML-using code, and I can't believe that it's any easier for the poor programmer using that package). The hook(mod) (if it exists) is called before looking at the others - that way it can, for example, test sys.version and adjust what's in hiddenimports.
ImportTracker has a getwarnings() method that returns all the warnings accumulated by the instance, and by the Module instances in its modules dict. Generally, it is ImportTracker who will accumulate the warnings generated during the structural phase, and Modules that will get the warnings generated during the code scan.
Note that by using a hook module, you can silence some particularly tiresome warnings, but not all of them.
Once a full analysis (that is, an analyze_r call) has been done, you can get a cross reference by using getxref(). This returns a list of tuples. Each tuple is (modulename, importers), where importers is a list of the (fully qualified) names of the modules importing modulename. Both the returned list and the importers list are sorted.
A simple example follows:
>>> import mf >>> a = mf.ImportTracker() >>> a.analyze_r("os") ['os', 'sys', 'posixpath', 'nt', 'stat', 'string', 'strop', 're', 'pcre', 'ntpath', 'dospath', 'macpath', 'win32api', 'UserDict', 'copy', 'types', 'repr', 'tempfile'] >>> a.analyze_one("os") ['os'] >>> a.modules['string'].imports [('strop', 0, 0), ('strop.*', 0, 0), ('re', 1, 1)] >>>
The tuples in the imports list are (name, delayed, conditional).
>>> for w in a.modules['string'].warnings: print w ... W: delayed eval hack detected at line 359 W: delayed eval hack detected at line 389 W: delayed eval hack detected at line 418 >>> for w in a.getwarnings(): print w ... W: no module named pwd (delayed, conditional import by posixpath) W: no module named dos (conditional import by os) W: no module named os2 (conditional import by os) W: no module named posix (conditional import by os) W: no module named mac (conditional import by os) W: no module named MACFS (delayed, conditional import by tempfile) W: no module named macfs (delayed, conditional import by tempfile) W: top-level conditional exec statment detected at line 47 - os (C:\Program Files\Python\Lib\os.py) W: delayed eval hack detected at line 359 - string (C:\Program Files\Python\Lib\string.py) W: delayed eval hack detected at line 389 - string (C:\Program Files\Python\Lib\string.py) W: delayed eval hack detected at line 418 - string (C:\Program Files\Python\Lib\string.py) >>>
Module iu grows out of the pioneering work that Greg Stein did with imputil (actually, it includes some verbatim imputil code, but since Greg didn't copyright it, we won't mention it). Both modules can take over Python's builtin import and ease writing of at least certain kinds of import hooks.
iu differs from imputil: * faster * better emulation of builtin import * more managable
There is an ImportManager which provides the replacement for builtin import and hides all the semantic complexities of a Python import request from it's delegates.
ImportManager formalizes the concept of a metapath. This concept implicitly exists in native Python in that builtins and frozen modules are searched before sys.path, (on Windows there's also a search of the registry while on Mac, resources may be searched). This metapath is a list populated with ImportDirector instances. There are ImportDirector subclasses for builtins, frozen modules, (on Windows) modules found through the registry and a PathImportDirector for handling sys.path. For a top-level import (that is, not an import of a module in a package), ImportManager tries each director on it's metapath until one succeeds.
ImportManager hides the semantic complexity of an import from the directors. It's up to the ImportManager to decide if an import is relative or absolute; to see if the module has already been imported; to keep sys.modules up to date; to handle the fromlist and return the correct module object.
An ImportDirector just needs to respond to getmod(name) by returning a module object or None. As you will see, an ImportDirector can consider name to be atomic - it has no need to examine name to see if it is dotted.
To see how this works, we need to examine the PathImportDirector.
The PathImportDirector subclass manages a list of names - most notably, sys.path. To do so, it maintains a shadowpath - a dictionary mapping the names on its pathlist (eg, sys.path) to their associated Owners. (It could do this directly, but the assumption that sys.path is occupied solely by strings seems ineradicable.) Owners of the appropriate kind are created as needed (if all your imports are satisfied by the first two elements of sys.path, the PathImportDirector's shadowpath will only have two entries).
An Owner is much like an ImportDirector but manages a much more concrete piece of turf. For example, a DirOwner manages one directory. Since there are no other officially recognized filesystem-like namespaces for importing, that's all that's included in iu, but it's easy to imagine Owners for zip files (and I have one for my own .pyz archive format) or even URLs.
As with ImportDirectors, an Owner just needs to respond to getmod(name) by returning a module object or None, and it can consider name to be atomic.
So structurally, we have a tree, rooted at the ImportManager. At the next level, we have a set of ImportDirectors. At least one of those directors, the PathImportDirector in charge of sys.path, has another level beneath it, consisting of Owners. This much of the tree covers the entire top-level import namespace.
The rest of the import namespace is covered by treelets, each rooted in a package module (an __init__.py).
To make this work, Owners need to recognize when a module is a package. For a DirOwner, this means that name is a subdirectory which contains an __init__.py. The __init__ module is loaded and its __path__ is initialized with the subdirectory. Then, a PathImportDirector is created to manage this __path__. Finally the new PathImportDirector's getmod is assigned to the package's __importsub__ function.
When a module within the package is imported, the request is routed (by the ImportManager) diretly to the package's __importsub__. In a hierarchical namespace (like a filesystem), this means that __importsub__ (which is really the bound getmod method of a PathImportDirector instance) needs only the module name, not the package name or the fully qualified name. And that's exactly what it gets. (In a flat namespace - like most archives - it is perfectly easy to route the request back up the package tree to the archive Owner, qualifying the name at each step.)
Let's say we want to import from zip files. So, we subclass Owner. The __init__ method should take a filename, and raise a ValueError if the file is not an acceptable .zip file, (when a new name is encountered on sys.path or a package's __path__, registered Owners are tried until one accepts the name). The getmod method would check the zip file's contents and return None if the name is not found. Otherwise, it would extract the marshalled code object from the zip, create a new module object and perform a bit of initialization (12 lines of code all told for my own archive format, including initializing a pack age with it's __subimporter__).
Once the new Owner class is registered with iu, you can put a zip file on sys.path. A package could even put a zip file on its __path__.
This code has been tested with the PyXML, mxBase and Win32 packages, covering over a dozen import hacks from manipulations of __path__ to replacing a module in sys.modules with a different one. Emulation of Python's native import is nearly exact, including the names recorded in sys.modules and module attributes (packages imported through iu have an extra attribute - __importsub__).
In most cases, iu is slower than builtin import (by 15 to 20%) but faster than imputil (by 15 to 20%). By inserting archives at the front of sys.path containing the standard lib and the package being tested, this can be reduced to 5 to 10% slower (or, on my 1.52 box, 10% faster!) than builtin import. A bit more can be shaved off by manipulating the ImportManager's metapath.
This module makes no attempt to facilitate policy import hacks. It is easy to implement certain kinds of policies within a particular domain, but fundamentally iu works by dividing up the import namespace into independent domains.
Quite simply, I think cross-domain import hacks are a very bad idea. As author of the original package on which PyInstaller is based, McMillan worked with import hacks for many years. Many of them are highly fragile; they often rely on undocumented (maybe even accidental) features of implementation. A cross-domain import hack is not likely to work with PyXML, for example.
That rant aside, you can modify ImportManger to implement different policies. For example, a version that implements three import primitives: absolute import, relative import and recursive-relative import. No idea what the Python syntax for those should be, but __aimport__, __rimport__ and __rrimport__ were easy to implement.
Here's a simple example of using iu as a builtin import replacement.
>>> import iu >>> iu.ImportManager().install() >>> >>> import DateTime >>> DateTime.__importsub__ <method PathImportDirector.getmod of PathImportDirector instance at 825900> >>>

subset: commoncrawl


text:
Deep & Dark Ganache Cake Recipe
- 6 ounces bittersweet chocolate, chopped
- 1-1/2 cups hot brewed coffee
- 4 eggs
- 3 cups sugar
- 3/4 cup canola oil
- 2 teaspoons vanilla extract
- 2-1/2 cups all-purpose flour
- 1 cup baking cocoa
- 2 teaspoons baking soda
- 3/4 teaspoon baking powder
- 1-1/4 teaspoons salt
- 1-1/2 cups buttermilk
- 16 ounces bittersweet chocolate, chopped
- 2 cups heavy whipping cream
- 5 teaspoons light corn syrup
- Preheat oven to 325°. Line bottoms of three greased 8-in.-square baking pans with parchment paper; grease paper.
- Place chocolate in a small bowl. Pour hot coffee over chocolate; stir with a whisk until smooth. Cool slightly.
- In a large bowl, beat eggs on high speed until lemon-colored. Gradually add sugar, oil, vanilla and chocolate mixture, beating until well blended. In another bowl, mix flour, cocoa, baking soda, baking powder and salt; add to chocolate mixture alternately with buttermilk, beating well after each addition.
- Transfer to prepared pans. Bake 30-35 minutes or until a toothpick inserted in center comes out clean. Cool 10 minutes before removing from pans to wire racks; remove paper. Cool completely.
- For ganache, place chocolate in a large bowl. In a small saucepan, bring cream and corn syrup just to a boil. Pour over chocolate; stir with a whisk until smooth.
- Let stand at room temperature to cool and thicken slightly, about 45 minutes, stirring occasionally. (Mixture will be very soft, but will thicken when spread onto cake.)
- Place one cake layer on a serving plate; spread with 1/3 cup ganache. Repeat layers. Top with remaining cake layer. Spread remaining ganache over top and sides of cake. Yield: 24 servings.
Reviews for Deep & Dark Ganache Cake
Sort By :
Really good cake, especially for those who prefer a cake that is not too sweet. I omitted the corn syrup as I always make my ganache with raw honey. I sub the same amount of honey for corn syrup. My ganache also set up instantly and was nice and thick. Great cake.
I'm normally not a chocolate cake fan, but for some reason, this cake appealed to me. I'm so glad that I made it. It was delicious! I do agree as others have said, that you need to be a dark chocolate lover for this cake. The cake was a bit more dense in texture than I expected and if anyone else had the same issue, I'd like to know or if there are suggestions on lightening the texture, I'd appreciate the suggestions. Following the recipe, the ganache had a little more bite than I'd expected so I added a little extra corn syrup for sweetness. Maybe this added to time that it took for the ganache to thicken, but it definitely took more than 45 minutes. Since I didn't have square cake pans, I used round and was disappointed that my finished results weren't smooth and pretty. However, I took the cake to work and used my co-workers as guinea pigs (as I so often do with new recipes) and they loved the cake! One of my friends actually requested that I make it for her daughter's wedding as the groom's cake - which I did, adding blueberries as part of the decorations. It was such a hit at her daughter's wedding that I was asked to make it for another wedding! Now, I'm making it again for someone's birthday. I have to give this cake recipe five stars. Wonderful!!!
I agree with bakergirlmd, corn syrup is totally NOT necessary to make ganache! I also enjoyed the helpful tips in jennycrocker review. Looking forward to trying this cake!
This good for feb love month,and everybody know kid love chocolat
Amazing recipe; I've made something similar over the years. The addition of coffee to already-dark chocolate is the quintessential combination! The buttermilk gives it the added acid plus moistness you would not otherwise have in this type of cake. I gave the recipe four stars as I'm not a fan of the ganache containing corn syrup...the cake is rich enough on its own. I definitely left it out. I just slightly warm cream in a saucepan and break up the chocolate into pieces and keep stirring 'til the chocolate melts....voila, you have ganache!


text:
Get it Fast with Wells & Kimich Quick Ship Program!
Some customers are forced into situations where they need work stations for their employees in a hurry. This could be due to corporate merges, large windfall projects or replacement of furniture after natural disasters. We currently stock a large quantity of panels and components that can build the size workstations you require in heights of 42' x 62".
Standard sixes are 4'x2' sales stations, 6'x6' & 8'x8' professional stations. Please call us for help in designing cubicles for your workspace.
The Quick Ship cubicles from Wells & Kimich Office Furnishings feature the following:


text:
You are here: Coupons > Store Offers > AJ Madison Coupons
Up to 15% off Refrigerators plus Free Delivery on Orders over $999(expires on 10/31/15)
No Code Needed
Shop Now ► AJ Madison
2.5% Cash Back
2.5% Cash Back for FatWallet members on this purchase!» What is Cash Back?
» Cash Back Details
More AJ Madison Offers
AJ Madison Offer Discussion
Cash Back Details
|2.5% Cash Back is Available on offers that display the cash back symbol.
- Cash Back only available on online orders
- Cash Back is not available on orders placed from a mobile device.
- Cash Back not available on Miele products


text:
BALTIMORE (AP) - Maryland's three casinos pulled in $43.1 million in November, led by the new Maryland Live Casino in Anne Arundel County.
The Maryland Lottery and Gaming Control Agency announced Wednesday that Maryland Live, which opened in June, accounted for $34.4 million of the revenues. The casino took in $30.6 million in October.
The Hollywood Casino Perryville generated $5.4 million in November, down slightly from the month before, but off more than 40 percent from November 2011.
The Casino at Ocean Downs, meanwhile, generated $3.3 million in November, a 6.9 percent increase over Nov. 2011.
(Copyright 2012 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.)


text:
Payroll Tax Hikes Take a Bite Out of Wal-Mart's Sales
Kyle is a member of The Motley Fool Blog Network -- entries represent the personal opinion of the blogger and are not formally edited.
This article will discuss how the expiration of the payroll tax cuts, which were initially implemented in 2010 and were phased out as of Dec. 31, 2012, apparently affected Wal-Mart's (NYSE: WMT) February sales and how this might be a yellow flag for the broader retail sector.
What is the Payroll Tax Rate for 2013?
The payroll tax rate, or FICA rate, is the combined social security tax rate of 6.2 percent and the Medicare tax rate of 1.45 percent. The Bush tax cut package cut the social security portion from 6.2 to 4.2 percent.
When Congress and the Obama Administration kicked the can on a budget compromise last year, the pay roll tax reduction was restored to 6.2 percent. Furthermore, the Social Security Administration announced last December that the Social Security wage base will increase this year to $113,700 from the 2012 base rate of $110,100. This is an increase of $3,600.
The bottom line: this year taxpayers began paying 2 percentage points more in Social Security taxes on their first $113,700 in wages. This is roughly $15 a week for those making $40,000 a year, and the increases may be dragging down retail sales.
Wal-Marts' February Sales Numbers Fall
Several news sources recently reported that Wal-Mart had weak February sales numbers and other retailers might be similarly situated. In fact, head honchos said in internal e-mails that month-to-date figures were a "total disaster." This was the retail chain's worst sales start since 2006.
The company's shares fell by about 2% after the leaked emails floated to the surface in a story initially reported by Bloomberg News. In addition, this might not be good news for the retail sector. Combining the possible effect of the tax rate hike with rising gasoline and food prices means that discount retail customers at Wal-Mart and other stores might tighten their belts since take home pay has been dinged.
But the question remains as to whether or not shoppers will have less buying power for the rest of the year. And it's not as if discount retailers have never seen consumers pull back. In such scenarios, one way to maintain market share is by offering deeper discounts that will keep consumers hopes alive and slow the falling sales numbers.
Given the lingering economic uncertainty, investors may use this as an opportunity to take some money off the table while resisting the urge to panic. Whether this is a small blip on the economic radar for 2013 or the beginning of a dip in the retail sector is unclear.
And some analysts noted that other retail outlets like Family Dollar Stores (NYSE: FDO) and Target (NYSE: TGT) may also be feeling the pain.
Target - the retail outlet that sells everything from clothes to home goods to groceries - reported a solid 3.1 percent increase in revenue in January. That was boosted in part because of solid sales of clearance items. The figure also beat the 1.7 percent estimate of some analysts. The February sales figures should be available on March 1, so investors will have a better idea as to if the payroll tax hike affected its sales.
In an appearance on CNBC's Squawk Box last week Family Dollar's chief said that the payroll tax hike should not be a "major challenge" for the retailer's business. While the next earnings announcement is not until April 10, 2012 earnings per share were $3.65 and estimates for first half of 2013 are $3.98. This gain might not factor in the payroll tax hike figures, but it does not appear that the bogey man of return to normal payroll deductions will be an impediment.
In other words Wal-Mart's competitors may not be feeling the pain, and that outfits' February sales slump may be a reflection of other challenges besides the payroll tax hike like customer service and its business model in general.
Wal-Mart Q4 Earnings
Wal-Mart reported that sales rose 1 percent in the fourth quarter of FY 2012. The company had forecast an increase of 1 percent to 3 percent. In the same period in 2011, Wal-Mart's U.S. same-store sales rose 1.5 percent. The retailer also earned $5.61 billion, or $1.67 per share (up from $5.19 billion or $1.51 per share a year earlier).
Moreover, the retail outfit spent $157 million last year on an internal probe of its major Mexican unit that surfaced in April 2012. The company said its forecast includes about $40 million to $45 million in first-quarter costs related to Foreign Corrupt Practices Act and other compliance matters.
So, the Q4 numbers are actually a bit better than analysts' projections, and it's too early to determine what the rest of 2013 has in store Wal-Mart. Meanwhile, investors and retail buyers alike should proceed with caution.
kcolona has no position in any stocks mentioned. The Motley Fool has no position in any of the stocks mentioned. Try any of our Foolish newsletter services free for 30 days. We Fools may not all hold the same opinions, but we all believe that considering a diverse range of insights makes us better investors. The Motley Fool has a disclosure policy. Is this post wrong? Click here. Think you can do better? Join us and write your own!


text:
There has been quite a bit of upheaval on the Florida Panthers' roster, which does give them some sleeper value selections, but the Panthers most definitely lack elite fantasy prospects.
Even goaltender Tomas Vokoun, who puts up a first-rate save percentage (.925 over the last two years combined), has won only 49 games in the last two seasons because of his limited supporting cast. He's a good No. 2 goaltender for fantasy, but risky as the starter.
Working out from the net, the Panthers do have a couple of decent defencemen. Bryan McCabe isn't an offensive force the way he was at his peak, but last year's 43 points tied him for 17th among defencemen.
Dennis Wideman endured a difficult season in Boston, a veritable collapse from his career year in 2008-2009, but rebounded to lead the Bruins in playoff scoring. Wideman should see lots of ice time, so there will be opportunities to be productive, yet also opportunities to fall on the minus side of the plus-minus ledger if things aren't going well.
The Panthers do have some wingers with good upside. Left winger David Booth could be Florida's most dangerous offensive threat, but concussions ruined his 2009-2010 season, so there is an element of risk in selecting him. There aren't a lot of potential 30-goal scorers on left wing, however, so Booth deserves fair consideration.
Third-year winger Michael Frolik has a finisher's flair as well, scoring 21 goals in each of his first two seasons but, given his talent, 30 isn't out of the question.
Stephen Weiss is a sound, reliable two-way pivot who scored a career-high 28 goals last season and has put up at least 60 points in back-to-back years, but with a supporting cast that is longer on potential than proven producers, it's difficult to expect more from Weiss.
There is further potential from rookie winger Michael Grabner, or veterans Cory Stillman and Christopher Higgins could recapture some of their productive past, but they are selections for those in deep leagues only.


text:
It's the most important day in the history of Earth—the dawn of a new age of harmony or the start of its final war. The Doctor must face his most difficult challenge yet: It's a battle he can't take sides in and a day when no one must die … Meera Syal, Stephen Moore and Neve McIntosh guest star.
Season 5 Episodes View All
Cold Blood
Season: 5 | Episode: 9 | Original Air Date: 19 June, 2010


text: I recently purchased a replica nemrod holster from Kcr7pr and need a leather strap that holds the side arm in place by snapping onto the holster as well a leather loop that attaches to the top of the holster and rests on the leather ESB belt. Please PM if interested. thxs


text:
An Atlanta man pleaded not guilty Monday to charges that he shot and killed a 36-year-old father, who was gunned down minutes after he dropped off his 2-year-old son at a suburban preschool.
Defense attorney Doug Peters entered the plea on behalf of Hemy Neuman, who didn't speak during the 15-minute hearing at the DeKalb County Courthouse. Neuman is charged with the November killing of Russell Sneiderman outside the Dunwoody Prep preschool, a slaying that shocked the affluent north Atlanta suburb of Dunwoody.
Prosecutors have said little publicly about a possible motive in the case, but some details have emerged. Neuman, 48, supervised Sneiderman's wife, Andrea, in the quality and engineering department of GE Energy in Atlanta, the company said.
Police have not implicated Andrea Sneiderman in the killing, and she has said she was shocked when she learned of Neuman's arrest and that she considered him a "friend of our family."
After the hearing, an attorney representing Neuman's wife Ariela, told reporters her client believes that the suspect and the victim's widow were having an affair. Esther Panitch said she wants to interview both Andrea Sneiderman and Hemy Neuman as part of a civil lawsuit filed on behalf of Neuman's wife, but she has so far been rebuffed.
"We believe there was an extramarital affair between Mr. Neuman and Mrs. Sneiderman," she said, adding that she believes access to the two will prove the allegation.
Sneiderman, a father of two who was a financial consultant before joining a private venture firm, was killed in the parking lot of the preschool minutes after dropping off his son.
The high-profile killing rocked the suburban community, where authorities urged witnesses to come forward with tips and Sneiderman's family offered a reward. Police even set up a system that allowed tipsters to send encrypted text messages, and nervous residents were on the lookout for a silver minivan matching the description of the getaway vehicle.
Neuman, who is from Israel, was arrested three months ago, and refused to answer questions after a January court appearance. He has a home in suburban Cobb County, authorities said, and his Facebook page said he was a graduate of Georgia Tech and a father of three, including two children who study engineering at his alma mater.
Monday's hearing set the stage for more pre-trial legal maneuvering. A judge gave Sneiderman's defense team a 30 day extension to review more than 6,200 pages of documents and dozens of hours of recorded interviews that prosecutors submitted as discovery. Peters said it was "certainly one of the more complicated criminal cases" ever brought in the county.
DeKalb County District Attorney Robert James said the state is ready to proceed with the trial, but he said he understands why the judge granted the defense team more time to pore over the records.
"This is not your average murder case," he said.
KMSP-TV11358 Viking DriveEden Prairie, MN 55344
Phone: (952) 944-9999Fax: (952) 942-0455


text:
Born Free USA Blog
by Adam M Roberts,
Chief Executive Officer
When it comes to animals, Adam Roberts not only talks the talk, but also walks the walk. Since beginning his animal advocacy career in Washington, D.C. in 1991, Adam's ambition, tireless involvement, and profound knowledge of conservation and wildlife issues have cemented him as a go-to voice for protecting animals — and he has elevated Born Free USA to the respected and impactful organization that we know today. Adam's compassionate, informed, and forward-thinking blogs will surely motivate you to join us in our fight to Keep Wildlife in the Wild.
Hip Replacement? How about Moral Compass Replacement!
So, Spain is in dire straights. Massive debts and nearly one in four unemployed. A new government may be about to take charge, but who knows. People are hurting!
And so, apparently is Juan Carlos, the King of Spain — but not for any of the above reasons.
While his fellow countrymen are wondering how to make ends meet, the king was adventuring in Bostwana hunting elephants (without his moral compass).
What? Yes, the picture of the king standing in front of a magnificent bull elephant, slumped dead against a tree, has shocked millions of people for a variety of reasons.
Shouldn't the king be setting an example and working to help lift his fellow citizens out of the mess they are in?
Shouldn't the king be setting an example and, as elephants face annihilation across much of Africa, join efforts to protect a species under threat (poaching and the illegal ivory trade are rampant across many parts of the continent? (See www.bloodyivory.org for details.)
Newspaper and media reports in Spain are highly critical of the king's lifestyle and his pursuit of threatened species. In an attempt to justify his "sport," it has been claimed that trophy hunting of elephants in Botswana (which is legal) is a method of controlling elephant numbers. Poppycock! It is nothing of the sort. It simply terminates a number of the most magnificent (and possibly the most genetically significant) bulls while doing nothing whatsoever to control numbers (if numbers need to be controlled in the first place).
Apparently, the king suffered an accident while on his sojourn of slaughter — requiring hip replacement surgery. Maybe his time convalescing will give him the opportunity to reflect on just how badly his actions are viewed both at home and internationally. His hip may heal but the elephant is dead, gone forever.
A modern monarch should be in touch with the people. Juan Carlos seems to be all at sea.
Blogging off(in disgust),


text:
About CMS
The Center for Migration Studies of New York (CMS) is an educational institute/think tank devoted to the study of international migration, to the promotion of understanding between immigrants and receiving communities, and to public policies that safeguard the dignity and rights of migrants, refugees and newcomers.
Upcoming EventsSep29Mon9:15 am Democratizing Data on Non-Citize... @ Center for Migration StudiesDemocratizing Data on Non-Citize... @ Center for Migration StudiesSep 29 @ 9:15 am – 3:00 pmSep30Tue9:30 am IMR 50th Anniversary Symposium @ Fried FrankIMR 50th Anniversary Symposium @ Fried FrankSep 30 @ 9:30 am – 5:15 pm6:00 pm Golden Anniversary Gala @ Battery GardensGolden Anniversary Gala @ Battery GardensSep 30 @ 6:00 pm – 10:00 pmOct21Tue9:00 am 11th Annual Immigration Law and ... @ Georgetown University Law Center Bernard P. McDonough Hall, Hart Auditorium11th Annual Immigration Law and ... @ Georgetown University Law Center Bernard P. McDonough Hall, Hart AuditoriumOct 21 @ 9:00 am – 5:00 pm
Stay Connected
Barack Obama Archive
The Migration of Unaccompanied Children to the United States: Stumbling Towards a Humanitarian SolutionPosted on June 23, 2014 | No CommentsOn June 20, 2014, the White House announced the expansion of comprehensive measures to address the increased flow of unaccompanied migrant children arriving to the US-Mexico border. The Obama Administration […]
Deferred Action for the DREAMersPosted on June 16, 2012 | No CommentsOn June 15, 2012, President Barack Obama announced that the so-called "DREAMers"- young people raised in the United States but without legal status – would be granted "deferred action" in […]


text:
After Abe's victory, Tokyo shifts to earnings
The market's leadership is switching from bank stocks to big exporters, like Toyota.
The Liberal Democratic Party of Prime Minister Shinzo Abe and its allied New Komeito party swept to victory in Sunday's elections for Japan's upper house of parliament. With the two parties expected to control at least 133 of the 242 seats in the House of Councillors, the upper house of the Diet, Abe will be able to move his economic and reform programs ahead without worrying about a dispirited opposition.
The Nikkei 225 ($JP:N225) moved up just 0.47% in Tokyo as the election trend became clear. That's not surprising, since the results were largely anticipated. Now markets will wait to see how Abe uses his majorities.
The Abe government put off action on that list in the run up to the election, out of worry that proposed changes would alienate conservative voters. Experts say that Abe has to hit the ground running with his proposals to restructure the economy if he's to avoid defeat by conservative elements in his own party. Abe has promised a concrete set of proposals by September.
But the Tokyo market should have plenty to occupy it in the meantime. Japan's earnings season starts next week -- and the country's big exporters are expected to show year over year earnings growth of 10% to 20% thanks to a weaker yen. Many companies used 90 yen to the dollar in their last forecasts for the quarter but in the event the exchange rate for the quarter was close to 99 yen to the U.S. dollar. That's likely to push earnings growth toward the upper end of the 10% to 20% range at the same time as companies and analysts announce upwards revisions to earnings estimates for the next quarter.
In anticipation of these trends market leadership has switched from bank stocks to big exporters such as Toyota Motor (TM), a member of my Jubak's Picks portfolio. The company is scheduled to announce quarterly earnings on August 2.
Full disclosure: I don't own shares of any of the companies mentioned in this post in my personal portfolio. When in 2010 I started the mutual fund I manage, Jubak Global Equity Fund, I liquidated all my individual stock holdings and put the money into the fund. The fund did own shares of Toyota Motor as of the end of March. For a full list of the stocks in the fund as of the end of March see the fund's portfolio.
MSN Money on Twitter and Facebook
Like us on Facebook: MSN Money and Top Stocks
Follow us on Twitter: @msn_money and @topstocksmsn
Copyright © 2014 Microsoft. All rights reserved.
Fundamental company data and historical chart data provided by Morningstar Inc. Real-time index quotes and delayed quotes supplied by Morningstar Inc. Quotes delayed by up to 15 minutes, except where indicated otherwise. Fund summary, fund performance and dividend data provided by Morningstar Inc. Analyst recommendations provided by Zacks Investment Research. StockScouter data provided by Verus Analytics. IPO data provided by Hoover's Inc. Index membership data provided by Morningstar Inc.
As geopolitical tensions threaten to spin out of control, investors are wondering how best to position their portfolios for the global turmoil.
Top Stocks provides analysis about the most noteworthy stocks in the market each day, combining some of the best content from around the MSN Money site and the rest of the Web.
Contributors include professional investors and journalists affiliated with MSN Money.
Follow us on Twitter @topstocksmsn.


text:
This conversation is closed.
What is one thing that you wished you could have handled differently in a past relationship?
All of us must have had a relationship with someone in some way --- be it in friendship, in family, or a lover. Some of us must have learnt the hard way of handling relationships. What advice can you give, of how relationships with people can be better handled/balanced, so that relationships stay strong and grow?
Topics: life love relationships
Showing single comment thread. View the full conversation.
Showing single comment thread. View the full conversation.


text:
- News
- Weather
- Sports
- Community
- Features
- Programming
- Station Info
- Featured on 4
Tuesday, January 4, 2011 - 7:12pm
PHILIPPINES— A Filipino councilman left a haunting image after he was shot and killed.
Reynaldo Dagsa, a local councilman, captured the image of his killer before he was shot and killed.
Dagsa was taking a picture of his family outside of his home on New Year's Eve. The picture clearly shows a man aiming a gun from behind Dagsa's family only seconds before he was murdered.
Dagsa died of his injuries at the hospital.
Dagsa's family said they didn't hear the gunshot due to all the firecrackers going off around them.
Police used the picture to arrest two men whom they say are the killer and his accomplice.
Dagsa's funeral was Tuesday.


text:
On Friday's Chat Room, Sun-Times Spash Editor Susanna Negovan, lifestyle consultant Rochelle Trotter and GDC anchor Anna Davlantes discussed social media to combat flash mobs, the top restaurants for cheaters, Asian beauty queens getting plastic surgery and the new Candyland game.
Senior Pastor Rev. Wilfredo De Jesús of New Life Covenant Ministries joined Chat Room to discuss the church, one of the fastest growing in Chicago. Rev. De Jesús was recently named one of the 100 most influential people in the world.
Follow @fox32news
35 Skyline DriveLake Mary, FL 32746
Phone: (407) 644-3535News Tips: (866) 55-FOX35


text:
Jefferson County DA Brandon Falls announced Thursday that the two suspects in Monday's triple fatal collision in north Birmingham will be charged with felony murder.
Dominique Rashad Smith, 20, and Jeffery Howe, 18, both of Mulga, are charged with three counts each of first degree murder after authorities say they killed a family of three after colliding with their car.
Birmingham police Sgt. Johnny Williams says that both men are being held at the Birmingham City Jail. Howe is being held on a $750,000 bond and Smith is being held on a $225,000 bond.
Smith and Howe are accused in several crimes that occurred Monday, Oct. 1. Cordova Police Chief Kenneth Bobo says that the two men robbed an elderly couple as they returned to their home on Long Avenue. When the 77-year-old husband refused to give up his wallet, Bobo says one of the men hit him in the head with a gun.
After the robbery, Bobo says the two men fled in a white SUV through Dora and Adamsville. Some time after that, a Jefferson County Sheriff's deputy recognized their vehicle from a BOLO and started to give chase. However, authorities say that as the deputy tried to make a u-turn to follow, he overturned in a ditch.
Smith and Howe reportedly continued on to the intersection of Minor Parkway and Birmingport Road, where police say they collided with a car at the traffic light. Inside that car was Nicole Verus, Ryan Culwell and their 10-month-old daughter Rogue Culwell. All three died in the collision.
Witnesses to the accident as well as authorities say that after the wreck, Smith and Howe exited their white SUV and fled on foot from the scene.
A manhunt for the two suspects began Monday night and ended Tuesday evening. Smith reportedly turned himself into Cooper Green Tuesday for treatment of injuries from the collision. Howe was taken into custody at a home in Ensley. A third man was taken into custody at the same home and has been charged with hindering prosecution.
Check back to MyFoxAl.com for more information as this story develops.
Copyright 2012 WBRC. All rights reserved.
12 East Delano Avenue
Montgomery, AL 36105
(334) 288-1212
FCC Public File
EEO Report
Closed Captioning


text:
It's the ULTIMATE mystery bag! Add products to cart, creating a minimum value of $20. Then use code MYSTERY in the coupon code box at checkout to receive one of THREE FREEMystery Bags-a $21 value each ! Set will automatically ship with your order. Cannot be combined with other offers or applied to previous purchases. Limit one per customer. Online only. Hurry, offer ends midnight PST!
Sized to slip easily into your purse or travel bag, this soft, faux leather portfolio houses five professional-quality brushes for beautiful on-the-go makeup application.
Set includes:
All e.l.f. professional makeup brushes have been designed and tested by our professional team of makeup artists. Each brush has been ergonomically designed to fit perfectly into your hand and facilitate a flawless finish with every application.
Set includes:
- Travel Powder Brush
- Travel Brow & Brush Comb
- Travel Angled Brush
- Travel Eyeshadow/Concealer Brush
- Travel Eyeshadow Applicator
All e.l.f. professional makeup brushes have been designed and tested by our professional team of makeup artists. Each brush has been ergonomically designed to fit perfectly into your hand and facilitate a flawless finish with every application.
e.l.f. Essential Professional Travel Brush Kit
- $5.00
Professional Travel Brush Kit is rated out of 5 by 31.
Rated 1 out of 5 by Trinimia from Horrid quality I got this brush set a few days ago and was excited about having it for my purse but OMG the powder brush is so coarse it's unbelievable. I'm so upset, I'm not expecting cashmere for the price but not something so harsh on the face. And the shedding is so annoying, it sheds a lot. At this rate I doubt there'll be any bristles left after a week. Very disappointing :(
Date published: 2014-08-22
Rated 3 out of 5 by Zoseph from I really love how convenient this is to pack around but the powder brush is horrid, the bristles are rough and it sheds like crazy.
Date published: 2014-08-06
Rated 2 out of 5 by DraykesMom from Ok I bought this product about 2 months ago. All the brushes are good for travel use with the exception of the full use brush. With a swipe of face powder on my face I had the bristles all over my face.
Date published: 2014-06-03
Rated 3 out of 5 by Larissa from Cute but incomplete With the exception of the powder brush, I am glad I bought it. It's good for traveling but you need to bring your everyday powder brush with you too. The powder brush sheds horribly and is soooo pokey and irritating on the skin. Because of that, I would call this set incomplete.
Date published: 2014-03-29
Rated 2 out of 5 by makeupjunkie15 from HMMMM? I bought these brushes over a year ago.Totally not worth it. They shed like crazy and the handles have broken off (I have no idea why) . They do not aply makeup that well, I would not repurchase any of the essential brushes again! Purchase the Professional ELF brushes! Now those are amazing!
Date published: 2013-12-01
Rated 3 out of 5 by Kim from Falling apart The powder brush's bristles are falling out on the first use. I thought perhaps it was just a few that hadn't fully bonded to the holder and tried again. Nope, wound up with a face full of fur! Compact size was good and the other brushes are fine. Altogether, pretty good for the price. But disappointed with that one.
Date published: 2013-10-05
Rated 2 out of 5 by Shani from Not worth it I got excited about this set but I was highly disappointed. On the first use the brush started to shed hair all over. When I was done with it my face looked like a hair ball :/
Date published: 2013-07-30
Rated 5 out of 5 by LadyLioness from Convenient This is the perfect little set of brushes that meets every need when traveling! The brushes are soft, and just the right size!
Date published: 2013-07-09
Copyright © 2014 J.A. Cosmetics US, Inc Powered by BlueSwitch.