Look here: [Twisted Web in 60 seconds][1]. That&#39;s a group of blog posts describing step by step how to do lots of common stuff with Twisted, all written by Jean-Paul Calderone, the biggest contributor of Twisted. It&#39;s really where you should start.

After that, look at the Twisted [core documentation][2] then refer to the [API][3] and then into the [source code][4].

Have fun! 


  [1]: http://jcalderone.livejournal.com/tag/sixty%20seconds
  [2]: http://twistedmatrix.com/documents/current/core/howto/index.html
  [3]: http://twistedmatrix.com/documents/current/api/
  [4]: http://twistedmatrix.com/trac/browser/tags/releases/twisted-9.0.0/twisted

There&#39;s a great tutorial here - it&#39;s usually the one I send to new Twisty&#39;s :-)

http://krondo.com/blog/?page_id=1327

Its worth remembering that Twisted programming is more of a thinking paradigm than a programming one. Also, it&#39;s worth doing away with the client server model too - in Twisted there&#39;s just one broker talking in either direction to another.

Take a look here after the above too:

http://twistedmatrix.com/documents/current/core/howto/pb-intro.html

Enjoy :-)

When we do multitouch with two fingers in a UIScrollView, we get two CG points. I want to find the distance between them. Then when again we do the pinch(inside or outside), Then we will again get two points. Then after finding the distance again between these two points , I want to decide whether I pinched in or out. If i have pinched in, surely the new distance will be lesser and vice versa.

But don&#39;t know how to find an accurate measurement for the distance between 2 points for doing comparison ? Is anyone having idea about this ?

How to find the distance between two CG points?

I understand that the Set&lt;K&gt; returned from a Map&lt;K,V&gt;&#39;s keySet() method does not guarantee any particular order.

My question is, does it guarantee the **same** order over multiple iterations.  For example

    Map&lt;K,V&gt; map = getMap();

    for( K k : map.keySet() )
    {
    }

    ...

    for( K k : map.keySet() )
    {
    }

In the above code, assuming that the map is **not** modified, will the iteration over the keySets be in the same order.  Using Sun&#39;s jdk15 it **does** iterate in the same order, but before I depend on this behavior, I&#39;d like to know if all JDKs will do the same.


**EDIT**

I see from the answers that I cannot depend on it.  Too bad.  I was hoping to get away with not having to build some new Collection to guarantee my ordering.  My code needed to iterate through, do some logic, and then iterate through again with the same ordering.  I&#39;ll just create a new ArrayList from the keySet which will guarantee order.

is the Java HashMap keySet() iteration order consistent?

I am trying to start learning twisted for socket servers creation. I want to add some useful features (like auth, and maybe some other). Maybe someone can point me to  a good tutorial which will help me to start (+ maybe some other ideas)

Python twisted: where to start

<p>I am trying to start learning twisted for socket servers creation. I want to add some useful features (like auth, and maybe some other). Maybe someone can point me to  a good tutorial which will help me to start (+ maybe some other ideas)</p>


I have PDF forms that I want to autopopulate with data from my Django web application and then offer to the user to download.  What python library would let me easily pre-populate PDF forms?  These forms are intended to be printed out.

How can I auto-populate a PDF form in Django/Python?

How do I get a Tkinter application to jump to the front? Currently, the window appears behind all my other windows and doesn&#39;t get focus. 

Is there some method I should be calling?

How to make a Tkinter window jump to the front?

Another developer and I disagree about whether `PYTHONPATH` or `sys.path` should be used to allow Python to find a Python package in a user (e.g., development) directory.

We have a Python project with a typical directory structure:

    Project
        setup.py
        package
            __init__.py
            lib.py
            script.py

In script.py, we need to do `import package.lib`.  When the package is installed in site-packages, script.py can find `package.lib`.

When working from a user directory, however, something else needs to be done.  My solution is to set my `PYTHONPATH` to include `&quot;~/Project&quot;`.  Another developer wants to put this line of code in the beginning of script.py:

    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

So that Python can find the local copy of `package.lib`.  

I think this is a bad idea, as this line is only useful for developers or people running from a local copy, but I can&#39;t give a good reason why it is a bad idea.

Should we use `PYTOHNPATH`, `sys.path`, or is either fine?

PYTHONPATH vs. sys.path

I was wondering what the simplest way is to convert a string representation of a list like the following to a `list`:

    x = &#39;[ &quot;A&quot;,&quot;B&quot;,&quot;C&quot; , &quot; D&quot;]&#39;

Even in cases where the user puts spaces in between the commas, and spaces inside of the quotes, I need to handle that as well and convert it to:

    x = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;] 

