What is Reddit's opinion of py2exe?

From 3.5 billion Reddit comments

Yes, from the py2exe tutorial:

>py2exe turns Python programs into packages that can be run on other Windows computers without needing to install Python on those computers.

Yes - and I've shipped a project with py2exe. It used wxWidgets and was a nifty little app.

Your problems can be solved if you read the documentation.

> py2exe, it was mostly "use this script" without any explanation

That's because you didn't follow the tutorial.

libtcod is just a library, and barring some really crazy obscure ones won't really impact whether or not you can package your game for Steam -- just make sure to include the appropriate DLLs (Windows) or .so files (Linux/Mac) alongside your packaged Python app.

Python apps absolutely can be packaged and distributed on Steam; probably the most famous example is EVE Online. You'll probably want to use something like py2exe or cx_Freeze to create an executable from your Python app before you distribute it; RogueBasin, naturally, has a good overview of your options here.

NB: None of this constitutes legal advice vis-a-vis licensing restrictions that may apply; this addresses the question solely from a technical standpoint.

I'd suggest using the py2exe package from http://www.py2exe.org/ This allows you to turn a specific file into an executable by running the setup.py file through the command line. (i.e. 'cmd' on windows) ~ Although I suggest you read the read-me file attached :D

Hope I was of some use!

It depends on how you are going to have a user install it. ~~You can create a setup script (https://docs.python.org/2/distutils/setupscript.html)~~, you could use pip and have a requirements file (https://pip.readthedocs.org/en/1.1/requirements.html) or you can try p2exe to make a windows executable (http://www.py2exe.org/).

Edit: as /u/wlu56 points out, distutils is not the way to go. :)

There's definitely a Python API for working with excel files, I haven't used it though. http://www.python-excel.org/

and there are ways of turning your python scripts into .exe files for example py2exe http://www.py2exe.org/ It can sometimes be a little tricky to get it to package things all into one file, but it is possible, and even if it doesn't, you just have to move some dll's with the .exe file.

