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 |
|---|---|---|---|---|---|---|---|---|---|
Does an application-wide exception handler make sense? | 95,642 | <p>Long story short, I have a substantial Python application that, among other things, does outcalls to "losetup", "mount", etc. on Linux. Essentially consuming system resources that must be released when complete.</p>
<p>If my application crashes, I want to ensure these system resources are properly released.</p>
<p>Does it make sense to do something like the following?</p>
<pre><code>def main():
# TODO: main application entry point
pass
def cleanup():
# TODO: release system resources here
pass
if __name__ == "__main__":
try:
main()
except:
cleanup()
raise
</code></pre>
<p>Is this something that is typically done? Is there a better way? Perhaps the destructor in a singleton class?</p>
| 10 | 2008-09-18T18:52:30Z | 95,676 | <p>I like top-level exception handlers in general (regardless of language). They're a great place to cleanup resources that may not be immediately related to resources consumed inside the method that throws the exception.</p>
<p>It's also a fantastic place to <strong>log</strong> those exceptions if you have such a framework in place. Top-level handlers will catch those bizarre exceptions you didn't plan on and let you correct them in the future, otherwise, you may never know about them at all.</p>
<p>Just be careful that your top-level handler doesn't throw exceptions!</p>
| 11 | 2008-09-18T18:55:38Z | [
"python",
"exception-handling"
] |
Does an application-wide exception handler make sense? | 95,642 | <p>Long story short, I have a substantial Python application that, among other things, does outcalls to "losetup", "mount", etc. on Linux. Essentially consuming system resources that must be released when complete.</p>
<p>If my application crashes, I want to ensure these system resources are properly released.</p>
<p>Does it make sense to do something like the following?</p>
<pre><code>def main():
# TODO: main application entry point
pass
def cleanup():
# TODO: release system resources here
pass
if __name__ == "__main__":
try:
main()
except:
cleanup()
raise
</code></pre>
<p>Is this something that is typically done? Is there a better way? Perhaps the destructor in a singleton class?</p>
| 10 | 2008-09-18T18:52:30Z | 95,682 | <p>A destructor (as in a __del__ method) is a bad idea, as these are not guaranteed to be called. The atexit module is a safer approach, although these will still not fire if the Python interpreter crashes (rather than the Python application), or if os._exit() is used, or the process is killed aggressively, or the machine reboots. (Of course, the last item isn't an issue in your case.) If your process is crash-prone (it uses fickle third-party extension modules, for instance) you may want to do the cleanup in a simple parent process for more isolation.</p>
<p>If you aren't really worried, use the atexit module.</p>
| 7 | 2008-09-18T18:56:07Z | [
"python",
"exception-handling"
] |
Does an application-wide exception handler make sense? | 95,642 | <p>Long story short, I have a substantial Python application that, among other things, does outcalls to "losetup", "mount", etc. on Linux. Essentially consuming system resources that must be released when complete.</p>
<p>If my application crashes, I want to ensure these system resources are properly released.</p>
<p>Does it make sense to do something like the following?</p>
<pre><code>def main():
# TODO: main application entry point
pass
def cleanup():
# TODO: release system resources here
pass
if __name__ == "__main__":
try:
main()
except:
cleanup()
raise
</code></pre>
<p>Is this something that is typically done? Is there a better way? Perhaps the destructor in a singleton class?</p>
| 10 | 2008-09-18T18:52:30Z | 95,692 | <p>That seems like a reasonable approach, and more straightforward and reliable than a destructor on a singleton class. You might also look at the "<a href="http://docs.python.org/lib/module-atexit.html" rel="nofollow">atexit</a>" module. (Pronounced "at exit", not "a tex it" or something like that. I confused that for a long while.)</p>
| 1 | 2008-09-18T18:56:44Z | [
"python",
"exception-handling"
] |
Does an application-wide exception handler make sense? | 95,642 | <p>Long story short, I have a substantial Python application that, among other things, does outcalls to "losetup", "mount", etc. on Linux. Essentially consuming system resources that must be released when complete.</p>
<p>If my application crashes, I want to ensure these system resources are properly released.</p>
<p>Does it make sense to do something like the following?</p>
<pre><code>def main():
# TODO: main application entry point
pass
def cleanup():
# TODO: release system resources here
pass
if __name__ == "__main__":
try:
main()
except:
cleanup()
raise
</code></pre>
<p>Is this something that is typically done? Is there a better way? Perhaps the destructor in a singleton class?</p>
| 10 | 2008-09-18T18:52:30Z | 98,085 | <p>if you use classes, you should free the resources they allocate in their destructors instead, of course. Use the try: on entire application just if you want to free resources that aren't already liberated by your classes' destructors.</p>
<p>And instead of using a catch-all except:, you should use the following block:</p>
<pre><code>try:
main()
finally:
cleanup()
</code></pre>
<p>That will ensure cleanup in a more pythonic way.</p>
| 2 | 2008-09-18T23:45:15Z | [
"python",
"exception-handling"
] |
Does an application-wide exception handler make sense? | 95,642 | <p>Long story short, I have a substantial Python application that, among other things, does outcalls to "losetup", "mount", etc. on Linux. Essentially consuming system resources that must be released when complete.</p>
<p>If my application crashes, I want to ensure these system resources are properly released.</p>
<p>Does it make sense to do something like the following?</p>
<pre><code>def main():
# TODO: main application entry point
pass
def cleanup():
# TODO: release system resources here
pass
if __name__ == "__main__":
try:
main()
except:
cleanup()
raise
</code></pre>
<p>Is this something that is typically done? Is there a better way? Perhaps the destructor in a singleton class?</p>
| 10 | 2008-09-18T18:52:30Z | 120,224 | <p>Consider writing a context manager and using the with statement.</p>
| 1 | 2008-09-23T10:26:25Z | [
"python",
"exception-handling"
] |
Python reading Oracle path | 95,950 | <p>On my desktop I have written a small Pylons app that connects to Oracle. I'm now trying to deploy it to my server which is running Win2k3 x64. (My desktop is 32-bit XP) The Oracle installation on the server is also 64-bit.</p>
<p>I was getting errors about loading the OCI dll, so I installed the 32 bit client into <code>C:\oracle32</code>.</p>
<p>If I add this to the <code>PATH</code> environment variable, it works great. But I also want to run the Pylons app as a service (<a href="http://wiki.pylonshq.com/display/pylonscookbook/How+to+run+Pylons+as+a+Windows+service" rel="nofollow">using this recipe</a>) and don't want to put this 32-bit library on the path for all other applications. </p>
<p>I tried using <code>sys.path.append("C:\\oracle32\\bin")</code> but that doesn't seem to work.</p>
| 0 | 2008-09-18T19:19:43Z | 96,016 | <p>sys.path is python's internal representation of the PYTHONPATH, it sounds to me like you want to modify the PATH.</p>
<p>I'm not sure that this will work, but you can try:</p>
<pre><code>import os
os.environ['PATH'] += os.pathsep + "C:\\oracle32\\bin"
</code></pre>
| 2 | 2008-09-18T19:26:04Z | [
"python",
"oracle",
"pylons",
"cx-oracle"
] |
Python reading Oracle path | 95,950 | <p>On my desktop I have written a small Pylons app that connects to Oracle. I'm now trying to deploy it to my server which is running Win2k3 x64. (My desktop is 32-bit XP) The Oracle installation on the server is also 64-bit.</p>
<p>I was getting errors about loading the OCI dll, so I installed the 32 bit client into <code>C:\oracle32</code>.</p>
<p>If I add this to the <code>PATH</code> environment variable, it works great. But I also want to run the Pylons app as a service (<a href="http://wiki.pylonshq.com/display/pylonscookbook/How+to+run+Pylons+as+a+Windows+service" rel="nofollow">using this recipe</a>) and don't want to put this 32-bit library on the path for all other applications. </p>
<p>I tried using <code>sys.path.append("C:\\oracle32\\bin")</code> but that doesn't seem to work.</p>
| 0 | 2008-09-18T19:19:43Z | 125,163 | <p>You need to append the c:\Oracle32\bin directory to the PATH variable of your environment before you execute python.exe.<br>
In Linux, I need to set up the LD_LIBRARY_PATH variable for similar reasons, to locate the Oracle libraries, before calling python. I use wrapper shell scripts that set the variable and then call Python.<br>
In your case, maybe you can call, in the service startup, a .cmd or .vbs script that sets the PATH variable and then calls python.exe with your .py script.</p>
<p>I hope this helps!</p>
| 0 | 2008-09-24T02:58:07Z | [
"python",
"oracle",
"pylons",
"cx-oracle"
] |
Python reading Oracle path | 95,950 | <p>On my desktop I have written a small Pylons app that connects to Oracle. I'm now trying to deploy it to my server which is running Win2k3 x64. (My desktop is 32-bit XP) The Oracle installation on the server is also 64-bit.</p>
<p>I was getting errors about loading the OCI dll, so I installed the 32 bit client into <code>C:\oracle32</code>.</p>
<p>If I add this to the <code>PATH</code> environment variable, it works great. But I also want to run the Pylons app as a service (<a href="http://wiki.pylonshq.com/display/pylonscookbook/How+to+run+Pylons+as+a+Windows+service" rel="nofollow">using this recipe</a>) and don't want to put this 32-bit library on the path for all other applications. </p>
<p>I tried using <code>sys.path.append("C:\\oracle32\\bin")</code> but that doesn't seem to work.</p>
| 0 | 2008-09-18T19:19:43Z | 142,775 | <p>If your Python application runs in the 64-bit space, you will need to access a 64-bit installation of Oracle's oci.dll, rather than the 32-bit version. Normally you would update the system path to include the appropriate Oracle Home bin directory, prior to running the script. The solution may also vary depending on what component you are using to access Oracle from Python.</p>
| 0 | 2008-09-27T02:21:39Z | [
"python",
"oracle",
"pylons",
"cx-oracle"
] |
How to associated the cn in an ssl cert of pyOpenSSL verify_cb to a generated socket | 96,508 | <p>I am a little new to pyOpenSSL. I am trying to figure out how to associate the generated socket to an ssl cert. verify_cb gets called which give me access to the cert and a conn but how do I associate those things when this happens:</p>
<p>cli,addr = self.server.accept()</p>
| 3 | 2008-09-18T20:24:43Z | 96,797 | <p>After the handshake is complete, you can get the client certificate. While the client certificate is also available in the verify callback (verify_cb), there's not really any reason to try to do anything aside from verify the certificate in that callback. Setting up an application-specific mapping is better done after the handshake has completely successfully. So, consider using the OpenSSL.SSL.Connection instance returned by the accept method to get the certificate (and from there, the commonName) and associate it with the connection object at that point. For example,</p>
<pre><code>client, clientAddress = self.server.accept()
client.do_handshake()
commonNamesToConnections[client.get_peer_certificate().commonName] = client
</code></pre>
<p>You might want to check the mapping to make sure you're not overwriting any existing connection (perhaps using a list of connections instead of just mapping each common name to one). And of course you need to remove entries when connections are lost.</p>
<p>The `do_handshake´ call forces the handshake to actually happen. Without this, the handshake will happen when application data is first transferred over the connection. That's fine, but it would make setting up this mapping slightly more complicated.</p>
| 4 | 2008-09-18T20:49:43Z | [
"python",
"pyopenssl"
] |
How to load a python module into a fresh interactive shell in Komodo? | 97,513 | <p>When using PyWin I can easily load a python file into a fresh interactive shell and I find this quite handy for prototyping and other exploratory tasks.</p>
<p>I would like to use Komodo as my python editor, but I haven't found a replacement for PyWin's ability to restart the shell and reload the current module. How can I do this in Komodo?</p>
<p>It is also very important to me that when I reload I get a fresh shell. I would prefer it if my previous interactions are in the shell history, but it is more important to me that the memory be isolated from the previous versions and attempts.</p>
| 2 | 2008-09-18T22:09:21Z | 97,635 | <p>I use Komodo Edit, which might be a little less sophisticated than full Komodo.</p>
<p>I create a "New Command" with <code>%(python) -i %f</code> as the text of the command. I have this run in a "New Console". I usually have the starting directory as %p, the top of the project directory.</p>
<p>The -i option runs the file and drops into interactive Python.</p>
| 5 | 2008-09-18T22:25:29Z | [
"python",
"shell",
"interpreter",
"komodo"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,146 | <p>Any particular reason you want to use Django's templates? Both <a href="http://jinja.pocoo.org/">Jinja</a> and <a href="http://genshi.edgewall.org/">Genshi</a> are, in my opinion, superior.</p>
<p><hr /></p>
<p>If you really want to, then see the <a href="http://docs.djangoproject.com/en/dev/topics/settings/#topics-settings">Django documentation on <code>settings.py</code></a>. Especially the section "Using settings without setting <code>DJANGO_SETTINGS_MODULE</code>". Use something like this:</p>
<pre><code>from django.conf import settings
settings.configure (FOO='bar') # Your settings go here
</code></pre>
| 8 | 2008-09-18T23:56:36Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,150 | <p>Google <code>AppEngine</code> uses the Django templating engine, have you taken a look at how they do it? You could possibly just use that.</p>
| 0 | 2008-09-18T23:57:12Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,154 | <p>Found this:</p>
<p><a href="http://snippets.dzone.com/posts/show/3339" rel="nofollow">http://snippets.dzone.com/posts/show/3339</a></p>
| 1 | 2008-09-18T23:58:12Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,178 | <p>The solution is simple. It's actually <a href="http://docs.djangoproject.com/en/dev/ref/templates/api/#configuring-the-template-system-in-standalone-mode">well documented</a>, but not too easy to find. (I had to dig around -- it didn't come up when I tried a few different Google searches.)</p>
<p>The following code works:</p>
<pre><code>>>> from django.template import Template, Context
>>> from django.conf import settings
>>> settings.configure()
>>> t = Template('My name is {{ my_name }}.')
>>> c = Context({'my_name': 'Daryl Spitzer'})
>>> t.render(c)
u'My name is Daryl Spitzer.'
</code></pre>
<p>See the Django documentation (linked above) for a description of some of the settings you may want to define (as keyword arguments to configure).</p>
| 117 | 2008-09-19T00:01:39Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,214 | <p><a href="http://jinja.pocoo.org/2/">Jinja2</a> <a href="http://jinja.pocoo.org/2/documentation/templates">syntax</a> is pretty much the same as Django's with very few differences, and you get a much more powerfull template engine, which also compiles your template to bytecode (FAST!).</p>
<p>I use it for templating, including in Django itself, and it is very good. You can also easily write extensions if some feature you want is missing.</p>
<p>Here is some demonstration of the code generation:</p>
<pre><code>>>> import jinja2
>>> print jinja2.Environment().compile('{% for row in data %}{{ row.name | upper }}{% endfor %}', raw=True)
from __future__ import division
from jinja2.runtime import LoopContext, Context, TemplateReference, Macro, Markup, TemplateRuntimeError, missing, concat, escape, markup_join, unicode_join
name = None
def root(context, environment=environment):
l_data = context.resolve('data')
t_1 = environment.filters['upper']
if 0: yield None
for l_row in l_data:
if 0: yield None
yield unicode(t_1(environment.getattr(l_row, 'name')))
blocks = {}
debug_info = '1=9'
</code></pre>
| 38 | 2008-09-19T00:08:41Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 98,276 | <p>I echo the above statements. Jinja 2 is a pretty good superset of Django templates for general use. I think they're working on making the Django templates a little less coupled to the settings.py, but Jinja should do well for you.</p>
| 0 | 2008-09-19T00:18:31Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 109,380 | <p>I would also recommend jinja2. There is a <a href="https://web.archive.org/web/20090421084229/http://lucumr.pocoo.org/2008/9/16/why-jinja-is-not-django-and-why-django-should-have-a-look-at-it" rel="nofollow">nice article</a> on <code>django</code> vs. <code>jinja2</code> that gives some in-detail information on why you should prefere the later.</p>
| 7 | 2008-09-20T21:02:58Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 304,195 | <p>Don't. Use <a href="http://www.stringtemplate.org/" rel="nofollow">StringTemplate</a> instead--there is no reason to consider any other template engine once you know about it.</p>
| 1 | 2008-11-20T02:43:43Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 345,360 | <p>I would say <a href="http://jinja.pocoo.org/" rel="nofollow">Jinja</a> as well. It is definitely <strong>more powerful</strong> than Django Templating Engine and it is <strong>stand alone</strong>.</p>
<p>If this was an external plug to an existing Django application, you could create <a href="http://docs.djangoproject.com/en/dev/howto/custom-management-commands/#howto-custom-management-commands" rel="nofollow">a custom command</a> and use the templating engine within your projects environment. Like this;</p>
<pre><code>manage.py generatereports --format=html
</code></pre>
<p>But I don't think it is worth just using the Django Templating Engine instead of Jinja.</p>
| 2 | 2008-12-05T22:15:35Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 11,519,049 | <p>While running the <code>manage.py</code> shell:</p>
<pre><code>>>> from django import template
>>> t = template.Template('My name is {{ me }}.')
>>> c = template.Context({'me': 'ShuJi'})
>>> t.render(c)
</code></pre>
| 0 | 2012-07-17T08:50:43Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 20,480,267 | <p>Thanks for the help folks. Here is one more addition. The case where you need to use custom template tags.</p>
<p>Let's say you have this important template tag in the module read.py</p>
<pre><code>from django import template
register = template.Library()
@register.filter(name='bracewrap')
def bracewrap(value):
return "{" + value + "}"
</code></pre>
<p>This is the html template file "temp.html":</p>
<pre><code>{{var|bracewrap}}
</code></pre>
<p>Finally, here is a Python script that will tie to all together</p>
<pre><code>import django
from django.conf import settings
from django.template import Template, Context
import os
#load your tags
from django.template.loader import get_template
django.template.base.add_to_builtins("read")
# You need to configure Django a bit
settings.configure(
TEMPLATE_DIRS=(os.path.dirname(os.path.realpath(__file__)), ),
)
#or it could be in python
#t = Template('My name is {{ my_name }}.')
c = Context({'var': 'stackoverflow.com rox'})
template = get_template("temp.html")
# Prepare context ....
print template.render(c)
</code></pre>
<p>The output would be</p>
<pre><code>{stackoverflow.com rox}
</code></pre>
| 2 | 2013-12-09T20:37:34Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
How do I use Django templates without the rest of Django? | 98,135 | <p>I want to use the Django template engine in my (Python) code, but I'm not building a Django-based web site. How do I use it without having a settings.py file (and others) and having to set the DJANGO_SETTINGS_MODULE environment variable?</p>
<p>If I run the following code:</p>
<pre><code>>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')
</code></pre>
<p>I get:</p>
<pre><code>ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.
</code></pre>
| 85 | 2008-09-18T23:55:21Z | 34,494,931 | <p>According to the Jinja documentation, <a href="http://jinja.pocoo.org/docs/dev/intro/#experimental-python-3-support" rel="nofollow">Python 3 support is still experimental</a>. So if you are on Python 3 and performance is not an issue, you can use django's built in template engine. </p>
<p>Django 1.8 introduced support for <a href="https://docs.djangoproject.com/en/1.9/releases/1.8/#multiple-template-engines" rel="nofollow">multiple template engines</a> which requires a change to the way templates are initialized. You have to explicitly configure <code>settings.DEBUG</code> which is used by the default template engine provided by django. Here's the code to use templates without using the rest of django. </p>
<pre><code>from django.template import Template, Context
from django.template.engine import Engine
from django.conf import settings
settings.configure(DEBUG=False)
template_string = "Hello {{ name }}"
template = Template(template_string, engine=Engine())
context = Context({"name": "world"})
output = template.render(context) #"hello world"
</code></pre>
| 0 | 2015-12-28T14:00:18Z | [
"python",
"django",
"templates",
"django-templates",
"template-engine"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 98,703 | <p>Wrap your connection class.</p>
<p>Set a limit on how many connections you make.
Return an unused connection.
Intercept close to free the connection.</p>
<p>Update:
I put something like this in dbpool.py:</p>
<pre><code>import sqlalchemy.pool as pool
import MySQLdb as mysql
mysql = pool.manage(mysql)
</code></pre>
| 11 | 2008-09-19T01:38:19Z | [
"python",
"mysql",
"connection-pooling"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 98,906 | <p>IMO, the "more obvious/more idiomatic/better solution" is to use an existing ORM rather than invent DAO-like classes.</p>
<p>It appears to me that ORM's are more popular than "raw" SQL connections. Why? Because Python <em>is</em> OO, and the mapping from SQL row to to object <em>is</em> absolutely essential. There aren't many cases where you deal with SQL rows that don't map to Python objects.</p>
<p>I think that <a href="http://www.sqlalchemy.org/">SQLAlchemy</a> or <a href="http://www.sqlobject.org/">SQLObject</a> (and the associated connection pooling) the more idiomatic Pythonic solution.</p>
<p>Pooling as a separate feature isn't very common because pure SQL (without object mapping) isn't very popular for the kind of complex, long-running processes that benefit from connection pooling. Yes, pure SQL <em>is</em> used, but it's always used in simpler or more controlled applications where pooling isn't helpful.</p>
<p>I think you might have two alternatives:</p>
<ol>
<li>Revise your classes to use SQLAlchemy or SQLObject. While this appears painful at first [all that work wasted], you should be able to leverage all the design and thought and it's merely an exercise in adopting a widely-used ORM and pooling solution.</li>
<li>Roll your own simple connection pool using the algorithm you outlined -- a simple Set or List of connections that you cycle through. </li>
</ol>
| 12 | 2008-09-19T02:13:07Z | [
"python",
"mysql",
"connection-pooling"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 99,565 | <p>In MySQL?</p>
<p>I'd say don't bother with the connection pooling. They're often a source of trouble and with MySQL they're not going to bring you the performance advantage you're hoping for. This road may be a lot of effort to follow--politically--because there's so much best practices hand waving and textbook verbiage in this space about the advantages of connection pooling.</p>
<p>Connection pools are simply a bridge between the post-web era of stateless applications (e.g. HTTP protocol) and the pre-web era of stateful long-lived batch processing applications. Since connections were very expensive in pre-web databases (since no one used to care too much about how long a connection took to establish), post-web applications devised this connection pool scheme so that every hit didn't incur this huge processing overhead on the RDBMS.</p>
<p>Since MySQL is more of a web-era RDBMS, connections are extremely lightweight and fast. I have written many high volume web applications that don't use a connection pool at all for MySQL.</p>
<p>This is a complication you may benefit from doing without, so long as there isn't a political obstacle to overcome.</p>
| 21 | 2008-09-19T04:11:38Z | [
"python",
"mysql",
"connection-pooling"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 864,728 | <p>I've just been looking for the same sort of thing.</p>
<p>I've found <a href="http://code.google.com/p/pysqlpool/" rel="nofollow">pysqlpool</a> and the <a href="http://www.sqlalchemy.org/docs/04/pooling.html" rel="nofollow">sqlalchemy pool module</a></p>
| 1 | 2009-05-14T17:41:51Z | [
"python",
"mysql",
"connection-pooling"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 7,154,158 | <p>Making your own connection pool is a BAD idea if your app ever decides to start using multi-threading. Making a connection pool for a multi-threaded application is much more complicated than one for a single-threaded application. You can use something like PySQLPool in that case.</p>
<p>It's also a BAD idea to use an ORM if you're looking for performance.</p>
<p>If you'll be dealing with huge/heavy databases that have to handle lots of selects, inserts,
updates and deletes at the same time, then you're going to need performance, which means you'll need custom SQL written to optimize lookups and lock times. With an ORM you don't usually have that flexibility.</p>
<p>So basically, yeah, you can make your own connection pool and use ORMs but only if you're sure you won't need anything of what I just described.</p>
| 2 | 2011-08-22T22:05:55Z | [
"python",
"mysql",
"connection-pooling"
] |
What is the best solution for database connection pooling in python? | 98,687 | <p>I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework. </p>
<p>The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect. </p>
<p>What is the best "drop in" solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java. </p>
<p>The process is long running and has many threads that need to make requests, but not all at the same time... specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.</p>
<p>Edited to add:
After some more searching I found <a href="http://furius.ca/antiorm/">anitpool.py</a> which looks decent, but as I'm relatively new to python I guess I just want to make sure I'm not missing a more obvious/more idiomatic/better solution. </p>
| 24 | 2008-09-19T01:36:03Z | 24,741,694 | <p>Old thread, but for general-purpose pooling (connections or any expensive object), I use something like:</p>
<pre><code>def pool(ctor, limit=None):
local_pool = multiprocessing.Queue()
n = multiprocesing.Value('i', 0)
@contextlib.contextmanager
def pooled(ctor=ctor, lpool=local_pool, n=n):
# block iff at limit
try: i = lpool.get(limit and n.value >= limit)
except multiprocessing.queues.Empty:
n.value += 1
i = ctor()
yield i
lpool.put(i)
return pooled
</code></pre>
<p>Which constructs lazily, has an optional limit, and should generalize to any use case I can think of. Of course, this assumes that you really need the pooling of whatever resource, which you may not for many modern SQL-likes. Usage:</p>
<pre><code># in main:
my_pool = pool(lambda: do_something())
# in thread:
with my_pool() as my_obj:
my_obj.do_something()
</code></pre>
<p>This does assume that whatever object ctor creates has an appropriate destructor if needed (some servers don't kill connection objects unless they are closed explicitly).</p>
| 2 | 2014-07-14T16:53:14Z | [
"python",
"mysql",
"connection-pooling"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 100,037 | <p>Metaclasses are the secret sauce that make 'class' work. The default metaclass for a new style object is called 'type'.</p>
<pre class="lang-none prettyprint-override"><code>class type(object)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
</code></pre>
<p>Metaclasses take 3 args. '<strong>name</strong>', '<strong>bases</strong>' and '<strong>dict</strong>'</p>
<p>Here is where the secret starts. Look for where name, bases and the dict come from in this example class definition.</p>
<pre><code>class ThisIsTheName(Bases, Are, Here):
All_the_code_here
def doesIs(create, a):
dict
</code></pre>
<p>Lets define a metaclass that will demonstrate how '<strong>class:</strong>' calls it.</p>
<pre><code>def test_metaclass(name, bases, dict):
print 'The Class Name is', name
print 'The Class Bases are', bases
print 'The dict has', len(dict), 'elems, the keys are', dict.keys()
return "yellow"
class TestName(object, None, int, 1):
__metaclass__ = test_metaclass
foo = 1
def baz(self, arr):
pass
print 'TestName = ', repr(TestName)
# output =>
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName = 'yellow'
</code></pre>
<p>And now, an example that actually means something, this will automatically make the variables in the list "attributes" set on the class, and set to None.</p>
<pre><code>def init_attributes(name, bases, dict):
if 'attributes' in dict:
for attr in dict['attributes']:
dict[attr] = None
return type(name, bases, dict)
class Initialised(object):
__metaclass__ = init_attributes
attributes = ['foo', 'bar', 'baz']
print 'foo =>', Initialised.foo
# output=>
foo => None
</code></pre>
<p>Note that the magic behaviour that 'Initalised' gains by having the metaclass <code>init_attributes</code> is not passed onto a subclass of Initalised.</p>
<p>Here is an even more concrete example, showing how you can subclass 'type' to make a metaclass that performs an action when the class is created. This is quite tricky:</p>
<pre><code>class MetaSingleton(type):
instance = None
def __call__(cls, *args, **kw):
if cls.instance is None:
cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
return cls.instance
class Foo(object):
__metaclass__ = MetaSingleton
a = Foo()
b = Foo()
assert a is b
</code></pre>
| 217 | 2008-09-19T06:26:10Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 100,059 | <p>I think the ONLamp introduction to metaclass programming is well written and gives a really good introduction to the topic despite being several years old already.</p>
<p><a href="http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html">http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html</a></p>
<p>In short: A class is a blueprint for the creation of an instance, a metaclass is a blueprint for the creation of a class. It can be easily seen that in Python classes need to be first-class objects too to enable this behavior.</p>
<p>I've never written one myself, but I think one of the nicest uses of metaclasses can be seen in the <a href="http://www.djangoproject.com/">Django framework</a>. The model classes use a metaclass approach to enable a declarative style of writing new models or form classes. While the metaclass is creating the class, all members get the possibility to customize the class itself.</p>
<ul>
<li><a href="http://docs.djangoproject.com/en/dev/intro/tutorial01/#id3">Creating a new model</a></li>
<li><a href="http://code.djangoproject.com/browser/django/trunk/django/db/models/base.py#L25">The metaclass enabling this</a></li>
</ul>
<p>The thing that's left to say is: If you don't know what metaclasses are, the probability that you <strong>will not need them</strong> is 99%.</p>
| 56 | 2008-09-19T06:32:58Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 100,091 | <p>One use for metaclasses is adding new properties and methods to an instance automatically.</p>
<p>For example, if you look at <a href="http://docs.djangoproject.com/en/dev/topics/db/models/">Django models</a>, their definition looks a bit confusing. It looks as if you are only defining class properties:</p>
<pre><code>class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
</code></pre>
<p>However, at runtime the Person objects are filled with all sorts of useful methods. See the <a href="http://code.djangoproject.com/browser/django/trunk/django/db/models/base.py">source</a> for some amazing metaclassery.</p>
| 82 | 2008-09-19T06:45:40Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 100,146 | <p>A metaclass is the class of a class. Like a class defines how an instance of the class behaves, a metaclass defines how a class behaves. A class is an instance of a metaclass.</p>
<p><a href="http://i.stack.imgur.com/QQ0OK.png"><img src="http://i.stack.imgur.com/QQ0OK.png" alt="metaclass diagram"></a></p>
<p>While in Python you can use arbitrary callables for metaclasses (like <a href="http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python/100037#100037">Jerub</a> shows), the more useful approach is actually to make it an actual class itself. <code>type</code> is the usual metaclass in Python. In case you're wondering, yes, <code>type</code> is itself a class, and it is its own type. You won't be able to recreate something like <code>type</code> purely in Python, but Python cheats a little. To create your own metaclass in Python you really just want to subclass <code>type</code>.</p>
<p>A metaclass is most commonly used as a class-factory. Like you create an instance of the class by calling the class, Python creates a new class (when it executes the 'class' statement) by calling the metaclass. Combined with the normal <code>__init__</code> and <code>__new__</code> methods, metaclasses therefore allow you to do 'extra things' when creating a class, like registering the new class with some registry, or even replace the class with something else entirely.</p>
<p>When the <code>class</code> statement is executed, Python first executes the body of the <code>class</code> statement as a normal block of code. The resulting namespace (a dict) holds the attributes of the class-to-be. The metaclass is determined by looking at the baseclasses of the class-to-be (metaclasses are inherited), at the <code>__metaclass__</code> attribute of the class-to-be (if any) or the <code>__metaclass__</code> global variable. The metaclass is then called with the name, bases and attributes of the class to instantiate it.</p>
<p>However, metaclasses actually define the <em>type</em> of a class, not just a factory for it, so you can do much more with them. You can, for instance, define normal methods on the metaclass. These metaclass-methods are like classmethods, in that they can be called on the class without an instance, but they are also not like classmethods in that they cannot be called on an instance of the class. <code>type.__subclasses__()</code> is an example of a method on the <code>type</code> metaclass. You can also define the normal 'magic' methods, like <code>__add__</code>, <code>__iter__</code> and <code>__getattr__</code>, to implement or change how the class behaves.</p>
<p>Here's an aggregated example of the bits and pieces:</p>
<pre><code>def make_hook(f):
"""Decorator to turn 'foo' method into '__foo__'"""
f.is_hook = 1
return f
class MyType(type):
def __new__(cls, name, bases, attrs):
if name.startswith('None'):
return None
# Go over attributes and see if they should be renamed.
newattrs = {}
for attrname, attrvalue in attrs.iteritems():
if getattr(attrvalue, 'is_hook', 0):
newattrs['__%s__' % attrname] = attrvalue
else:
newattrs[attrname] = attrvalue
return super(MyType, cls).__new__(cls, name, bases, newattrs)
def __init__(self, name, bases, attrs):
super(MyType, self).__init__(name, bases, attrs)
# classregistry.register(self, self.interfaces)
print "Would register class %s now." % self
def __add__(self, other):
class AutoClass(self, other):
pass
return AutoClass
# Alternatively, to autogenerate the classname as well as the class:
# return type(self.__name__ + other.__name__, (self, other), {})
def unregister(self):
# classregistry.unregister(self)
print "Would unregister class %s now." % self
class MyObject:
__metaclass__ = MyType
class NoneSample(MyObject):
pass
# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)
class Example(MyObject):
def __init__(self, value):
self.value = value
@make_hook
def add(self, other):
return self.__class__(self.value + other.value)
# Will unregister the class
Example.unregister()
inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()
print inst + inst
class Sibling(MyObject):
pass
ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__
</code></pre>
| 1,179 | 2008-09-19T07:01:58Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 6,428,779 | <p>Others have explained how metaclasses work and how they fit into the Python type system. Here's an example of what they can be used for. In a testing framework I wrote, I wanted to keep track of the order in which classes were defined, so that I could later instantiate them in this order. I found it easiest to do this using a metaclass.</p>
<pre><code>class MyMeta(type):
counter = 0
def __init__(cls, name, bases, dic):
type.__init__(cls, name, bases, dic)
cls._order = MyMeta.counter
MyMeta.counter += 1
class MyType(object):
__metaclass__ = MyMeta
</code></pre>
<p>Anything that's a subclass of <code>MyType</code> then gets a class attribute <code>_order</code> that records the order in which the classes were defined.</p>
| 70 | 2011-06-21T16:30:26Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 6,581,949 | <h1>Classes as objects</h1>
<p>Before understanding metaclasses, you need to master classes in Python. And Python has a very peculiar idea of what classes are, borrowed from the Smalltalk language.</p>
<p>In most languages, classes are just pieces of code that describe how to produce an object. That's kinda true in Python too:</p>
<pre><code>>>> class ObjectCreator(object):
... pass
...
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>
</code></pre>
<p>But classes are more than that in Python. Classes are objects too.</p>
<p>Yes, objects. </p>
<p>As soon as you use the keyword <code>class</code>, Python executes it and creates
an OBJECT. The instruction</p>
<pre><code>>>> class ObjectCreator(object):
... pass
...
</code></pre>
<p>creates in memory an object with the name "ObjectCreator". </p>
<p><strong>This object (the class) is itself capable of creating objects (the instances),
and this is why it's a class</strong>. </p>
<p>But still, it's an object, and therefore:</p>
<ul>
<li>you can assign it to a variable</li>
<li>you can copy it</li>
<li>you can add attributes to it</li>
<li>you can pass it as a function parameter</li>
</ul>
<p>e.g.:</p>
<pre><code>>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
... print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>
</code></pre>
<h1>Creating classes dynamically</h1>
<p>Since classes are objects, you can create them on the fly, like any object.</p>
<p>First, you can create a class in a function using <code>class</code>:</p>
<pre><code>>>> def choose_class(name):
... if name == 'foo':
... class Foo(object):
... pass
... return Foo # return the class, not an instance
... else:
... class Bar(object):
... pass
... return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>
</code></pre>
<p>But it's not so dynamic, since you still have to write the whole class yourself.</p>
<p>Since classes are objects, they must be generated by something.</p>
<p>When you use the <code>class</code> keyword, Python creates this object automatically. But as
with most things in Python, it gives you a way to do it manually.</p>
<p>Remember the function <code>type</code>? The good old function that lets you know what
type an object is:</p>
<pre><code>>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>
</code></pre>
<p>Well, <a href="http://docs.python.org/2/library/functions.html#type"><code>type</code></a> has a completely different ability, it can also create classes on the fly. <code>type</code> can take the description of a class as parameters,
and return a class.</p>
<p>(I know, it's silly that the same function can have two completely different uses according to the parameters you pass to it. It's an issue due to backwards
compatibility in Python)</p>
<p><code>type</code> works this way:</p>
<pre><code>type(name of the class,
tuple of the parent class (for inheritance, can be empty),
dictionary containing attributes names and values)
</code></pre>
<p>e.g.:</p>
<pre><code>>>> class MyShinyClass(object):
... pass
</code></pre>
<p>can be created manually this way:</p>
<pre><code>>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>
</code></pre>
<p>You'll notice that we use "MyShinyClass" as the name of the class
and as the variable to hold the class reference. They can be different,
but there is no reason to complicate things.</p>
<p><code>type</code> accepts a dictionary to define the attributes of the class. So:</p>
<pre><code>>>> class Foo(object):
... bar = True
</code></pre>
<p>Can be translated to:</p>
<pre><code>>>> Foo = type('Foo', (), {'bar':True})
</code></pre>
<p>And used as a normal class:</p>
<pre><code>>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True
</code></pre>
<p>And of course, you can inherit from it, so:</p>
<pre><code>>>> class FooChild(Foo):
... pass
</code></pre>
<p>would be:</p>
<pre><code>>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True
</code></pre>
<p>Eventually you'll want to add methods to your class. Just define a function
with the proper signature and assign it as an attribute.</p>
<pre><code>>>> def echo_bar(self):
... print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True
</code></pre>
<p>And you can add even more methods after you dynamically create the class, just like adding methods to a normally created class object.</p>
<pre><code>>>> def echo_bar_more(self):
... print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True
</code></pre>
<p>You see where we are going: in Python, classes are objects, and you can create a class on the fly, dynamically.</p>
<p>This is what Python does when you use the keyword <code>class</code>, and it does so by using a metaclass.</p>
<h1>What are metaclasses (finally)</h1>
<p>Metaclasses are the 'stuff' that creates classes.</p>
<p>You define classes in order to create objects, right?</p>
<p>But we learned that Python classes are objects.</p>
<p>Well, metaclasses are what create these objects. They are the classes' classes,
you can picture them this way:</p>
<pre><code>MyClass = MetaClass()
MyObject = MyClass()
</code></pre>
<p>You've seen that <code>type</code> lets you do something like this:</p>
<pre><code>MyClass = type('MyClass', (), {})
</code></pre>
<p>It's because the function <code>type</code> is in fact a metaclass. <code>type</code> is the
metaclass Python uses to create all classes behind the scenes.</p>
<p>Now you wonder why the heck is it written in lowercase, and not <code>Type</code>?</p>
<p>Well, I guess it's a matter of consistency with <code>str</code>, the class that creates
strings objects, and <code>int</code> the class that creates integer objects. <code>type</code> is
just the class that creates class objects.</p>
<p>You see that by checking the <code>__class__</code> attribute. </p>
<p>Everything, and I mean everything, is an object in Python. That includes ints,
strings, functions and classes. All of them are objects. And all of them have
been created from a class:</p>
<pre><code>>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>
</code></pre>
<p>Now, what is the <code>__class__</code> of any <code>__class__</code> ?</p>
<pre><code>>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>
</code></pre>
<p>So, a metaclass is just the stuff that creates class objects.</p>
<p>You can call it a 'class factory' if you wish.</p>
<p><code>type</code> is the built-in metaclass Python uses, but of course, you can create your
own metaclass.</p>
<h1>The <a href="http://docs.python.org/2/reference/datamodel.html?highlight=__metaclass__#__metaclass__"><code>__metaclass__</code></a> attribute</h1>
<p>You can add a <code>__metaclass__</code> attribute when you write a class:</p>
<pre><code>class Foo(object):
__metaclass__ = something...
[...]
</code></pre>
<p>If you do so, Python will use the metaclass to create the class <code>Foo</code>.</p>
<p>Careful, it's tricky.</p>
<p>You write <code>class Foo(object)</code> first, but the class object <code>Foo</code> is not created
in memory yet.</p>
<p>Python will look for <code>__metaclass__</code> in the class definition. If it finds it,
it will use it to create the object class <code>Foo</code>. If it doesn't, it will use
<code>type</code> to create the class.</p>
<p>Read that several times.</p>
<p>When you do:</p>
<pre><code>class Foo(Bar):
pass
</code></pre>
<p>Python does the following:</p>
<p>Is there a <code>__metaclass__</code> attribute in <code>Foo</code>?</p>
<p>If yes, create in memory a class object (I said a class object, stay with me here), with the name <code>Foo</code> by using what is in <code>__metaclass__</code>.</p>
<p>If Python can't find <code>__metaclass__</code>, it will look for a <code>__metaclass__</code> at the MODULE level, and try to do the same (but only for classes that don't inherit anything, basically old-style classes). </p>
<p>Then if it can't find any <code>__metaclass__</code> at all, it will use the <code>Bar</code>'s (the first parent) own metaclass (which might be the default <code>type</code>) to create the class object.</p>
<p>Be careful here that the <code>__metaclass__</code> attribute will not be inherited, the metaclass of the parent (<code>Bar.__class__</code>) will be. If <code>Bar</code> used a <code>__metaclass__</code> attribute that created <code>Bar</code> with <code>type()</code> (and not <code>type.__new__()</code>), the subclasses will not inherit that behavior.</p>
<p>Now the big question is, what can you put in <code>__metaclass__</code> ?</p>
<p>The answer is: something that can create a class.</p>
<p>And what can create a class? <code>type</code>, or anything that subclasses or uses it.</p>
<h1>Custom metaclasses</h1>
<p>The main purpose of a metaclass is to change the class automatically,
when it's created.</p>
<p>You usually do this for APIs, where you want to create classes matching the
current context.</p>
<p>Imagine a stupid example, where you decide that all classes in your module
should have their attributes written in uppercase. There are several ways to
do this, but one way is to set <code>__metaclass__</code> at the module level.</p>
<p>This way, all classes of this module will be created using this metaclass,
and we just have to tell the metaclass to turn all attributes to uppercase.</p>
<p>Luckily, <code>__metaclass__</code> can actually be any callable, it doesn't need to be a
formal class (I know, something with 'class' in its name doesn't need to be
a class, go figure... but it's helpful).</p>
<p>So we will start with a simple example, by using a function.</p>
<pre><code># the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
"""
Return a class object, with the list of its attribute turned
into uppercase.
"""
# pick up any attribute that doesn't start with '__' and uppercase it
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
# let `type` do the class creation
return type(future_class_name, future_class_parents, uppercase_attr)
__metaclass__ = upper_attr # this will affect all classes in the module
class Foo(): # global __metaclass__ won't work with "object" though
# but we can define __metaclass__ here instead to affect only this class
# and this will work with "object" children
bar = 'bip'
print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True
f = Foo()
print(f.BAR)
# Out: 'bip'
</code></pre>
<p>Now, let's do exactly the same, but using a real class for a metaclass:</p>
<pre><code># remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
# __new__ is the method called before __init__
# it's the method that creates the object and returns it
# while __init__ just initializes the object passed as parameter
# you rarely use __new__, except when you want to control how the object
# is created.
# here the created object is the class, and we want to customize it
# so we override __new__
# you can do some stuff in __init__ too if you wish
# some advanced use involves overriding __call__ as well, but we won't
# see this
def __new__(upperattr_metaclass, future_class_name,
future_class_parents, future_class_attr):
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return type(future_class_name, future_class_parents, uppercase_attr)
</code></pre>
<p>But this is not really OOP. We call <code>type</code> directly and we don't override
or call the parent <code>__new__</code>. Let's do it:</p>
<pre><code>class UpperAttrMetaclass(type):
def __new__(upperattr_metaclass, future_class_name,
future_class_parents, future_class_attr):
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
# reuse the type.__new__ method
# this is basic OOP, nothing magic in there
return type.__new__(upperattr_metaclass, future_class_name,
future_class_parents, uppercase_attr)
</code></pre>
<p>You may have noticed the extra argument <code>upperattr_metaclass</code>. There is
nothing special about it: <code>__new__</code> always receives the class it's defined in, as first parameter. Just like you have <code>self</code> for ordinary methods which receive the instance as first parameter, or the defining class for class methods.</p>
<p>Of course, the names I used here are long for the sake of clarity, but like
for <code>self</code>, all the arguments have conventional names. So a real production
metaclass would look like this:</p>
<pre><code>class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return type.__new__(cls, clsname, bases, uppercase_attr)
</code></pre>
<p>We can make it even cleaner by using <code>super</code>, which will ease inheritance (because yes, you can have metaclasses, inheriting from metaclasses, inheriting from type):</p>
<pre><code>class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)
</code></pre>
<p>That's it. There is really nothing more about metaclasses.</p>
<p>The reason behind the complexity of the code using metaclasses is not because
of metaclasses, it's because you usually use metaclasses to do twisted stuff
relying on introspection, manipulating inheritance, vars such as <code>__dict__</code>, etc.</p>
<p>Indeed, metaclasses are especially useful to do black magic, and therefore
complicated stuff. But by themselves, they are simple:</p>
<ul>
<li>intercept a class creation</li>
<li>modify the class</li>
<li>return the modified class</li>
</ul>
<h1>Why would you use metaclasses classes instead of functions?</h1>
<p>Since <code>__metaclass__</code> can accept any callable, why would you use a class
since it's obviously more complicated?</p>
<p>There are several reasons to do so:</p>
<ul>
<li>The intention is clear. When you read <code>UpperAttrMetaclass(type)</code>, you know
what's going to follow</li>
<li>You can use OOP. Metaclass can inherit from metaclass, override parent methods. Metaclasses can even use metaclasses.</li>
<li>You can structure your code better. You never use metaclasses for something as
trivial as the above example. It's usually for something complicated. Having the
ability to make several methods and group them in one class is very useful
to make the code easier to read.</li>
<li>You can hook on <code>__new__</code>, <code>__init__</code> and <code>__call__</code>. Which will allow
you to do different stuff. Even if usually you can do it all in <code>__new__</code>,
some people are just more comfortable using <code>__init__</code>.</li>
<li>These are called metaclasses, damn it! It must mean something!</li>
</ul>
<h1>Why would you use metaclasses?</h1>
<p>Now the big question. Why would you use some obscure error prone feature?</p>
<p>Well, usually you don't:</p>
<blockquote>
<p>Metaclasses are deeper magic that
99% of users should never worry about.
If you wonder whether you need them,
you don't (the people who actually
need them know with certainty that
they need them, and don't need an
explanation about why). </p>
</blockquote>
<p><em>Python Guru Tim Peters</em></p>
<p>The main use case for a metaclass is creating an API. A typical example of this is the Django ORM.</p>
<p>It allows you to define something like this:</p>
<pre><code>class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
</code></pre>
<p>But if you do this:</p>
<pre><code>guy = Person(name='bob', age='35')
print(guy.age)
</code></pre>
<p>It won't return an <code>IntegerField</code> object. It will return an <code>int</code>, and can even take it directly from the database.</p>
<p>This is possible because <code>models.Model</code> defines <code>__metaclass__</code> and
it uses some magic that will turn the <code>Person</code> you just defined with simple statements
into a complex hook to a database field. </p>
<p>Django makes something complex look simple by exposing a simple API
and using metaclasses, recreating code from this API to do the real job
behind the scenes.</p>
<h1>The last word</h1>
<p>First, you know that classes are objects that can create instances.</p>
<p>Well in fact, classes are themselves instances. Of metaclasses.</p>
<pre><code>>>> class Foo(object): pass
>>> id(Foo)
142630324
</code></pre>
<p>Everything is an object in Python, and they are all either instances of classes
or instances of metaclasses.</p>
<p>Except for <code>type</code>.</p>
<p><code>type</code> is actually its own metaclass. This is not something you could
reproduce in pure Python, and is done by cheating a little bit at the implementation
level.</p>
<p>Secondly, metaclasses are complicated. You may not want to use them for
very simple class alterations. You can change classes by using two different techniques:</p>
<ul>
<li><a href="http://en.wikipedia.org/wiki/Monkey_patch">monkey patching</a></li>
<li>class decorators</li>
</ul>
<p>99% of the time you need class alteration, you are better off using these.</p>
<p>But 99% of the time, you don't need class alteration at all.</p>
| 4,510 | 2011-07-05T11:29:50Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 21,999,253 | <p>A metaclass is a class that tells how (some) other class should be created.</p>
<p>This is a case where I saw metaclass as a solution to my problem:
I had a really complicated problem, that probably could have been solved differently, but I chose to solve it using a metaclass. Because of the complexity, it is one of the few modules I have written where the comments in the module surpass the amount of code that has been written. Here it is...</p>
<pre><code>#!/usr/bin/env python
# Copyright (C) 2013-2014 Craig Phillips. All rights reserved.
# This requires some explaining. The point of this metaclass excercise is to
# create a static abstract class that is in one way or another, dormant until
# queried. I experimented with creating a singlton on import, but that did
# not quite behave how I wanted it to. See now here, we are creating a class
# called GsyncOptions, that on import, will do nothing except state that its
# class creator is GsyncOptionsType. This means, docopt doesn't parse any
# of the help document, nor does it start processing command line options.
# So importing this module becomes really efficient. The complicated bit
# comes from requiring the GsyncOptions class to be static. By that, I mean
# any property on it, may or may not exist, since they are not statically
# defined; so I can't simply just define the class with a whole bunch of
# properties that are @property @staticmethods.
#
# So here's how it works:
#
# Executing 'from libgsync.options import GsyncOptions' does nothing more
# than load up this module, define the Type and the Class and import them
# into the callers namespace. Simple.
#
# Invoking 'GsyncOptions.debug' for the first time, or any other property
# causes the __metaclass__ __getattr__ method to be called, since the class
# is not instantiated as a class instance yet. The __getattr__ method on
# the type then initialises the class (GsyncOptions) via the __initialiseClass
# method. This is the first and only time the class will actually have its
# dictionary statically populated. The docopt module is invoked to parse the
# usage document and generate command line options from it. These are then
# paired with their defaults and what's in sys.argv. After all that, we
# setup some dynamic properties that could not be defined by their name in
# the usage, before everything is then transplanted onto the actual class
# object (or static class GsyncOptions).
#
# Another piece of magic, is to allow command line options to be set in
# in their native form and be translated into argparse style properties.
#
# Finally, the GsyncListOptions class is actually where the options are
# stored. This only acts as a mechanism for storing options as lists, to
# allow aggregation of duplicate options or options that can be specified
# multiple times. The __getattr__ call hides this by default, returning the
# last item in a property's list. However, if the entire list is required,
# calling the 'list()' method on the GsyncOptions class, returns a reference
# to the GsyncListOptions class, which contains all of the same properties
# but as lists and without the duplication of having them as both lists and
# static singlton values.
#
# So this actually means that GsyncOptions is actually a static proxy class...
#
# ...And all this is neatly hidden within a closure for safe keeping.
def GetGsyncOptionsType():
class GsyncListOptions(object):
__initialised = False
class GsyncOptionsType(type):
def __initialiseClass(cls):
if GsyncListOptions._GsyncListOptions__initialised: return
from docopt import docopt
from libgsync.options import doc
from libgsync import __version__
options = docopt(
doc.__doc__ % __version__,
version = __version__,
options_first = True
)
paths = options.pop('<path>', None)
setattr(cls, "destination_path", paths.pop() if paths else None)
setattr(cls, "source_paths", paths)
setattr(cls, "options", options)
for k, v in options.iteritems():
setattr(cls, k, v)
GsyncListOptions._GsyncListOptions__initialised = True
def list(cls):
return GsyncListOptions
def __getattr__(cls, name):
cls.__initialiseClass()
return getattr(GsyncListOptions, name)[-1]
def __setattr__(cls, name, value):
# Substitut option names: --an-option-name for an_option_name
import re
name = re.sub(r'^__', "", re.sub(r'-', "_", name))
listvalue = []
# Ensure value is converted to a list type for GsyncListOptions
if isinstance(value, list):
if value:
listvalue = [] + value
else:
listvalue = [ None ]
else:
listvalue = [ value ]
type.__setattr__(GsyncListOptions, name, listvalue)
# Cleanup this module to prevent tinkering.
import sys
module = sys.modules[__name__]
del module.__dict__['GetGsyncOptionsType']
return GsyncOptionsType
# Our singlton abstract proxy class.
class GsyncOptions(object):
__metaclass__ = GetGsyncOptionsType()
</code></pre>
| 20 | 2014-02-24T21:20:49Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 31,930,795 | <blockquote>
<h1>What are metaclasses? What do you use them for?</h1>
</blockquote>
<p>A class is to an instance as a metaclass is to a class. </p>
<p>Put another way, a class is an instance of a metaclass.</p>
<p>Put a third way, a metaclass is a class's class.</p>
<p>Still hopelessly confused? So was I, until I learned the following and demonstrated how one can actually use metaclasses:</p>
<h1>You use a metaclass every time you create a class:</h1>
<p>When you create a class definition, for example, like this,</p>
<pre><code>class Foo(object): 'demo'
</code></pre>
<p>it's the same as functionally calling <code>type</code> with the appropriate arguments and assigning the result to a variable of that name:</p>
<pre><code>name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)
</code></pre>
<p>Note, some things automatically get added to the <code>__dict__</code>, i.e., the namespace:</p>
<pre><code>>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': 'demo'})
</code></pre>
<p>The <em>metaclass</em> of the object we created, in both cases, is <code>type</code>. </p>
<h1>We can extend <code>type</code> just like any other class definition:</h1>
<p>Here's the default <code>__repr__</code> of classes:</p>
<pre><code>>>> Foo
<class '__main__.Foo'>
</code></pre>
<p>One of the most valuable things we can do by default in writing a Python object is to provide it with a good <code>__repr__</code>. When we call <code>help(repr)</code> we learn that there's a good test for a <code>__repr__</code> that also requires a test for equality - <code>obj == eval(repr(obj))</code>. The following simple implementation of <code>__repr__</code> and <code>__eq__</code> for class instances of our type class provides us with a demonstration that may improve on the default <code>__repr__</code> of classes:</p>
<pre><code>class Type(type):
def __repr__(cls):
"""
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> eval(repr(Baz))
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
"""
metaname = type(cls).__name__
name = cls.__name__
parents = ', '.join(b.__name__ for b in cls.__bases__)
if parents:
parents += ','
namespace = ', '.join(': '.join(
(repr(k), repr(v) if not isinstance(v, type) else v.__name__))
for k, v in cls.__dict__.items())
return '{0}(\'{1}\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)
def __eq__(cls, other):
"""
>>> Baz == eval(repr(Baz))
True
"""
return (cls.__name__, cls.__bases__, cls.__dict__) == (
other.__name__, other.__bases__, other.__dict__)
</code></pre>
<p>So now when we create an object with this metaclass, the <code>__repr__</code> echoed on the command line provides a much less ugly sight than the default:</p>
<pre><code>>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
</code></pre>
<p>With a <code>__repr__</code> defined for the class instance, we have a stronger ability to debug our code.</p>
<h1>An expected usage: <code>__prepare__</code> a namespace</h1>
<p>If, for example, we want to know in what order a class's methods are created in, we could provide an ordered dict as the namespace of the class. We would do this with <code>__prepare__</code> which <a href="https://docs.python.org/3/reference/datamodel.html#preparing-the-class-namespace">returns the namespace dict for the class if it is implemented in Python 3</a>: </p>
<pre><code>from collections import OrderedDict
class OrderedType(Type):
@classmethod
def __prepare__(metacls, name, bases, **kwargs):
return OrderedDict()
def __new__(cls, name, bases, namespace, **kwargs):
result = Type.__new__(cls, name, bases, dict(namespace))
result.members = tuple(namespace)
return result
</code></pre>
<p>And usage:</p>
<pre><code>class OrderedMethodsObject(object, metaclass=OrderedType):
def method1(self): pass
def method2(self): pass
def method3(self): pass
def method4(self): pass
</code></pre>
<p>And now we have a record of the order in which these methods (and other class attributes) were created:</p>
<pre><code>>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')
</code></pre>
<p>Note, this example was adapted from the <a href="https://docs.python.org/3/reference/datamodel.html#metaclass-example">docs</a>. </p>
<p>So what we did was instantiate a metaclass by creating a class. We can also treat the metaclass as we would any other class. It has a method resolution order:</p>
<pre><code>>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)
</code></pre>
<p>And it has approximately the correct <code>repr</code> (which we can no longer eval unless we can find a way to represent our functions.):</p>
<pre><code>>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})
</code></pre>
| 38 | 2015-08-10T23:28:09Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 35,732,111 | <p><strong>Python 3 update</strong></p>
<p>There are (at this point) two key methods in a metaclass:</p>
<ul>
<li><code>__prepare__</code>, and</li>
<li><code>__new__</code></li>
</ul>
<p><code>__prepare__</code> lets you supply a custom mapping (such as an <code>OrderedDict</code>) to be used as the namespace while the class is being created. You must return an instance of whatever namespace you choose. If you don't implement <code>__prepare__</code> a normal <code>dict</code> is used.</p>
<p><code>__new__</code> is responsible for the actual creation/modification of the final class.</p>
<p>A bare-bones, do-nothing-extra metaclass would like:</p>
<pre><code>class Meta(type):
def __prepare__(metaclass, cls, bases):
return dict()
def __new__(metacls, cls, bases, clsdict):
return super().__new__(metacls, cls, bases, clsdict)
</code></pre>
<p>A simple example:</p>
<p>Say you want some simple validation code to run on your attributes -- like it must always be an <code>int</code> or a <code>str</code>. Without a metaclass, your class would look something like:</p>
<pre><code>class Person:
weight = ValidateType('weight', int)
age = ValidateType('age', int)
name = ValidateType('name', str)
</code></pre>
<p>As you can see, you have to repeat the name of the attribute twice. This makes typos possible along with irritating bugs.</p>
<p>A simple metaclass can address that problem:</p>
<pre><code>class Person(metaclass=Validator):
weight = ValidateType(int)
age = ValidateType(int)
name = ValidateType(str)
</code></pre>
<p>This is what the metaclass would look like (not using <code>__prepare__</code> since it is not needed):</p>
<pre><code>class Validator(type):
def __new__(metacls, cls, bases, clsdict):
# search clsdict looking for ValidateType descriptors
for name, attr in clsdict.items():
if isinstance(attr, ValidateType):
attr.name = name
attr.attr = '_' + name
# create final class and return it
return super().__new__(metacls, cls, bases, clsdict)
</code></pre>
<p>A sample run of:</p>
<pre><code>p = Person()
p.weight = 9
print(p.weight)
p.weight = '9'
</code></pre>
<p>produces:</p>
<pre><code>9
Traceback (most recent call last):
File "simple_meta.py", line 36, in <module>
p.weight = '9'
File "simple_meta.py", line 24, in __set__
(self.name, self.type, value))
TypeError: weight must be of type(s) <class 'int'> (got '9')
</code></pre>
<hr>
<p><strong>Note</strong>: This example is simple enough it could have also been accomplished with a class decorator, but presumably an actual metaclass would be doing much more.</p>
<p>The 'ValidateType' class for reference:</p>
<pre><code>class ValidateType:
def __init__(self, type):
self.name = None # will be set by metaclass
self.attr = None # will be set by metaclass
self.type = type
def __get__(self, inst, cls):
if inst is None:
return self
else:
return inst.__dict__[self.attr]
def __set__(self, inst, value):
if not isinstance(value, self.type):
raise TypeError('%s must be of type(s) %s (got %r)' %
(self.name, self.type, value))
else:
inst.__dict__[self.attr] = value
</code></pre>
| 23 | 2016-03-01T19:48:34Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 38,858,285 | <p><code>type</code> is actually a <code>metaclass</code> -- a class that creates another classes.
Most <code>metaclass</code> are the subclasses of <code>type</code>. The <code>metaclass</code> receives the <code>new</code> class as its first argument and provide access to class object with details as mentioned below:</p>
<pre><code>>>> class MetaClass(type):
... def __init__(cls, name, bases, attrs):
... print ('class name: %s' %name )
... print ('Defining class %s' %cls)
... print('Bases %s: ' %sbases)
... print('Attributes')
... for (name, value) in attrs.items():
... print ('%s :%r' %(name, value))
...
>>> class NewClass(object, metaclass=MetaClass):
... get_choch='dairy'
...
class name: NewClass
Bases <class 'object'>:
Defining class <class 'NewClass'>
get_choch :'dairy'
__module__ :'builtins'
__qualname__ :'NewClass'
</code></pre>
<p>Notice that the class was not instantiated at any time; the simple act of creating the class triggered execution of the <code>metaclass</code>.</p>
| 4 | 2016-08-09T18:49:44Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is a metaclass in Python? | 100,003 | <p>What are metaclasses? What do you use them for?</p>
| 3,219 | 2008-09-19T06:10:46Z | 40,017,019 | <h1>Role of a metaclass's <code>__call__()</code> method when creating a class instance</h1>
<p>If you've done Python programming for more than a few months you'll eventually stumble upon code that looks like this:</p>
<pre><code># define a class
class SomeClass(object):
# ...
# some definition here ...
# ...
# create an instance of it
instance = SomeClass()
# then call the object as if it's a function
result = instance('foo', 'bar')
</code></pre>
<p>The latter is possible when you implement the <code>__call__()</code> magic method on the class.</p>
<pre><code>class SomeClass(object):
# ...
# some definition here ...
# ...
def __call__(self, foo, bar):
return bar + foo
</code></pre>
<p>The <code>__call__()</code> method is invoked when an instance of a class is used as a callable. But as we've seen from previous answers a class itself is an instance of a metaclass, so when we use the class as a callable (i.e. when we create an instance of it) we're actually calling its metaclass's <code>__call__()</code> method. At this point most Python programmers are a bit confused because they've been told that when creating an instance like this <code>instance = SomeClass()</code> you're calling it's <code>__init__()</code> method. Some who've dug a bit deeper know that before <code>__init__()</code> there's <code>__new__()</code>. Well, today another layer of truth is being revealed, before <code>__new__()</code> there's the metaclass's <code>__call__()</code>.</p>
<p>Let's study the method call chain from specifically the perspective of creating an instance of a class.</p>
<p>This is a metaclass that logs exactly the moment before an instance is created and the moment it's about to return it.</p>
<pre><code>class Meta_1(type):
def __call__(cls):
print "Meta_1.__call__() before creating an instance of ", cls
instance = super(Meta_1, cls).__call__()
print "Meta_1.__call__() about to return instance."
return instance
</code></pre>
<p>This is a class that uses that metaclass </p>
<pre><code>class Class_1(object):
__metaclass__ = Meta_1
def __new__(cls):
print "Class_1.__new__() before creating an instance."
instance = super(Class_1, cls).__new__(cls)
print "Class_1.__new__() about to return instance."
return instance
def __init__(self):
print "entering Class_1.__init__() for instance initialization."
super(Class_1,self).__init__()
print "exiting Class_1.__init__()."
</code></pre>
<p>And now let's create an instance of <code>Class_1</code></p>
<pre><code>instance = Class_1()
# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.
# Class_1.__new__() before creating an instance.
# Class_1.__new__() about to return instance.
# entering Class_1.__init__() for instance initialization.
# exiting Class_1.__init__().
# Meta_1.__call__() about to return instance.
</code></pre>
<p>The code above doesn't actually do anything other than logging the task and then delegating the actual work to the parent (i.e. keeping the default behavior). So with <code>type</code> being <code>Meta_1</code>'s parent class, we can imagine that this would be the pseudo implementation of <code>type.__call__()</code>:</p>
<pre><code>class type:
def __call__(cls, *args, **kwarg):
# ... maybe a few things done to cls here
# then we call __new__() on the class to create an instance
instance = cls.__new__(cls, *args, **kwargs)
# ... maybe a few things done to the instance here
# then we initialize the instance with its __init__() method
instance.__init__(*args, **kwargs)
# ... maybe a few more things done to instance here
# then we return it
return instance
</code></pre>
<p>We can see that the metaclass's <code>__call__()</code> method is the one that's called first. It then delegates creation of the instance to the class's <code>__new__()</code> method and initialization to the instance's <code>__init__()</code>. It's also the one that ultimately returns the instance.</p>
<p>From the above it stems that the metaclass's <code>__call__()</code> is also given the opportunity to decide whether or not a call to <code>Class_1.__new__()</code> or <code>Class_1.__init__()</code> will eventually be made. Over the course of its execution it could actually return an object that hasn't been touched by either of these methods. Take for example this approach to the singleton pattern:</p>
<pre><code>class Meta_2(type):
def __call__(cls, module):
if hasattr(module, '__Class_2_singleton__'):
# we return the only instance and skip a call to __new__()
# and __init__()
print ("{} singleton returning from Meta_2.__call__(), "
"skipping creation of new instance.".format(cls))
return module.__Class_2_singleton__
# else if the singleton isn't present we proceed as usual
print "Meta_2.__call__() before creating an instance."
instance = super(Meta_2, cls).__call__(module)
module.__Class_2_singleton__ = instance
print "Meta_2.__call__() returning new instance."
return instance
class Class_2(object):
__metaclass__ = Meta_2
def __new__(cls, module, **kwargs):
print "Class_2.__new__() before creating instance."
instance = super(Class_2, cls).__new__(cls)
print "Class_2.__new__() returning instance."
return instance
def __init__(self, module, **kwargs):
print "entering Class_2.__init__() for initialization."
super(Class_2,self).__init__()
print "exiting Class_2.__init__()."
</code></pre>
<p>Let's observe what happens when repeatedly trying to create an object of type <code>Class_2</code></p>
<pre><code>import sys
a = Class_2(sys.modules['__main__'])
# Meta_2.__call__() before creating an instance.
# Class_2.__new__() before creating instance.
# Class_2.__new__() returning instance.
# entering Class_2.__init__() for initialization.
# exiting Class_2.__init__().
# Meta_2.__call__() returning new instance.
b = Class_2(sys.modules['__main__'])
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.
c = Class_2(sys.modules['__main__'])
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.
a is b is c # True
</code></pre>
| 0 | 2016-10-13T09:21:26Z | [
"python",
"oop",
"metaclass",
"python-datamodel"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 100,250 | <p>Try adding a datetime.datetime to a datetime.timedelta. If you only want the time portion, you can call the time() method on the resultant datetime.datetime object to get it.</p>
| 1 | 2008-09-19T07:29:25Z | [
"python",
"datetime",
"time",
"math"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 100,345 | <p>You can use full <code>datetime</code> variables with <code>timedelta</code>, and by providing a dummy date then using <code>time</code> to just get the time value.</p>
<p>For example:</p>
<pre><code>import datetime
a = datetime.datetime(100,1,1,11,34,59)
b = a + datetime.timedelta(0,3) # days, seconds, then other fields.
print a.time()
print b.time()
</code></pre>
<p>results in the two values, three seconds apart:</p>
<pre><code>11:34:59
11:35:02
</code></pre>
<p>You could also opt for the more readable</p>
<pre><code>b = a + datetime.timedelta(seconds=3)
</code></pre>
<p>if you're so inclined.</p>
<hr>
<p>If you're after a function that can do this, you can look into using <code>addSecs</code> below:</p>
<pre><code>import datetime
def addSecs(tm, secs):
fulldate = datetime.datetime(100, 1, 1, tm.hour, tm.minute, tm.second)
fulldate = fulldate + datetime.timedelta(seconds=secs)
return fulldate.time()
a = datetime.datetime.now().time()
b = addSecs(a, 300)
print a
print b
</code></pre>
<p>This outputs:</p>
<pre><code> 09:11:55.775695
09:16:55
</code></pre>
| 281 | 2008-09-19T07:54:39Z | [
"python",
"datetime",
"time",
"math"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 100,404 | <p>One little thing, might add clarity to override the default value for seconds</p>
<pre><code>>>> b = a + datetime.timedelta(seconds=3000)
>>> b
datetime.datetime(1, 1, 1, 12, 24, 59)
</code></pre>
| 9 | 2008-09-19T08:08:10Z | [
"python",
"datetime",
"time",
"math"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 100,776 | <p>Thanks to @<a href="#100345">Pax Diablo</a>, @bvmou and @Arachnid for the suggestion of using full datetimes throughout. If I have to accept datetime.time objects from an external source, then this seems to be an alternative <code>add_secs_to_time()</code> function:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
dummy_date = datetime.date(1, 1, 1)
full_datetime = datetime.datetime.combine(dummy_date, timeval)
added_datetime = full_datetime + datetime.timedelta(seconds=secs_to_add)
return added_datetime.time()
</code></pre>
<p>This verbose code can be compressed to this one-liner:</p>
<pre><code>(datetime.datetime.combine(datetime.date(1, 1, 1), timeval) + datetime.timedelta(seconds=secs_to_add)).time()
</code></pre>
<p>but I think I'd want to wrap that up in a function for code clarity anyway.</p>
| 7 | 2008-09-19T09:40:06Z | [
"python",
"datetime",
"time",
"math"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 101,947 | <p>As others here have stated, you can just use full datetime objects throughout:</p>
<pre><code>sometime = get_some_time() # the time to which you want to add 3 seconds
later = (datetime.combine(date.today(), sometime) + timedelta(seconds=3)).time()
</code></pre>
<p>However, I think it's worth explaining why full datetime objects are required. Consider what would happen if I added 2 hours to 11pm. What's the correct behavior? An exception, because you can't have a time larger than 11:59pm? Should it wrap back around?</p>
<p>Different programmers will expect different things, so whichever result they picked would surprise a lot of people. Worse yet, programmers would write code that worked just fine when they tested it initially, and then have it break later by doing something unexpected. This is very bad, which is why you're not allowed to add timedelta objects to time objects.</p>
| 34 | 2008-09-19T13:47:29Z | [
"python",
"datetime",
"time",
"math"
] |
What is the standard way to add N seconds to datetime.time in Python? | 100,210 | <p>Given a <code>datetime.time</code> value in Python, is there a standard way to add an integer number of seconds to it, so that <code>11:34:59</code> + 3 = <code>11:35:02</code>, for example?</p>
<p>These obvious ideas don't work:</p>
<pre><code>>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
</code></pre>
<p>In the end I have written functions like this:</p>
<pre><code>def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
secs += secs_to_add
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
</code></pre>
<p>I can't help thinking that I'm missing an easier way to do this though.</p>
<h3>Related</h3>
<ul>
<li><a href="http://stackoverflow.com/questions/656297/python-time-timedelta-equivalent">python time + timedelta equivalent</a></li>
</ul>
| 188 | 2008-09-19T07:19:36Z | 6,839,259 | <p>If it's worth adding another file / dependency to your project, I've just written a tiny little class that extends <code>datetime.time</code> with the ability to do arithmetic. When you go past midnight, it wraps around zero. Now, "What time will it be, 24 hours from now" has a lot of corner cases, including daylight savings time, leap seconds, historical timezone changes, and so on. But sometimes you really do need the simple case, and that's what this will do.</p>
<p>Your example would be written:</p>
<pre><code>>>> import datetime
>>> import nptime
>>> nptime.nptime(11, 34, 59) + datetime.timedelta(0, 3)
nptime(11, 35, 2)
</code></pre>
<p><code>nptime</code> inherits from <code>datetime.time</code>, so any of those methods should be usable, too.</p>
<p>It's available from PyPi as <code>nptime</code> ("non-pedantic time"), or on GitHub: <a href="https://github.com/tgs/nptime" rel="nofollow">https://github.com/tgs/nptime</a></p>
| 4 | 2011-07-27T03:49:05Z | [
"python",
"datetime",
"time",
"math"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 100,394 | <p>For static analysis there is <a href="http://www.logilab.org/857">pylint</a> and <a href="http://pychecker.sourceforge.net/">pychecker</a>. Personally I use pylint as it seems to be more comprehensive than pychecker. </p>
<p>For cyclomatic complexity you can try <a href="http://www.journyx.com/curt/complexity.html">this perl program</a>, or this <a href="http://www.traceback.org/2008/03/31/measuring-cyclomatic-complexity-of-python-code/">article</a> which introduces a python program to do the same</p>
| 17 | 2008-09-19T08:05:48Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 100,687 | <p>Thanks to <a href="http://pydev.org/" rel="nofollow">Pydev</a>, you can <a href="http://pydev.org/manual_adv_pylint.html" rel="nofollow">integrate pylint</a> in the <a href="http://www.eclipse.org/" rel="nofollow">Eclipse IDE</a> really easily and get a code report each time you save a modified file.</p>
| 6 | 2008-09-19T09:19:57Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 105,473 | <p>For measuring cyclomatic complexity, there's a nice tool available at <a href="http://www.traceback.org/2008/03/31/measuring-cyclomatic-complexity-of-python-code/">traceback.org</a>. The page also gives a good overview of how to interpret the results.</p>
<p>+1 for <a href="http://www.logilab.org/project/pylint">pylint</a>. It is great at verifying adherence to coding standards (be it <a href="http://www.python.org/dev/peps/pep-0008/">PEP8</a> or your own organization's variant), which can in the end help to reduce cyclomatic complexity.</p>
| 29 | 2008-09-19T20:44:22Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 574,673 | <p>There is a tool called
<a href="http://clonedigger.sourceforge.net/" rel="nofollow">CloneDigger</a> that helps you find similar code snippets.</p>
| 4 | 2009-02-22T09:57:22Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 2,799,127 | <p>Pycana works like charm when you need to understand a new project!</p>
<blockquote>
<p><a href="http://sourceforge.net/projects/pycana/">PyCAna</a> (Python Code Analyzer) is
a fancy name for a simple code
analyzer for python that creates a
class diagram after executing your
code.</p>
</blockquote>
<p>See how it works:
<a href="http://pycana.sourceforge.net/">http://pycana.sourceforge.net/</a></p>
<p>output:</p>
<p><img src="http://pycana.sourceforge.net/relations.png" alt="alt text"></p>
| 11 | 2010-05-09T20:50:34Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 14,793,812 | <p>For cyclomatic complexity you can use <code>radon</code>: <a href="https://github.com/rubik/radon">https://github.com/rubik/radon</a></p>
<p>(Use <code>pip</code> to install it: <code>pip install radon</code>)</p>
<p>Additionally it also has these features:</p>
<ul>
<li>raw metrics (these include SLOC, comment lines, blank lines, &c.)</li>
<li>Halstead metrics (all of them)</li>
<li>Maintainability Index (the one used in Visual Studio)</li>
</ul>
| 24 | 2013-02-10T01:47:31Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 22,649,562 | <p>Use <a href="https://pypi.python.org/pypi/flake8" rel="nofollow">flake8</a>, which provides pep8, pyflakes, and cyclomatic complexity analysis in one tool</p>
| 4 | 2014-03-26T01:08:02Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
How can I analyze Python code to identify problematic areas? | 100,298 | <p>I have a large source repository split across multiple projects. I would like to produce a report about the health of the source code, identifying problem areas that need to be addressed.</p>
<p>Specifically, I'd like to call out routines with a high cyclomatic complexity, identify repetition, and perhaps run some lint-like static analysis to spot suspicious (and thus likely erroneous) constructs.</p>
<p>How might I go about constructing such a report?</p>
| 91 | 2008-09-19T07:40:22Z | 39,937,878 | <p>For checking cyclomatic complexity, there is of course the <a href="https://pypi.python.org/pypi/mccabe/" rel="nofollow"><strong><code>mccabe</code></strong></a> package.</p>
<p>Installation:</p>
<pre><code>$ sudo pip install --upgrade mccabe
</code></pre>
<p>Usage:</p>
<pre><code>$ python -m mccabe --min=6 /path/to/myfile.py
</code></pre>
<p>Note the threshold of 6 above. Per <a href="https://stackoverflow.com/a/1365185/832230">this answer</a>, scores >5 probably should be simplified.</p>
<p>Sample output with <code>--min=3</code>:</p>
<pre><code>68:1: 'Fetcher.fetch' 3
48:1: 'Fetcher._read_dom_tag' 3
103:1: 'main' 3
</code></pre>
<p>It can optionally also be used via <a href="https://pypi.python.org/pypi/pylint-mccabe/" rel="nofollow"><code>pylint-mccabe</code></a> or <a href="https://pypi.python.org/pypi/prospector/" rel="nofollow"><code>prospector</code></a>, etc.</p>
| 0 | 2016-10-08T22:11:25Z | [
"python",
"static-analysis",
"cyclomatic-complexity"
] |
Python on Windows - how to wait for multiple child processes? | 100,624 | <p>How to wait for multiple child processes in Python on Windows, without active wait (polling)? Something like this <em>almost</em> works for me:</p>
<pre><code>proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"
</code></pre>
<p>The problem is that when <code>proc2</code> finishes before <code>proc1</code>, the parent process will still wait for <code>proc1</code>. On Unix one would use <code>waitpid(0)</code> in a loop to get the child processes' return codes as they finish - how to achieve something like this in Python on Windows?</p>
| 20 | 2008-09-19T09:02:43Z | 100,886 | <p>It might seem overkill, but, here it goes:</p>
<pre><code>import Queue, thread, subprocess
results= Queue.Queue()
def process_waiter(popen, description, que):
try: popen.wait()
finally: que.put( (description, popen.returncode) )
process_count= 0
proc1= subprocess.Popen( ['python', 'mytest.py'] )
thread.start_new_thread(process_waiter,
(proc1, "1 finished", results))
process_count+= 1
proc2= subprocess.Popen( ['python', 'mytest.py'] )
thread.start_new_thread(process_waiter,
(proc2, "2 finished", results))
process_count+= 1
# etc
while process_count > 0:
description, rc= results.get()
print "job", description, "ended with rc =", rc
process_count-= 1
</code></pre>
| 12 | 2008-09-19T10:09:47Z | [
"python",
"windows",
"asynchronous"
] |
Python on Windows - how to wait for multiple child processes? | 100,624 | <p>How to wait for multiple child processes in Python on Windows, without active wait (polling)? Something like this <em>almost</em> works for me:</p>
<pre><code>proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"
</code></pre>
<p>The problem is that when <code>proc2</code> finishes before <code>proc1</code>, the parent process will still wait for <code>proc1</code>. On Unix one would use <code>waitpid(0)</code> in a loop to get the child processes' return codes as they finish - how to achieve something like this in Python on Windows?</p>
| 20 | 2008-09-19T09:02:43Z | 111,225 | <p>Twisted has an <a href="http://twistedmatrix.com/documents/8.1.0/api/twisted.internet.interfaces.IReactorProcess.html">asynchronous process-spawning API</a> which works on Windows. There are actually several different implementations, many of which are not so great, but you can switch between them without changing your code.</p>
| 5 | 2008-09-21T15:25:33Z | [
"python",
"windows",
"asynchronous"
] |
Python on Windows - how to wait for multiple child processes? | 100,624 | <p>How to wait for multiple child processes in Python on Windows, without active wait (polling)? Something like this <em>almost</em> works for me:</p>
<pre><code>proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"
</code></pre>
<p>The problem is that when <code>proc2</code> finishes before <code>proc1</code>, the parent process will still wait for <code>proc1</code>. On Unix one would use <code>waitpid(0)</code> in a loop to get the child processes' return codes as they finish - how to achieve something like this in Python on Windows?</p>
| 20 | 2008-09-19T09:02:43Z | 149,327 | <p>Twisted on Windows will perform an active wait under the covers. If you don't want to use threads, you will have to use the win32 API to avoid polling. Something like this:</p>
<pre><code>import win32process
import win32event
# Note: CreateProcess() args are somewhat cryptic, look them up on MSDN
proc1, thread1, pid1, tid1 = win32process.CreateProcess(...)
proc2, thread2, pid2, tid2 = win32process.CreateProcess(...)
thread1.close()
thread2.close()
processes = {proc1: "proc1", proc2: "proc2"}
while processes:
handles = processes.keys()
# Note: WaitForMultipleObjects() supports at most 64 processes at a time
index = win32event.WaitForMultipleObjects(handles, False, win32event.INFINITE)
finished = handles[index]
exitcode = win32process.GetExitCodeProcess(finished)
procname = processes.pop(finished)
finished.close()
print "Subprocess %s finished with exit code %d" % (procname, exitcode)
</code></pre>
| 4 | 2008-09-29T15:52:35Z | [
"python",
"windows",
"asynchronous"
] |
Python on Windows - how to wait for multiple child processes? | 100,624 | <p>How to wait for multiple child processes in Python on Windows, without active wait (polling)? Something like this <em>almost</em> works for me:</p>
<pre><code>proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"
</code></pre>
<p>The problem is that when <code>proc2</code> finishes before <code>proc1</code>, the parent process will still wait for <code>proc1</code>. On Unix one would use <code>waitpid(0)</code> in a loop to get the child processes' return codes as they finish - how to achieve something like this in Python on Windows?</p>
| 20 | 2008-09-19T09:02:43Z | 573,196 | <p>Building on zseil's answer, you can do this with a mix of subprocess and win32 API calls. I used straight ctypes, because my Python doesn't happen to have win32api installed. I'm just spawning sleep.exe from MSYS here as an example, but clearly you could spawn any process you like. I use OpenProcess() to get a HANDLE from the process' PID, and then WaitForMultipleObjects to wait for any process to finish.</p>
<pre><code>import ctypes, subprocess
from random import randint
SYNCHRONIZE=0x00100000
INFINITE = -1
numprocs = 5
handles = {}
for i in xrange(numprocs):
sleeptime = randint(5,10)
p = subprocess.Popen([r"c:\msys\1.0\bin\sleep.exe", str(sleeptime)], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
h = ctypes.windll.kernel32.OpenProcess(SYNCHRONIZE, False, p.pid)
handles[h] = p.pid
print "Spawned Process %d" % p.pid
while len(handles) > 0:
print "Waiting for %d children..." % len(handles)
arrtype = ctypes.c_long * len(handles)
handle_array = arrtype(*handles.keys())
ret = ctypes.windll.kernel32.WaitForMultipleObjects(len(handle_array), handle_array, False, INFINITE)
h = handle_array[ret]
ctypes.windll.kernel32.CloseHandle(h)
print "Process %d done" % handles[h]
del handles[h]
print "All done!"
</code></pre>
| 5 | 2009-02-21T15:12:19Z | [
"python",
"windows",
"asynchronous"
] |
Python on Windows - how to wait for multiple child processes? | 100,624 | <p>How to wait for multiple child processes in Python on Windows, without active wait (polling)? Something like this <em>almost</em> works for me:</p>
<pre><code>proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"
</code></pre>
<p>The problem is that when <code>proc2</code> finishes before <code>proc1</code>, the parent process will still wait for <code>proc1</code>. On Unix one would use <code>waitpid(0)</code> in a loop to get the child processes' return codes as they finish - how to achieve something like this in Python on Windows?</p>
| 20 | 2008-09-19T09:02:43Z | 20,292,161 | <p>You can use <a href="https://code.google.com/p/psutil/" rel="nofollow">psutil</a>:</p>
<pre><code>>>> import subprocess
>>> import psutil
>>>
>>> proc1 = subprocess.Popen(['python','mytest.py'])
>>> proc2 = subprocess.Popen(['python','mytest.py'])
>>> ls = [psutil.Process(proc1.pid), psutil.Process(proc2.pid)]
>>>
>>> gone, alive = psutil.wait_procs(ls, timeout=3)
</code></pre>
<p>'gone' and 'alive' are lists indicating which processes are gone and which ones are still alive.</p>
<p>Optionally you can specify a callback which gets invoked every time one of the watched processes terminates:</p>
<pre><code>>>> def on_terminate(proc):
... print "%s terminated" % proc
...
>>> gone, alive = psutil.wait_procs(ls, timeout=3, callback=on_terminate)
</code></pre>
| 1 | 2013-11-29T19:17:31Z | [
"python",
"windows",
"asynchronous"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,762 | <p>In the first test, Python try to convert the object to a <code>bool</code> value if it is not already one. Roughly, <strong>we are asking the object : are you meaningful or not ?</strong> This is done using the following algorithm :</p>
<ol>
<li><p>If the object has a <code>__nonzero__</code> special method (as do numeric built-ins, <code>int</code> and <code>float</code>), it calls this method. It must either return a <code>bool</code> value which is then directly used, or an <code>int</code> value that is considered <code>False</code> if equal to zero.</p></li>
<li><p>Otherwise, if the object has a <code>__len__</code> special method (as do container built-ins, <code>list</code>, <code>dict</code>, <code>set</code>, <code>tuple</code>, ...), it calls this method, considering a container <code>False</code> if it is empty (length is zero).</p></li>
<li><p>Otherwise, the object is considered <code>True</code> unless it is <code>None</code> in which case, it is considered <code>False</code>.</p></li>
</ol>
<p>In the second test, the object is compared for equality to <code>None</code>. Here, <strong>we are asking the object, "Are you equal to this other value?"</strong> This is done using the following algorithm :</p>
<ol>
<li><p>If the object has a <code>__eq__</code> method, it is called, and the return value is then converted to a <code>bool</code>value and used to determine the outcome of the <code>if</code>.</p></li>
<li><p>Otherwise, if the object has a <code>__cmp__</code> method, it is called. This function must return an <code>int</code> indicating the order of the two object (<code>-1</code> if <code>self < other</code>, <code>0</code> if <code>self == other</code>, <code>+1</code> if <code>self > other</code>).</p></li>
<li><p>Otherwise, the object are compared for identity (ie. they are reference to the same object, as can be tested by the <code>is</code> operator).</p></li>
</ol>
<p>There is another test possible using the <code>is</code> operator. <strong>We would be asking the object, "Are you this particular object?"</strong></p>
<p>Generally, I would recommend to use the first test with non-numerical values, to use the test for equality when you want to compare objects of the same nature (two strings, two numbers, ...) and to check for identity only when using sentinel values (<code>None</code> meaning not initialized for a member field for exemple, or when using the <code>getattr</code> or the <code>__getitem__</code> methods).</p>
<p>To summarize, we have :</p>
<pre><code>>>> class A(object):
... def __repr__(self):
... return 'A()'
... def __nonzero__(self):
... return False
>>> class B(object):
... def __repr__(self):
... return 'B()'
... def __len__(self):
... return 0
>>> class C(object):
... def __repr__(self):
... return 'C()'
... def __cmp__(self, other):
... return 0
>>> class D(object):
... def __repr__(self):
... return 'D()'
... def __eq__(self, other):
... return True
>>> for obj in ['', (), [], {}, 0, 0., A(), B(), C(), D(), None]:
... print '%4s: bool(obj) -> %5s, obj == None -> %5s, obj is None -> %5s' % \
... (repr(obj), bool(obj), obj == None, obj is None)
'': bool(obj) -> False, obj == None -> False, obj is None -> False
(): bool(obj) -> False, obj == None -> False, obj is None -> False
[]: bool(obj) -> False, obj == None -> False, obj is None -> False
{}: bool(obj) -> False, obj == None -> False, obj is None -> False
0: bool(obj) -> False, obj == None -> False, obj is None -> False
0.0: bool(obj) -> False, obj == None -> False, obj is None -> False
A(): bool(obj) -> False, obj == None -> False, obj is None -> False
B(): bool(obj) -> False, obj == None -> False, obj is None -> False
C(): bool(obj) -> True, obj == None -> True, obj is None -> False
D(): bool(obj) -> True, obj == None -> True, obj is None -> False
None: bool(obj) -> False, obj == None -> True, obj is None -> True
</code></pre>
| 139 | 2008-09-19T09:38:10Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,764 | <p>Because <code>None</code> is not the only thing that is considered false.</p>
<pre><code>if not False:
print "False is false."
if not 0:
print "0 is false."
if not []:
print "An empty list is false."
if not ():
print "An empty tuple is false."
if not {}:
print "An empty dict is false."
if not "":
print "An empty string is false."
</code></pre>
<p><code>False</code>, <code>0</code>, <code>()</code>, <code>[]</code>, <code>{}</code> and <code>""</code> are all different from <code>None</code>, so your two code snippets are <em>not</em> equivalent.</p>
<p>Moreover, consider the following:</p>
<pre><code>>>> False == 0
True
>>> False == ()
False
</code></pre>
<p><code>if object:</code> is <em>not</em> an equality check. <code>0</code>, <code>()</code>, <code>[]</code>, <code>None</code>, <code>{}</code>, etc. <em>are</em> all different from each other, but they all <em>evaluate</em> to False.</p>
<p>This is the "magic" behind short circuiting expressions like:</p>
<pre><code>foo = bar and spam or eggs
</code></pre>
<p>which is shorthand for:</p>
<pre><code>if bar:
foo = spam
else:
foo = eggs
</code></pre>
<p>although you really should write:</p>
<pre><code>foo = spam if bar else egg
</code></pre>
| 30 | 2008-09-19T09:38:26Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,766 | <p>These two comparisons serve different purposes. The former checks for boolean value of something, the second checks for identity with None value.</p>
| 2 | 2008-09-19T09:38:37Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,768 | <p>For one the first example is shorter and looks nicer. As per the other posts what you choose also depends on what you really want to do with the comparison.</p>
| 0 | 2008-09-19T09:39:01Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,771 | <p><a href="http://www.python.org/dev/peps/pep-0008/" rel="nofollow">Style guide</a> recommends to use is or is not if you are testing for None-ness</p>
<blockquote>
<pre><code>- Comparisons to singletons like None should always be done with
'is' or 'is not', never the equality operators.
</code></pre>
</blockquote>
<p>On the other hand if you are testing for more than None-ness, you should use the boolean operator.</p>
| 1 | 2008-09-19T09:39:16Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,775 | <p>The answer is "it depends".</p>
<p>I use the first example if I consider 0, "", [] and False (list not exhaustive) to be equivalent to None in this context.</p>
| 0 | 2008-09-19T09:39:41Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,828 | <p>Personally, I chose a consistent approach across languages: I do <code>if (var)</code> (or equivalent) only if var is declared as boolean (or defined as such, in C we don't have a specific type). I even prefix these variables with a <code>b</code> (so it would be <code>bVar</code> actually) to be sure I won't accidentally use another type here.<br />
I don't really like implicit casting to boolean, even less when there are numerous, complex rules.</p>
<p>Of course, people will disagree. Some go farther, I see <code>if (bVar == true)</code> in the Java code at my work (too redundant for my taste!), others love too much compact syntax, going <code>while (line = getNextLine())</code> (too ambiguous for me).</p>
| 0 | 2008-09-19T09:53:04Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,903 | <p>These are actually both poor practices. Once upon a time, it was considered OK to casually treat None and False as similar. However, since Python 2.2 this is not the best policy.</p>
<p>First, when you do an <code>if x</code> or <code>if not x</code> kind of test, Python has to implicitly convert <code>x</code> to boolean. The rules for the <code>bool</code> function describe a raft of things which are False; everything else is True. If the value of x wasn't properly boolean to begin with, this implicit conversion isn't really the clearest way to say things. </p>
<p>Before Python 2.2, there was no bool function, so it was even less clear.</p>
<p>Second, you shouldn't really test with <code>== None</code>. You should use <code>is None</code> and <code>is not None</code>.</p>
<p>See PEP 8, <a href="http://www.python.org/dev/peps/pep-0008/">Style Guide for Python Code</a>. </p>
<blockquote>
<pre><code>- Comparisons to singletons like None should always be done with
'is' or 'is not', never the equality operators.
Also, beware of writing "if x" when you really mean "if x is not None"
-- e.g. when testing whether a variable or argument that defaults to
None was set to some other value. The other value might have a type
(such as a container) that could be false in a boolean context!
</code></pre>
</blockquote>
<p>How many singletons are there? Five: <code>None</code>, <code>True</code>, <code>False</code>, <code>NotImplemented</code> and <code>Ellipsis</code>. Since you're really unlikely to use <code>NotImplemented</code> or <code>Ellipsis</code>, and you would never say <code>if x is True</code> (because simply <code>if x</code> is a lot clearer), you'll only ever test <code>None</code>.</p>
| 39 | 2008-09-19T10:12:34Z | [
"python"
] |
Why is "if not someobj:" better than "if someobj == None:" in Python? | 100,732 | <p>I've seen several examples of code like this:</p>
<pre><code>if not someobj:
#do something
</code></pre>
<p>But I'm wondering why not doing:</p>
<pre><code>if someobj == None:
#do something
</code></pre>
<p>Is there any difference? Does one have an advantage over the other?</p>
| 82 | 2008-09-19T09:29:19Z | 100,974 | <p>If you ask</p>
<pre><code>if not spam:
print "Sorry. No SPAM."
</code></pre>
<p>the <em>__nonzero__</em> method of <em>spam</em> gets called. From the Python manual:</p>
<blockquote>
<p><strong>__nonzero__</strong>(<em>self</em>)
Called to implement truth value testing, and the built-in operation bool(); should return False or True, or their integer equivalents 0 or 1. When this method is not defined, __len__() is called, if it is defined (see below). If a class defines neither __len__() nor __nonzero__(), all its instances are considered true.</p>
</blockquote>
<p>If you ask</p>
<pre><code>if spam == None:
print "Sorry. No SPAM here either."
</code></pre>
<p>the <em>__eq__</em> method of <em>spam</em> gets called with the argument <em>None</em>.</p>
<p>For more information of the customization possibilities have a look at the Python documenation at <a href="https://docs.python.org/reference/datamodel.html#basic-customization" rel="nofollow">https://docs.python.org/reference/datamodel.html#basic-customization</a></p>
| 3 | 2008-09-19T10:27:52Z | [
"python"
] |
Building Python C extension modules for Windows | 101,061 | <p>I have a C extension module and it would be nice to distribute built binaries. Setuptools makes it easy to build extensions modules on OS X and GNU/Linux, since those OSs come with GCC, but I don't know how to do it in Windows.</p>
<p>Would I need to buy a copy of Visual Studio, or does Visual Studio Express work? Can I just use Cygwin or MinGW?</p>
| 10 | 2008-09-19T10:53:12Z | 101,087 | <p>You can use both MinGW and VC++ Express (free, no need to buy it).</p>
<p>See:</p>
<ol>
<li><a href="http://eli.thegreenplace.net/2008/06/28/compiling-python-extensions-with-distutils-and-mingw/">http://eli.thegreenplace.net/2008/06/28/compiling-python-extensions-with-distutils-and-mingw/</a></li>
<li><a href="http://eli.thegreenplace.net/2008/06/27/creating-python-extension-modules-in-c/">http://eli.thegreenplace.net/2008/06/27/creating-python-extension-modules-in-c/</a></li>
</ol>
| 13 | 2008-09-19T10:57:36Z | [
"python",
"windows"
] |
Building Python C extension modules for Windows | 101,061 | <p>I have a C extension module and it would be nice to distribute built binaries. Setuptools makes it easy to build extensions modules on OS X and GNU/Linux, since those OSs come with GCC, but I don't know how to do it in Windows.</p>
<p>Would I need to buy a copy of Visual Studio, or does Visual Studio Express work? Can I just use Cygwin or MinGW?</p>
| 10 | 2008-09-19T10:53:12Z | 101,090 | <p>Setuptools and distutils don't come with gcc, but they use the same compiler Python was built with. The difference is mostly that on the typical UNIX system that compiler is 'gcc' and you have it installed.</p>
<p>In order to compile extension modules on Windows, you need a compiler for Windows. MSVS will do, even the Express version I believe, but it does have to be the same MSVC++ version as Python was built with. Or you can use Cygwin or MinGW; See the appropriate section of <a href="http://docs.python.org/install/index.html#gnu-c-cygwin-mingw" rel="nofollow">Installing Python Modules</a>.</p>
| 1 | 2008-09-19T10:57:53Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 101,143 | <p>Try win32clipboard from the win32all package (that's probably installed if you're on ActiveState Python).</p>
<p>See sample here: <a href="http://code.activestate.com/recipes/474121/" rel="nofollow">http://code.activestate.com/recipes/474121/</a></p>
| 3 | 2008-09-19T11:15:07Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 101,167 | <p>You can use the module called <a href="http://docs.activestate.com/activepython/2.5/pywin32/win32clipboard.html">win32clipboard</a>, which is part of <a href="http://sourceforge.net/projects/pywin32/">pywin32</a>.</p>
<p>Here is an example that first sets the clipboard data then gets it:</p>
<pre><code>import win32clipboard
# set clipboard data
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardText('testing 123')
win32clipboard.CloseClipboard()
# get clipboard data
win32clipboard.OpenClipboard()
data = win32clipboard.GetClipboardData()
win32clipboard.CloseClipboard()
print data
</code></pre>
<p>An important reminder from the documentation:</p>
<blockquote>
<p>When the window has finished examining or changing the clipboard,
close the clipboard by calling CloseClipboard. This enables other
windows to access the clipboard. Do not place an object on the
clipboard after calling CloseClipboard.</p>
</blockquote>
| 47 | 2008-09-19T11:20:29Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 8,039,424 | <p>I've seen many suggestions to use the win32 module, but Tkinter provides the shortest and easiest method I've seen, as in this post: <a href="http://stackoverflow.com/questions/579687/how-do-i-copy-a-string-to-the-clipboard-on-windows-using-python/4203897#4203897">How do I copy a string to the clipboard on Windows using Python?</a></p>
<p>Plus, Tkinter is in the python standard library.</p>
| 18 | 2011-11-07T16:27:31Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 11,096,779 | <p>The most upvoted answer above is weird in a way that it simply clears the Clipboard and then gets the content (which is then empty). One could clear the clipboard to be sure that some clipboard content type like "formated text" does not "cover" your plain text content you want to save in the clipboard.</p>
<p>The following piece of code replaces all newlines in the clipboard by spaces, then removes all double spaces and finally saves the content back to the clipboard:</p>
<pre><code>import win32clipboard
win32clipboard.OpenClipboard()
c = win32clipboard.GetClipboardData()
win32clipboard.EmptyClipboard()
c = c.replace('\n', ' ')
c = c.replace('\r', ' ')
while c.find(' ') != -1:
c = c.replace(' ', ' ')
win32clipboard.SetClipboardText(c)
win32clipboard.CloseClipboard()
</code></pre>
| 10 | 2012-06-19T08:00:02Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 23,285,159 | <p>If you don't want to install extra packages, <code>ctypes</code> can get the job done as well.</p>
<pre><code>import ctypes
CF_TEXT = 1
kernel32 = ctypes.windll.kernel32
user32 = ctypes.windll.user32
user32.OpenClipboard(0)
if user32.IsClipboardFormatAvailable(CF_TEXT):
data = user32.GetClipboardData(CF_TEXT)
data_locked = kernel32.GlobalLock(data)
text = ctypes.c_char_p(data_locked)
print(text.value)
kernel32.GlobalUnlock(data_locked)
else:
print('no text in clipboard')
user32.CloseClipboard()
</code></pre>
| 4 | 2014-04-25T05:54:12Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 23,844,754 | <p>you can easily get this done through the built-in module <a href="https://docs.python.org/2/library/tkinter.html">Tkinter</a> which is basically a GUI library. This code creates a blank widget to get the clipboard content from OS.</p>
<pre><code>#from tkinter import Tk # Python 3
from Tkinter import Tk
Tk().clipboard_get()
</code></pre>
| 10 | 2014-05-24T11:58:36Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 27,995,097 | <p>For my <strong>console program</strong> the answers with tkinter above did not quite work for me because the .destroy() always gave an error,:</p>
<blockquote>
<p>can't invoke "event" command: application has been destroyed while executing...</p>
</blockquote>
<p>or when using .withdraw() the console window did not get the focus back.</p>
<p>To solve this you also have to call .update() before the .destroy(). Example:</p>
<pre><code># Python 3
import tkinter
r = tkinter.Tk()
text = r.clipboard_get()
r.withdraw()
r.update()
r.destroy()
</code></pre>
<p>The r.withdraw() prevents the frame from showing for a milisecond, and then it will be destroyed giving the focus back to the console.</p>
| 1 | 2015-01-17T01:08:26Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 36,886,989 | <p>Use Pythons library <a href="https://pypi.python.org/pypi/clipboard/0.0.4" rel="nofollow">Clipboard </a> </p>
<p>Its simply used like this:</p>
<pre><code>import clipboard
clipboard.copy("this text is now in the clipboard")
print clipboard.paste()
</code></pre>
| 1 | 2016-04-27T10:19:44Z | [
"python",
"windows"
] |
How do I read text from the (windows) clipboard from python? | 101,128 | <p>How do I read text from the (windows) clipboard from python?</p>
| 44 | 2008-09-19T11:09:27Z | 38,171,680 | <p>I found out this was the easiest way to get access to the clipboard from python:</p>
<p>1) Install pyperclip:
<code>pip install pyperclip</code></p>
<p>2) Usage:</p>
<pre><code>import pyperclip
s = pyperclip.paste()
pyperclip.copy(s)
# the type of s is string
</code></pre>
<p>Tested on Win10 64-bit, Python 3.5. Seems to work with non-ASCII characters, too.
Tested characters include ±°©©αβγθÎΨΦåäö</p>
| 0 | 2016-07-03T15:54:43Z | [
"python",
"windows"
] |
Is there a zip-like method in .Net? | 101,174 | <p>In Python there is a really neat function called <code>zip</code> which can be used to iterate through two lists at the same time:</p>
<pre><code>list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
for v1, v2 in zip(list1, list2):
print v1 + " " + v2
</code></pre>
<p>The above code shoul produce the following:</p>
<pre>1 a
2 b
3 c</pre>
<p>I wonder if there is a method like it available in .Net? I'm thinking about writing it myself, but there is no point if it's already available.</p>
| 12 | 2008-09-19T11:21:57Z | 101,207 | <p>Nope, there is no such function in .NET. You have roll out your own. Note that C# doesn't support tuples, so python-like syntax sugar is missing too.</p>
<p>You can use something like this:</p>
<pre><code>class Pair<T1, T2>
{
public T1 First { get; set;}
public T2 Second { get; set;}
}
static IEnumerable<Pair<T1, T2>> Zip<T1, T2>(IEnumerable<T1> first, IEnumerable<T2> second)
{
if (first.Count() != second.Count())
throw new ArgumentException("Blah blah");
using (IEnumerator<T1> e1 = first.GetEnumerator())
using (IEnumerator<T2> e2 = second.GetEnumerator())
{
while (e1.MoveNext() && e2.MoveNext())
{
yield return new Pair<T1, T2>() {First = e1.Current, Second = e2.Current};
}
}
}
...
var ints = new int[] {1, 2, 3};
var strings = new string[] {"A", "B", "C"};
foreach (var pair in Zip(ints, strings))
{
Console.WriteLine(pair.First + ":" + pair.Second);
}
</code></pre>
| 5 | 2008-09-19T11:31:17Z | [
".net",
"python",
"list",
"iteration"
] |
Is there a zip-like method in .Net? | 101,174 | <p>In Python there is a really neat function called <code>zip</code> which can be used to iterate through two lists at the same time:</p>
<pre><code>list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
for v1, v2 in zip(list1, list2):
print v1 + " " + v2
</code></pre>
<p>The above code shoul produce the following:</p>
<pre>1 a
2 b
3 c</pre>
<p>I wonder if there is a method like it available in .Net? I'm thinking about writing it myself, but there is no point if it's already available.</p>
| 12 | 2008-09-19T11:21:57Z | 101,222 | <p>Update: It is built-in in C# 4 as <a href="https://msdn.microsoft.com/en-us/library/vstudio/dd267698(v=vs.110).aspx" rel="nofollow">System.Linq.Enumerable.Zip Method</a></p>
<p>Here is a C# 3 version:</p>
<pre><code>IEnumerable<TResult> Zip<TResult,T1,T2>
(IEnumerable<T1> a,
IEnumerable<T2> b,
Func<T1,T2,TResult> combine)
{
using (var f = a.GetEnumerator())
using (var s = b.GetEnumerator())
{
while (f.MoveNext() && s.MoveNext())
yield return combine(f.Current, s.Current);
}
}
</code></pre>
<p>Dropped the C# 2 version as it was showing its age.</p>
| 25 | 2008-09-19T11:34:43Z | [
".net",
"python",
"list",
"iteration"
] |
Is there a zip-like method in .Net? | 101,174 | <p>In Python there is a really neat function called <code>zip</code> which can be used to iterate through two lists at the same time:</p>
<pre><code>list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
for v1, v2 in zip(list1, list2):
print v1 + " " + v2
</code></pre>
<p>The above code shoul produce the following:</p>
<pre>1 a
2 b
3 c</pre>
<p>I wonder if there is a method like it available in .Net? I'm thinking about writing it myself, but there is no point if it's already available.</p>
| 12 | 2008-09-19T11:21:57Z | 101,227 | <p>As far as I know there is not. I wrote one for myself (as well as a few other useful extensions and put them in a project called <a href="http://www.codeplex.com/nextension" rel="nofollow">NExtension</a> on Codeplex.</p>
<p>Apparently the Parallel extensions for .NET have a Zip function.</p>
<p>Here's a simplified version from NExtension (but please check it out for more useful extension methods):</p>
<pre><code>public static IEnumerable<TResult> Zip<T1, T2, TResult>(this IEnumerable<T1> source1, IEnumerable<T2> source2, Func<T1, T2, TResult> combine)
{
using (IEnumerator<T1> data1 = source1.GetEnumerator())
using (IEnumerator<T2> data2 = source2.GetEnumerator())
while (data1.MoveNext() && data2.MoveNext())
{
yield return combine(data1.Current, data2.Current);
}
}
</code></pre>
<p>Usage:</p>
<pre><code>int[] list1 = new int[] {1, 2, 3};
string[] list2 = new string[] {"a", "b", "c"};
foreach (var result in list1.Zip(list2, (i, s) => i.ToString() + " " + s))
Console.WriteLine(result);
</code></pre>
| 8 | 2008-09-19T11:35:28Z | [
".net",
"python",
"list",
"iteration"
] |
Is there a zip-like method in .Net? | 101,174 | <p>In Python there is a really neat function called <code>zip</code> which can be used to iterate through two lists at the same time:</p>
<pre><code>list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
for v1, v2 in zip(list1, list2):
print v1 + " " + v2
</code></pre>
<p>The above code shoul produce the following:</p>
<pre>1 a
2 b
3 c</pre>
<p>I wonder if there is a method like it available in .Net? I'm thinking about writing it myself, but there is no point if it's already available.</p>
| 12 | 2008-09-19T11:21:57Z | 101,284 | <p>There's also one in F#:</p>
<p>let zipped = Seq.zip firstEnumeration secondEnumation</p>
| 2 | 2008-09-19T11:55:09Z | [
".net",
"python",
"list",
"iteration"
] |
IronClad equivalent for Jython | 101,301 | <p>For IronPython there is a project - <a href="http://www.resolversystems.com/documentation/index.php/Ironclad" rel="nofollow">IronClad</a>, that aims to transparently run C extensions in it. Is there a similiar project for Jython?</p>
| 3 | 2008-09-19T11:58:00Z | 101,539 | <p>You can probably use Java's loadLibrary to do that (provided it works in your platform's java). It is in the java library: <a href="http://java.sun.com/javase/6/docs/api/java/lang/System.html#loadLibrary(java.lang.String)" rel="nofollow" title="sun.com loadLibrary documentation">java.System.loadLibrary()</a>.</p>
<p>Note that sometimes you will have to write a wrapper in C and/or in Java depending on the library you want to use and target system, since details are platform dependant.
Refer to the documentation for more details.</p>
| 1 | 2008-09-19T12:44:51Z | [
"python",
"c",
"ironpython",
"jython",
"ironclad"
] |
IronClad equivalent for Jython | 101,301 | <p>For IronPython there is a project - <a href="http://www.resolversystems.com/documentation/index.php/Ironclad" rel="nofollow">IronClad</a>, that aims to transparently run C extensions in it. Is there a similiar project for Jython?</p>
| 3 | 2008-09-19T11:58:00Z | 30,607,649 | <p>Keep an eye on JyNI (<a href="http://www.jyni.org" rel="nofollow">http://www.jyni.org</a>), which is to Jython exactly what is Ironclad to IronPython. As of this writing JyNI is still alpha state though.</p>
<p>If you just want to use some C-library from Jython, simply use JNA from Jython like you would do from Java. If you need finer control, look at JNI or SWIG.</p>
<p>Also, you might want to take a look at JEP (<a href="https://github.com/mrj0/jep" rel="nofollow">https://github.com/mrj0/jep</a>) or JPY (<a href="https://github.com/bcdev/jpy" rel="nofollow">https://github.com/bcdev/jpy</a>).</p>
| 1 | 2015-06-02T22:23:15Z | [
"python",
"c",
"ironpython",
"jython",
"ironclad"
] |
How do you access an authenticated Google App Engine service from a (non-web) python client? | 101,742 | <p>I have a Google App Engine app - <a href="http://mylovelyapp.appspot.com/">http://mylovelyapp.appspot.com/</a>
It has a page - mylovelypage</p>
<p>For the moment, the page just does <code>self.response.out.write('OK')</code></p>
<p>If I run the following Python at my computer:</p>
<pre><code>import urllib2
f = urllib2.urlopen("http://mylovelyapp.appspot.com/mylovelypage")
s = f.read()
print s
f.close()
</code></pre>
<p>it prints "OK"</p>
<p>the problem is if I add <code>login:required</code> to this page in the app's yaml</p>
<p>then this prints out the HTML of the Google Accounts login page</p>
<p>I've tried "normal" authentication approaches. e.g.</p>
<pre><code>passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(None,
uri='http://mylovelyapp.appspot.com/mylovelypage',
user='[email protected]',
passwd='billybobspasswd')
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
</code></pre>
<p>But it makes no difference - I still get the login page's HTML back.</p>
<p>I've tried <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google's ClientLogin auth API</a>, but I can't get it to work.</p>
<pre><code>h = httplib2.Http()
auth_uri = 'https://www.google.com/accounts/ClientLogin'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
myrequest = "Email=%s&Passwd=%s&service=ah&source=DALELANE-0.0" % ("[email protected]", "billybobspassword")
response, content = h.request(auth_uri, 'POST', body=myrequest, headers=headers)
if response['status'] == '200':
authtok = re.search('Auth=(\S*)', content).group(1)
headers = {}
headers['Authorization'] = 'GoogleLogin auth=%s' % authtok.strip()
headers['Content-Length'] = '0'
response, content = h.request("http://mylovelyapp.appspot.com/mylovelypage",
'POST',
body="",
headers=headers)
while response['status'] == "302":
response, content = h.request(response['location'], 'POST', body="", headers=headers)
print content
</code></pre>
<p>I do seem to be able to get some token correctly, but attempts to use it in the header when I call 'mylovelypage' still just return me the login page's HTML. :-( </p>
<p>Can anyone help, please?</p>
<p>Could I use the <a href="http://code.google.com/p/gdata-python-client/">GData client library</a> to do this sort of thing? From
what I've read, I think it should be able to access App Engine apps,
but I haven't been any more successful at getting the authentication working for App Engine stuff there either </p>
<p>Any pointers to samples, articles, or even just keywords I should be
searching for to get me started, would be very much appreciated.</p>
<p>Thanks!</p>
| 49 | 2008-09-19T13:19:09Z | 102,158 | <p>I'm not a python expert or a app engine expert. But did you try following the sample appl at <a href="http://code.google.com/appengine/docs/gettingstarted/usingusers.html" rel="nofollow">http://code.google.com/appengine/docs/gettingstarted/usingusers.html</a>. I created one at <a href="http://quizengine.appspot.com" rel="nofollow">http://quizengine.appspot.com</a>, it seemed to work fine with Google authentication and everything.
Just a suggestion, but look in to the getting started guide. Take it easy if the suggestion sounds naive. :)
Thanks.</p>
| -1 | 2008-09-19T14:16:12Z | [
"python",
"web-services",
"google-app-engine",
"authentication"
] |
How do you access an authenticated Google App Engine service from a (non-web) python client? | 101,742 | <p>I have a Google App Engine app - <a href="http://mylovelyapp.appspot.com/">http://mylovelyapp.appspot.com/</a>
It has a page - mylovelypage</p>
<p>For the moment, the page just does <code>self.response.out.write('OK')</code></p>
<p>If I run the following Python at my computer:</p>
<pre><code>import urllib2
f = urllib2.urlopen("http://mylovelyapp.appspot.com/mylovelypage")
s = f.read()
print s
f.close()
</code></pre>
<p>it prints "OK"</p>
<p>the problem is if I add <code>login:required</code> to this page in the app's yaml</p>
<p>then this prints out the HTML of the Google Accounts login page</p>
<p>I've tried "normal" authentication approaches. e.g.</p>
<pre><code>passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(None,
uri='http://mylovelyapp.appspot.com/mylovelypage',
user='[email protected]',
passwd='billybobspasswd')
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
</code></pre>
<p>But it makes no difference - I still get the login page's HTML back.</p>
<p>I've tried <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google's ClientLogin auth API</a>, but I can't get it to work.</p>
<pre><code>h = httplib2.Http()
auth_uri = 'https://www.google.com/accounts/ClientLogin'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
myrequest = "Email=%s&Passwd=%s&service=ah&source=DALELANE-0.0" % ("[email protected]", "billybobspassword")
response, content = h.request(auth_uri, 'POST', body=myrequest, headers=headers)
if response['status'] == '200':
authtok = re.search('Auth=(\S*)', content).group(1)
headers = {}
headers['Authorization'] = 'GoogleLogin auth=%s' % authtok.strip()
headers['Content-Length'] = '0'
response, content = h.request("http://mylovelyapp.appspot.com/mylovelypage",
'POST',
body="",
headers=headers)
while response['status'] == "302":
response, content = h.request(response['location'], 'POST', body="", headers=headers)
print content
</code></pre>
<p>I do seem to be able to get some token correctly, but attempts to use it in the header when I call 'mylovelypage' still just return me the login page's HTML. :-( </p>
<p>Can anyone help, please?</p>
<p>Could I use the <a href="http://code.google.com/p/gdata-python-client/">GData client library</a> to do this sort of thing? From
what I've read, I think it should be able to access App Engine apps,
but I haven't been any more successful at getting the authentication working for App Engine stuff there either </p>
<p>Any pointers to samples, articles, or even just keywords I should be
searching for to get me started, would be very much appreciated.</p>
<p>Thanks!</p>
| 49 | 2008-09-19T13:19:09Z | 102,162 | <p>Im not too familiar with AppEngine, or Googles web apis, but for a brute force approach you could write a script with something like mechanize (<a href="http://wwwsearch.sourceforge.net/mechanize/" rel="nofollow">http://wwwsearch.sourceforge.net/mechanize/</a>) to simply walk through the login process before you begin doing the real work of the client.</p>
| 0 | 2008-09-19T14:16:24Z | [
"python",
"web-services",
"google-app-engine",
"authentication"
] |
How do you access an authenticated Google App Engine service from a (non-web) python client? | 101,742 | <p>I have a Google App Engine app - <a href="http://mylovelyapp.appspot.com/">http://mylovelyapp.appspot.com/</a>
It has a page - mylovelypage</p>
<p>For the moment, the page just does <code>self.response.out.write('OK')</code></p>
<p>If I run the following Python at my computer:</p>
<pre><code>import urllib2
f = urllib2.urlopen("http://mylovelyapp.appspot.com/mylovelypage")
s = f.read()
print s
f.close()
</code></pre>
<p>it prints "OK"</p>
<p>the problem is if I add <code>login:required</code> to this page in the app's yaml</p>
<p>then this prints out the HTML of the Google Accounts login page</p>
<p>I've tried "normal" authentication approaches. e.g.</p>
<pre><code>passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(None,
uri='http://mylovelyapp.appspot.com/mylovelypage',
user='[email protected]',
passwd='billybobspasswd')
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
</code></pre>
<p>But it makes no difference - I still get the login page's HTML back.</p>
<p>I've tried <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google's ClientLogin auth API</a>, but I can't get it to work.</p>
<pre><code>h = httplib2.Http()
auth_uri = 'https://www.google.com/accounts/ClientLogin'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
myrequest = "Email=%s&Passwd=%s&service=ah&source=DALELANE-0.0" % ("[email protected]", "billybobspassword")
response, content = h.request(auth_uri, 'POST', body=myrequest, headers=headers)
if response['status'] == '200':
authtok = re.search('Auth=(\S*)', content).group(1)
headers = {}
headers['Authorization'] = 'GoogleLogin auth=%s' % authtok.strip()
headers['Content-Length'] = '0'
response, content = h.request("http://mylovelyapp.appspot.com/mylovelypage",
'POST',
body="",
headers=headers)
while response['status'] == "302":
response, content = h.request(response['location'], 'POST', body="", headers=headers)
print content
</code></pre>
<p>I do seem to be able to get some token correctly, but attempts to use it in the header when I call 'mylovelypage' still just return me the login page's HTML. :-( </p>
<p>Can anyone help, please?</p>
<p>Could I use the <a href="http://code.google.com/p/gdata-python-client/">GData client library</a> to do this sort of thing? From
what I've read, I think it should be able to access App Engine apps,
but I haven't been any more successful at getting the authentication working for App Engine stuff there either </p>
<p>Any pointers to samples, articles, or even just keywords I should be
searching for to get me started, would be very much appreciated.</p>
<p>Thanks!</p>
| 49 | 2008-09-19T13:19:09Z | 102,509 | <p>appcfg.py, the tool that uploads data to App Engine has to do exactly this to authenticate itself with the App Engine server. The relevant functionality is abstracted into appengine_rpc.py. In a nutshell, the solution is:</p>
<ol>
<li>Use the <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google ClientLogin API</a> to obtain an authentication token. appengine_rpc.py does this in <a href="http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/tools/appengine%5Frpc.py#180">_GetAuthToken</a></li>
<li>Send the auth token to a special URL on your App Engine app. That page then returns a cookie and a 302 redirect. Ignore the redirect and store the cookie. appcfg.py does this in <a href="http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/tools/appengine%5Frpc.py#228">_GetAuthCookie</a></li>
<li>Use the returned cookie in all future requests.</li>
</ol>
<p>You may also want to look at <a href="http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/tools/appengine%5Frpc.py#253">_Authenticate</a>, to see how appcfg handles the various return codes from ClientLogin, and <a href="http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/tools/appengine%5Frpc.py#397">_GetOpener</a>, to see how appcfg creates a urllib2 OpenerDirector that doesn't follow HTTP redirects. Or you could, in fact, just use the AbstractRpcServer and HttpRpcServer classes wholesale, since they do pretty much everything you need.</p>
| 38 | 2008-09-19T14:55:24Z | [
"python",
"web-services",
"google-app-engine",
"authentication"
] |
How do you access an authenticated Google App Engine service from a (non-web) python client? | 101,742 | <p>I have a Google App Engine app - <a href="http://mylovelyapp.appspot.com/">http://mylovelyapp.appspot.com/</a>
It has a page - mylovelypage</p>
<p>For the moment, the page just does <code>self.response.out.write('OK')</code></p>
<p>If I run the following Python at my computer:</p>
<pre><code>import urllib2
f = urllib2.urlopen("http://mylovelyapp.appspot.com/mylovelypage")
s = f.read()
print s
f.close()
</code></pre>
<p>it prints "OK"</p>
<p>the problem is if I add <code>login:required</code> to this page in the app's yaml</p>
<p>then this prints out the HTML of the Google Accounts login page</p>
<p>I've tried "normal" authentication approaches. e.g.</p>
<pre><code>passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(None,
uri='http://mylovelyapp.appspot.com/mylovelypage',
user='[email protected]',
passwd='billybobspasswd')
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
</code></pre>
<p>But it makes no difference - I still get the login page's HTML back.</p>
<p>I've tried <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google's ClientLogin auth API</a>, but I can't get it to work.</p>
<pre><code>h = httplib2.Http()
auth_uri = 'https://www.google.com/accounts/ClientLogin'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
myrequest = "Email=%s&Passwd=%s&service=ah&source=DALELANE-0.0" % ("[email protected]", "billybobspassword")
response, content = h.request(auth_uri, 'POST', body=myrequest, headers=headers)
if response['status'] == '200':
authtok = re.search('Auth=(\S*)', content).group(1)
headers = {}
headers['Authorization'] = 'GoogleLogin auth=%s' % authtok.strip()
headers['Content-Length'] = '0'
response, content = h.request("http://mylovelyapp.appspot.com/mylovelypage",
'POST',
body="",
headers=headers)
while response['status'] == "302":
response, content = h.request(response['location'], 'POST', body="", headers=headers)
print content
</code></pre>
<p>I do seem to be able to get some token correctly, but attempts to use it in the header when I call 'mylovelypage' still just return me the login page's HTML. :-( </p>
<p>Can anyone help, please?</p>
<p>Could I use the <a href="http://code.google.com/p/gdata-python-client/">GData client library</a> to do this sort of thing? From
what I've read, I think it should be able to access App Engine apps,
but I haven't been any more successful at getting the authentication working for App Engine stuff there either </p>
<p>Any pointers to samples, articles, or even just keywords I should be
searching for to get me started, would be very much appreciated.</p>
<p>Thanks!</p>
| 49 | 2008-09-19T13:19:09Z | 103,410 | <p>thanks to Arachnid for the answer - it worked as suggested</p>
<p>here is a simplified copy of the code, in case it is helpful to the next person to try! </p>
<pre><code>import os
import urllib
import urllib2
import cookielib
users_email_address = "[email protected]"
users_password = "billybobspassword"
target_authenticated_google_app_engine_uri = 'http://mylovelyapp.appspot.com/mylovelypage'
my_app_name = "yay-1.0"
# we use a cookie to authenticate with Google App Engine
# by registering a cookie handler here, this will automatically store the
# cookie returned when we use urllib2 to open http://currentcost.appspot.com/_ah/login
cookiejar = cookielib.LWPCookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookiejar))
urllib2.install_opener(opener)
#
# get an AuthToken from Google accounts
#
auth_uri = 'https://www.google.com/accounts/ClientLogin'
authreq_data = urllib.urlencode({ "Email": users_email_address,
"Passwd": users_password,
"service": "ah",
"source": my_app_name,
"accountType": "HOSTED_OR_GOOGLE" })
auth_req = urllib2.Request(auth_uri, data=authreq_data)
auth_resp = urllib2.urlopen(auth_req)
auth_resp_body = auth_resp.read()
# auth response includes several fields - we're interested in
# the bit after Auth=
auth_resp_dict = dict(x.split("=")
for x in auth_resp_body.split("\n") if x)
authtoken = auth_resp_dict["Auth"]
#
# get a cookie
#
# the call to request a cookie will also automatically redirect us to the page
# that we want to go to
# the cookie jar will automatically provide the cookie when we reach the
# redirected location
# this is where I actually want to go to
serv_uri = target_authenticated_google_app_engine_uri
serv_args = {}
serv_args['continue'] = serv_uri
serv_args['auth'] = authtoken
full_serv_uri = "http://mylovelyapp.appspot.com/_ah/login?%s" % (urllib.urlencode(serv_args))
serv_req = urllib2.Request(full_serv_uri)
serv_resp = urllib2.urlopen(serv_req)
serv_resp_body = serv_resp.read()
# serv_resp_body should contain the contents of the
# target_authenticated_google_app_engine_uri page - as we will have been
# redirected to that page automatically
#
# to prove this, I'm just gonna print it out
print serv_resp_body
</code></pre>
| 34 | 2008-09-19T16:22:06Z | [
"python",
"web-services",
"google-app-engine",
"authentication"
] |
How do you access an authenticated Google App Engine service from a (non-web) python client? | 101,742 | <p>I have a Google App Engine app - <a href="http://mylovelyapp.appspot.com/">http://mylovelyapp.appspot.com/</a>
It has a page - mylovelypage</p>
<p>For the moment, the page just does <code>self.response.out.write('OK')</code></p>
<p>If I run the following Python at my computer:</p>
<pre><code>import urllib2
f = urllib2.urlopen("http://mylovelyapp.appspot.com/mylovelypage")
s = f.read()
print s
f.close()
</code></pre>
<p>it prints "OK"</p>
<p>the problem is if I add <code>login:required</code> to this page in the app's yaml</p>
<p>then this prints out the HTML of the Google Accounts login page</p>
<p>I've tried "normal" authentication approaches. e.g.</p>
<pre><code>passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(None,
uri='http://mylovelyapp.appspot.com/mylovelypage',
user='[email protected]',
passwd='billybobspasswd')
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
</code></pre>
<p>But it makes no difference - I still get the login page's HTML back.</p>
<p>I've tried <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html">Google's ClientLogin auth API</a>, but I can't get it to work.</p>
<pre><code>h = httplib2.Http()
auth_uri = 'https://www.google.com/accounts/ClientLogin'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
myrequest = "Email=%s&Passwd=%s&service=ah&source=DALELANE-0.0" % ("[email protected]", "billybobspassword")
response, content = h.request(auth_uri, 'POST', body=myrequest, headers=headers)
if response['status'] == '200':
authtok = re.search('Auth=(\S*)', content).group(1)
headers = {}
headers['Authorization'] = 'GoogleLogin auth=%s' % authtok.strip()
headers['Content-Length'] = '0'
response, content = h.request("http://mylovelyapp.appspot.com/mylovelypage",
'POST',
body="",
headers=headers)
while response['status'] == "302":
response, content = h.request(response['location'], 'POST', body="", headers=headers)
print content
</code></pre>
<p>I do seem to be able to get some token correctly, but attempts to use it in the header when I call 'mylovelypage' still just return me the login page's HTML. :-( </p>
<p>Can anyone help, please?</p>
<p>Could I use the <a href="http://code.google.com/p/gdata-python-client/">GData client library</a> to do this sort of thing? From
what I've read, I think it should be able to access App Engine apps,
but I haven't been any more successful at getting the authentication working for App Engine stuff there either </p>
<p>Any pointers to samples, articles, or even just keywords I should be
searching for to get me started, would be very much appreciated.</p>
<p>Thanks!</p>
| 49 | 2008-09-19T13:19:09Z | 4,813,590 | <p>for those who can't get ClientLogin to work, try app engine's <a href="http://code.google.com/appengine/docs/python/oauth/overview.html" rel="nofollow">OAuth support</a>.</p>
| 1 | 2011-01-27T06:59:18Z | [
"python",
"web-services",
"google-app-engine",
"authentication"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 101,787 | <p>Not at the moment and you would be lucky to get Jython to work soon. If you're planning to start your development now you would be better off with just sticking to Java for now on.</p>
| 20 | 2008-09-19T13:26:53Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 256,069 | <p>As a <a href="http://en.wikipedia.org/wiki/Python_%28programming_language%29">Python</a> lover and Android programmer, I am sad to say this is not really a good way to go. There are two problems.</p>
<p>One problem is that there is a lot more than just a programming language to the Android development tools. A lot of the Android graphics involve XML files to configure the display, similar to HTML. The built-in java objects are really integrated with this XML layout, and it's a lot easier than writing your own code to go from logic to bitmap.</p>
<p>The other problem is that the G1 (and probably other Android devices for the near future) are really not that fast. 200 MHz processors, and RAM is very limited. Even in Java you have to do a decent amount of rewriting-to-avoid-more-object-creation if you want to make your app perfectly smooth. Python is going to be too slow for a while still on mobile devices.</p>
| 40 | 2008-11-01T20:29:44Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 383,473 | <p>I just posted some <a href="http://www.damonkohler.com/2008/12/python-on-android.html">directions for cross compiling Python 2.4.5 for Android</a>. It takes some patching, and not all modules are supported, but the basics are there.</p>
| 37 | 2008-12-20T16:56:57Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 973,765 | <p><a href="http://google-opensource.blogspot.com/2009/06/introducing-android-scripting.html">YES!</a></p>
<p>An example <a href="http://www.mattcutts.com/blog/android-barcode-scanner/">via Matt Cutts</a> -- "hereâs a barcode scanner written in six lines of Python code:</p>
<pre><code>import android
droid = android.Android()
code = droid.scanBarcode()
isbn = int(code['result']['SCAN_RESULT'])
url = "http://books.google.com?q=%d" % isbn
droid.startActivity('android.intent.action.VIEW', url)
</code></pre>
| 143 | 2009-06-10T05:13:13Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 973,786 | <p>There is also the new <a href="http://www.talkandroid.com/1225-android-scripting-environment/">Android Scripting Environment</a> (ASE) project. It looks awesome, and it has some integration with native Android components. </p>
| 248 | 2009-06-10T05:24:29Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 4,381,935 | <p>Check out the blog post <a href="http://www.saffirecorp.com/?p=113">http://www.saffirecorp.com/?p=113</a> that explains how to install and run <a href="http://en.wikipedia.org/wiki/Python_%28programming_language%29">Python</a> and a simple webserver written in Python on Android.</p>
| 16 | 2010-12-07T21:46:18Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 4,828,127 | <p><em>"The <a href="http://www.renpy.org/pygame/">Pygame Subset for Android</a> is a port of a subset of Pygame functionality to the Android platform. The goal of the project is to allow the creation of Android-specific games, and to ease the porting of games from PC-like platforms to Android."</em></p>
<p>The examples include a complete game packaged in an APK, which is pretty interesting. </p>
| 54 | 2011-01-28T12:18:47Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 5,475,949 | <p>There's also python-on-a-chip possibly running mosync: <a href="http://groups.google.com/group/python-on-a-chip/browse_thread/thread/df1c837bae2200f2/02992219b9c0003e?lnk=gst&q=mosync#02992219b9c0003e" rel="nofollow">google group</a></p>
| 7 | 2011-03-29T16:42:06Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 6,136,305 | <p>There's also <a href="https://github.com/damonkohler/sl4a" rel="nofollow">SL4A</a> written by a Google employee.</p>
| 54 | 2011-05-26T09:21:31Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 7,741,114 | <p>I've posted instructions and a patch for cross compiling Python 2.7.2 for Android, you can get it at my blog here: <a href="http://mdqinc.com/blog/2011/09/cross-compiling-python-for-android/">http://mdqinc.com/blog/2011/09/cross-compiling-python-for-android/</a></p>
<p>EDIT: I've open sourced <a href="http://ignifuga.org">Ignifuga</a>, my 2D Game Engine, it's Python/SDL based and it cross compiles for Android. Even if you don't use it for games, you might get useful ideas from the code and the builder utility (named Schafer, after Tim...you know who).</p>
| 50 | 2011-10-12T13:49:09Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 8,189,603 | <p>One way is to use <a href="http://kivy.org/">Kivy</a>:</p>
<blockquote>
<p>Open source Python library for rapid development of applications
that make use of innovative user interfaces, such as multi-touch apps.</p>
</blockquote>
<p></p>
<blockquote>
<p>Kivy runs on Linux, Windows, OS X, Android and iOS. You can run the same [python] code on all supported platforms.</p>
</blockquote>
<p><a href="https://play.google.com/store/apps/details?id=org.kivy.showcase">Kivy Showcase app</a> </p>
| 539 | 2011-11-18T21:49:45Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Subsets and Splits