I know I can strip spaces with `strip()` and `split()` and check for non-letter characters. But the code was getting very kludgy. Is there a quick function that I&#39;m not aware of?

How to convert string representation of list to a list?

I&#39;m using cProfile to profile my Python program. Based upon [this talk][1] I was under the impression that KCacheGrind could parse and display the output from cProfile.

However, when I go to import the file, KCacheGrind just displays an &#39;Unknown File Format&#39; error in the status bar and sits there displaying nothing.

Is there something special I need to do before my profiling stats are compatible with KCacheGrind?

    ...
    if profile:
        import cProfile
        
        profileFileName = &#39;Profiles/pythonray_&#39; + time.strftime(&#39;%Y%m%d_%H%M%S&#39;) + &#39;.profile&#39;
        
        profile = cProfile.Profile()
        profile.run(&#39;pilImage = camera.render(scene, samplePattern)&#39;)
        
        profile.dump_stats(profileFileName)
        profile.print_stats()
    else:            
        pilImage = camera.render(scene, samplePattern)
    ...

__Package Versions__

 - KCacheGrind 4.3.1
 - Python 2.6.2

  [1]: http://blip.tv/file/1957086/

Using cProfile results with KCacheGrind

Everything I&#39;ve read and experienced ( Tornado based apps ) leads me to believe that ePoll is a natural replacement for Select and Poll based networking, especially with Twisted.  Which makes me paranoid, its pretty rare for a better technique or methodology not to come with a price.

   Reading a couple dozen comparisons between epoll and alternatives shows that epoll is clearly the champion for speed and scalability, specifically that it scales in a linear fashion which is fantastic.  That said, what about processor and memory utilization, is epoll still the champ?


Caveats of select/poll vs. epoll reactors in Twisted

Assuming a team of developers are equally comfortable with writing Javascript on the server side as they are with Python &amp; Twisted, when is Node.js going to be more appropriate than Twisted (and vice versa)?

What are the use cases of Node.js vs Twisted?

I have been reading up on the threaded model of programming versus the asynchronous model from this really good article. http://krondo.com/blog/?p=1209

However, the article mentions the following points.

 1. An async program will simply outperform a sync program by switching between tasks whenever there is a I/O.
 2. Threads are managed by the operating system.

I remember reading that threads are managed by the operating system by moving around TCBs between the Ready-Queue and the Waiting-Queue(amongst other queues). In this case, threads don&#39;t waste time on waiting either do they?

In light of the above mentioned, what are the advantages of async programs over threaded programs?

Threads vs. Async

I tried to implement a protocol that can run TLS over TLS using `twisted.protocols.tls`, an interface to OpenSSL using a memory BIO.

I implemented this as a protocol wrapper that mostly looks like a regular TCP transport, but which has `startTLS` and `stopTLS` methods for adding and removing a layer of TLS respectively.  This works fine for the first layer of TLS.  It also works fine if I run it over a &quot;native&quot; Twisted TLS transport.  However, if I try to add a second TLS layer using the `startTLS` method provided by this wrapper, there&#39;s immediately a handshake error and the connection ends up in some unknown unusable state.

The wrapper and the two helpers that let it work looks like this:

    from twisted.python.components import proxyForInterface
    from twisted.internet.error import ConnectionDone
    from twisted.internet.interfaces import ITCPTransport, IProtocol
    from twisted.protocols.tls import TLSMemoryBIOFactory, TLSMemoryBIOProtocol
    from twisted.protocols.policies import ProtocolWrapper, WrappingFactory

    class TransportWithoutDisconnection(proxyForInterface(ITCPTransport)):
        &quot;&quot;&quot;
        A proxy for a normal transport that disables actually closing the connection.
        This is necessary so that when TLSMemoryBIOProtocol notices the SSL EOF it
        doesn&#39;t actually close the underlying connection.

        All methods except loseConnection are proxied directly to the real transport.
        &quot;&quot;&quot;
        def loseConnection(self):
            pass


    class ProtocolWithoutConnectionLost(proxyForInterface(IProtocol)):
        &quot;&quot;&quot;
        A proxy for a normal protocol which captures clean connection shutdown
        notification and sends it to the TLS stacking code instead of the protocol.
        When TLS is shutdown cleanly, this notification will arrive.  Instead of telling
        the protocol that the entire connection is gone, the notification is used to
        unstack the TLS code in OnionProtocol and hidden from the wrapped protocol.  Any
        other kind of connection shutdown (SSL handshake error, network hiccups, etc) are
        treated as real problems and propagated to the wrapped protocol.
        &quot;&quot;&quot;
        def connectionLost(self, reason):
            if reason.check(ConnectionDone):
                self.onion._stopped()
            else:
                super(ProtocolWithoutConnectionLost, self).connectionLost(reason)


    class OnionProtocol(ProtocolWrapper):
        &quot;&quot;&quot;
        OnionProtocol is both a transport and a protocol.  As a protocol, it can run over
        any other ITransport.  As a transport, it implements stackable TLS.  That is,
        whatever application traffic is generated by the protocol running on top of
        OnionProtocol can be encapsulated in a TLS conversation.  Or, that TLS conversation
        can be encapsulated in another TLS conversation.  Or **that** TLS conversation can
        be encapsulated in yet *another* TLS conversation.

        Each layer of TLS can use different connection parameters, such as keys, ciphers,
        certificate requirements, etc.  At the remote end of this connection, each has to
        be decrypted separately, starting at the outermost and working in.  OnionProtocol
        can do this itself, of course, just as it can encrypt each layer starting with the
        innermost.
        &quot;&quot;&quot;
        def makeConnection(self, transport):
            self._tlsStack = []
            ProtocolWrapper.makeConnection(self, transport)


        def startTLS(self, contextFactory, client, bytes=None):
            &quot;&quot;&quot;
            Add a layer of TLS, with SSL parameters defined by the given contextFactory.

            If *client* is True, this side of the connection will be an SSL client.
            Otherwise it will be an SSL server.

            If extra bytes which may be (or almost certainly are) part of the SSL handshake
            were received by the protocol running on top of OnionProtocol, they must be
            passed here as the **bytes** parameter.
            &quot;&quot;&quot;
            # First, create a wrapper around the application-level protocol
            # (wrappedProtocol) which can catch connectionLost and tell this OnionProtocol 
            # about it.  This is necessary to pop from _tlsStack when the outermost TLS
            # layer stops.
            connLost = ProtocolWithoutConnectionLost(self.wrappedProtocol)
            connLost.onion = self
            # Construct a new TLS layer, delivering events and application data to the
            # wrapper just created.
            tlsProtocol = TLSMemoryBIOProtocol(None, connLost, False)
            tlsProtocol.factory = TLSMemoryBIOFactory(contextFactory, client, None)

            # Push the previous transport and protocol onto the stack so they can be
            # retrieved when this new TLS layer stops.
            self._tlsStack.append((self.transport, self.wrappedProtocol))

            # Create a transport for the new TLS layer to talk to.  This is a passthrough
            # to the OnionProtocol&#39;s current transport, except for capturing loseConnection
            # to avoid really closing the underlying connection.
            transport = TransportWithoutDisconnection(self.transport)

            # Make the new TLS layer the current protocol and transport.
            self.wrappedProtocol = self.transport = tlsProtocol

            # And connect the new TLS layer to the previous outermost transport.
            self.transport.makeConnection(transport)

            # If the application accidentally got some bytes from the TLS handshake, deliver
            # them to the new TLS layer.
            if bytes is not None:
                self.wrappedProtocol.dataReceived(bytes)


        def stopTLS(self):
            &quot;&quot;&quot;
            Remove a layer of TLS.
            &quot;&quot;&quot;
            # Just tell the current TLS layer to shut down.  When it has done so, we&#39;ll get
            # notification in *_stopped*.
            self.transport.loseConnection()


        def _stopped(self):
            # A TLS layer has completely shut down.  Throw it away and move back to the
            # TLS layer it was wrapping (or possibly back to the original non-TLS
            # transport).
            self.transport, self.wrappedProtocol = self._tlsStack.pop()


I have simple client and server programs for exercising this, available from launchpad (`bzr branch lp:~exarkun/+junk/onion`).  When I use it to call the `startTLS` method above twice, with no intervening call to `stopTLS`,  this OpenSSL error comes up:

    OpenSSL.SSL.Error: [(&#39;SSL routines&#39;, &#39;SSL23_GET_SERVER_HELLO&#39;, &#39;unknown protocol&#39;)]

Why do things go wrong?


Why is there a handshake failure when trying to run TLS over TLS with this code?

Why do we need RabbitMQ when we have a more powerful network framework in Python called Twisted. I am trying to understand the reason why someone would want to use RabbitMQ. 

Could you please provide a scenario or an example using RabbitMQ?

Also, where can I find a tutorial on how to use RabbitMQ?



Content Type	Original Author	Original Content on Stackoverflow
Question	Oleg Tarasenko	View Question on Stackoverflow
Solution 1 - Python	Etienne	View Answer on Stackoverflow
Solution 2 - Python	Ben Hughes	View Answer on Stackoverflow

Python twisted: where to start

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

is the Java HashMap keySet() iteration order consistent?

How to find the distance between two CG points?

Attributions