In terms of GUIs there are a few options, python comes packaged with library called tkinter, which is fairly simple, so you can get stuff together reasonably quickly, but it's not the most powerfull, one thing that really annoys me is it doesn't have a table widget. Alternatives to tkinter are pyQT and wxPython (though that's python 2.7), and there are plenty more, but building GUIs is a pretty major thing so I'd do some proper research before picking one.

So basically, yes! you can definitely do what you want... however, if you don't have any experience coding, it will take some time, but I'd say python is a pretty good choice for small applications, and a great language to choose to start coding in.

I'll gently direct you towards this site.

> py2exe allows to create an executable (.exe) file that bundles everything necessary to run the script.

(No, people won't need their own python environment, it will be packed in your .exe file)

Have fun with Python! :)

IF you want to provide a Python program to other people to run on computers without python, then you can convert it to an exe with a utility like py2exe. Normally, you don't want to do that. They'd still have to know how to run a program from the command line, so it's easier to ask them to install Python, and then provide them with the script.

I believe that it is possible to use py2exe to bundle all the modules needed for a graphical Python program into an installable Windows package, but that's hard to get right. If you want to create a graphical Windows program for distribution without Python, then it'd be better to choose a language suited to that purpose like Visual C#.

You can convert the Python code into an executable using cx_freeze or py2exe. I did this to make Windows/Linux builds for my PyGame entry.

Definitely get this working before the compo starts though in case it doesn't go smoothly.

If you are on windows you can write a .bat file that simply contains the commands you would type into the command line. It could be as simple as:

python c:\path\to\my\script.py

This assumes that the person has python and the script on their computer (or maybe a network location). If you need something a little more robust, py2exe could be what you are looking for.

OpenGL is used plenty by Linux and especially OS X developers, and Python is really easy to set up on Windows. What are you talking about?

EDIT: Ah, you're saying that the average Windows consumer can't set up Python. This is true, but they don't have to.

There's no compiling in any of the python-to-exe packages. It just wraps up the python interpreter, libraries, and required modules into a zip or exe, extracts and executes them.

The py2exe tutorials give plenty of info.

Python is not completely cross platform (many functions behave differently or just don't exist depending on environment), so you'll need to check your code in each. The biggest gotcha is time.time() and time.clock(). In windows, time.time() is wall clock and time.clock() is higher precision clock. In *nix, time.time() is process time and time.clock() is wall clock time.

My understanding is that you're looking for something that will give you something like an exe or app package that people can click to open.

If that is correct, there are a few options:

• cxfreeze
• py2app
• py2exe

You will need to compile once on OS X and once on Windows to get each package. There may be other options as well, but not I'm aware of them.

I'm also a Python beginner and running into the same issue as you are, which is to get standalone binary distributions out of Python code (makes it really hard to distribute your code when 90% of your target PCs are running Windows and 95% of their users think python is only a big snake!)

That said, I've been using py2exe with Python 2.7 to some, moderate success - have you given it a try?

Be warned, however, that the wx library is a mess to compile, and it creates >10 Megabytes just for the dependencies. You might also run into some DLL problems, especially different OS DLLs versions from those included in your distribution.

I guess you could try to use more up-to-date-but-not-necessarily-better third party application cxFreeze, but again it's quite complicated to get it to work.

Hope anyone else can help you (and maybe me)!

huh? python compiles into bytecode actually, with .pyc files analogous to java .class files (or actually java .class files in the case of jython). You can AoT byte-compile python and install without actual source files. Bytecode is still not native code, but it's all not a lot different to java (python even had .egg analogous to .jar). It's more of a different community conventions / culture not to because space is cheap, open source is best anyway, and the source is useful for debugging, not because it's impossible.

Coming from traditional linux land with vaguely competent packaging systems it's not something I'd personally bother with or encourage, but you can generate single-executable python bundles too with e.g. for windows with py2exe. They're just embedding python, but it's enough to keep windozers culturally fixated on single-binary delivery happy (forex trading company I used to work for did it for years and most people didn't even know it was python).

I remember seeing Elliot code his own Metasploit modules. That is above script kiddie level.

Using popular platforms like Kali Linux is a good way to make attribution more difficult.

You can create stand-alone Python Windows executables that do not need an interpreter installed on the endpoint. See py2exe for example.

http://www.py2exe.org

IMHO Mr Robot offers fairly realistic hacking scenes, thanks to the quality of the technical advisors.

Try googling? Top result I found was this.

EDIT: Or this from SO.

EDIT 2: If you can guarantee the user already has python installed (be it system requirements for assumptions or whatever), you can also just write a batch script with the line python [relative path to file] that can be double clicked.

I just recently found out about Py2exe: "py2exe is a Python Distutils extension which converts Python scripts into executable Windows programs, able to run without requiring a Python installation."

Since you're developing a desktop application, I thought this might be useful somehow. I'm also looking for a project to work on regarding Python...and I'm also a beginner in Python. If you want some help, let me know.

You should be able to have a much much smaller executable.

see http://www.py2exe.org/index.cgi/OptimizingSize - he manages to get it to 2.15 MB by compressing it and excluding certain libraries.

OK what you are looking for is py2exe http://www.py2exe.org/ and a GUI toolkit like wxPython https://wxpython.org/ . She will be able to run without Python installed.

Be warned, adding a GUI to a project and GUI programming itself could triple the development time. But if she really knows nothing and you want to make it as easy as possible, this is the way to go.

Being a professor, she should be able to follow simple instructions... like how to install Python, how to install libraries etc., so that could be less painful / time consuming, if you know how to write good documentation.

Or you know, you could do it the old fashioned way and ask her to come to your desk and run it with her : ).

> The deployment gets a little bit more tricky- they need a Python runtime, but yes, you could do this.

Not that tricky at all. You can use tools like pyinstaller or py2exe to compile your Python programs into a folder or file that contains all required libraries, so they don't need to have Python installed.

I've used pyinstaller to create small self-contained programs for my students and have never had any major issues. The only thing to keep in mind is the target architecture. If you want the portable file/folder to run on a 32-bit machine, it should be compiled with 32-bit Python.

If you want to run your program on computers that don't have python, you can compile your program to an exe or app

Python is a scripting langauge, and is not really intended for making executables - people that use your code will normally be expected to have the Python interpreter and required libraries already installed.

However, you can create fully executable packages with Python - you need something like Py2Exe, which creates a package of all the Python components needed. Be warned though, its use is not terribly easy, and certainly not something you want to do when you are first starting out with the language.

As for the second question - yes, Python is great for making games, and there are lots of libraries available to help you. Take a look at PyGame, for example.

The short answer is, you don't. Python is an interpreted language, which means that you don't convert it into a machine-executable file (.exe on Windows), you use the language's runtime environment to interpret the source code of the program and execute each statement, one at a time.

So basically, you should type:

python.exe myprogram.py

...and it will run your program.

Now, someday down the road if you want to take the program you wrote and package it for someone else to run, you can do that - try py2exe: http://www.py2exe.org/ - but this is just a "trick" for distribution, it's not actually turning your Python into an .exe, it's actually just creating an .exe that contains both Python and your source code.

You said you're learning Python. Python is actually pretty good for such a thing.

You can generate executables, although they'll be large in comparison to say, a C++ executable, by using py2exe (http://www.py2exe.org/)

Google for web scraping with Python for some tutorials. You may want to try using Scrapy (http://doc.scrapy.org/intro/tutorial.html) with Python. Although Python has some built in stuff that may be a bit more complex to use.

To get the data references from the URL, you'll probably want to use something called regular expressions ("regex"). Just google around for "Regular expressions in Python" or whatnot.

And then using scrapy or whatever, you can fill in information and submit it, then retrieve and parse through the data. You will need to know a bit about the HTML structure to parse information from a webpage. If you use Firefox, you can use Firebug to easily analyze through the HTML. I think Chrome can do this easily without any extras. And of course you can always just look at the source, but for example with Firebug, if you want to know the name of an input bar, you can just hover over it.

If you want to get very fancy or make it really user-friendly, you may want to look into making a GUI with wxPython. There are a lot of resources to help with that. EricTboneJackson mentioned that web apps were popular. Instead of making a GUI, you could indeed get a host and use a Python CGI script to provide a web interface. I think a web framework like DJango would be too much unless you wanted to be really slick.

Good luck.

Here is some stuff about packaging PyQT5 applications. Your best bet is probably PyInstaller, which creates nice cross-platform executables. There's also py2exe, which is delightfully simple, but only supports Windows executables.

I'd think as a SysAdmin you would be the first to jump on the idea of any sort of file backup mechanism, :P.

I use py2exe for binary releases at my job and it's fantastic.

Create a setup py file, run it through python, include any external dll's you need alongside the exported executable, and wham! No need for python or any packages to be installed.

For Python:

Tkinter handles anything graphical and is built into Python IIRC. If you've never worked with GUIs, I'd download some python sample codes you find on stackoverflow, and just tweak and tweak and tweak until you start understanding widget interactions. Some Widgets have unfortunately poor documentation, and you really do need to play with each widget you use to get a feel for them. Just google around and you can find results like this: http://www.tkdocs.com/tutorial/firstexample.html

As for turning python into an executable, http://www.py2exe.org/ Using py2exe will take your script, and bundle it with a super stripped down version of Python so it can run without Python itself being installed. This is great is you need to deploy the software over multiple machines, but imo launching through command prompt is always best, unless that's not an option.

This is what I found with a simple google-search.

my_data_files = [('file_1', [filepath_1]), ('file_2', [filepath_2])]

Then just include my_data_files in your setup() with the data_files=my_data_files argument.

EDIT: No, relative filepaths shouldn't be an issue. If you want to be 100 % sure your dirs work correctly, I'd use os.getcwd() for the current directory, which is compatible with both Unix-systems (mac), and Windows.

1. http://www.py2exe.org/ for instance. Or you could also simply provide a launcher so that the user does not have to open the cmd and type (but this is mostly a windows problem anyway, in linux that is much simpler)
2. Not sure whats so bad on giving jars out ... they are bound to java anyhow so you can simply double-click run them (same as .py files btw). But yes, there are also launchers available to bundle everything into a nice exe if that's your kink.
3. Well, you end up with an .exe, but it still depends on the user having the right version of .net installed on their machine, so you really don't gain anything.

I made a lot of Windows desktop applications, using Python 3, Qt4 for the interface, py2exe ( http://www.py2exe.org/ ) to build a stand-alone executable, and InnoSetup to pack everything into an installer file. I'm very happy with it.

please tell me what it is, specifically, you're trying to accomplish and then I might be able to suggest a tool that might help. on the most basic level if what you're looking for is a command line package manager then what you're looking for is pip. what other tasks are you looking to accomplish?

unittest is a python built in and it integrates with CI tools like jenkins through a command line interface. python is interpreted so there's no need to have something like a Makefile to deal with compiling. "building" a python app usually doesn't involve anything besides installing your package dependencies through pip and then running your test suite through unittest to make sure it all works.

are you looking for a tool that produces redistributable Python executables? the only one I know of for that purpose is py2exe which is supposed to produce distributable packages to run on Windows machines.

all of the other use cases I've personally used Python for simply don't require any kind of packaging or distributing. one of the luxuries of web server development I suppose. Its Unix and its just IO streams start to finish, so it just kinda works already. WSGI does the hard work.

There are a lot of different alternatives, however cx_Freeze tends to be the most used.

I've used py2exe before - which is an alternative, although I'd recommend cx_Freeze.

I can only talk about the ones I've used... For a more extensive search I suggest you look at this stackoverflow post

I believe py2exe and cx_freeze may be what you are looking for. I know of them but have not used them myself.

If you visit /r/pygame and search for py2exe there are some threads that may point you in the right direction.

For your second question:

py2exe

pyinstaller

There may be more options, those are just off the top of my head. Also I've never actually used them myself, so can't speak to how well they work.

In your py2exe script, you have to set bundle_files = 1. This will bundle "everything", including the Python interpreter, into a single .exe file. Now, I put quotes around that word because it will actually produce a Windows DLL file and in my experience with wxPython, a wxpopopen file. But the thing is, you can just ignore those and give your end users just the .exe, since in most cases now they will have the .DLL on their computer already (I've tested this).

Here's a page where you can see a sample script with this (and they also turn off the zip option):

page: http://www.py2exe.org/index.cgi/SingleFileExecutable

Search for this section: "Using "bundle_files" and "zipfile"" Using "bundle_files" and "zipfile"

There isn't separation between your code and your GUI. You write your GUI in code. This may not be true in all cases, but is definitely true with Python. You should look up the docs on Tkinter. Then, what you should do is look up something like py2exe.

In this case, it sounds like you'll be needed to package up the file with a python interpreter; look into projects such as cx_Freeze and py2exe for this.

I'm a developer with amateur Python experience and I find python isn't the most user friendly thing to distribute on Windows. Have you ever tried http://www.py2exe.org/? Just curious as I knew people would be really keen to use your implementation of portify, but it's quite difficult for a layman to figure out how to run I imagine (and as evidenced by posts in this thread).

There are a couple ways.

1. Move the script yourself (Easy)
2. Use py2exe if it's just windows. (Moderate)
3. Make a package and use setup.py for multi-platform distribution. (Hard)

Each has its own tradeoffs and learning curves. If you need any more specific help, send me a pm!

There is no standard library for controlling the mouse. I actually just wrote a script that uses this:

import win32api, win32con win32api.SetCursorPos((x, y)) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0)

I have had great success with py2exe to bundle everything together into an exe. And with this you can run it on a computer that doesn't even have python installed.

I don't have an answer for you from experience, but here are two links about stuff built into python for distributing your own modules:
Distutils Python3.4
Distutils Python2.7

There is also py2exe for packaging and distributing in a Windows environment

The DLLs are a problem. You might not actually have the license to distribute them legally. The tutorial for py2exe will show you how to automatically copy the DLLs but you have to check what version of the Visual C runtime you have to see if you are legally allowed to redistribute it.

these two pages helped me figure out py2exe with pygtk:

• http://unpythonic.blogspot.nl/2007/07/pygtk-py2exe-and-inno-setup-for-single.html

• http://www.py2exe.org/index.cgi/Py2exeAndPyGTK

sorry i'm only a beginner myself and I don't usually use glade, only the pygtk documentation. hope you can figure it out.

99.99% of Windows users won't have Python installed in the first place, so if you wanted them to actually use it, you'd have to include Python and your script in a single downloadable package. Years ago I used this to do that, but I don't know if there's something better these days.

The fact that you're asking this tells me you're either:

1. Not a programmer
2. Know a little programming, but don't really understand it

Python's a programming language (duh). So you can use it for basically anything you'd use any other programming language for. The benefit of using Python is:

1. it has arguably the simplest syntax of any language in existence
2. has a huge community of users publishing a huge variety of free open source packages for doing nearly anything you can think of

Connecting to remote computers? Use [Fabric](fabfile.org/).

Create a GUI? Use the built-in Tk library, or something a little fancier like Wx.

Package your program into a Windows exe? Use py2exe. Based on what libraries and functionality you use, you might be able to seamlessly port it to Linux and OSX as well.

I manage the IT infrastructure and website for a small company, and I use Python for nearly everything. Database access. Code deployments. File system maintenance and reporting.

Py2exe creates a Windows executable from (almost) any python script. Assuming your teacher uses Windows, you can send an executable. Other than that, I have no idea except what's been said in the other comments.

I didn't mean to imply that it was impossible, in fact it's easier than I thought it would be. But still, for a complete beginner, that's some pretty advanced stuff. I just meant that it's not like a .exe that you can just link to on Dropbox, you can't just put up some .py files and expect people to know what to do.

Does the obvious Py2EXE tutorial not work for you? I've only played with Py2EXE, but it does seem to work. And of course some very well-known programs, like the Mercurial DVCS, are written in Python and very successfully distributed as stand-alone packages.

glob is a Python library that helps to created the proper file path to the dlls. You can read more about it here http://docs.python.org/library/glob.html

For more details about the Microsoft redistributables and Py2Exe, see here: http://www.py2exe.org/index.cgi/Tutorial#Step5

Py2exe can help with the first two points. It basically bundles the python interpreter and imported libraries into a windows executable. I don't know about the third one.

Py2exe site

Py2exe on pygame wiki

> not sure how to protect my source code

Do you want to distribute your game's source code? Do you plan on having your users install the Python interpreter to run your game? If so, I urge you to think again.

> create a game in python

Have you started creating your game yet? There are not too many game libraries / frameworks for Python and no engine that I know of. There are many such tools for other languages. There are also many languages that compile to executables without an interpreter - that makes distributing your games much easier.

Having said that, there is this thing for Python (and maybe there are like this one, I don't know):

• P2exe http://www.py2exe.org/

It looks like you may need to add tkinter's filedialog to your code from this stackexchange answer

from tkinter import filedialog

Or you could look into py2exe as an alternative which has a decent help page concerning matplotlib

You could always make a simple bat or bash file to run the script. For example, in Windows the command is

>py -3 path_to_python_file

which you could just add to a "run.bat" file.

Another option is to use a converter, something like cx_Freeze or py2exe. Do a search for "converting Python script into exe" and you'll find a lot of options. I personally prefer cx_Freeze because it's cross platform.

Each major OS just handles a lot of stuff differently so in the end you'll always have to handle each of the different platforms and their particularities!

Though it's not impossible to freeze a Python package into executables for different systems : http://www.py2exe.org/

I've never done it properly but unfortunately you'll have to distribute different executables for each of the OS.

QT for Python is a great UI framework -- it handles the interactions with the actual operating system so that's a plus again.

Plus the pathutils module in Python 3 is great and seamlessly handles the different OS as well!

There are a couple of ways to do it, and this stackoverflow answer covers them pretty well.

To answer your second question py2exe might be useful.

Your recipient won't need an IDE, but to execute a python script they would need python installed to interpret and run the script.

You could look at py2exe or py2app (If your recipient uses windows or Mac, respectively). These tools will let you compile a script into an executable and you can then send the executable to your recipient.

http://www.py2exe.org/index.cgi/Tutorial

You could also consider converting your quiz into a website (you could implement the server with python) and then just share a URL.

I don't know what's the platform of your choice (Console on Win/Linux, web, PyGame or something?), and seeing that other people have already suggested Flask, here's another way.

You could use Pyinstaller or py2exe and use the Github Releases feature to deliver these binaries for the Operating Systems you want.

Make a nice README.md for your project, where you take credit, explain your design decisions, what you have learnt from this proejct, and advice people to not look at the source before playing the game to avoid spoiler. Then, feel free to post the game here ;)

Okay, little more info now:

• Python code is interpreted. It needs to be packaged with a Python interpreter to be able to become an executable. Py2exe is one such program to pack a Python script into an executable (BTW: Jetbrains, the creators of IntelliJ have PyCharm - an excellent Python IDE)
• Java compiles to .class files that can be turned into .jar files as I have illustrated in my previous comment.
• C++ compiles to directly executable code. You should have .exe files from your programs.

Nice tool ! You might want to convert it to an exe for easier setup (http://www.py2exe.org/) and maybe connect it inside github releases :) but it's already a nice thing for discord users to stalk people yay !

py2exe and pyinstaller are the most well known. That said, for producing natively executable files I'd strongly recommend learning a compiled language over using a Python compiler.

The concept of "building" mostly means "compiling and bundling into an executeable app". For python there are several such tools like py2exe and PyInstaller for windows or QPython for Android.

You would need python and the necessary libraries installed on both pcs or you can make an exe

Also, it depends how similar the computers are, because you're "hacking" your way using these automation tools, the position of the things is important, so if the resolution of the monitors is different, you would need to tailor your scrips accordingly, be aware of things like that

The __future__ means it enables print("blah") instead of print "blah" making it compatible across ALL versions of Python that are 2.7+.

There's several ways to make it run for somebody who doesn't have them, I believe.

• py2exe for windows (http://www.py2exe.org/)
  
• cx_freeze (http://cx-freeze.sourceforge.net/)

I've never used windeployqt before, but I have deployed some PyQt and PySide apps to Windows before.

My usual setup is to use py2exe or cx_Freeze. There is a weird bug with PyQt4 and py2exe, so I'd recommend cx_Freeze as that's what I've switched over to now. Also cx_Freeze's support of bdist_msi is awesome and takes a huge amount of the deployment worries away!

This guide isn't great but it's a starting point.

Also would recommend py2exe to convert python to an executable. I did a bunch of freelance work on the side (eg: writing some stock analysis software that would download a given list of stocks from yahoo and try out a few different strategies on past data) and it was really nice to be able to send a executable when my users were PC users. It is such an easy tool to use: http://www.py2exe.org/index.cgi/Tutorial

~~cx_Freeze does not require you to be on a Mac~~

-from the docs for cx_Freeze FAQs, "cx_Freeze works on Windows, Mac and Linux, but on each platform it only makes an executable that runs on that platform. So if you want to freeze your program for Windows, freeze it on Windows; if you want to run it on Macs, freeze it on a Mac."

edit: I understand what you meant now, 'they require you to be on a Mac IF you want to build for Mac, likewise for Linux, Windows, etc'

There's also pyinstaller and py2exe

https://github.com/pyinstaller/pyinstaller/wiki

http://www.py2exe.org/

I'm not sure of a solution for Cross-Compiling. Part of the problem is that you're wanting to bundle your App for many operating systems, each of which will need OS specific files bundled with your app. If you don't have these files on your local computer then there's no way to bundle them into your app.

These programs which do the bundling don't come with the files pre-installed due to copyright restrictions - ie. cx_Freeze isn't bundled with Windows specific .dll's which come from Microsoft, however the program knows where to look for them if they exist locally.

You're best bet may be to try and get access to a local machine for each OS you want to build for.

If there's an easier way to do this - I'd love to find out about it as well

You can use py2exe to generate the executable and, for example PyQt, wxPython, or Kivy for the UI, you can find some tipps for using different libraries with py2exe here

Oh wait, I'm an idiot, the error is from Twython, not saying that it can't find some twython file.

I'd use a debugger, set a breakpoint on line 163, step into it to see what's going on. I'm still guessing it's some required module or data file not being included that you might have to manually include.

Both of those try to figure out what python modules your script needs by looking at the import statements...and they sometimes fail.

You'll probably have to include "twython.exceptions" in the 'packages' options of py2exe.

Not without details. :P

py2exe is a pretty simple concept behind the scenes. It looks at your python file and tries to guess all of the files it needs by looking at the imports. It grabs all of these, throws them into a zip file (external or packed in with the .exe), along with python itself. When you run the exe, it just extracts python and your files and runs them.

Depending on the "bundle_files" setting, you could end up with a .zip file (or some renamed .zip) that's there with your exe is part of the package you need to send;

• 3 (default) - nothing is bundled into the zip (small exe, but huge separate zip is required, doesn't work well with multiple 'exe' files in one dir)
• 2 - only python is put into the zip, all source goes into the exe (big exe, but the separate zip is required)
• 1 - everything is put into the exe (biggest exe)

If you're going to have multiple exe files in the same directory, you can use 2. That way, your complete source is in the exe, but all of the exes can use the python interpreter in the zip. But, for simplicity, I almost always use 1...no way you or anyone else can mess it up by not knowing the zip is part of the package. I'm not sure what the load-time speed difference is between them.

What's the traceback of something that doesn't run? I'm guessing you didn't include the zip, so it's using the installed python on machines that have it, and borking on machines that don't.

> return zipimport.zipimporter.load_module(self, fullname)

This makes me think there's some at-run-time importing from a zip file going on. I'm guessing py2exe isn't detecting something to include.

In the build dir, you can look and see all that's being included. Make sure the packages and their data files are being included. If the package or any sub packages aren't being included, use the "packages" option to include it.

If the package is being included, then you might have to include the missing data files (jsonschema\schemas\draft3.json) with the data_files option? I don't know.

Take a look at PyInstaller and Py2Exe. I don't think any of those include facilities to run the binary as a service, but they allow you to bundle a python app as a .exe file. Then you can use something else, like Inno Setup, to create a installer that fits your needs.

I personally use py2exe . Here you can find tutorial to start with. And to include external files, put in as option in config:

Mydata_files = [('images', ['c:/path/to/image/image.png'])] setup( console=['trypyglet.py'], data_files = Mydata_files, options={ "py2exe":{ "unbuffered": True, "optimize": 2, "excludes": ["email"] } }

Everything here can be done in Python, no problem. However the main caveat is you want to compile the code to a .exe. I have used py2exe pretty extensively and it can get tricky when you want to package in modules that are not pure python (ie. numpy).

Check out http://www.py2exe.org/index.cgi/WorkingWithVariousPackagesAndModules for help when you are working with various modules including numpy and matplotlib.

Also I would suggest you check out Brandon Rhodes video this year about other options for creating .exe's with Python https://www.youtube.com/watch?v=wsczq6j3_bA

You don't usually want to do that. You can compile it with a compiler (such as py2exe for MS Windows, which itself apparently runs only on Windows), but the resulting program file is extremely platform-specific (and I can't even find information about which Windows platforms py2exe supports).

The source code on the other hand will run on anything that has Python. Just about every sensible computer installation today should have Python already installed, and if not, it is easily installed and the administrator (or owner) is probably going to have to install it sooner or later anyway so the users (or the owner) can run Python programs, which is a lot of programs.

If you want to make it easier on the most unskilled computer users, you can always bundle your code with the appropriate Python installer for those systems that don't come with Python, or just link to the Python download page from your download page. Or you can compile your program and provide binaries for specific platforms. But also provide the source code so that everyone else can run your program too. :)

You can create a win distributable version that is much smaller using py2exe.

Use portable python with only the modules pygame, numpy, pywin32, and py2exe checked for install. http://portablepython.com/wiki/PortablePython2.7.6.1/

Use these instructions for py2exe: http://www.py2exe.org/index.cgi/Tutorial

Then zip up the output folder. You get a file that is only 9.75mb and nothing needs to be installed for others to take a look. I assume you can add the file to your github.

After extracting, run start_game.exe.

Also, your game seems to require a 1080p resolution to see it all on screen.

You can build something like that pretty easily with mechanize and BeautifulSoup and then compile it to an exe with py2exe. Give it a try :)

You can use py2exe to "compile" your Python script/app into a Windows binary. (You sacrifice some performance, since the executable essentially extracts the Python runtime and your code to a temporary location and runs it, but the effect is the same as any executable.)

This is the basic one, written in python. You can compile this to an .exe file with http://www.py2exe.org/ .

The script: http://pastebin.com/aDWXnbSr

Tried too add some comments :p but as you can see it runs "sh start" and saves each host to it's own .txt file.

Also, for creating the EXE, you should look at py2exe[1]. I found it decently easy to use, other than that I had to set up a development environment on windows to use it (I normally develop on Linux or OS X).

[1] http://www.py2exe.org/

Firstly, I must reinforce the other posts - you really will have to learn to use the command line to be a good programmer. May tools are usable from it and many (most) Python scripts only run from it. I'm afraid that you need to stop arguing and just try it out.

With regard to your actual question, Python is not normally compiled - it is interpreted. The difference can be subtle but it means that you distribute the scripts. However, take a look at http://www.py2exe.org/ which packages scripts into an easily distributable exe.

You may not know that you can "compile" python scripts into stand alone executables. So it's not necessary to have the interpreter installed Check that out here: http://www.py2exe.org/

How did you get around the sockets problem?

You can access PALM from a web server outside the office?? I didn't know that it was publicly available. That's interesting.

I don't have a great understanding about how you got around/through the firewall but I bet there is a way to address it.

Just use whatever you want, and then use py2exe as tmske mentioned. Then you can either distro it as a zip or build an installer with NSIS if you wanna be fancy. If you need non-windows users to deal with the excel files, xlrd is quite good. I've distro'ed pygtk apps this way and it's worked fine. No one needs to care it's in python.

Python is one of the best languages out there right now, it's not just a "learning programming language", and if you want to create a Windows executable file, you can use a tool like py2exe (http://www.py2exe.org). On versions of linux/unix it's even easier (http://stackoverflow.com/questions/304883/what-do-i-use-on-linux-to-make-a-python-program-executable).