title
stringlengths 10
172
| question_id
int64 469
40.1M
| question_body
stringlengths 22
48.2k
| question_score
int64 -44
5.52k
| question_date
stringlengths 20
20
| answer_id
int64 497
40.1M
| answer_body
stringlengths 18
33.9k
| answer_score
int64 -38
8.38k
| answer_date
stringlengths 20
20
| tags
sequence |
|---|---|---|---|---|---|---|---|---|---|
If it is decided that our system needs an overhaul, what is the best way to go about it? | 87,522 | <p>We are mainting a web application that is built on Classic ASP using VBScript as the primary language. We are in agreement that our backend (framework if you will) is out dated and doesn't provide us with the proper tools to move forward in a quick manner. We have pretty much embraced the current webMVC pattern that is all over the place, and cannot do it, in a reasonable manner, with the current technology. The big missing features are proper dispatching and templating with inheritance, amongst others.</p>
<p>Currently there are two paths being discussed:</p>
<ol>
<li>Port the existing application to Classic ASP using JScript, which will allow us to hopefully go from there to .NET MSJscript without too much trouble, and eventually end up on the .NET platform (preferably the MVC stuff will be done by then, ASP.NET isn't much better than were we are on now, in our opinions). This has been argued as the safer path with less risk than the next option, albeit it might take slightly longer.</li>
<li>Completely rewrite the application using some other technology, right now the leader of the pack is Python WSGI with a custom framework, ORM, and a good templating solution. There is wiggle room here for even django and other pre-built solutions. This method would hopefully be the quickest solution, as we would probably run a beta beside the actual product, but it does have the potential for a big waste of time if we can't/don't get it right.</li>
</ol>
<p>This does not mean that our logic is gone, as what we have built over the years is fairly stable, as noted just difficult to deal with. It is built on SQL Server 2005 with heavy use of stored procedures and published on IIS 6, just for a little more background.</p>
<p>Now, the question. Has anyone taken either of the two paths above? If so, was it successful, how could it have been better, etc. We aren't looking to deviate much from doing one of those two things, but some suggestions or other solutions would potentially be helpful.</p>
| 3 | 2008-09-17T20:48:45Z | 89,434 | <p>Don't throw away your code!</p>
<p>It's the single worst mistake you can make (on a large codebase). See <a href="http://www.joelonsoftware.com/articles/fog0000000069.html" rel="nofollow">Things You Should Never Do, Part 1</a>.</p>
<p>You've invested a lot of effort into that old code and worked out many bugs. Throwing it away is a classic developer mistake (and one I've done many times). It makes you feel "better", like a spring cleaning. But you don't need to buy a new apartment and all new furniture to outfit your house. You can work on one room at a time... and maybe some things just need a new paintjob. Hence, this is where refactoring comes in.</p>
<p>For new functionality in your app, <a href="http://blog.danbartels.com/articles/322.aspx" rel="nofollow">write it in C# and call it from your classic ASP</a>. You'll be forced to be modular when you rewrite this new code. When you have time, refactor parts of your old code into C# as well, and work out the bugs as you go. Eventually, you'll have replaced your app with all new code.</p>
<p>You could also write your own compiler. We wrote one for our classic ASP app a long time ago to allow us to output PHP. It's called <a href="http://www.joelonsoftware.com/items/2006/09/01b.html" rel="nofollow">Wasabi</a> and I think it's the reason Jeff Atwood thought Joel Spolsky went off his rocker. Actually, maybe we should just ship it, and then you could use that. </p>
<p>It allowed us to switch our entire codebase to .NET for the next release while only rewriting a very small portion of our source. It also caused a bunch of people to call us crazy, but writing a compiler is not that complicated, and it gave us a lot of flexibility.</p>
<p>Also, if this is an internal only app, just leave it. Don't rewrite it - you are the only customer and if the requirement is you need to run it as classic asp, you can meet that requirement.</p>
| 7 | 2008-09-18T02:19:51Z | [
"python",
"asp-classic",
"vbscript"
] |
If it is decided that our system needs an overhaul, what is the best way to go about it? | 87,522 | <p>We are mainting a web application that is built on Classic ASP using VBScript as the primary language. We are in agreement that our backend (framework if you will) is out dated and doesn't provide us with the proper tools to move forward in a quick manner. We have pretty much embraced the current webMVC pattern that is all over the place, and cannot do it, in a reasonable manner, with the current technology. The big missing features are proper dispatching and templating with inheritance, amongst others.</p>
<p>Currently there are two paths being discussed:</p>
<ol>
<li>Port the existing application to Classic ASP using JScript, which will allow us to hopefully go from there to .NET MSJscript without too much trouble, and eventually end up on the .NET platform (preferably the MVC stuff will be done by then, ASP.NET isn't much better than were we are on now, in our opinions). This has been argued as the safer path with less risk than the next option, albeit it might take slightly longer.</li>
<li>Completely rewrite the application using some other technology, right now the leader of the pack is Python WSGI with a custom framework, ORM, and a good templating solution. There is wiggle room here for even django and other pre-built solutions. This method would hopefully be the quickest solution, as we would probably run a beta beside the actual product, but it does have the potential for a big waste of time if we can't/don't get it right.</li>
</ol>
<p>This does not mean that our logic is gone, as what we have built over the years is fairly stable, as noted just difficult to deal with. It is built on SQL Server 2005 with heavy use of stored procedures and published on IIS 6, just for a little more background.</p>
<p>Now, the question. Has anyone taken either of the two paths above? If so, was it successful, how could it have been better, etc. We aren't looking to deviate much from doing one of those two things, but some suggestions or other solutions would potentially be helpful.</p>
| 3 | 2008-09-17T20:48:45Z | 89,452 | <p>Don't try and go 2.0 ( more features then currently exists or scheduled) instead build your new platform with the intent of resolving the current issues with the code base (maintainability/speed/wtf) and go from there. </p>
| 0 | 2008-09-18T02:23:49Z | [
"python",
"asp-classic",
"vbscript"
] |
If it is decided that our system needs an overhaul, what is the best way to go about it? | 87,522 | <p>We are mainting a web application that is built on Classic ASP using VBScript as the primary language. We are in agreement that our backend (framework if you will) is out dated and doesn't provide us with the proper tools to move forward in a quick manner. We have pretty much embraced the current webMVC pattern that is all over the place, and cannot do it, in a reasonable manner, with the current technology. The big missing features are proper dispatching and templating with inheritance, amongst others.</p>
<p>Currently there are two paths being discussed:</p>
<ol>
<li>Port the existing application to Classic ASP using JScript, which will allow us to hopefully go from there to .NET MSJscript without too much trouble, and eventually end up on the .NET platform (preferably the MVC stuff will be done by then, ASP.NET isn't much better than were we are on now, in our opinions). This has been argued as the safer path with less risk than the next option, albeit it might take slightly longer.</li>
<li>Completely rewrite the application using some other technology, right now the leader of the pack is Python WSGI with a custom framework, ORM, and a good templating solution. There is wiggle room here for even django and other pre-built solutions. This method would hopefully be the quickest solution, as we would probably run a beta beside the actual product, but it does have the potential for a big waste of time if we can't/don't get it right.</li>
</ol>
<p>This does not mean that our logic is gone, as what we have built over the years is fairly stable, as noted just difficult to deal with. It is built on SQL Server 2005 with heavy use of stored procedures and published on IIS 6, just for a little more background.</p>
<p>Now, the question. Has anyone taken either of the two paths above? If so, was it successful, how could it have been better, etc. We aren't looking to deviate much from doing one of those two things, but some suggestions or other solutions would potentially be helpful.</p>
| 3 | 2008-09-17T20:48:45Z | 101,074 | <p>Half a year ago I took over a large web application (fortunately already in Python) which had some major architectural deficiencies (templates and code mixed, code duplication, you name it...).</p>
<p>My plan is to eventually have the system respond to WSGI, but I am not there yet. I found the best way to do it, is in small steps. Over the last 6 month, code reuse has gone up and progress has accelerated. </p>
<p>General principles which have worked for me:</p>
<ol>
<li>Throw away code which is not used or commented out</li>
<li>Throw away all comments which are not useful</li>
<li>Define a <em>layer hierarchy</em> (models, business logic, view/controller logic, display logic, etc.) of your application. This has not to be very clear cut architecture but rather should <em>help you think about the various parts of your application</em> and help you better categorize your code.</li>
<li>If something grossly violates this hierarchy, change the offending code. Move the code around, recode it at another place, etc. At the same time adjust the rest of your application to use this code instead of the old one. Throw the old one away if not used anymore.</li>
<li><strong>Keep you APIs simple!</strong></li>
</ol>
<p>Progress can be painstakingly slow, but should be worth it. </p>
| 1 | 2008-09-19T10:56:06Z | [
"python",
"asp-classic",
"vbscript"
] |
If it is decided that our system needs an overhaul, what is the best way to go about it? | 87,522 | <p>We are mainting a web application that is built on Classic ASP using VBScript as the primary language. We are in agreement that our backend (framework if you will) is out dated and doesn't provide us with the proper tools to move forward in a quick manner. We have pretty much embraced the current webMVC pattern that is all over the place, and cannot do it, in a reasonable manner, with the current technology. The big missing features are proper dispatching and templating with inheritance, amongst others.</p>
<p>Currently there are two paths being discussed:</p>
<ol>
<li>Port the existing application to Classic ASP using JScript, which will allow us to hopefully go from there to .NET MSJscript without too much trouble, and eventually end up on the .NET platform (preferably the MVC stuff will be done by then, ASP.NET isn't much better than were we are on now, in our opinions). This has been argued as the safer path with less risk than the next option, albeit it might take slightly longer.</li>
<li>Completely rewrite the application using some other technology, right now the leader of the pack is Python WSGI with a custom framework, ORM, and a good templating solution. There is wiggle room here for even django and other pre-built solutions. This method would hopefully be the quickest solution, as we would probably run a beta beside the actual product, but it does have the potential for a big waste of time if we can't/don't get it right.</li>
</ol>
<p>This does not mean that our logic is gone, as what we have built over the years is fairly stable, as noted just difficult to deal with. It is built on SQL Server 2005 with heavy use of stored procedures and published on IIS 6, just for a little more background.</p>
<p>Now, the question. Has anyone taken either of the two paths above? If so, was it successful, how could it have been better, etc. We aren't looking to deviate much from doing one of those two things, but some suggestions or other solutions would potentially be helpful.</p>
| 3 | 2008-09-17T20:48:45Z | 593,057 | <p>A good place to begin if you're considering the move to Python is to rewrite your administrator interface in Django. This will help you get some of the kinks worked out in terms of getting Python up and running with IIS (or to migrate it to Apache). Speaking of which, I recommend <a href="http://code.google.com/p/isapi-wsgi/" rel="nofollow">isapi-wsgi</a>. It's by far the easiest way to get up and running with IIS.</p>
| 0 | 2009-02-27T00:10:31Z | [
"python",
"asp-classic",
"vbscript"
] |
If it is decided that our system needs an overhaul, what is the best way to go about it? | 87,522 | <p>We are mainting a web application that is built on Classic ASP using VBScript as the primary language. We are in agreement that our backend (framework if you will) is out dated and doesn't provide us with the proper tools to move forward in a quick manner. We have pretty much embraced the current webMVC pattern that is all over the place, and cannot do it, in a reasonable manner, with the current technology. The big missing features are proper dispatching and templating with inheritance, amongst others.</p>
<p>Currently there are two paths being discussed:</p>
<ol>
<li>Port the existing application to Classic ASP using JScript, which will allow us to hopefully go from there to .NET MSJscript without too much trouble, and eventually end up on the .NET platform (preferably the MVC stuff will be done by then, ASP.NET isn't much better than were we are on now, in our opinions). This has been argued as the safer path with less risk than the next option, albeit it might take slightly longer.</li>
<li>Completely rewrite the application using some other technology, right now the leader of the pack is Python WSGI with a custom framework, ORM, and a good templating solution. There is wiggle room here for even django and other pre-built solutions. This method would hopefully be the quickest solution, as we would probably run a beta beside the actual product, but it does have the potential for a big waste of time if we can't/don't get it right.</li>
</ol>
<p>This does not mean that our logic is gone, as what we have built over the years is fairly stable, as noted just difficult to deal with. It is built on SQL Server 2005 with heavy use of stored procedures and published on IIS 6, just for a little more background.</p>
<p>Now, the question. Has anyone taken either of the two paths above? If so, was it successful, how could it have been better, etc. We aren't looking to deviate much from doing one of those two things, but some suggestions or other solutions would potentially be helpful.</p>
| 3 | 2008-09-17T20:48:45Z | 994,326 | <p>I agree with Michael Pryor and Joel that it's almost always a better idea to continue evolving your existing code base rather than re-writing from scratch. There are typically opportunities to just re-write or re-factor certain components for performance or flexibility.</p>
| 0 | 2009-06-15T02:33:35Z | [
"python",
"asp-classic",
"vbscript"
] |
Setting Environment Variables for Mercurial Hook | 88,194 | <p>I am trying to call a shell script that sets a bunch of environment variables on our server from a mercurial hook. The shell script gets called fine when a new changegroup comes in, but the environment variables aren't carrying over past the call to the shell script.</p>
<p>My hgrc file on the respository looks like this:</p>
<p><pre><code>
[hooks]
changegroup = shell_script
changegroup.env = env
</pre></code></p>
<p>I can see the output of the shell script, and then the output of the env command, but the env command doesn't include the new environment variables set by the shell script.</p>
<p>I have verified that the shell script works fine when run by itself but when run in the context of the mercurial hook it does not properly set the environment.</p>
<p>Thank you guys for any help you can provide.</p>
| 1 | 2008-09-17T22:05:56Z | 88,209 | <p>Shell scripts can't modify their enviroment. </p>
<p><a href="http://tldp.org/LDP/abs/html/gotchas.html" rel="nofollow">http://tldp.org/LDP/abs/html/gotchas.html</a></p>
<blockquote>
<p>A script may not export variables back to its parent process, the shell, or to the environment. Just as we learned in biology, a child process can inherit from a parent, but not vice versa</p>
</blockquote>
<pre><code>$ cat > eg.sh
export FOO="bar";
^D
$ bash eg.sh
$ echo $FOO;
$
</code></pre>
<p>also, the problem is greater, as you have multiple calls of bash </p>
<pre><code>bash 1 -> hg -> bash 2 ( shell script )
-> bash 3 ( env call )
</code></pre>
<p>it would be like thinking I could set a variable in one php script and then magically get it with another simply by running one after the other. </p>
| 2 | 2008-09-17T22:09:08Z | [
"python",
"shell",
"mercurial",
"mercurial-hook"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 88,331 | <p><strong>Update:</strong> <a href="http://django-configurations.readthedocs.org/en/latest/">django-configurations</a> has been released which is probably a better option for most people than doing it manually.</p>
<p>If you would prefer to do things manually, my earlier answer still applies:</p>
<p>I have multiple settings files.</p>
<ul>
<li><code>settings_local.py</code> - host-specific configuration, such as database name, file paths, etc.</li>
<li><code>settings_development.py</code> - configuration used for development, e.g. <code>DEBUG = True</code>.</li>
<li><code>settings_production.py</code> - configuration used for production, e.g. <code>SERVER_EMAIL</code>.</li>
</ul>
<p>I tie these all together with a <code>settings.py</code> file that firstly imports <code>settings_local.py</code>, and then one of the other two. It decides which to load by two settings inside <code>settings_local.py</code> - <code>DEVELOPMENT_HOSTS</code> and <code>PRODUCTION_HOSTS</code>. <code>settings.py</code> calls <code>platform.node()</code> to find the hostname of the machine it is running on, and then looks for that hostname in the lists, and loads the second settings file depending on which list it finds the hostname in.</p>
<p>That way, the only thing you really need to worry about is keeping the <code>settings_local.py</code> file up to date with the host-specific configuration, and everything else is handled automatically.</p>
<p>Check out an example <a href="http://github.com/JimDabell/lojban-website/tree/master/lojban">here</a>.</p>
| 79 | 2008-09-17T22:27:35Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 88,344 | <p>I have two files. <code>settings_base.py</code> which contains common/default settings, and which is checked into source control. Each deployment has a separate <code>settings.py</code>, which executes <code>from settings_base import *</code> at the beginning and then overrides as needed.</p>
| 11 | 2008-09-17T22:29:30Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 89,338 | <p>In addition to the multiple settings files mentioned by Jim, I also tend to place two settings into my settings.py file at the top <code>BASE_DIR</code> and <code>BASE_URL</code> set to the path of the code and the URL to the base of the site, all other settings are modified to append themselves to these.</p>
<p><code>BASE_DIR = "/home/sean/myapp/"</code>
e.g. <code>MEDIA_ROOT = "%smedia/" % BASEDIR</code></p>
<p>So when moving the project I only have to edit these settings and not search the whole file.</p>
<p>I would also recommend looking at fabric and <a href="http://en.wikipedia.org/wiki/Capistrano" rel="nofollow">Capistrano</a> (Ruby tool, but it can be used to deploy Django applications) which facilitate automation of remote deployment.</p>
| 1 | 2008-09-18T01:59:37Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 89,823 | <p>Personally, I use a single settings.py for the project, I just have it look up the hostname it's on (my development machines have hostnames that start with "gabriel" so I just have this:</p>
<pre><code>import socket
if socket.gethostname().startswith('gabriel'):
LIVEHOST = False
else:
LIVEHOST = True
</code></pre>
<p>then in other parts I have things like:</p>
<pre><code>if LIVEHOST:
DEBUG = False
PREPEND_WWW = True
MEDIA_URL = 'http://static1.grsites.com/'
else:
DEBUG = True
PREPEND_WWW = False
MEDIA_URL = 'http://localhost:8000/static/'
</code></pre>
<p>and so on. A little bit less readable, but it works fine and saves having to juggle multiple settings files.</p>
| 25 | 2008-09-18T03:45:38Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 91,608 | <p>At the end of settings.py I have the following:</p>
<pre><code>try:
from settings_local import *
except ImportError:
pass
</code></pre>
<p>This way if I want to override default settings I need to just put settings_local.py right next to settings.py.</p>
| 21 | 2008-09-18T10:57:14Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 108,512 | <p>I think it depends on the size of the site as to whether you need to step up from using SQLite, I've successfully used SQLite on several smaller live sites and it runs great.</p>
| 0 | 2008-09-20T15:37:23Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 1,527,240 | <p>I have my settings.py file in an external directory. That way, it doesn't get checked into source control, or over-written by a deploy. I put this in the settings.py file under my Django project, along with any default settings:</p>
<pre><code>import sys
import os.path
def _load_settings(path):
print "Loading configuration from %s" % (path)
if os.path.exists(path):
settings = {}
# execfile can't modify globals directly, so we will load them manually
execfile(path, globals(), settings)
for setting in settings:
globals()[setting] = settings[setting]
_load_settings("/usr/local/conf/local_settings.py")
</code></pre>
<p>*Note: This is very dangerous if you can't trust local_settings.py.* </p>
| 1 | 2009-10-06T18:22:51Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 3,201,509 | <p>The most simplistic way I found was:</p>
<p>1) use the default <strong>settings.py</strong> for local development and 2)
create a <strong>production-settings.py</strong> starting with:</p>
<pre><code>import os
from settings import *
</code></pre>
<p>And then just override the settings that differ in production:</p>
<pre><code>DEBUG = False
TEMPLATE_DEBUG = DEBUG
DATABASES = {
'default': {
....
}
}
</code></pre>
| 6 | 2010-07-08T07:38:28Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 6,846,857 | <p>Somewhat related, for the issue of deploying Django itself with multiple databases, you may want to take a look at <a href="http://bitnami.org/stack/djangostack" rel="nofollow">Djangostack</a>. You can download a completely free installer that allows you to install Apache, Python, Django, etc. As part of the installation process we allow you to select which database you want to use (MySQL, SQLite, PostgreSQL). We use the installers extensively when automating deployments internally (they can be run in unattended mode).</p>
| 2 | 2011-07-27T15:20:25Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 7,047,633 | <p>Well i use this configuration</p>
<p>at the end of settings.py</p>
<pre><code>#settings.py
try:
from locale_settings import *
except ImportError:
pass
</code></pre>
<p>and in locale_settings.py</p>
<pre><code>#locale_settings.py
class Settings(object):
def __init__(self):
import settings
self.settings = settings
def __getattr__(self, name):
return getattr(self.settings, name)
settings = Settings()
INSTALLED_APPS = settings.INSTALLED_APPS + (
'gunicorn',)
# delete duplicate settings maybe not needed but i prefer to do it
del settings
del Settings
</code></pre>
| 0 | 2011-08-13T00:16:52Z | [
"python",
"django"
] |
How do you configure Django for simple development and deployment? | 88,259 | <p>I tend to use <a href="http://en.wikipedia.org/wiki/SQLite">SQLite</a> when doing <a href="http://en.wikipedia.org/wiki/Django%5F%28web%5Fframework%29">Django</a>
development, but on a live server something more robust is
often needed (<a href="http://en.wikipedia.org/wiki/MySQL">MySQL</a>/<a href="http://en.wikipedia.org/wiki/PostgreSQL">PostgreSQL</a>, for example).
Invariably, there are other changes to make to the Django
settings as well: different logging locations / intensities,
media paths, etc.</p>
<p>How do you manage all these changes to make deployment a
simple, automated process?</p>
| 104 | 2008-09-17T22:16:43Z | 9,694,966 | <p>I use environment </p>
<pre><code>if os.environ.get('WEB_MODE', None) == 'production' :
from settings_production import *
else :
from settings_dev import *
</code></pre>
<p>I believe this is much better approach because eventually you need special settings for your test environment and you can easily add it to this condition</p>
| 0 | 2012-03-14T02:04:30Z | [
"python",
"django"
] |
How do I unit test an __init__() method of a python class with assertRaises()? | 88,325 | <p>I have a class:</p>
<pre><code>class MyClass:
def __init__(self, foo):
if foo != 1:
raise Error("foo is not equal to 1!")
</code></pre>
<p>and a unit test that is supposed to make sure the incorrect arg passed to the constructor properly raises an error:</p>
<pre><code>def testInsufficientArgs(self):
foo = 0
self.assertRaises((Error), myClass = MyClass(Error, foo))
</code></pre>
<p>But I get...</p>
<pre><code>NameError: global name 'Error' is not defined
</code></pre>
<p>Why? Where should I be defining this Error object? I thought it was built-in as a default exception type, no?</p>
| 16 | 2008-09-17T22:26:37Z | 88,346 | <p>'Error' in this example could be any exception object. I think perhaps you have read a code example that used it as a metasyntatic placeholder to mean, "The Appropriate Exception Class".</p>
<p>The baseclass of all exceptions is called 'Exception', and most of its subclasses are descriptive names of the type of error involved, such as 'OSError', 'ValueError', 'NameError', 'TypeError'.</p>
<p>In this case, the appropriate error is 'ValueError' (the value of foo was wrong, therefore a ValueError). I would recommend replacing 'Error' with 'ValueError' in your script.</p>
<p>Here is a complete version of the code you are trying to write, I'm duplicating everything because you have a weird keyword argument in your original example that you seem to be conflating with an assignment, and I'm using the 'failUnless' function name because that's the non-aliased name of the function:</p>
<pre><code>class MyClass:
def __init__(self, foo):
if foo != 1:
raise ValueError("foo is not equal to 1!")
import unittest
class TestFoo(unittest.TestCase):
def testInsufficientArgs(self):
foo = 0
self.failUnlessRaises(ValueError, MyClass, foo)
if __name__ == '__main__':
unittest.main()
</code></pre>
<p>The output is:</p>
<pre><code>.
----------------------------------------------------------------------
Ran 1 test in 0.007s
OK
</code></pre>
<p>There is a flaw in the unit testing library 'unittest' that other unit testing frameworks fix. You'll note that it is impossible to gain access to the exception object from the calling context. If you want to fix this, you'll have to redefine that method in a subclass of UnitTest:</p>
<p>This is an example of it in use:</p>
<pre><code>class TestFoo(unittest.TestCase):
def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
try:
callableObj(*args, **kwargs)
except excClass, excObj:
return excObj # Actually return the exception object
else:
if hasattr(excClass,'__name__'): excName = excClass.__name__
else: excName = str(excClass)
raise self.failureException, "%s not raised" % excName
def testInsufficientArgs(self):
foo = 0
excObj = self.failUnlessRaises(ValueError, MyClass, foo)
self.failUnlessEqual(excObj[0], 'foo is not equal to 1!')
</code></pre>
<p>I have copied the failUnlessRaises function from unittest.py from python2.5 and modified it slightly.</p>
| 18 | 2008-09-17T22:29:33Z | [
"python",
"unit-testing",
"exception"
] |
How do I unit test an __init__() method of a python class with assertRaises()? | 88,325 | <p>I have a class:</p>
<pre><code>class MyClass:
def __init__(self, foo):
if foo != 1:
raise Error("foo is not equal to 1!")
</code></pre>
<p>and a unit test that is supposed to make sure the incorrect arg passed to the constructor properly raises an error:</p>
<pre><code>def testInsufficientArgs(self):
foo = 0
self.assertRaises((Error), myClass = MyClass(Error, foo))
</code></pre>
<p>But I get...</p>
<pre><code>NameError: global name 'Error' is not defined
</code></pre>
<p>Why? Where should I be defining this Error object? I thought it was built-in as a default exception type, no?</p>
| 16 | 2008-09-17T22:26:37Z | 88,357 | <p>I think you're thinking of <a href="http://docs.python.org/lib/module-exceptions.html" rel="nofollow">Exception</a>s. Replace the word Error in your description with Exception and you should be good to go :-)</p>
| 0 | 2008-09-17T22:30:21Z | [
"python",
"unit-testing",
"exception"
] |
How do I unit test an __init__() method of a python class with assertRaises()? | 88,325 | <p>I have a class:</p>
<pre><code>class MyClass:
def __init__(self, foo):
if foo != 1:
raise Error("foo is not equal to 1!")
</code></pre>
<p>and a unit test that is supposed to make sure the incorrect arg passed to the constructor properly raises an error:</p>
<pre><code>def testInsufficientArgs(self):
foo = 0
self.assertRaises((Error), myClass = MyClass(Error, foo))
</code></pre>
<p>But I get...</p>
<pre><code>NameError: global name 'Error' is not defined
</code></pre>
<p>Why? Where should I be defining this Error object? I thought it was built-in as a default exception type, no?</p>
| 16 | 2008-09-17T22:26:37Z | 88,369 | <p>How about this:</p>
<pre><code>class MyClass:
def __init__(self, foo):
if foo != 1:
raise Exception("foo is not equal to 1!")
import unittest
class Tests(unittest.TestCase):
def testSufficientArgs(self):
foo = 1
MyClass(foo)
def testInsufficientArgs(self):
foo = 2
self.assertRaises(Exception, MyClass, foo)
if __name__ == '__main__':
unittest.main()
</code></pre>
| 4 | 2008-09-17T22:32:16Z | [
"python",
"unit-testing",
"exception"
] |
In Python, how do you take tokenized input such as with the C++? | 88,554 | <p>In C++, I can have take input like this: </p>
<p>cin >> a >> b >> c;</p>
<p>And a can be int, b can be float, and c can be whatever... How do I do the same in python? </p>
<p>input() and raw_input(), the way I'm using them, don't seem to be giving me the desired results.</p>
| 2 | 2008-09-17T23:06:21Z | 88,587 | <p>You generally shouldn't use <code>input()</code> in production code. If you want an int and then a float, try this:
<code><pre>
>>> line = raw_input().split()
>>> a = int(line[0])
>>> b = float(line[1])
>>> c = " ".join(line[2:])
</pre></code></p>
<p>It all depends on what exactly you're trying to accomplish, but remember that readability counts. Obscure one-liners may seem cool but in the face of maintainability, try to choose something sensible :)</p>
<p>(P.S.: Don't forget to check for errors with try: ... except (ValueError, IndexError):)</p>
| 4 | 2008-09-17T23:12:21Z | [
"c++",
"python",
"input"
] |
In Python, how do you take tokenized input such as with the C++? | 88,554 | <p>In C++, I can have take input like this: </p>
<p>cin >> a >> b >> c;</p>
<p>And a can be int, b can be float, and c can be whatever... How do I do the same in python? </p>
<p>input() and raw_input(), the way I'm using them, don't seem to be giving me the desired results.</p>
| 2 | 2008-09-17T23:06:21Z | 88,589 | <p>Depending upon what you are doing, something like the <a href="http://docs.python.org/lib/module-getopt.html" rel="nofollow">getopt</a> module could be useful, but only in certain situations and I'm not sure if it would apply in yours.</p>
| 0 | 2008-09-17T23:12:46Z | [
"c++",
"python",
"input"
] |
In Python, how do you take tokenized input such as with the C++? | 88,554 | <p>In C++, I can have take input like this: </p>
<p>cin >> a >> b >> c;</p>
<p>And a can be int, b can be float, and c can be whatever... How do I do the same in python? </p>
<p>input() and raw_input(), the way I'm using them, don't seem to be giving me the desired results.</p>
| 2 | 2008-09-17T23:06:21Z | 88,714 | <p>Since the C++ cin reads from sys.stdin, you'll often do something more like the following.</p>
<pre><code>import sys
tokens= sys.stdin.read().split()
try:
a= int(token[0])
b= float(token[1])
except ValueError, e:
print e # handle the invalid input
</code></pre>
| 3 | 2008-09-17T23:35:49Z | [
"c++",
"python",
"input"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 88,639 | <p>Regular expressions:</p>
<pre><code>>>> import re
>>> splitter = re.compile(r'([+*/])')
>>> splitter.split("2+24*48/32")
</code></pre>
<p>You can expand the regular expression to include any other characters you want to split on.</p>
| 4 | 2008-09-17T23:21:58Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 88,661 | <blockquote>
<blockquote>
<blockquote>
<p>s = "2+24*48/32"</p>
<p>p = re.compile(r'(\W+)')</p>
<p>p.split(s)</p>
</blockquote>
</blockquote>
</blockquote>
| 4 | 2008-09-17T23:25:52Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 88,663 | <p>You can use <code>split</code> from the <code>re</code> module. </p>
<p><a href="http://docs.python.org/library/re.html#re.split" rel="nofollow">re.split(pattern, string, maxsplit=0, flags=0)</a></p>
<blockquote>
<p>Split string by the occurrences of pattern. If capturing parentheses
are used in pattern, then the text of all groups in the pattern are
also returned as part of the resulting list.</p>
</blockquote>
<p>Example code:</p>
<pre><code>import re
data = re.split(r'(\D)', '2+24*48/32')
</code></pre>
<hr>
<p>\D</p>
<blockquote>
<p>When the UNICODE flag is not specified, \D matches any non-digit
character; this is equivalent to the set [^0-9].</p>
</blockquote>
| 35 | 2008-09-17T23:25:56Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 88,783 | <p>This looks like a parsing problem, and thus I am compelled to present a solution based on parsing techniques.</p>
<p>While it may seem that you want to 'split' this string, I think what you actually want to do is 'tokenize' it. Tokenization or lexxing is the compilation step before parsing. I have amended my original example in an edit to implement a proper recursive decent parser here. This is the easiest way to implement a parser by hand.</p>
<pre><code>import re
patterns = [
('number', re.compile('\d+')),
('*', re.compile(r'\*')),
('/', re.compile(r'\/')),
('+', re.compile(r'\+')),
('-', re.compile(r'\-')),
]
whitespace = re.compile('\W+')
def tokenize(string):
while string:
# strip off whitespace
m = whitespace.match(string)
if m:
string = string[m.end():]
for tokentype, pattern in patterns:
m = pattern.match(string)
if m:
yield tokentype, m.group(0)
string = string[m.end():]
def parseNumber(tokens):
tokentype, literal = tokens.pop(0)
assert tokentype == 'number'
return int(literal)
def parseMultiplication(tokens):
product = parseNumber(tokens)
while tokens and tokens[0][0] in ('*', '/'):
tokentype, literal = tokens.pop(0)
if tokentype == '*':
product *= parseNumber(tokens)
elif tokentype == '/':
product /= parseNumber(tokens)
else:
raise ValueError("Parse Error, unexpected %s %s" % (tokentype, literal))
return product
def parseAddition(tokens):
total = parseMultiplication(tokens)
while tokens and tokens[0][0] in ('+', '-'):
tokentype, literal = tokens.pop(0)
if tokentype == '+':
total += parseMultiplication(tokens)
elif tokentype == '-':
total -= parseMultiplication(tokens)
else:
raise ValueError("Parse Error, unexpected %s %s" % (tokentype, literal))
return total
def parse(tokens):
tokenlist = list(tokens)
returnvalue = parseAddition(tokenlist)
if tokenlist:
print 'Unconsumed data', tokenlist
return returnvalue
def main():
string = '2+24*48/32'
for tokentype, literal in tokenize(string):
print tokentype, literal
print parse(tokenize(string))
if __name__ == '__main__':
main()
</code></pre>
<p>Implementation of handling of brackets is left as an exercise for the reader. This example will correctly do multiplication before addition.</p>
| 18 | 2008-09-17T23:54:14Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 89,003 | <p>i'm sure Tim meant </p>
<pre><code>splitter = re.compile(r'([\D])').
</code></pre>
<p>if you copy exactly what he has down you only get the <code>digits</code> not the <code>operators</code>.</p>
| 0 | 2008-09-18T00:45:18Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 89,534 | <pre><code>>>> import re
>>> re.findall(r'\d+|\D+', '2+24*48/32=10')
['2', '+', '24', '*', '48', '/', '32', '=', '10']
</code></pre>
<p>Matches consecutive digits or consecutive non-digits.</p>
<p>Each match is returned as a new element in the list.</p>
<p>Depending on the usage, you may need to alter the regular expression. Such as if you need to match numbers with a decimal point.</p>
<pre><code>>>> re.findall(r'[0-9\.]+|[^0-9\.]+', '2+24*48/32=10.1')
['2', '+', '24', '*', '48', '/', '32', '=', '10.1']
</code></pre>
| 17 | 2008-09-18T02:39:38Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 89,666 | <p>Another solution to this would be to avoid writing a calculator like that altogether. Writing an RPN parser is much simpler, and doesn't have any of the ambiguity inherent in writing math with infix notation.</p>
<pre><code>import operator, math
calc_operands = {
'+': (2, operator.add),
'-': (2, operator.sub),
'*': (2, operator.mul),
'/': (2, operator.truediv),
'//': (2, operator.div),
'%': (2, operator.mod),
'^': (2, operator.pow),
'**': (2, math.pow),
'abs': (1, operator.abs),
'ceil': (1, math.ceil),
'floor': (1, math.floor),
'round': (2, round),
'trunc': (1, int),
'log': (2, math.log),
'ln': (1, math.log),
'pi': (0, lambda: math.pi),
'e': (0, lambda: math.e),
}
def calculate(inp):
stack = []
for tok in inp.split():
if tok in self.calc_operands:
n_pops, func = self.calc_operands[tok]
args = [stack.pop() for x in xrange(n_pops)]
args.reverse()
stack.append(func(*args))
elif '.' in tok:
stack.append(float(tok))
else:
stack.append(int(tok))
if not stack:
raise ValueError('no items on the stack.')
return stack.pop()
if stack:
raise ValueError('%d item(s) left on the stack.' % len(stack))
calculate('24 38 * 32 / 2 +')
</code></pre>
| 4 | 2008-09-18T03:07:27Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 99,259 | <p>Why not just use <a href="http://code.google.com/p/sympy/" rel="nofollow">SymPy</a>? It should do what you're trying to achieve.</p>
| 0 | 2008-09-19T03:22:35Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 100,283 | <p>This is a parsing problem, so neither regex not split() are the "good" solution. Use a parser generator instead.</p>
<p>I would look closely at <a href="http://pyparsing.wikispaces.com/">pyparsing</a>. There have also been some decent articles about pyparsing in the <a href="http://pymag.phparch.com/">Python Magazine</a>.</p>
| 6 | 2008-09-19T07:37:18Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 111,355 | <p>It just so happens that the tokens you want split are already Python tokens, so you can use the built-in <code>tokenize</code> module. It's almost a one-liner:</p>
<pre><code>from cStringIO import StringIO
from tokenize import generate_tokens
STRING = 1
list(token[STRING] for token
in generate_tokens(StringIO('2+24*48/32').readline)
if token[STRING])
['2', '+', '24', '*', '48', '/', '32']
</code></pre>
| 49 | 2008-09-21T16:25:42Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 3,517,872 | <p>This doesn't answer the question exactly, but I believe it solves what you're trying to achieve. I would add it as a comment, but I don't have permission to do so yet.</p>
<p>I personally would take advantage of Python's maths functionality directly with exec:</p>
<blockquote>
<p>expression = "2+24*48/32"<br>
<strong>exec</strong> "result = " + expression<br>
<strong>print</strong> result<br>
38</p>
</blockquote>
| 0 | 2010-08-19T00:38:43Z | [
"python",
"string",
"list",
"split"
] |
How do I split a string into a list? | 88,613 | <p>If I have this string:</p>
<blockquote>
<p>2+24*48/32</p>
</blockquote>
<p>what is the most efficient approach for creating this list:</p>
<blockquote>
<p>['2', '+', '24', '*', '48', '/', '32']</p>
</blockquote>
| 35 | 2008-09-17T23:17:12Z | 8,863,507 | <pre><code>>>> import re
>>> my_string = "2+24*48/32"
>>> my_list = re.findall(r"-?\d+|\S", my_string)
>>> print my_list
['2', '+', '24', '*', '48', '/', '32']
</code></pre>
<p>This will do the trick. I have encountered this kind of problem before.</p>
| 1 | 2012-01-14T16:21:15Z | [
"python",
"string",
"list",
"split"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,237 | <pre><code>import os
os.system("your command")
</code></pre>
<p>Note that this is dangerous, since the command isn't cleaned. I leave it up to you to google for the relevant docs on the 'os' and 'sys' modules. There are a bunch of functions (exec* , spawn*) that will do similar things.</p>
| 27 | 2008-09-18T01:37:24Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,238 | <pre><code>import os
cmd = 'ls -al'
os.system(cmd)
</code></pre>
<p>If you want to return the results of the command, you can use <a href="https://docs.python.org/2/library/os.html#os.popen"><code>os.popen</code></a>. However, this is deprecated since version 2.6 in favor of the <a href="https://docs.python.org/2/library/subprocess.html#module-subprocess">subprocess module</a>, which other answers have covered well.</p>
| 46 | 2008-09-18T01:37:49Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,243 | <p>Look at the <a href="https://docs.python.org/2/library/subprocess.html">subprocess module</a> in the stdlib:</p>
<pre><code>from subprocess import call
call(["ls", "-l"])
</code></pre>
<p>The advantage of subprocess vs system is that it is more flexible (you can get the stdout, stderr, the "real" status code, better error handling, etc...). I think os.system is deprecated, too, or will be:</p>
<p><a href="https://docs.python.org/2/library/subprocess.html#replacing-older-functions-with-the-subprocess-module">https://docs.python.org/2/library/subprocess.html#replacing-older-functions-with-the-subprocess-module</a></p>
<p>For quick/dirty/one time scripts, <code>os.system</code> is enough, though.</p>
| 2,184 | 2008-09-18T01:39:35Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,255 | <p>I'd recommend using the subprocess module instead of os.system because it does shell escaping for you and is therefore much safer: <a href="http://docs.python.org/library/subprocess.html">http://docs.python.org/library/subprocess.html</a></p>
<pre><code>subprocess.call(['ping', 'localhost'])
</code></pre>
| 63 | 2008-09-18T01:42:30Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,262 | <p><a href="https://docs.python.org/2/library/subprocess.html">https://docs.python.org/2/library/subprocess.html</a></p>
<p>...or for a very simple command:</p>
<pre><code>import os
os.system('cat testfile')
</code></pre>
| 9 | 2008-09-18T01:43:30Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,267 | <p>os.system has been superceeded by the subprocess module. Use subproccess instead.</p>
| 6 | 2008-09-18T01:43:56Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 89,304 | <p>os.system is OK, but kind of dated. It's also not very secure. Instead, try subprocess. subprocess does not call sh directly and is therefore more secure than os.system.</p>
<p>Get more information at <a href="https://docs.python.org/library/subprocess.html" rel="nofollow">https://docs.python.org/library/subprocess.html</a></p>
| 11 | 2008-09-18T01:53:27Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 92,395 | <p>Here's a summary of the ways to call external programs and the advantages and disadvantages of each:</p>
<ol>
<li><p><code>os.system("some_command with args")</code> passes the command and arguments to your system's shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection. For example: </p>
<pre><code>os.system("some_command < input_file | another_command > output_file")
</code></pre>
<p>However, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, etc. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs. See <a href="https://docs.python.org/2/library/os.html#os.system">the documentation</a>.</p></li>
<li><p><code>stream = os.popen("some_command with args")</code> will do the same thing as <code>os.system</code> except that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don't need to worry about escaping anything. See <a href="https://docs.python.org/2/library/os.html#os.popen">the documentation</a>.</p></li>
<li><p>The <code>Popen</code> class of the <code>subprocess</code> module. This is intended as a replacement for <code>os.popen</code> but has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you'd say:</p>
<pre><code>print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
</code></pre>
<p>instead of: </p>
<pre><code>print os.popen("echo Hello World").read()
</code></pre>
<p>but it is nice to have all of the options there in one unified class instead of 4 different popen functions. See <a href="https://docs.python.org/2/library/subprocess.html#popen-constructor">the documentation</a>.</p></li>
<li><p>The <code>call</code> function from the <code>subprocess</code> module. This is basically just like the <code>Popen</code> class and takes all of the same arguments, but it simply waits until the command completes and gives you the return code. For example:</p>
<pre><code>return_code = subprocess.call("echo Hello World", shell=True)
</code></pre>
<p>See <a href="https://docs.python.org/2/library/subprocess.html#subprocess.call">the documentation</a>.</p></li>
<li><p>If you're on Python 3.5 or later, you can use the new <a href="https://docs.python.org/3.5/library/subprocess.html#subprocess.run"><code>subprocess.run</code></a> function, which is a lot like the above but even more flexible and returns a <a href="https://docs.python.org/3.5/library/subprocess.html#subprocess.CompletedProcess"><code>CompletedProcess</code></a> object when the command finishes executing.</p></li>
<li><p>The os module also has all of the fork/exec/spawn functions that you'd have in a C program, but I don't recommend using them directly.</p></li>
</ol>
<p>The <code>subprocess</code> module should probably be what you use.</p>
<p>Finally please be aware that for all methods where you pass the final command to be executed by the shell as a string and you are responsible for escaping it. <strong>There are serious security implications</strong> if any part of the string that you pass can not be fully trusted. For example, if a user is entering some/any part of the string. If you are unsure, only use these methods with constants. To give you a hint of the implications consider this code:</p>
<pre><code>print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()
</code></pre>
<p>and imagine that the user enters "my mama didnt love me && rm -rf /".</p>
| 1,889 | 2008-09-18T13:11:46Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 95,246 | <p>I typically use:</p>
<pre><code>import subprocess
p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
print line,
retval = p.wait()
</code></pre>
<p>You are free to do what you want with the stdout data in the pipe. In fact, you can simply omit those parameters (stdout= and stderr=) and it'll behave like os.system().</p>
| 153 | 2008-09-18T18:20:46Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 2,030,768 | <p>There is another difference here which is not mentioned above.</p>
<p>subprocess.Popen executes the as a subprocess. In my case, I need to execute file which needs to communicate with another program . </p>
<p>I tried subprocess, execution was successful. However could not comm w/ .
everything normal when I run both from the terminal.</p>
<p>One more:
(NOTE: kwrite behaves different from other apps. If you try below with firefox results will not be the same)</p>
<p>If you try os.system("kwrite"), program flow freezes until user closes kwrite. To overcome that I tried instead os.system(konsole -e kwrite). This time program continued to flow but kwrite became the subprocess of the konsole.</p>
<p>Anyone runs the kwrite not being a subprocess (i.e. at the system monitor it must be appear at the leftmost edge of the tree)</p>
| 7 | 2010-01-08T21:11:30Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 2,251,026 | <p>Some hints on detaching the child process from the calling one (starting the child process in background).</p>
<p>Suppose you want to start a long task from a CGI-script, that is the child process should live longer than the CGI-script execution process.</p>
<p>The classical example from the subprocess module docs is:</p>
<pre><code>import subprocess
import sys
# some code here
pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess
# some more code here
</code></pre>
<p>The idea here is that you do not want to wait in the line 'call subprocess' until the longtask.py is finished. But it is not clear what happens after the line 'some more code here' from the example.</p>
<p>My target platform was freebsd, but the development was on windows, so I faced the problem on windows first.</p>
<p>On windows (win xp), the parent process will not finish until the longtask.py has finished its work. It is not what you want in CGI-script. The problem is not specific to Python, in PHP community the problems are the same.</p>
<p>The solution is to pass DETACHED_PROCESS flag to the underlying CreateProcess function in win API.
If you happen to have installed pywin32 you can import the flag from the win32process module, otherwise you should define it yourself:</p>
<pre><code>DETACHED_PROCESS = 0x00000008
pid = subprocess.Popen([sys.executable, "longtask.py"],
creationflags=DETACHED_PROCESS).pid
</code></pre>
<p>/* <em>UPD 2015.10.27</em> @eryksun in a comment below notes, that the semantically correct flag is CREATE_NEW_CONSOLE (0x00000010) */</p>
<p>On freebsd we have another problem: when the parent process is finished, it finishes the child processes as well. And that is not what you want in CGI-script either. Some experiments showed that the problem seemed to be in sharing sys.stdout. And the working solution was the following:</p>
<pre><code>pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
</code></pre>
<p>I have not checked the code on other platforms and do not know the reasons of the behaviour on freebsd. If anyone knows, please share your ideas. Googling on starting background processes in Python does not shed any light yet.</p>
| 95 | 2010-02-12T10:15:34Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 3,879,406 | <p>Check "pexpect" python library, too.
It allows for interactive controlling of external programs/commands, even ssh, ftp, telnet etc. You can just type something like:</p>
<pre><code>child = pexpect.spawn('ftp 192.168.0.24')
child.expect('(?i)name .*: ')
child.sendline('anonymous')
child.expect('(?i)password')
</code></pre>
| 32 | 2010-10-07T07:09:04Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 4,728,086 | <p><code>subprocess.check_call</code> is convenient if you don't want to test return values. It throws an exception on any error.</p>
| 7 | 2011-01-18T19:21:44Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 5,824,565 | <p>If what you need is the output from the command you are calling you can use subprocess.check_output since Python 2.7</p>
<pre><code>>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
</code></pre>
| 23 | 2011-04-28T20:29:29Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 9,676,642 | <p>I always use <code>fabric</code> for this things like:</p>
<pre><code>from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )
</code></pre>
<p>But this seem to be a good tool: <a href="https://github.com/amoffat/sh"><code>sh</code> (Python subprocess interface)</a>.</p>
<p>Look an example:</p>
<pre><code>from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)
</code></pre>
| 31 | 2012-03-13T00:12:54Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 10,988,365 | <p><code>os.system</code> does not allow you to store results, so if you want to store results in some list or something <code>subprocess.call</code> works.</p>
| 7 | 2012-06-11T22:28:35Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 11,507,283 | <p>you can use Popen, then you can check procedure's status</p>
<pre><code>from subprocess import Popen
proc = Popen(['ls', '-l'])
if proc.poll() is None:
proc.kill()
</code></pre>
<p>Check this out <a href="http://docs.python.org/library/subprocess.html#popen-objects">subprocess.Popen</a></p>
| 5 | 2012-07-16T15:16:24Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 11,644,161 | <p>Very simplest way to run any command and get result back:</p>
<pre><code>from commands import getstatusoutput
try:
return getstatusoutput("ls -ltr")
except Exception, e:
return None
</code></pre>
| 4 | 2012-07-25T06:51:50Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 11,940,294 | <p>I quite like <a href="http://shell-command.readthedocs.org/en/latest/index.html" rel="nofollow">shell_command</a> for its simplicity. It's built on top of the subprocess module.</p>
| 3 | 2012-08-13T18:36:32Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 13,106,558 | <p>This is how I run my commands. This code has everything you need pretty much</p>
<pre><code>from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()
</code></pre>
| 24 | 2012-10-28T05:14:01Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 13,402,722 | <h1>Update:</h1>
<p><code>subprocess.run</code> is the recommended approach <a href="https://docs.python.org/3.6/whatsnew/3.5.html#whatsnew-subprocess">as of Python 3.5</a> if your code does not need to maintain compatibility with earlier Python versions. It's more consistent and offers similar ease-of-use as Envoy. (Piping isn't as straightforward though. See <a href="http://stackoverflow.com/questions/7389662/link-several-popen-commands-with-pipes">this question for how</a>.)</p>
<p>Here's some examples from <a href="https://docs.python.org/3.6/library/subprocess.html#subprocess.run">the docs</a>.</p>
<p>Run a process:</p>
<pre><code>>>> subprocess.run(["ls", "-l"]) # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)
</code></pre>
<p>Raise on failed run:</p>
<pre><code>>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
</code></pre>
<p>Capture output:</p>
<pre><code>>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')
</code></pre>
<h1>Original answer:</h1>
<p>I recommend trying <a href="https://github.com/kennethreitz/envoy">Envoy</a>. It's a wrapper for subprocess, which in turn <a href="http://docs.python.org/2/library/subprocess.html">aims to replace</a> the older modules and functions. Envoy is subprocess for humans.</p>
<p>Example usage from <a href="https://github.com/kennethreitz/envoy#readme">the readme</a>:</p>
<pre><code>>>> r = envoy.run('git config', data='data to pipe in', timeout=2)
>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''
</code></pre>
<p>Pipe stuff around too:</p>
<pre><code>>>> r = envoy.run('uptime | pbcopy')
>>> r.command
'pbcopy'
>>> r.status_code
0
>>> r.history
[<Response 'uptime'>]
</code></pre>
| 17 | 2012-11-15T17:13:22Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 15,954,964 | <h1>With Standard Library</h1>
<p>Use <a href="http://docs.python.org/2/library/subprocess.html" rel="nofollow">subprocess module</a>:</p>
<pre><code>from subprocess import call
call(['ls', '-l'])
</code></pre>
<p>It is the recommended standard way. However, more complicated tasks (pipes, output, input, etc.) can be tedious to construct and write.</p>
<p><em>Note: <a href="https://docs.python.org/2/library/shlex.html#shlex.split" rel="nofollow">shlex.split</a> can help you to parse the command for <code>call</code> and other <code>subprocess</code> functions in case you don't want (or you can't!) provide them in form of lists:</em></p>
<pre><code>import shlex
from subprocess import call
call(shlex.split('ls -l'))
</code></pre>
<h1>With External Dependencies</h1>
<p>If you do not mind external dependencies, use <a href="https://pypi.python.org/pypi/plumbum" rel="nofollow">plumbum</a>:</p>
<pre><code>from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())
</code></pre>
<p>It is the best <code>subprocess</code> wrapper. It's cross-platform, i.e. it works on both Windows and Unix-like systems. Install by <code>pip install plumbum</code>.</p>
<p>Another popular library is <a href="https://pypi.python.org/pypi/sh" rel="nofollow">sh</a>:</p>
<pre><code>from sh import ifconfig
print(ifconfig('wlan0'))
</code></pre>
<p>However, <code>sh</code> dropped Windows support, so it's not as awesome as it used to be. Install by <code>pip install sh</code>.</p>
| 18 | 2013-04-11T17:17:53Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 16,062,355 | <p>There are a lot of different ways to run external commands in python,
and all of them have their own plus sides and drawbacks.</p>
<p>My colleagues and me have been writing python sysadmin tools, so we need to
run a lot of external commands, and sometimes you want them to block or run asynchronously,
time-out, update every second...</p>
<p>There are also different ways of handling the return code and errors,
and you might want to parse the output, and provide new input (in an <a href="http://en.wikipedia.org/wiki/Expect" rel="nofollow">expect</a> kind of style)
Or you will need to redirect stdin, stdout and stderr to run in a different tty (e.g., when using screen)</p>
<p>So you will probably have to write a lot of wrappers around the external command.
So here is a python module which we have written which can handle
almost anything you would want, and if not, it's very flexible so you can easily extend it:</p>
<p><a href="https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py" rel="nofollow">https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py</a></p>
| 4 | 2013-04-17T14:10:06Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 16,072,857 | <p>without the output of result</p>
<pre><code>import os
os.system("your command here")
</code></pre>
<p>with output of result</p>
<pre><code>import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")
</code></pre>
| 18 | 2013-04-18T01:09:33Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 16,089,689 | <p>The <a href="http://docs.python.org/2/library/subprocess.html" rel="nofollow">subprocess module</a> described above by Eli is very powerful, but the syntax to make a bog-standard system call and inspect its output, is unnecessarily prolix.</p>
<p>The easiest way to make a system call is with the <a href="http://docs.python.org/2/library/commands.html" rel="nofollow">commands module</a> (Linux only).</p>
<pre><code>> import commands
> commands.getstatusoutput("grep matter alice-in-wonderland.txt")
(0, "'Then it doesn't matter which way you go,' said the Cat.")
</code></pre>
<p>The first item in the tuple is the return code of the process. The second item is its standard output (and standard error, merged).</p>
<hr>
<p>The Python devs have 'deprecated' the commands module, but that doesn't mean you shouldn't use it. Only that they're not developing it anymore, which is okay, because it's already perfect (at its small but important function).</p>
| 0 | 2013-04-18T17:39:50Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 17,202,916 | <p>Just to add to the discussion, if you include using a Python console, you can call external commands from ipython. While in the ipython prompt, you can call call shell commands by prefixing '!'. You can also combine python code with shell, and assign the output of shell scripts to python variables. </p>
<p>For instance: </p>
<pre><code>In [9]: mylist = !ls
In [10]: mylist
Out[10]:
['file1',
'file2',
'file3',]
</code></pre>
| 4 | 2013-06-19T23:18:34Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 22,395,328 | <p>After some research, I have the following code which works very well for me. It basically prints both stdout and stderr in real time. Hope it helps someone else who needs it.</p>
<pre><code>stdout_result = 1
stderr_result = 1
def stdout_thread(pipe):
global stdout_result
while True:
out = pipe.stdout.read(1)
stdout_result = pipe.poll()
if out == '' and stdout_result is not None:
break
if out != '':
sys.stdout.write(out)
sys.stdout.flush()
def stderr_thread(pipe):
global stderr_result
while True:
err = pipe.stderr.read(1)
stderr_result = pipe.poll()
if err == '' and stderr_result is not None:
break
if err != '':
sys.stdout.write(err)
sys.stdout.flush()
def exec_command(command, cwd=None):
if cwd is not None:
print '[' + ' '.join(command) + '] in ' + cwd
else:
print '[' + ' '.join(command) + ']'
p = subprocess.Popen(
command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
)
out_thread = threading.Thread(name='stdout_thread', target=stdout_thread, args=(p,))
err_thread = threading.Thread(name='stderr_thread', target=stderr_thread, args=(p,))
err_thread.start()
out_thread.start()
out_thread.join()
err_thread.join()
return stdout_result + stderr_result
</code></pre>
| 2 | 2014-03-14T02:59:05Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 23,030,076 | <p>Use <a href="https://docs.python.org/2/library/subprocess.html" rel="nofollow">subprocess.call</a>:</p>
<pre class="lang-python prettyprint-override"><code>from subprocess import call
# using list
call(["echo", "Hello", "world"])
# single string argument varies across platforms so better split it
call("echo Hello world".split(" "))
</code></pre>
| 1 | 2014-04-12T11:58:23Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 23,391,049 | <p>I tend to use <a href="https://docs.python.org/2/library/subprocess.html">subprocess</a> together with <a href="https://docs.python.org/2/library/shlex.html">shlex</a> (to handle escaping of quoted strings):</p>
<pre><code>>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)
</code></pre>
| 5 | 2014-04-30T14:37:04Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 23,416,345 | <p>Shameless plug, I wrote a library for this :P
<a href="https://github.com/houqp/shell.py">https://github.com/houqp/shell.py</a></p>
<p>It's basically a wrapper for popen and shlex for now. It also supports piping commands so you can chain commands easier in Python. So you can do things like:</p>
<pre><code>ex('echo hello shell.py') | "awk '{print $2}'"
</code></pre>
| 5 | 2014-05-01T20:49:01Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 25,476,624 | <p>A simple way is to use the os module:</p>
<pre><code>import os
os.system('ls')
</code></pre>
<p>Alternatively you can also use the subprocess module</p>
<pre><code>import subprocess
subprocess.check_call('ls')
</code></pre>
<p>If you want the result to be stored in a variable try:</p>
<pre><code>import subprocess
r = subprocess.check_output('ls')
</code></pre>
| 2 | 2014-08-24T21:46:12Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 26,305,089 | <p>There is also <a href="http://plumbum.readthedocs.org/en/latest/">Plumbum</a></p>
<pre><code>>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad() # Notepad window pops up
u'' # Notepad window is closed by user, command returns
</code></pre>
| 10 | 2014-10-10T17:41:13Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 31,114,625 | <pre><code>import os
cmd = 'ls -al'
os.system(cmd)
</code></pre>
<p><strong>os - This module provides a portable way of using operating system dependent functionality</strong></p>
<p>for the more os functions <a href="https://docs.python.org/2/library/os.html">here</a> is the documentation.</p>
| 6 | 2015-06-29T11:34:22Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 31,618,111 | <p>Using <strong>Popen</strong> function of <strong>subprocess</strong> python module is the simplest way of running linux commands. In that, <strong>Popen.communicate()</strong> function will give your commands output. For example</p>
<pre><code>import subprocess
..
process = subprocess.Popen(..) # pass command and arguments to the function
stdout, stderr = process.communicate() # get command output and error
..
</code></pre>
| 1 | 2015-07-24T19:12:21Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 33,118,899 | <p>Here are my 2 cents: In my view this is best practice when dealing with external commands...</p>
<p>This is return values from execute method...</p>
<pre><code>pass, stdout, stderr = execute(["ls","-la"],"/home/user/desktop")
</code></pre>
<p>This is execute method...</p>
<pre><code>def execute(cmdArray,workingDir):
stdout = ''
stderr = ''
try:
try:
process = subprocess.Popen(cmdArray,cwd=workingDir, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1)
except OSError:
return [False, '', 'ERROR : command(' + ' '.join(cmdArray) + ') could not get executed!']
for line in iter(process.stdout.readline, b''):
try:
echoLine = line.decode("utf-8")
except:
echoLine = str(line)
stdout += echoLine
for line in iter(process.stderr.readline, b''):
try:
echoLine = line.decode("utf-8")
except:
echoLine = str(line)
stderr += echoLine
except (KeyboardInterrupt,SystemExit) as err:
return [False,'',str(err)]
process.stdout.close()
returnCode = process.wait()
if returnCode != 0 or stderr != '':
return [False, stdout, stderr]
else:
return [True, stdout, stderr]
</code></pre>
| 4 | 2015-10-14T07:12:51Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 36,058,314 | <p>For python 3.5+ it is recommended that you use the <a href="https://docs.python.org/3.5/library/subprocess.html#subprocess.run" rel="nofollow">run function from the subprocess module</a>. This returns a <code>CompletedProcess</code> object, from which you can easily obtain the output as well as return code.</p>
<pre><code>from subprocess import PIPE, run
command = ['echo', 'hello']
result = run(command, stdout=PIPE, stderr=PIPE, universal_newlines=True)
print(result.returncode, result.stdout, result.stderr)
</code></pre>
| 3 | 2016-03-17T10:48:32Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 36,913,076 | <p>I would recommend the following method 'run' and it will help us in getting STDOUT, STDERR and exit status as dictionary; The caller of this can read the dictionary return by 'run' method to know the actual state of process. </p>
<pre><code> def run (cmd):
print "+ DEBUG exec({0})".format(cmd)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=True)
(out, err) = p.communicate()
ret = p.wait()
out = filter(None, out.split('\n'))
err = filter(None, err.split('\n'))
ret = True if ret == 0 else False
return dict({'output': out, 'error': err, 'status': ret})
#end
</code></pre>
| 1 | 2016-04-28T11:18:22Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 37,877,635 | <p>In windows you can just import subprocess module and run external commands by calling subprocess.Popen(), subprocess.Popen().communicate() and subprocess.Popen().wait() as below:</p>
<pre><code># Python script to run a command line
import subprocess
def execute(cmd):
"""
Purpose : To execute a command and return exit status
Argument : cmd - command to execute
Return : exit_code
"""
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
if rc != 0:
print "Error: failed to execute command:", cmd
print error
return result
# def
command = "tasklist | grep python"
print "This process detail: \n", execute(command)
</code></pre>
<p>Output:</p>
<pre><code>This process detail:
python.exe 604 RDP-Tcp#0 4 5,660 K
</code></pre>
| 0 | 2016-06-17T09:14:24Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 38,012,358 | <p>import subprocess</p>
<pre><code>p = subprocess.Popen("df -h", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")
</code></pre>
<p>Gives nice output which is easier to work with</p>
<pre><code>['Filesystem Size Used Avail Use% Mounted on',
'/dev/sda6 32G 21G 11G 67% /',
'none 4.0K 0 4.0K 0% /sys/fs/cgroup',
'udev 1.9G 4.0K 1.9G 1% /dev',
'tmpfs 387M 1.4M 386M 1% /run',
'none 5.0M 0 5.0M 0% /run/lock',
'none 1.9G 58M 1.9G 3% /run/shm',
'none 100M 32K 100M 1% /run/user',
'/dev/sda5 340G 222G 100G 69% /home',
'']
</code></pre>
| 1 | 2016-06-24T11:29:00Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 38,477,871 | <p>To fetch the network id from the openstack neutron:</p>
<pre><code>#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read() /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)
</code></pre>
<p>Output of <strong>nova net-list</strong></p>
<pre><code>+--------------------------------------+------------+------+
| ID | Label | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1 | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal | None |
+--------------------------------------+------------+------+
</code></pre>
<p>Output of <strong>print(networkId)</strong></p>
<pre><code>27a74fcd-37c0-4789-9414-9531b7e3f126
</code></pre>
| 4 | 2016-07-20T09:50:01Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 39,447,501 | <p>Many way to call command.</p>
<ul>
<li>e.g:</li>
</ul>
<p>if <code>and.exe</code> needs two parameters.In cmd we can call sample.exe use this:
<code>and.exe 2 3</code> and it show <code>5</code> on screen.</p>
<p>if we use python script to call <code>and.exe</code>,we should do like..</p>
<ol>
<li><p><code>os.system(cmd,...)</code></p>
<ul>
<li><code>os.system(("and.exe" + " " + "2" + " " + "3"))</code></li>
</ul></li>
<li><p><code>os.popen(cmd,...)</code></p>
<ul>
<li><code>os.popen(("and.exe" + " " + "2" + " " + "3"))</code></li>
</ul></li>
<li>```subprocess.Popen(cmd,...)
<ul>
<li><code>subprocess.Popen(("and.exe" + " " + "2" + " " + "3"))</code></li>
</ul></li>
</ol>
<p>It's too hard ,so we can join cmd with space,so it in short:</p>
<pre><code>import os
cmd = " ".join(exename,parameters)
os.popen(cmd)
</code></pre>
| 0 | 2016-09-12T09:44:09Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
Calling an external command in Python | 89,228 | <p>How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?</p>
| 2,312 | 2008-09-18T01:35:30Z | 39,969,619 | <p>Here is calling a external command and return or print commands output.</p>
<p>Python <a href="https://docs.python.org/2/library/subprocess.html" rel="nofollow">Subprocess</a> check_output is good for </p>
<blockquote>
<p>Run command with arguments and return its output as a byte string.</p>
</blockquote>
<pre><code>import subprocess
proc = subprocess.check_output('ipconfig /all')
print proc
</code></pre>
| 0 | 2016-10-11T02:26:49Z | [
"python",
"shell",
"command",
"subprocess",
"external"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 89,915 | <p>use a regex and see if it matches!</p>
<pre><code>([a-z][A-Z][0-9]\_\-)*
</code></pre>
| -1 | 2008-09-18T04:06:30Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 89,919 | <p>A regular expression will do the trick with very little code:</p>
<pre><code>import re
...
if re.match("^[A-Za-z0-9_-]*$", my_little_string):
# do something here
</code></pre>
| 77 | 2008-09-18T04:08:19Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 89,937 | <pre><code> pat = re.compile ('[^\w-]')
def onlyallowed(s):
return not pat.search (s)
</code></pre>
| 3 | 2008-09-18T04:12:00Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 89,940 | <p>You could always use a list comprehension and check the results with all, it would be a little less resource intensive than using a regex: <code>all([c in string.letters + string.digits + ["_", "-"] for c in mystring])</code></p>
| 0 | 2008-09-18T04:12:12Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 89,971 | <p>There are a variety of ways of achieving this goal, some are clearer than others. For each of my examples, 'True' means that the string passed is valid, 'False' means it contains invalid characters.</p>
<p>First of all, there's the naive approach:</p>
<pre><code>import string
allowed = string.letters + string.digits + '_' + '-'
def check_naive(mystring):
return all(c in allowed for c in mystring)
</code></pre>
<p>Then there's use of a regular expression, you can do this with re.match(). Note that '-' has to be at the end of the [] otherwise it will be used as a 'range' delimiter. Also note the $ which means 'end of string'. Other answers noted in this question use a special character class, '\w', I always prefer using an explicit character class range using [] because it is easier to understand without having to look up a quick reference guide, and easier to special-case.</p>
<pre><code>import re
CHECK_RE = re.compile('[a-zA-Z0-9_-]+$')
def check_re(mystring):
return CHECK_RE.match(mystring)
</code></pre>
<p>Another solution noted that you can do an inverse match with regular expressions, I've included that here now. Note that [^...] inverts the character class because the ^ is used:</p>
<pre><code>CHECK_INV_RE = re.compile('[^a-zA-Z0-9_-]')
def check_inv_re(mystring):
return not CHECK_INV_RE.search(mystring)
</code></pre>
<p>You can also do something tricky with the 'set' object. Have a look at this example, which removes from the original string all the characters that are allowed, leaving us with a set containing either a) nothing, or b) the offending characters from the string:</p>
<pre><code>def check_set(mystring):
return not set(mystring) - set(allowed)
</code></pre>
| 12 | 2008-09-18T04:18:40Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 91,564 | <p>As an alternative to using regex you could do it in Sets:</p>
<pre><code>from sets import Set
allowed_chars = Set('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-')
if Set(my_little_sting).issubset(allowed_chars):
# your action
print True
</code></pre>
| 4 | 2008-09-18T10:47:49Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 91,572 | <p>If it were not for the dashes and underscores, the easiest solution would be</p>
<pre><code>my_little_string.isalnum()
</code></pre>
<p>(Section <a href="https://docs.python.org/3/library/stdtypes.html#str.isalnum" rel="nofollow">3.6.1</a> of the Python Library Reference)</p>
| 10 | 2008-09-18T10:49:54Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 92,000 | <p>[Edit] There's another solution not mentioned yet, and it seems to outperform the others given so far in most cases.</p>
<p>Use string.translate to replace all valid characters in the string, and see if we have any invalid ones left over. This is pretty fast as it uses the underlying C function to do the work, with very little python bytecode involved.</p>
<p>Obviously performance isn't everything - going for the most readable solutions is probably the best approach when not in a performance critical codepath, but just to see how the solutions stack up, here's a performance comparison of all the methods proposed so far. check_trans is the one using the string.translate method.</p>
<p>Test code:</p>
<pre><code>import string, re, timeit
pat = re.compile('[\w-]*$')
pat_inv = re.compile ('[^\w-]')
allowed_chars=string.ascii_letters + string.digits + '_-'
allowed_set = set(allowed_chars)
trans_table = string.maketrans('','')
def check_set_diff(s):
return not set(s) - allowed_set
def check_set_all(s):
return all(x in allowed_set for x in s)
def check_set_subset(s):
return set(s).issubset(allowed_set)
def check_re_match(s):
return pat.match(s)
def check_re_inverse(s): # Search for non-matching character.
return not pat_inv.search(s)
def check_trans(s):
return not s.translate(trans_table,allowed_chars)
test_long_almost_valid='a_very_long_string_that_is_mostly_valid_except_for_last_char'*99 + '!'
test_long_valid='a_very_long_string_that_is_completely_valid_' * 99
test_short_valid='short_valid_string'
test_short_invalid='/$%$%&'
test_long_invalid='/$%$%&' * 99
test_empty=''
def main():
funcs = sorted(f for f in globals() if f.startswith('check_'))
tests = sorted(f for f in globals() if f.startswith('test_'))
for test in tests:
print "Test %-15s (length = %d):" % (test, len(globals()[test]))
for func in funcs:
print " %-20s : %.3f" % (func,
timeit.Timer('%s(%s)' % (func, test), 'from __main__ import pat,allowed_set,%s' % ','.join(funcs+tests)).timeit(10000))
print
if __name__=='__main__': main()
</code></pre>
<p>The results on my system are:</p>
<pre><code>Test test_empty (length = 0):
check_re_inverse : 0.042
check_re_match : 0.030
check_set_all : 0.027
check_set_diff : 0.029
check_set_subset : 0.029
check_trans : 0.014
Test test_long_almost_valid (length = 5941):
check_re_inverse : 2.690
check_re_match : 3.037
check_set_all : 18.860
check_set_diff : 2.905
check_set_subset : 2.903
check_trans : 0.182
Test test_long_invalid (length = 594):
check_re_inverse : 0.017
check_re_match : 0.015
check_set_all : 0.044
check_set_diff : 0.311
check_set_subset : 0.308
check_trans : 0.034
Test test_long_valid (length = 4356):
check_re_inverse : 1.890
check_re_match : 1.010
check_set_all : 14.411
check_set_diff : 2.101
check_set_subset : 2.333
check_trans : 0.140
Test test_short_invalid (length = 6):
check_re_inverse : 0.017
check_re_match : 0.019
check_set_all : 0.044
check_set_diff : 0.032
check_set_subset : 0.037
check_trans : 0.015
Test test_short_valid (length = 18):
check_re_inverse : 0.125
check_re_match : 0.066
check_set_all : 0.104
check_set_diff : 0.051
check_set_subset : 0.046
check_trans : 0.017
</code></pre>
<p>The translate approach seems best in most cases, dramatically so with long valid strings, but is beaten out by regexes in test_long_invalid (Presumably because the regex can bail out immediately, but translate always has to scan the whole string). The set approaches are usually worst, beating regexes only for the empty string case.</p>
<p>Using all(x in allowed_set for x in s) performs well if it bails out early, but can be bad if it has to iterate through every character. isSubSet and set difference are comparable, and are consistently proportional to the length of the string regardless of the data.</p>
<p>There's a similar difference between the regex methods matching all valid characters and searching for invalid characters. Matching performs a little better when checking for a long, but fully valid string, but worse for invalid characters near the end of the string.</p>
| 20 | 2008-09-18T12:19:48Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 13,649,498 | <p>Here's something based on Jerub's "naive approach" (naive being his words, not mine!):</p>
<pre><code>import string
ALLOWED = frozenset(string.ascii_letters + string.digits + '_' + '-')
def check(mystring):
return all(c in ALLOWED for c in mystring)
</code></pre>
<p>If <code>ALLOWED</code> was a string then I think <code>c in ALLOWED</code> would involve iterating over each character in the string until it found a match or reached the end. Which, to quote Joel Spolsky, is something of a <a href="http://www.joelonsoftware.com/articles/fog0000000319.html" rel="nofollow">Shlemiel the Painter algorithm</a>.</p>
<p>But testing for existence in a set should be more efficient, or at least less dependent on the number of allowed characters. Certainly this approach is a little bit faster on my machine. It's clear and I think it performs plenty well enough for most cases (on my slow machine I can validate tens of thousands of short-ish strings in a fraction of a second). I like it.</p>
<p><strong>ACTUALLY</strong> on my machine a regexp works out several times faster, and is just as simple as this (arguably simpler). So that probably is the best way forward.</p>
| 0 | 2012-11-30T16:50:13Z | [
"python",
"regex",
"string"
] |
How do I verify that a string only contains letters, numbers, underscores and dashes? | 89,909 | <p>I know how to do this if I iterate through all of the characters in the string but I am looking for a more elegant method.</p>
<p>Thanks</p>
| 54 | 2008-09-18T04:04:58Z | 19,970,696 | <p>Well you can ask the help of regex, the great in here :)</p>
<p>code:</p>
<pre><code>import re
string = 'adsfg34wrtwe4r2_()' #your string that needs to be matched.
regex = r'^[\w\d_()]*$' # you can also add a space in regex if u want to allow it in the string
if re.match(regex,string):
print 'yes'
else:
print 'false'
</code></pre>
<p>Output:</p>
<pre><code>yes
</code></pre>
<p>Hope this helps :)</p>
| 1 | 2013-11-14T06:04:42Z | [
"python",
"regex",
"string"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,064 | <p>Please, don't manually parse html in python! There are many better options available; I'd recommend the wonderful <a href="http://www.crummy.com/software/BeautifulSoup/" rel="nofollow">BeautifulSoup</a></p>
| 2 | 2008-09-18T04:38:36Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,095 | <p>Parsing things with regular expressions works for regular languages. HTML is not a regular language, and the stuff you find on web pages these days is absolute crap. <a href="http://www.crummy.com/software/BeautifulSoup/" rel="nofollow">BeautifulSoup</a> deals with tag-soup HTML with browser-like heuristics so you get parsed HTML that resembles what a browser would display.</p>
<p>The downside is it's not very fast. There's <a href="http://codespeak.net/lxml/" rel="nofollow">lxml</a> for parsing well-formed html, but you should really use BeautifulSoup if you're not 100% certain that your input will always be well-formed.</p>
| 4 | 2008-09-18T04:43:01Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,104 | <p>Because of the braces around the anchor tag, that part is interpreted as a capture group. This causes only the capture group to be returned, and not the whole regex match.</p>
<p>Put the entire regex in braces and you'll see the right matches showing up as the first element in the returned tuples.</p>
<p>But indeed, you should use a real parser.</p>
| 2 | 2008-09-18T04:44:24Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,138 | <p>This question has been asked in several forms over the last few days, so I'm going to say this very clearly.</p>
<h1>Q: How do I parse HTML with Regular Expressions?</h1>
<h1>A: Please Don't.</h1>
<p>Use <a href="http://www.crummy.com/software/BeautifulSoup/" rel="nofollow">BeautifulSoup</a>, <a href="http://code.google.com/p/html5lib/" rel="nofollow">html5lib</a> or <a href="http://codespeak.net/lxml/lxmlhtml.html" rel="nofollow">lxml.html</a>. Please.</p>
| 23 | 2008-09-18T04:52:26Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,206 | <p>As has been mentioned, you should use a parser instead of a regex.</p>
<p>This is how you could do it with a regex though:</p>
<pre><code>import re
html = '''
<body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
'''
p = re.compile(r'''
<(?P<header>h[0-9])> # store header tag for later use
\s* # zero or more whitespace
(<a\shref="(?P<href>.*?)">)? # optional link tag. store href portion
\s*
(?P<title>.*?) # title
\s*
(</a>)? # optional closing link tag
\s*
</(?P=header)> # must match opening header tag
''', re.IGNORECASE + re.VERBOSE)
stories = p.finditer(html)
for match in stories:
print '%(title)s [%(href)s]' % match.groupdict()
</code></pre>
<p>Here are a couple of good regular expression resources:</p>
<ul>
<li><a href="http://docs.python.org/dev/howto/regex.html" rel="nofollow">Python Regular Expression HOWTO</a></li>
<li><a href="http://www.regular-expressions.info/" rel="nofollow">Regular-Expressions.info</a></li>
</ul>
| 1 | 2008-09-18T05:10:43Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 90,894 | <p>Building on the answers so far:</p>
<p>It's best to use a parsing engine. It can cover a lot of cases and in an elegant way. I've tried <a href="http://www.crummy.com/software/BeautifulSoup/" rel="nofollow">BeautifulSoup</a> and I like it very much. Also easy to use, with a great tutorial.</p>
<p>If sometimes it feels like shooting flies with a cannon you can use a regular expression for quick parsing. If that's what you need here is the modified code that will catch all the headers (even those over multiple lines):</p>
<pre><code>p = re.compile(r'<(h[0-9])>(.+?)</\1>', re.IGNORECASE | re.DOTALL)
stories = re.findall(p, html)
for i in stories:
print i
</code></pre>
| 2 | 2008-09-18T08:18:38Z | [
"python",
"html",
"regex"
] |
Issue with Regular expressions in python | 90,052 | <p>Ok, so i'm working on a regular expression to search out all the header information in a site.</p>
<p>I've compiled the regular expression:</p>
<pre><code>regex = re.compile(r'''
<h[0-9]>\s?
(<a[ ]href="[A-Za-z0-9.]*">)?\s?
[A-Za-z0-9.,:'"=/?;\s]*\s?
[A-Za-z0-9.,:'"=/?;\s]?
''', re.X)
</code></pre>
<p>When i run this in python reg ex. tester, it works out wonderfully.</p>
<p>Sample data:</p>
<pre><code><body>
<h1>Dog </h1>
<h2>Cat </h2>
<h3>Fancy </h3>
<h1>Tall cup of lemons</h1>
<h1><a href="dog.com">Dog thing</a></h1>
</body>
</code></pre>
<p>Now, in the REDemo, it works wonderfully.</p>
<p>When i put it in my python code, however, it only prints <code><a href="dog.com"></code></p>
<p>Here's my python code, I'm not sure if i'm doing something wrong or if something is lost in translation. I appreciate your help.</p>
<pre><code>stories=[]
response = urllib2.urlopen('http://apricotclub.org/duh.html')
html = response.read().lower()
p = re.compile('<h[0-9]>\\s?(<a href=\"[A-Za-z0-9.]*\">)?\\s?[A-Za-z0-9.,:\'\"=/?;\\s]*\\s?[A-Za-z0-9.,:\'\"=/?;\\s]?')
stories=re.findall(p, html)
for i in stories:
if len(i) >= 5:
print i
</code></pre>
<p>I should also note, that when i take out the <code>(<a href=\"[A-Za-z0-9.]*\">)?</code> from the regular expression it works fine for non-link <code><hN></code> lines.</p>
| 2 | 2008-09-18T04:36:00Z | 618,080 | <p>I have used beautifulsoup to parse your desired HTML. I have the above HTML code in
a file called foo.html and later read as a file object.</p>
<pre><code>from BeautifulSoup import BeautifulSoup
H_TAGS = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']
def extract_data():
"""Extract the data from all headers
in a HTML page."""
f = open('foo.html', 'r+')
html = f.read()
soup = BeautifulSoup(html)
headers = [soup.findAll(h) for h in H_TAGS if soup.findAll(h)]
lst = []
for x in headers:
for y in x:
if y.string:
lst.append(y.string)
else:
lst.append(y.contents[0].string)
return lst
</code></pre>
<p>The above function returns:</p>
<pre><code>>>> [u'Dog ', u'Tall cup of lemons', u'Dog thing', u'Cat ', u'Fancy ']
</code></pre>
<p>You can add any number of header tags in h_tags list. I have assumed all the headers.
If you can solve things easily using BeautifulSoup then its better to use it. :)</p>
| 2 | 2009-03-06T08:40:04Z | [
"python",
"html",
"regex"
] |
How do you load an embedded icon from an exe file with PyWin32? | 90,775 | <p>I have an exe file generated with py2exe. In the setup.py I specify an icon to be embedded in the exe:</p>
<pre><code>windows=[{'script': 'my_script.py','icon_resources': [(0, 'my_icon.ico')], ...
</code></pre>
<p>I tried loading the icon using:</p>
<pre><code>hinst = win32api.GetModuleHandle(None)
hicon = win32gui.LoadImage(hinst, 0, win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>But this produces an (very unspecific) error:<br />
<strong>pywintypes.error: (0, 'LoadImage', 'No error message is available')</strong><br />
<br>
If I try specifying 0 as a string</p>
<pre><code>hicon = win32gui.LoadImage(hinst, '0', win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>then I get the error:<br />
<strong>pywintypes.error: (1813, 'LoadImage', 'The specified resource type cannot be found in the image file.')</strong><br />
<br>So, what's the correct method/syntax to load the icon?<br />
<em>Also please notice that I don't use any GUI toolkit - just the Windows API via PyWin32.</em></p>
| 7 | 2008-09-18T07:46:43Z | 91,245 | <p>You should set the icon ID to something other than 0:</p>
<pre><code>'icon_resources': [(42, 'my_icon.ico')]
</code></pre>
<p>Windows resource IDs must be between 1 and 32767.</p>
| 0 | 2008-09-18T09:41:01Z | [
"python",
"icons",
"exe",
"pywin32"
] |
How do you load an embedded icon from an exe file with PyWin32? | 90,775 | <p>I have an exe file generated with py2exe. In the setup.py I specify an icon to be embedded in the exe:</p>
<pre><code>windows=[{'script': 'my_script.py','icon_resources': [(0, 'my_icon.ico')], ...
</code></pre>
<p>I tried loading the icon using:</p>
<pre><code>hinst = win32api.GetModuleHandle(None)
hicon = win32gui.LoadImage(hinst, 0, win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>But this produces an (very unspecific) error:<br />
<strong>pywintypes.error: (0, 'LoadImage', 'No error message is available')</strong><br />
<br>
If I try specifying 0 as a string</p>
<pre><code>hicon = win32gui.LoadImage(hinst, '0', win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>then I get the error:<br />
<strong>pywintypes.error: (1813, 'LoadImage', 'The specified resource type cannot be found in the image file.')</strong><br />
<br>So, what's the correct method/syntax to load the icon?<br />
<em>Also please notice that I don't use any GUI toolkit - just the Windows API via PyWin32.</em></p>
| 7 | 2008-09-18T07:46:43Z | 91,670 | <p>If you're using wxPython, you can use the following simple code:</p>
<pre><code>wx.Icon(sys.argv[0], wx.BITMAP_TYPE_ICO)
</code></pre>
<p>I usually have code that checks whether it's running from an EXE or not, and acts accordingly:</p>
<pre><code>def get_app_icon():
if hasattr(sys, "frozen") and getattr(sys, "frozen") == "windows_exe":
return wx.Icon(sys.argv[0], wx.BITMAP_TYPE_ICO)
else:
return wx.Icon("gfx/myapp.ico", wx.BITMAP_TYPE_ICO)
</code></pre>
| 1 | 2008-09-18T11:10:35Z | [
"python",
"icons",
"exe",
"pywin32"
] |
How do you load an embedded icon from an exe file with PyWin32? | 90,775 | <p>I have an exe file generated with py2exe. In the setup.py I specify an icon to be embedded in the exe:</p>
<pre><code>windows=[{'script': 'my_script.py','icon_resources': [(0, 'my_icon.ico')], ...
</code></pre>
<p>I tried loading the icon using:</p>
<pre><code>hinst = win32api.GetModuleHandle(None)
hicon = win32gui.LoadImage(hinst, 0, win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>But this produces an (very unspecific) error:<br />
<strong>pywintypes.error: (0, 'LoadImage', 'No error message is available')</strong><br />
<br>
If I try specifying 0 as a string</p>
<pre><code>hicon = win32gui.LoadImage(hinst, '0', win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>then I get the error:<br />
<strong>pywintypes.error: (1813, 'LoadImage', 'The specified resource type cannot be found in the image file.')</strong><br />
<br>So, what's the correct method/syntax to load the icon?<br />
<em>Also please notice that I don't use any GUI toolkit - just the Windows API via PyWin32.</em></p>
| 7 | 2008-09-18T07:46:43Z | 92,710 | <p>Well, well... I installed py2exe and I think it's a bug. In py2exe<code>_</code>util.c they should init rt<code>_</code>icon<code>_</code>id to 1 instead of 0. The way it is now, it's impossible to load the first format of the first icon using LoadIcon/LoadImage.</p>
<p>I'll notify the developers about this if it's not already a known issue.</p>
<p>A workaround, in the meantime, would be to include the same icon twice in your setup.py:</p>
<pre><code>'icon_resources': [(1, 'my_icon.ico'), (2, 'my_icon.ico')]
</code></pre>
<p>You can load the second one, while Windows will use the first one as the shell icon. Remember to use non-zero IDs though. :)</p>
| 1 | 2008-09-18T13:52:27Z | [
"python",
"icons",
"exe",
"pywin32"
] |
How do you load an embedded icon from an exe file with PyWin32? | 90,775 | <p>I have an exe file generated with py2exe. In the setup.py I specify an icon to be embedded in the exe:</p>
<pre><code>windows=[{'script': 'my_script.py','icon_resources': [(0, 'my_icon.ico')], ...
</code></pre>
<p>I tried loading the icon using:</p>
<pre><code>hinst = win32api.GetModuleHandle(None)
hicon = win32gui.LoadImage(hinst, 0, win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>But this produces an (very unspecific) error:<br />
<strong>pywintypes.error: (0, 'LoadImage', 'No error message is available')</strong><br />
<br>
If I try specifying 0 as a string</p>
<pre><code>hicon = win32gui.LoadImage(hinst, '0', win32con.IMAGE_ICON, 0, 0, win32con.LR_DEFAULTSIZE)
</code></pre>
<p>then I get the error:<br />
<strong>pywintypes.error: (1813, 'LoadImage', 'The specified resource type cannot be found in the image file.')</strong><br />
<br>So, what's the correct method/syntax to load the icon?<br />
<em>Also please notice that I don't use any GUI toolkit - just the Windows API via PyWin32.</em></p>
| 7 | 2008-09-18T07:46:43Z | 110,777 | <p>@<a href="#92710">efotinis</a>: You're right. </p>
<p>Here is a workaround until py2exe gets fixed and you don't want to include the same icon twice:</p>
<pre><code>hicon = win32gui.CreateIconFromResource(win32api.LoadResource(None, win32con.RT_ICON, 1), True)
</code></pre>
<p>Be aware that <strong>1</strong> is not the ID you gave the icon in setup.py (which is the icon group ID), but the resource ID <em>automatically</em> assigned by py2exe to each icon in each icon group. At least that's how I understand it.</p>
<p>If you want to create an icon with a specified size (as CreateIconFromResource uses the system default icon size), you need to use CreateIconFromResourceEx, which isn't available via PyWin32:</p>
<pre><code>icon_res = win32api.LoadResource(None, win32con.RT_ICON, 1)
hicon = ctypes.windll.user32.CreateIconFromResourceEx(icon_res, len(icon_res), True,
0x00030000, 16, 16, win32con.LR_DEFAULTCOLOR)
</code></pre>
| 5 | 2008-09-21T11:07:16Z | [
"python",
"icons",
"exe",
"pywin32"
] |
I need to write code in python for comparing text of two documents using fingerprint techniques | 91,183 | <p>I need to write code in python language for comparing the text of document using fingerprint techniques. I do not know to take fingerprint of a document or to generate fingerprint of a document. I'm asking if anyone knows the method or has source code for generating fingerprints of documents which is stored in bits form.</p>
| 3 | 2008-09-18T09:25:30Z | 91,238 | <p>If you want <a href="http://en.wikipedia.org/wiki/Cryptographic_hash_function" rel="nofollow">message digests</a> (cryptographic hashes), use the <a href="http://docs.python.org/lib/module-hashlib.html" rel="nofollow">hashlib</a> library. Here's an example (<a href="http://ipython.scipy.org/" rel="nofollow">IPython</a> session):</p>
<pre>
In [1]: import hashlib
In [2]: md = hashlib.sha256(open('/tmp/Calendar.xls', 'rb').read())
In [3]: md.hexdigest()
Out[3]: '8517f1eae176f1a20de78d879f81f23de503cfd6b8e4be1d798fb2342934b187'
</pre>
| 4 | 2008-09-18T09:39:06Z | [
"python",
"diff"
] |
I need to write code in python for comparing text of two documents using fingerprint techniques | 91,183 | <p>I need to write code in python language for comparing the text of document using fingerprint techniques. I do not know to take fingerprint of a document or to generate fingerprint of a document. I'm asking if anyone knows the method or has source code for generating fingerprints of documents which is stored in bits form.</p>
| 3 | 2008-09-18T09:25:30Z | 91,249 | <p>You might try the following papers to get started with the concept of fingerprinting:</p>
<ul>
<li><a href="http://theory.stanford.edu/~aiken/publications/papers/sigmod03.pdf" rel="nofollow">Winnowing: Local Algorithms for Document Fingerprinting</a></li>
<li><a href="http://www.cs.cmu.edu/afs/cs/user/nch/www/koala/main.html" rel="nofollow">Scalable Document Fingerprinting</a></li>
</ul>
| 4 | 2008-09-18T09:41:55Z | [
"python",
"diff"
] |
Subsets and Splits