Initial import from SVN

.gitignore

@@ -0,0 +1,2 @@
+*.swp
+*.pyc

AUTHORS

@@ -0,0 +1,3 @@
+Julio Biason <julio.biason@gmail.com>
+Deepak Sarda <deepak@antrix.net>
+Gerald Kaszuba <gerald.kaszuba@gmail.com>

COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

MANIFEST

@@ -0,0 +1,21 @@
+mitter
+mitter.desktop
+setup.py
+mitterlib/__init__.py
+mitterlib/constants.py
+mitterlib/threadhttp.py
+mitterlib/twitter.py
+mitterlib/ui/__init__.py
+mitterlib/ui/console_utils.py
+mitterlib/ui/notify.py
+mitterlib/ui/timesince.py
+mitterlib/ui/ui_cmd.py
+mitterlib/ui/ui_pygtk.py
+mitterlib/ui/ui_tty.py
+mitterlib/ui/utils.py
+pixmaps/mitter-new.png
+pixmaps/mitter.png
+pixmaps/unknown.png
+AUTHORS
+COPYING
+THANKS

THANKS

@@ -0,0 +1,14 @@
+Many thanks to:
+
+- Wayne Richardson, who actually reminded that some people use Mitter and 
+  when I break stuff, it stops working for them and for the Ctrl+Enter to
+  send messages.
+- Santiago Gala, for the locale parsing patch.
+- Mike, who posted a comment on my blog with an issue of the TTY interface.
+- Faheem Pervez, for the Maemo deb.
+- Sugree Phatanapherom, for the constant testing in weird situations.
+- Apirak, who came with some interesting interface ideas.
+- Kristian Rietveld, who posted a solution to the auto-word-wrap GtkTreeView
+  (http://lists-archives.org/gtk/06637-tree-view-cell-size-negotiation.html)
+- Wiennat for the retweet patch.
+  

check

@@ -0,0 +1,3 @@
+#!/bin/sh
+find . -name '*.py' -exec pyflakes {} \;
+python utils/pep8.py --filename=*.py --repeat .

docs/Makefile

@@ -0,0 +1,75 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d .build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html web pickle htmlhelp latex changes linkcheck
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html      to make standalone HTML files"
+	@echo "  pickle    to make pickle files"
+	@echo "  json      to make JSON files"
+	@echo "  htmlhelp  to make HTML files and a HTML help project"
+	@echo "  latex     to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  changes   to make an overview over all changed/added/deprecated items"
+	@echo "  linkcheck to check all external links for integrity"
+
+clean:
+	-rm -rf .build/*
+
+html:
+	mkdir -p .build/html .build/doctrees
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) .build/html
+	@echo
+	@echo "Build finished. The HTML pages are in .build/html."
+
+pickle:
+	mkdir -p .build/pickle .build/doctrees
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) .build/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+web: pickle
+
+json:
+	mkdir -p .build/json .build/doctrees
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) .build/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	mkdir -p .build/htmlhelp .build/doctrees
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) .build/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in .build/htmlhelp."
+
+latex:
+	mkdir -p .build/latex .build/doctrees
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) .build/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in .build/latex."
+	@echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
+	      "run these through (pdf)latex."
+
+changes:
+	mkdir -p .build/changes .build/doctrees
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) .build/changes
+	@echo
+	@echo "The overview file is in .build/changes."
+
+linkcheck:
+	mkdir -p .build/linkcheck .build/doctrees
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) .build/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in .build/linkcheck/output.txt."

docs/conf.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+#
+# Mitter documentation build configuration file, created by
+# sphinx-quickstart on Sun Apr  5 18:19:25 2009.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# The contents of this file are pickled, so don't put values in the namespace
+# that aren't pickleable (module imports are okay, they're removed automatically).
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If your extensions are in another directory, add it here. If the directory
+# is relative to the documentation root, use os.path.abspath to make it
+# absolute, like shown here.
+sources = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(sources)
+
+# And now, for something completely ugly:
+mitterlib = os.path.join(sources, 'mitterlib')
+sys.path.append(mitterlib)
+
+mitterlib_network = os.path.join(mitterlib, 'network')
+sys.path.append(mitterlib_network)
+
+# General configuration
+# ---------------------
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.intersphinx']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['.templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'Mitter'
+copyright = u'2009, Julio Biason'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '1.0'
+# The full version, including alpha/beta/rc tags.
+release = '1.0'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of documents that shouldn't be included in the build.
+#unused_docs = []
+
+# List of directories, relative to source directory, that shouldn't be searched
+# for source files.
+exclude_trees = ['.build']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+
+# Options for HTML output
+# -----------------------
+
+# The style sheet to use for HTML and HTML Help pages. A file of that name
+# must exist either in Sphinx' static/ path, or in one of the custom paths
+# given in html_static_path.
+html_style = 'default.css'
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['.static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_use_modindex = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, the reST sources are included in the HTML build as _sources/<name>.
+#html_copy_source = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = ''
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Mitterdoc'
+
+
+# Options for LaTeX output
+# ------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+#latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = [
+  ('index', 'Mitter.tex', ur'Mitter Documentation',
+   ur'Julio Biason', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_use_modindex = True
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {'http://docs.python.org/dev': None}

docs/index.rst

@@ -0,0 +1,21 @@
+.. Mitter documentation master file, created by sphinx-quickstart on Sun Apr  5 18:19:25 2009.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to Mitter's documentation!
+==================================
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   networkbase
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+

docs/networkbase.rst

@@ -0,0 +1,15 @@
+:mod:`networkbase` -- Base classes for all networks
+===================================================
+
+.. automodule:: networkbase
+
+NetworkData -- Unified information about messages
+-------------------------------------------------
+
+.. autoclass:: NetworkData
+
+NetworkBase -- Base class for all networks
+------------------------------------------
+
+.. autoclass:: NetworkBase
+   :members:

mitter

@@ -0,0 +1,106 @@
+#!/usr/bin/python2.5
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import time
+import urllib
+import os
+import logging
+import warnings
+
+import mitterlib.network as network
+
+from mitterlib.configopt import ConfigOpt
+from mitterlib.network import Networks
+from mitterlib import ui
+
+log = logging.getLogger('mitter')
+
+
+def main():
+    """Main function."""
+
+    # options
+
+    options = ConfigOpt()
+    options.add_group('General', 'General options')
+    options.add_option('-d', '--debug',
+            group='General',
+            option='debug',
+            action='store_true',
+            help='Display debugging information.',
+            default=False,
+            is_config_option=False)
+    options.add_option('-i', '--interface',
+            group='General',
+            option='interface',
+            default=None,
+            metavar='INTERFACE',
+            help='Interface to be used.')
+
+    # Ask networks to add their options
+
+    connection = Networks(options)
+
+    # Ask interfaces to add their options
+
+    ui.interface_options(options)
+
+    # Parse the command line options and the config file
+
+    options()
+
+    # start the logging service
+
+    if options['General']['debug']:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+    log = logging.getLogger('mitter')
+
+    # disable the warnings. Interfaces may choose to receive the warnings
+    # changing the filter to "error"
+    warnings.simplefilter('ignore')
+
+    # select an interface (preferably, the one the user selected in the
+    # command line)
+    preferred_interface = options['General']['interface']
+    log.debug('Config interface: %s', preferred_interface)
+
+    if 'interface' in options.conflicts:
+        preferred_interface = options.conflicts['interface']
+        log.debug('Command line interface: %s', preferred_interface)
+
+    interface = ui.interface(preferred_interface)
+
+    if interface is None:
+        log.error('Sorry, no interface could be found for your system')
+        return
+
+    # now start the twitter connection
+    log.debug('Starting networks')
+    connection = Networks(options)
+    display = interface.Interface(connection, options)
+
+    # display the interface (the interface should take care of updating
+    # itself)
+    display()
+    options.save()
+
+if __name__ == '__main__':
+    main()

mitter.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Version=0.4
+Encoding=UTF-8
+Name=Mitter
+Comment=A client for twitter.com
+Exec=/usr/bin/mitter
+Icon=mitter
+Type=Application
+Categories=Network

mitterlib/__init__.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason, Deepak Sarda
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+
+def find_image(image_name):
+    """Using the iamge_name, search in the common places. Return the path for
+    the image or None if the image couldn't be found."""
+
+    # just because I'm a logging nut
+
+    log = logging.getLogger('mitterlib.find_image')
+
+    import os.path
+    import sys
+
+    # the order is the priority, so keep global paths before local paths
+
+    current_dir = os.path.abspath(os.path.dirname(__file__))
+
+    common_paths = [
+            os.path.join(sys.prefix, 'share', 'pixmaps'),
+            os.path.join('.', 'pixmaps'),
+            os.path.join(current_dir, '..', 'pixmaps')]
+
+    for path in common_paths:
+        filename = os.path.join(path, image_name)
+        log.debug('Checking %s...' % (filename))
+        if os.access(filename, os.F_OK):
+            log.debug('Default image is %s' % (filename))
+            return filename
+
+    return None

mitterlib/configopt.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python
+# ConfigOpt: An OptParse/ConfigParser object.
+
+import os.path
+import ConfigParser
+
+from optparse import OptionParser, OptionGroup, Option
+
+_true_values = ('True', 'true', 'Yes', 'yes')
+_false_values = ('False', 'false', 'No', 'no')
+
+
+class ReferenceOption(Option):
+
+    def __init__(self, *args, **kwargs):
+        if 'group' in kwargs:
+            self.group = kwargs['group']
+            del kwargs['group']
+        else:
+            self.group = None
+
+        if 'option' in kwargs:
+            self.option = kwargs['option']
+            del kwargs['option']
+        else:
+            self.option = None
+
+        if 'conflict_group' in kwargs:
+            self.conflict_group = kwargs['conflict_group']
+            del kwargs['conflict_group']
+        else:
+            self.conflict_group = None
+
+        Option.__init__(self, *args, **kwargs)
+
+
+class ConfigOptOption(object):
+    """An option."""
+
+    def __init__(self, *args, **kwargs):
+        if not 'name' in kwargs:
+            raise AttributeError('Missing option name')
+
+        self.name = kwargs['name']
+        del kwargs['name']
+
+        if 'is_cmd_option' in kwargs:
+            self._cmd_option = kwargs['is_cmd_option']
+            del kwargs['is_cmd_option']
+        else:
+            self._cmd_option = True # default value
+
+        if 'is_config_option' in kwargs:
+            self._config_option = kwargs['is_config_option']
+            del kwargs['is_config_option']
+        else:
+            self._config_option = True
+
+        if 'default' in kwargs:
+            self._default = kwargs['default']
+            del kwargs['default']   # Remove it so we don't pass it to
+                                    # OptionParser -- we have our own defaults
+                                    # and, passing it to OptionParser would
+                                    # make it always return as set in the
+                                    # command line, breaking the behaviour we
+                                    # want.
+        else:
+            self._default = None
+
+        self._params = kwargs
+        self._args = args
+        self.config_value = None
+        self.cmd_value = None
+        self._set_value = None
+
+    def _get_value(self):
+        """Return the value of a variable."""
+        # this is the priority order: First, the value set by the application;
+        # if it's not set, use the command line value; if there is no option
+        # in the command line, use the config value; if this is also not set,
+        # return the default value for the variable.
+        if self._set_value is not None:
+            return self._set_value
+
+        if self.cmd_value is not None:
+            return self.cmd_value
+
+        if self.config_value is not None:
+            return self.config_value
+
+        return self._default
+
+    def _set_value(self, x):
+        """Set the value of the variable. Used by the application to set a
+        value for it."""
+        self._set_value = x
+
+    value = property(_get_value, _set_value)
+
+    @property
+    def args(self):
+        return self._args
+
+    @property
+    def params(self):
+        return self._params
+
+    @property
+    def cmd_option(self):
+        return self._cmd_option
+
+    @property
+    def config_option(self):
+        return self._config_option
+
+
+class ConfigOptGroup(object):
+    """A group of options."""
+
+    def __init__(self, name, desc):
+        self.name = name
+        self.desc = desc
+        self.options = {}
+        return
+
+    def add_option(self, *args, **kwargs):
+        """Add an option in the group."""
+        id = kwargs['name']
+        if id in self.options:
+            return
+        self.options[id]= ConfigOptOption(*args, **kwargs)
+        return
+
+    def cmd_parser(self, parser):
+        """Build the command line parser for the option."""
+        group = OptionGroup(parser, self.desc)
+        options = 0     # to avoid adding an empty group
+
+        for option_id in self.options:
+            option = self.options[option_id]
+            if option.cmd_option:
+                internal_name = self.name + '_' + option.name   # to avoid
+                                                                # clashes
+                option_params = option.params
+                option_params['dest'] = internal_name
+                option_params['group'] = self.name
+                option_params['option'] = option.name
+
+                if not 'metavar' in option_params:
+                    option_params['metavar'] = option.name.upper()
+
+                group.add_option(*option.args, **option_params)
+
+                options += 1
+
+        if options > 0:
+            parser.add_option_group(group)
+
+        return
+
+    def __getitem__(self, key):
+        return self.options[key].value
+
+    def __setitem__(self, key, value):
+        self.options[key].value = value
+
+
+class ConfigOpt(object):
+    """Command line and config file option merger."""
+
+    def __init__(self, app_name=None):
+        """Class initialization. <app_name> is used to create the config file
+        in the user home directory."""
+
+        if app_name is None:
+            import sys
+            filename = os.path.basename(sys.argv[0])
+            (name, _) = os.path.splitext(filename)
+            app_name = name
+
+
+        self._config_name = os.path.expanduser(os.path.join('~', '.' +
+            app_name + '.ini'))
+        self._cmd_parser = OptionParser(option_class=ReferenceOption)
+
+        self._cmd_parser.add_option('-c', '--config',
+                dest='config_file',
+                help='Configuration file.',
+                default = self._config_name)
+
+        self._groups = {}
+        self._conflicts = None
+
+    @property
+    def conflicts(self):
+        """Return the dictionary with the groups in the conflict groups."""
+        return self._conflicts
+
+    def add_group(self, id, desc=None):
+        """Create a new group of options."""
+        if id in self._groups:
+            return
+        self._groups[id] = ConfigOptGroup(id, desc)
+        return
+
+    def add_option(self, *args, **kwargs):
+        """Add an option in the list of options."""
+        assert 'group' in kwargs
+        assert 'option' in kwargs
+
+        group_id = kwargs['group']
+        del kwargs['group']
+
+        option_id = kwargs['option']
+        del kwargs['option']
+
+        group = self._groups[group_id]
+        group.add_option(name=option_id, *args, **kwargs)
+
+    def load(self):
+        """Load the options for the config file."""
+        config = ConfigParser.SafeConfigParser()
+        config.read(self._config_name)
+
+        for section in config.sections():
+            if section not in self._groups:
+                continue        # ignore this group
+
+            for option in config.options(section):
+                if option not in self._groups[section].options:
+                    continue
+
+                value = config.get(section, option)
+                # convert int values
+                if value.isdigit():
+                    value = int(value)
+
+                # Convert boolean values
+                if value in _true_values or value in _false_values:
+                    value = (value in _true_values)
+
+                self._groups[section].options[option].config_value = value
+        return
+
+    def save(self):
+        """Save the config file."""
+        config = ConfigParser.SafeConfigParser()
+        for group in self._groups:
+            group_added = False
+
+            for option_id in self._groups[group].options:
+                option = self._groups[group].options[option_id]
+
+                if not option.config_option:
+                    continue
+
+                if not group_added:
+                    # prevents empty groups
+                    config.add_section(group)
+                    group_added = True
+
+                config.set(group, option.name, str(option.value))
+
+        config_file = file(self._config_name, 'w')
+        config.write(config_file)
+        config_file.close()
+        return
+
+    def __call__(self):
+        """Callable object, do the parsing of the command line and loads the
+        config file required."""
+        for group in self._groups:
+            self._groups[group].cmd_parser(self._cmd_parser)
+
+        (options, args) = self._cmd_parser.parse_args()
+        self._config_name = options.config_file
+        self._conflicts = {}
+
+        for group in self._cmd_parser.option_groups:
+            for option in group.option_list:
+                group_id = option.group
+                option_id = option.option
+                value = getattr(options, option.dest)
+                conflict_group = option.conflict_group
+
+                if value is None:
+                    continue
+
+                if conflict_group and conflict_group in self._conflicts:
+                    if group_id != self._conflicts[conflict_group]:
+                        self._cmd_parser.error(
+                                "You can't mix options from %s and %s." % (
+                                    self._conflicts[conflict_group], group_id))
+                        return
+
+                self._conflicts[conflict_group] = group_id
+                self._groups[group_id].options[option_id].cmd_value = value
+
+        self.load()
+
+    def __getitem__(self, key):
+        return self._groups[key]

mitterlib/constants.py

@@ -0,0 +1,697 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a simple client for Twitter.
+# Copyright (C) 2007, 2008  The Mitter Contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+version = '1.0.0.alpha1'
+
+gpl_3 = """
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+"""

mitterlib/network/__init__.py

@@ -0,0 +1,229 @@
+#!/usr/bin/python2.5
+# -*- coding: utf-8 -*-
+
+# Mitter, a simple client for Twitter
+# Copyright (C) 2007, 2008  The Mitter Contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os.path
+import glob
+import logging
+
+from mitterlib.network.networkbase import NetworkData
+
+_log = logging.getLogger('mitterlib.network.Networks')
+
+# List of files that are not networks
+SKIPPABLES = ('__init__.py', 'networkbase.py')
+
+#--------------------------------------------------------------------
+# Helper functions
+#--------------------------------------------------------------------
+
+
+def _import_name(module):
+    (name, _) = os.path.splitext(module)
+    return 'mitterlib.network.%s' % (name)
+
+
+def _networks():
+    network_dir = os.path.dirname(__file__)
+
+    networks = glob.glob(os.path.join(network_dir, '*.py'))
+    for network in networks:
+        network_name = os.path.basename(network)
+        if network_name in SKIPPABLES:
+            # not a real network
+            continue
+
+        module_name = _import_name(network_name)
+        yield module_name
+
+#--------------------------------------------------------------------
+# Exceptions
+#--------------------------------------------------------------------
+
+
+class NetworksError(Exception):
+    """Basic Networks exception."""
+    pass
+
+
+class NetworksNoSuchNetworkError(NetworksError):
+    """The request network does not exists."""
+
+    def __init__(self, network):
+        self._network = network
+
+    def __str__(self):
+        return 'Unknown network %s' % (self._network)
+    pass
+
+
+class NetworksNoNetworkSetupError(NetworksError):
+    """There are no networks set up."""
+    pass
+
+
+class NetworksErrorLoadingNetwork(NetworksError):
+    """Error loadig one of the networks."""
+
+    def __init__(self, network, exception):
+        self._network = network
+        self._exception = str(exception)
+
+    def __str__(self):
+        return "Couldn't load %s (%s)" % (self._network, self._exception)
+
+
+class Networks(object):
+    """Network transparency layer: Keeps a list of available networks and send
+    requests to all those who have been setup."""
+
+    def __init__(self, options):
+        self._networks = {}
+        self._options = options
+        self.options()
+
+    @property
+    def networks(self):
+        if self._networks:
+            return self._networks
+
+        for module_name in _networks():
+            try:
+                module = __import__(module_name, fromlist=[module_name])
+                connection = module.Connection(self._options)
+                self._networks[connection.SHORTCUT] = connection
+            except ImportError, ex:
+                raise NetworksErrorLoadingNetwork(module_name, ex)
+
+        return self._networks
+
+    def _targets(self, shortcut):
+        """Select a network based on the shortcut. If the shortcut is None,
+        returns all available network shortcuts."""
+        if shortcut:
+            if not shortcut in self.networks:
+                raise NetworksNoSuchNetworkError(shortcut)
+            else:
+                targets = [shortcut]
+        else:
+            targets = self.networks
+
+        setup = False
+        for target in targets:
+            if self.networks[target].is_setup():
+                setup = True
+                yield target
+
+        if not setup:
+            raise NetworksNoNetworkSetupError
+
+    def settings(self):
+        """Return a dictionary with the options that the interfaces need to
+        setup."""
+        result = []
+        for shortcut in self.networks:
+            settings = {
+                'shortcut': shortcut,
+                'name': self.networks[shortcut].NAMESPACE,
+                'options': self.networks[shortcut].AUTH,
+            }
+            result.append(settings)
+        return result
+
+    def options(self):
+        """Request all networks to add their options."""
+        for shortcut in self.networks:
+            conn = self.networks[shortcut]
+            conn.options(self._options)
+
+        return
+
+    def name(self, shortcut):
+        """Return the name of a network based on the shortcut."""
+        try:
+            name = self.networks[shortcut].NAMESPACE
+        except KeyError:
+            raise NetworksNoSuchNetworkError(shortcut)
+        return name
+
+    # This is basically a copy of all methods available in NetworkBase, with
+    # the additional parameter "network" (to request data from just one
+    # source)
+
+    def messages(self, network=None):
+        """Return a list of NetworkData objects for the main "timeline" (the
+        default list presented to the user.)"""
+        result = []
+        for shortcut in self._targets(network):
+            for message in self.networks[shortcut].messages():
+                message.network = shortcut
+                result.append(message)
+        return result
+
+    def update(self, status, reply_to=None, network=None):
+        """Update the user status. Must return the id for the new status."""
+        if reply_to and isinstance(reply_to, NetworkData):
+            # If you pass a NetworkData object, we get the proper network
+            network = reply_to.network
+
+        for shortcut in self._targets(network):
+            self.networks[shortcut].update(status, reply_to)
+        return None
+
+    def delete_message(self, message, network=None):
+        """Delete an update. Message can be a NetworkData object, in which
+        case network is not necessary; otherwise a network must be
+        provided."""
+        if isinstance(message, NetworkData):
+            network = message.network
+
+        self.networks[network].delete_message(message)
+        return
+
+    def message(self, message_id, network):
+        """Return a single NetworkData object for a specified message."""
+        if not network in self.networks:
+            raise NetworksNoSuchNetworkError(network)
+
+        data = self.networks[network].message(message_id)
+        data.network = network
+        return data
+
+    def replies(self, network=None):
+        """Return a list of NetworkData objects for the replies for the user
+        messages."""
+        result = []
+        for shortcut in self._targets(network):
+            for message in self.networks[shortcut].replies():
+                message.network = shortcut
+                result.append(message)
+        return result
+
+    def inbox(self, network=None):
+        """Return a list of NetworkData objects for the direct messages/inbox
+        of the user."""
+        return []
+
+    def available_requests(self, network=None):
+        """Return a dictionary with the available requests the user can
+        make to each network before getting capped."""
+        result = {}
+        for shortcut in self._targets(network):
+            requests = self.networks[shortcut].available_requests()
+            result[shortcut] = requests
+        return result

mitterlib/network/networkbase.py

@@ -0,0 +1,225 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a client for Twitter.
+# Copyright (C) 2007, 2008 The Mitter Contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+.. moduleauthor:: Julio Biason <julio.biason@gmail.com>
+
+The :mod:`networkbase` module defines the base classes for all networks.
+"""
+
+import logging
+import datetime
+
+from mitterlib.constants import version
+
+# logging
+_log = logging.getLogger('mitterlib.network.Network')
+
+
+def auth_options(namespace, options, auths):
+    """Convert the auth fields into options for the command line."""
+    for option in auths:
+        options.add_option(group=namespace,
+                option=option['name'],
+                default=None,
+                help=option['help'],
+                *(option['flags']))
+
+#--------------------------------------------------------------------
+# Exceptions
+#--------------------------------------------------------------------
+
+
+class NetworkError(Exception):
+    """Base class for all network related exceptions."""
+    pass
+
+
+class NetworkUnknownError(NetworkError):
+    """Some non-expected error occurred."""
+    pass
+
+
+class NetworkLimitExceededError(NetworkError):
+    """The number of requests available was exceeded."""
+    pass
+
+
+class NetworkDNSError(NetworkError):
+    """A DNS failure prevented the request to continue."""
+    pass
+
+
+class NetworkInvalidResponseError(NetworkError):
+    """The server returned the information in an unexpected way."""
+    pass
+
+
+class NetworkLowLevelError(NetworkError):
+    """A low level error occurred in the network layer."""
+    pass
+
+
+class NetworkBadStatusLineError(NetworkError):
+    """Bad status line exception."""
+    pass
+
+
+class NetworkAuthorizationFailError(NetworkError):
+    """Authorization failure."""
+    pass
+
+
+class NetworkPermissionDeniedError(NetworkError):
+    """Permission denied when accessing the message/list."""
+    pass
+
+#--------------------------------------------------------------------
+# Warnings
+#--------------------------------------------------------------------
+class NetworkWarning(Warning):
+    """Base warning for networks."""
+    pass
+
+class MessageTooLongWarning(NetworkWarning):
+    """The message is too long for the network."""
+    pass
+
+#--------------------------------------------------------------------
+# The classes
+#--------------------------------------------------------------------
+
+
+class NetworkData(object):
+    """Provides an uniform way to access information about posts. The
+    following fields should appear:
+
+    **id**
+       The message identification.
+
+    **name**
+       The name to be displayed as author of the message.
+
+    **username**
+       The message author username in the network.
+
+    **avatar**
+       URL to the author avatar.
+
+    **message**
+       The message.
+
+    **message_time**
+       Message timestamp (as a datetime object). Defaults to None.
+
+    **parent**
+       The parent of this message, in case of a reply.
+
+    **network**
+       The network id source of the message. Network classes don't need to
+       worry about this field themselves; :class:`Networks` will set it when
+       merging information from all networks.
+    """
+    def __init__(self):
+        self.id = ''
+        self.name = ''
+        self.username = ''
+        self.avatar = ''
+        self.message = ''
+        self.message_time = None
+        self.parent = ''
+        self.network = ''
+
+
+class NetworkBase(object):
+    """Base class for all networks."""
+    _user_agent = 'Mitter %s' % (version)
+
+    # TODO: We'll probably need a ICON attribute in the future.
+    #: Namespace of the network, used to identify options.
+    NAMESPACE = 'Meta'
+
+    AUTH = []
+    """List of fields the interface must request to the user in order to
+    retrieve information from the network. It's a list of dictionaries,
+    containing:
+
+    * *name*: Name of the option, used in ConfigOpt (for the name in the
+      config file and to access it through the options variable);
+
+    * *flags*: The list of command line options for this option (as in
+      OptParse);
+
+    * *prompt*: The prompt to be used by interfaces when requesting the
+      variable;
+
+    * *help*: Description for the value; it's used by ConfigOpt to show the
+      description of the paramater in the command line options and can be used
+      by interfaces to show tooltips about the field;
+
+    * *type*: The type of the option; valid values are:
+
+      * 'str': A string;
+
+      * 'passwd': Password; string, but interfaces should hide the information
+        if possible.
+    """
+
+
+    def is_setup(self):
+        """Should return a boolean indicating if the network have all
+        necessary options set up so it can retrieve information.
+        :class:`Networks` won't send requests to networks that return False to
+        this function."""
+        return False
+
+    def messages(self):
+        """Return a list of :class:`NetworkData` objects for the main
+        "timeline" (the default list presented to the user.)"""
+        return []
+
+    def update(self, status, reply_to=None):
+        """Update the user status. *status* should be the string with the
+        status update; *reply_to* should be used in case the message is a
+        reply to another message, it could be a simple id or the
+        :class:`NetworkData` object of the original data. Must return the id
+        for the new status."""
+        return None
+
+    def delete_message(self, message):
+        """Delete an update. Must return True if the message was deleted or
+        False if not. *message* can be either an id or a :class:`NetworkData`
+        object with the information about the message to be deleted."""
+        return False
+
+    def message(self, message_id):
+        """Return a single :class:`NetworkData` object for a specified
+        message."""
+        return None
+
+    def replies(self):
+        """Return a list of :class:`NetworkData` objects for the replies for
+        the user messages."""
+        return []
+
+    def available_requests(self):
+        """Return the number of requests the user can request before being
+        capped. If such limitation doesn't exist for the network, a negative
+        number should be returned."""
+        return -1

mitterlib/network/twitter.py

@@ -0,0 +1,414 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a client for Twitter.
+# Copyright (C) 2007, 2008 The Mitter Contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import urllib
+import urllib2
+import logging
+import datetime
+import base64
+import htmlentitydefs
+import re
+
+from httplib import BadStatusLine
+from socket import error as socketError
+
+from networkbase import NetworkBase, NetworkData, auth_options, \
+        NetworkDNSError, NetworkBadStatusLineError, NetworkLowLevelError, \
+        NetworkInvalidResponseError, NetworkPermissionDeniedError
+
+try:
+    # Python 2.6/3.0 JSON parser
+    import json
+except ImportError:
+    # Fallback to SimpleJSON
+    import simplejson as json
+
+# logging
+_log = logging.getLogger('mitterlib.network.Twitter')
+
+# the month names come directly from the site, so we are not affected by
+# locale settings.
+_month_names = [None, 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
+        'Sep', 'Oct', 'Nov', 'Dec']
+
+
+def _unhtml(text):
+    """Convert text coming in HTML encoded to UTF-8 representations."""
+    new_text = []
+    copy_pos = 0
+    _log.debug('Original text: %s', text)
+    for code in re.finditer(r'&(\w+);', text):
+        new_text.append(text[copy_pos:code.start()])
+        entity = text[code.start()+1:code.end()-1]
+        if entity in htmlentitydefs.name2codepoint:
+            new_text.append(unichr(
+                    htmlentitydefs.name2codepoint[entity]))
+        else:
+            new_text.append(code.group().decode('utf8'))
+        copy_pos = code.end()
+
+    new_text.append(text[copy_pos:])
+
+    _log.debug('New text: %s', new_text)
+    result = u''.join(new_text)
+    _log.debug('Result: %s', result)
+    return result
+
+
+def _htmlize(text):
+    """Convert accented characters to their HTML entities."""
+    new = []
+    # XXX: This is not very effective, but Twitter only accepts 140 chars,
+    # so it won't be a big pain.
+    for char in text:
+        if ord(char) in htmlentitydefs.codepoint2name:
+            new.append('&%s;' % (htmlentitydefs.codepoint2name[ord(char)]))
+        else:
+            new.append(char)
+    return ''.join(new)
+
+
+def _to_datetime(server_str):
+    """Convert a date send by the server to a datetime object.
+    Ex:
+        from this:
+            Tue Mar 13 00:12:41 +0000 2007
+            to datetime.
+    """
+    date_info = server_str.split(' ')
+    month = _month_names.index(date_info[1])
+    day = int(date_info[2])
+    year = int(date_info[5])
+
+    time_info = date_info[3].split(':')
+    hour = int(time_info[0])
+    minute = int(time_info[1])
+    second = int(time_info[2])
+
+    return datetime.datetime(year, month, day, hour, minute, second)
+
+
+def _make_datetime(response):
+    """Converts dates on responses to datetime objects."""
+    result = []
+    for tweet in response:
+        result.append(TwitterNetworkData(tweet))
+
+    return result
+
+
+class TwitterNetworkData(NetworkData):
+    """A simple wrapper around NetworkData, to make things easier to convert
+    twitter data into a NetworkData object."""
+
+    def __init__(self, data):
+        """Class initialization. Receives a dictionary with a single tweet."""
+        NetworkData.__init__(self)
+
+        self.id = data['id']
+        self.name = data['user']['name']
+        self.username = data['user']['screen_name']
+        self.avatar = data['user']['profile_image_url']
+        self.message_time = _to_datetime(data['created_at'])
+
+        if 'in_reply_to_status_id' in data and data['in_reply_to_status_id']:
+            self.parent = int(data['in_reply_to_status_id'])
+
+        # Twitter encodes a lot of HTML entities, which are not good when
+        # you want to *display* then (e.g., "<" returns to us as "&lt;").
+        # So we convert this here.
+        self.message = _unhtml(data['text'])
+
+        return
+
+
+class Connection(NetworkBase):
+    """Base class to talk to twitter."""
+
+    NAMESPACE = 'Twitter'
+    SHORTCUT = 'tw'     # TODO: find a way to move this to the config file
+
+    def is_setup(self):
+        """Return True or False if the network is setup/enabled."""
+        if (self._options[self.NAMESPACE]['username'] and
+                self._options[self.NAMESPACE]['password']):
+            # Consider the network enabled if there is an username and
+            # password
+            return True
+        else:
+            return False
+
+    def __init__(self, options):
+        self._options = options
+
+    @property
+    def server(self):
+        if self._options[self.NAMESPACE]['https']:
+            return self._options[self.NAMESPACE]['secure_server_url']
+        else:
+            return self._options[self.NAMESPACE]['server_url']
+
+    def _common_headers(self):
+        """Returns a string with the normal headers we should add on every
+        request"""
+
+        auth = base64.b64encode('%s:%s' % (
+            self._options[self.NAMESPACE]['username'],
+            self._options[self.NAMESPACE]['password']))
+
+        headers = {
+                'Authorization': 'Basic %s' % (auth),
+                'User-Agent': self._user_agent}
+        return headers
+
+    def _request(self, resource, headers=None, body=None):
+        """Send a request to the Twitter server. Once finished, call the
+        function at callback."""
+
+        url = '%s%s' % (self.server, resource)
+        _log.debug('Request %s' % (url))
+
+        request = urllib2.Request(url=url)
+        request_headers = self._common_headers()
+        if headers:
+            request_headers.update(headers)
+
+        for key in request_headers:
+            _log.debug('Header: %s=%s' % (key, request_headers[key]))
+            request.add_header(key, request_headers[key])
+
+        if body:
+            _log.debug('Body: %s' % (body))
+            request.add_data(body)
+
+        try:
+            _log.debug('Starting request of %s' % (url))
+            response = urllib2.urlopen(request)
+            data = response.read()
+        except urllib2.HTTPError, exc:
+            _log.debug('HTTPError: %d' % (exc.code))
+            _log.debug('HTTPError: response body:\n%s' % exc.read())
+            # To me, I got a lot of 502 for "replies". It shows the
+            # "Something is technically wrong" most of the time in the real
+            # pages.
+            if exc.code == 403:
+                # Permission denied.
+                raise NetworkPermissionDeniedError
+            raise NetworkInvalidResponseError
+        except urllib2.URLError, exc:
+            _log.error('URL error: %s' % exc.reason)
+            raise NetworkDNSError
+        except BadStatusLine:
+            _log.error('Bad status line (Twitter is going bananas)')
+            raise NetworkBadStatusLineError
+        except socketError:   # That's the worst exception ever.
+            _log.error('Socket connection error')
+            raise NetworkLowLevelError
+        # TODO: Permission denied?
+
+        # Introduced in Twitter in 2009.03.27
+        response_headers = response.info()
+        if 'X-RateLimit-Remaining' in response_headers:
+            self._rate_limit = int(response_headers['X-RateLimit-Remaining'])
+            _log.debug('Remaning hits: %d', self._rate_limit)
+        elif 'x-ratelimit-remaining' in response_headers:
+            self._rate_limit = int(response_headers['x-ratelimit-remaining'])
+            _log.debug('Remaning hits: %d', self._rate_limit)
+        else:
+            self._rate_limit = None
+
+        _log.debug('Request completed')
+        _log.debug('info(%s): %s', type(response.info()), response.info())
+
+        return json.loads(data)
+
+    #
+    # New network style methods
+    #
+    
+    AUTH = [
+                {'name': 'username',
+                 'flags': ['-u', '--username'],
+                 'prompt': 'Username',
+                 'help': 'Your twitter username',
+                 'type': 'str'},
+                {'name': 'password',
+                 'flags': ['-p', '--password'],
+                 'prompt': 'Password',
+                 'help': 'Your twitter password',
+                 'type': 'passwd'}]
+
+    @classmethod
+    def options(self, options):
+        """Add options related to Twitter."""
+        options.add_group(self.NAMESPACE, 'Twitter network')
+        options.add_option('-s', '--no-https',
+                group=self.NAMESPACE,
+                option='https',
+                default=True,   # Secure connections by default
+                help='Disable HTTPS (secure) connection with Twitter.',
+                action='store_false')
+        options.add_option(
+                group=self.NAMESPACE,
+                option='last_tweet',
+                default=0,
+                is_cmd_option=False)
+        options.add_option(
+                group=self.NAMESPACE,
+                option='last_reply',
+                default=0,
+                is_cmd_option=False)
+        options.add_option(
+                group=self.NAMESPACE,
+                option='server_url',
+                default='http://twitter.com',
+                is_cmd_option=False)
+        options.add_option(
+                group=self.NAMESPACE,
+                option='secure_server_url',
+                default='https://twitter.com',
+                is_cmd_option=False)
+        auth_options(self.NAMESPACE, options, self.AUTH)
+        return
+
+    def _timeline(self, config_var, url):
+        """Request one of the lists of tweets."""
+        last_id = int(self._options[self.NAMESPACE][config_var])
+        _log.debug('%s: %d', config_var, last_id)
+
+        params = {}
+
+        if last_id > 0:
+            params['since_id'] = last_id
+
+        page = 1
+        result = []
+        response = [0]  # So we stay in the loop.
+        high_id = 0
+
+        while response: # Not the cleanest code
+            if page > 1:
+                params['page'] = page
+
+            final_url = '?'.join([url, urllib.urlencode(params)])
+            response = self._request(final_url)
+
+            _log.debug('Page %d, %d results', page, len(response))
+
+            if response:
+                # extract the highest id in the respone and save it so we can
+                # use it when requesting data again (using the since_id
+                # parameter)
+
+                top_tweet_id = response[0]['id']
+                _log.debug('Top tweet: %d; Highest seen tweet: %d',
+                    top_tweet_id, high_id)
+
+                if top_tweet_id > high_id:
+                    high_id = top_tweet_id
+
+                result.extend(_make_datetime(response))
+                page += 1   # Request the next page
+
+            if last_id == 0:
+                # do not try to download everything if we don't have a
+                # previous list (or we'll blow the available requests in one
+                # short)
+                break
+
+        # only update the "last seen id" if everything goes alright
+        if high_id > int(self._options[self.NAMESPACE][config_var]):
+            _log.debug('Last tweet updated: %d', high_id)
+            self._options[self.NAMESPACE][config_var] = high_id
+
+        return result
+
+    def messages(self):
+        """Return a list of NetworkData objects for the main "timeline"."""
+        return self._timeline('last_tweet', '/statuses/friends_timeline.json')
+
+    def message(self, message_id):
+        """Retrieves the information of one message."""
+        response = self._request('/statuses/show/%d.json' % (message_id))
+        return TwitterNetworkData(response)
+
+    def replies(self):
+        """Return a list of NetworkData objects for the replies for the user
+        messages."""
+        return self._timeline('last_reply', '/statuses/replies.json')
+
+    def available_requests(self):
+        """Return the current user rate limit."""
+        if self._rate_limit:
+            return self._rate_limit
+
+        data = self._request('/account/rate_limit_status.json')
+        _log.debug('Requests: %s', data)
+        return int(data['remaining_hits'])
+
+
+    def update(self, status, reply_to=None):
+        """Update the user status."""
+        if len(status) > 140:
+            warnings.warn('Message too long', MessageTooLongWarning)
+
+        # In Python 2.5, urllib.urlencode calls str(), which removes the
+        # unicodeness of the "status". So we need to convert those peski
+        # accents to HTML entities, so everything falls into ASCII.
+
+        body = {
+            'status': _htmlize(status),
+            'source': 'mitter'}
+
+        if reply_to:
+            if isinstance(reply_to, NetworkData):
+                body['in_reply_to_status_id'] = reply_to.id
+
+                # This is to protect the user from himself. You don't *need*
+                # to start a reply with a @<username>, but it looks really
+                # confusing in the Twiter website. So if the line doesn't
+                # start with the username of the original user, we add it
+                # for the user.
+
+                if not status.startswith('@' + reply_to.username):
+                    body['status'] = '@' + reply_to.username + ' ' + \
+                            status
+            else:
+                body['in_reply_to_status_id'] = reply_to
+
+        _log.debug('Body: %s', body)
+        body = urllib.urlencode(body)
+        _log.debug('Message to twitter: %s' % (body))
+
+        data = self._request('/statuses/update.json', body=body)
+        # TODO: Check if twitter sends an error message when the message is
+        #       too large.
+        return TwitterNetworkData(data)
+
+    def delete_message(self, message):
+        """Delete a message."""
+        if isinstance(message, NetworkData):
+            message = message.id    # We don't need anything else for Twitter
+
+        # make a body, so _request makes it a post.
+        body = urllib.urlencode({'id': message})
+        resource = '/statuses/destroy/%s.json' % (message)
+        response = self._request(resource, body=body)
+        _log.debug('Delete response: %s', response)
+        return response

mitterlib/ui/__init__.py

@@ -0,0 +1,81 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+_log = logging.getLogger('ui.__init__')
+
+interfaces = [
+        'pygtk',
+        'cmd',
+        'mh',
+        'tty']
+
+
+def _import_name(interface):
+    """Return the name of the module for that interface."""
+    return 'mitterlib.ui.ui_%s' % (interface)
+
+
+def _interface_list(prefer=None):
+    """Return a list of UI modules."""
+    if prefer:
+        if prefer in interfaces:
+            yield _import_name(prefer)
+
+    for interface in interfaces:
+        module_name = _import_name(interface)
+        _log.debug('Module %s' % (module_name))
+        yield module_name
+
+
+def interface(prefer):
+    """Try to find an interface that works in the current user system."""
+    _log.debug('Preferred interface: %s' % (prefer))
+    interface = None
+    for module_name in _interface_list(prefer):
+        # try to import each using __import__
+        try:
+            _log.debug('Trying to import %s' % (module_name))
+            interface = __import__(module_name, fromlist=[module_name])
+            break
+        except ImportError, exc:
+            _log.debug('Failed')
+            _log.debug(str(exc))
+            pass
+
+    return interface
+
+
+def interface_options(options):
+    """Add options in the command line OptParser object for every
+    interface (yes, every interface, even the ones the user doesn't care)."""
+
+    available_interfaces = []
+    for module in _interface_list():
+        try:
+            _log.debug('Importing %s for options' % (module))
+            interface = __import__(module, fromlist=[module])
+
+            interface.options(options)
+            available_interfaces.append(module.split('_')[-1])
+        except ImportError:
+            pass    # so we don't care
+
+    return

mitterlib/ui/console_utils.py

@@ -0,0 +1,145 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason, Deepak Sarda
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import textwrap
+import locale
+import getpass
+
+from mitterlib.network.networkbase import NetworkData
+
+from timesince import timesince
+
+
+def encode_print(text):
+    """Try to print the text; if we get any UnicodeEncodeError, we print it
+    without encoding."""
+    try:
+        print text
+    except UnicodeEncodeError:
+        encoding = locale.getdefaultlocale()[1]
+        if not encoding:
+            encoding = 'ascii'
+        print text.encode(encoding, 'replace')
+        return
+
+
+def print_messages(data, connection, show_numbers=False, indent=0):
+    """Print the list of messages."""
+    count = 0
+    # the wrapping thing
+    indent_text = ' ' * (indent * 3)
+    wrapper = textwrap.TextWrapper()
+    wrapper.initial_indent = indent_text
+    wrapper.subsequent_indent = indent_text
+
+    if isinstance(data, NetworkData):
+        # If it's a single message, just print it
+        _display_message(wrapper, data, connection, show_numbers, count,
+                indent_text)
+        return
+    elif isinstance(data, str):
+        # If it just text, just print it.
+        _display_text(wrapper, data)
+        return
+
+    # Twitter sends us the data from the newest to latest, which is not
+    # good for displaying on a console. So we reverse the list.
+    # TODO: Check if this is true for ALL networks. Otherwise, we'll have
+    #       problems.
+    data.reverse()
+
+    print
+    for message in data:
+        count += 1
+
+        if isinstance(message, str):
+            _display_text(wrapper, message)
+        else:
+            _display_message(wrapper, message, connection,
+                    show_numbers, count, indent_text)
+    return
+
+
+def _display_message(wrapper, message, connection, show_numbers,
+        count, indent_text):
+    """Print a single message (NetworkData)."""
+    display = []
+    if show_numbers:
+        display.append('%d.' % (count))
+
+    if message.username != message.name:
+        display.append('%s (%s):' % (message.username, message.name))
+    else:
+        display.append('%s:' % (message.username))
+    display.append(message.message)
+
+    msg = ' '.join(display)
+    for line in wrapper.wrap(msg):
+        encode_print(line)
+
+    footer = '(%s ago, in %s [%s])' % (timesince(message.message_time),
+                connection.name(message.network), message.network)
+    for line in wrapper.wrap(footer):
+        encode_print(line)
+
+    print
+    print
+
+
+def _display_text(wrapper, text):
+    """Print a formated text."""
+    text = wrapper.wrap(text)
+    for line in text:
+        encode_print(line)
+    return
+
+
+def authorization(options, config):
+    for network in options:
+        namespace = network['name']
+
+        network_title = '%s credentials:' % (namespace)
+        print network_title
+        print '-' * len(network_title)
+
+        for option in network['options']:
+            name = option['name']
+            try:
+                old_value = config[namespace][name]
+            except KeyError:
+                # not setup yet (so it's not in the config -- it would
+                # probably never happen, since we are adding all options
+                # in the config right from start, but better safe than sorry)
+                old_value = None
+
+            if old_value:
+                old_value_prompt = ' (%s)' % (old_value)
+            else:
+                old_value_prompt = ''
+
+            prompt = '%s%s: ' % (option['prompt'], old_value_prompt)
+
+            if option['type'] == 'str':
+                value = raw_input(prompt)
+            elif option['type'] == 'passwd':
+                value = getpass.getpass(prompt)
+
+            if value:
+                config[namespace][name] = value
+        print

mitterlib/ui/notify.py

@@ -0,0 +1,84 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007  Julio Biason, Deepak Sarda
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import subprocess
+import logging
+import re
+
+
+class Notify():
+
+    def __init__(self, appname, timeout=5):
+        """appname: a string value specifying the name of the application
+        sending the message.
+        timeout: an integer value in seconds specifying the time for which
+        a notification should be shown"""
+
+        self.log = logging.getLogger('notify')
+        self.appname = appname
+        self.timeout = timeout
+        self.notify = None
+
+        try:
+            import dbus
+            bus = dbus.SessionBus()
+            proxy = bus.get_object('org.freedesktop.Notifications',
+                    '/org/freedesktop/Notifications')
+            self._dbus_notify = dbus.Interface(proxy,
+                    'org.freedesktop.Notifications')
+            self.notify = self._notify_galago
+            self.log.debug('Using Galago notifications')
+        except:
+            self.log.debug('Could not initialize Galago notification ' \
+                    'interface')
+
+        if not self.notify and os.getenv('KDE_FULL_SESSION'):
+            self.notify = self._notify_kde
+            self.log.debug('Using KDE notifications')
+
+        if not self.notify:
+            self.notify = self._notify_default
+            self.log.debug('Using default notifications')
+
+    def _notify_kde(self, msg, x, y):
+        try:
+            pid = subprocess.Popen(['kdialog', '--nograb', '--title',
+                    self.appname,
+                    '--geometry', '10x5+%d+%d' % (x, y),
+                    '--passivepopup', str(msg), str(self.timeout)]).pid
+        except Exception, e:
+            self.log.error('error %s' % e)
+            self._notify_default(msg, x, y)
+        finally:
+            del pid
+
+    def _notify_galago(self, msg, x, y):
+        msg = re.sub(r'<br\/?>', '', str(msg))
+        msg = re.sub(r'&(?!amp;)', r'&amp;', msg)
+
+        try:
+            self._dbus_notify.Notify(self.appname, 0, '', self.appname, msg,
+                    [], {'x': x, 'y': y}, 1000*self.timeout)
+        except Exception, e:
+            self.log.error('error %s' % e)
+            self._notify_default(msg, x, y)
+
+    def _notify_default(self, msg, x, y):
+        self.log.info('notification: %s' % msg)

mitterlib/ui/timesince.py

@@ -0,0 +1,90 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import datetime
+import math
+import time
+
+
+# Adapted from
+#  http://code.djangoproject.com/browser/django/trunk/django/utils/timesince.py
+# My version expects time to be given in UTC & returns timedelta from UTC.
+
+
+def pluralize(singular, plural, count):
+    if count == 1:
+        return singular
+    else:
+        return plural
+
+
+def timesince(d, now=None):
+    """
+    Takes two datetime objects and returns the time between then and now
+    as a nicely formatted string, e.g "10 minutes"
+    Adapted from http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
+    """
+    chunks = (
+        (60 * 60 * 24 * 365, lambda n: pluralize('year', 'years', n)),
+        (60 * 60 * 24 * 30, lambda n: pluralize('month', 'months', n)),
+        (60 * 60 * 24 * 7, lambda n: pluralize('week', 'weeks', n)),
+        (60 * 60 * 24, lambda n: pluralize('day', 'days', n)),
+        (60 * 60, lambda n: pluralize('hour', 'hours', n)),
+        (60, lambda n: pluralize('minute', 'minutes', n)))
+    # Convert datetime.date to datetime.datetime for comparison
+    if d.__class__ is not datetime.datetime:
+        d = datetime.datetime(d.year, d.month, d.day)
+    if now:
+        t = now.timetuple()
+    else:
+        t = time.gmtime()
+    now = datetime.datetime(t[0], t[1], t[2], t[3], t[4], t[5])
+
+    # ignore microsecond part of 'd' since we removed it from 'now'
+    delta = now - (d - datetime.timedelta(0, 0, d.microsecond))
+    since = delta.days * 24 * 60 * 60 + delta.seconds
+    if since <= 0:
+        return 'moments'
+
+    for i, (seconds, name) in enumerate(chunks):
+        count = since / seconds
+        if count != 0:
+            break
+
+    if count < 0:
+        return '%d milliseconds' % math.floor((now - d).microseconds / 1000)
+
+    s = '%d %s' % (count, name(count))
+    if i + 1 < len(chunks):
+        # Now get the second item
+        seconds2, name2 = chunks[i + 1]
+        count2 = (since - (seconds * count)) / seconds2
+        if count2 != 0:
+            s += ', %d %s' % (count2, name2(count2))
+    return s
+
+
+def timeuntil(d, now=None):
+    """
+    Like timesince, but returns a string measuring the time until
+    the given time.
+    """
+    if now == None:
+        now = datetime.datetime.now()
+    return timesince(now, d)

mitterlib/ui/ui_cmd.py

@@ -0,0 +1,326 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, micro-blogging client
+# Copyright (C) 2007, 2008  the Mitter contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+import cmd
+import mitterlib.ui.console_utils as console_utils
+import mitterlib.constants
+import datetime
+import warnings
+
+from mitterlib.network import NetworksNoNetworkSetupError, NetworksError
+from mitterlib.network.networkbase import NetworkError, \
+    NetworkPermissionDeniedError
+
+namespace = 'cmd' # TODO: rename this var to NAMESPACE (check other files too)
+_log = logging.getLogger('ui.cmd')
+
+
+def options(options):
+    # no options for this interface
+    return
+
+
+class Interface(cmd.Cmd):
+    """The command line interface for Mitter."""
+
+    # -----------------------------------------------------------------------
+    # Methods required by cmd.Cmd (our commands)
+    # -----------------------------------------------------------------------
+
+    def do_config(self, line=None):
+        """Setup the networks."""
+        options = self._connection.settings()
+        console_utils.authorization(options, self._options)
+        return
+
+    def do_timeline(self, line):
+        """Return a list of new messages in your friends timeline."""
+        try:
+            self._show_messages(self._connection.messages())
+        except NetworksNoNetworkSetupError:
+            # call the config
+            self.do_config()
+        except NetworkError:
+            print 'Network failure. Try again in a few minutes.'
+        return
+
+    def do_replies(self, line):
+        """Get a list of replies to you."""
+        try:
+            self._show_messages(self._connection.replies(), is_timeline=False)
+        except NetworksNoNetworkSetupError:
+            self.do_config()
+        except NetworkError:
+            print 'Network failure. Try again in a few minutes.'
+        return
+
+    def do_update(self, line):
+        """Update your status."""
+        if self._update(line):
+            print 'Status updated'
+        else:
+            print 'Failed to update your status. Try again in a few minutes.'
+
+    def do_exit(self, line):
+        """Quit the application."""
+        _log.debug('Exiting application')
+        return True
+
+    def do_EOF(self, line):
+        """Quit the application (it's the same as "exit"). You can also use
+        Ctrl+D."""
+        print       # Cmd doesn't add an empty line after the ^D
+        return self.do_exit(None)
+
+    def do_rt(self, line):
+        """"Retweet" a message in your list."""
+        pos = int(line)
+        if not self._check_message(pos):
+            return
+
+        original_message = self._messages[pos-1]
+        if not original_message.message.lower().startswith('rt @'):
+            new_message = 'RT @%s: %s' % (original_message.username,
+                    original_message.message)
+        else:
+            # if it is a retweet already, keep the original information
+            new_message = original_message.message
+        return self.do_update(new_message)
+
+    def do_r(self, line):
+        """Same as "reply"."""
+        return self.do_reply(line)
+
+    def do_reply(self, line):
+        """Reply to a message. Use "reply"/"r" <id> <message>."""
+        line_split = line.split()
+        pos = int(line_split[0])    # <number> message (cmd strips the
+                                    #  command already)
+        if not self._check_message(pos):
+            return
+
+        message = self._messages[pos - 1]
+        if self._update(' '.join(line_split[1:]), reply_to=message):
+            print 'Reply sent.'
+        else:
+            print "Couldn't send your reply. Try again in a few minutes."
+
+        return
+
+    def do_delete(self, line):
+        """Delete a message. You must provide the number of the displayed\
+        message."""
+        message_id = int(line)
+        real_message_id = self._messages[message_id - 1]
+        try:
+            self._connection.delete_message(real_message_id)
+        except NetworkPermissionDeniedError:
+            print 'Permission denied.'
+            return
+
+        print 'Message deleted.'
+        return
+
+    def do_thread(self, line):
+        """Retrieves the thread about a single message (like a reply.) Be
+        aware that this may consume a lot of your hourly requests if the
+        thread is too long."""
+        message_id = int(line)
+        _log.debug('Message in pos %d', message_id)
+        if not self._check_message(message_id):
+            return
+
+        message = self._messages[message_id - 1]
+        thread = [message]
+        self._thread(thread, message.parent, message.network)
+        return
+
+    def emptyline(self):
+        """Called when the user doesn't call any command. Default is to repeat
+        the last command; we are going to call timeline() again."""
+        return self.do_timeline(None)
+
+    def default(self, line):
+        """Called when we receive an unknown command; default is error
+        message, we are going to call update() instead."""
+        return self.do_update(line)
+
+    # -----------------------------------------------------------------------
+    # Helper functions
+    # -----------------------------------------------------------------------
+
+    def _check_message(self, message_id):
+        """Check if a message is valid in the current list."""
+        if message_id < 1 or message_id > len(self._messages):
+            print
+            print 'No such message.'
+            print
+            return False
+        return True
+
+    def _show_messages(self, data, is_timeline=True):
+        """Function called after we receive the list of messages."""
+
+        if is_timeline:
+            self._last_update = datetime.datetime.now()
+
+        self._messages = data
+        console_utils.print_messages(data, self._connection,
+                show_numbers=True)
+        self._update_prompt()
+        return
+
+    def _post_delete(self, data, error):
+        """Function called after we delete a message."""
+        if error:
+            if error == 403:
+                # Ok, we are *assuming* that, if you get a Forbidden
+                # error, it means it's not your message.
+                print "You can't delete this message."
+                # TODO: we are using Logging.Error in the Twitter
+                # object when we get this error. So the user will
+                # see connection errors instead of this simple
+                # message.
+            else:
+                print 'Error deleting message.'
+        else:
+            print 'Message deleted.'
+        self._update_prompt()
+        return
+
+    def _thread(self, thread_list, message_id, network):
+        """Build a conversation thread."""
+        _log.debug('Requesting message %s.%s' % (message_id, network))
+        try:
+            message = self._connection.message(message_id, network)
+        except NetworkError, exc:
+            _log.debug('Network error:')
+            _log.debug(exc)
+            thread_list.insert(0, 'Network error')
+            self._print_thread(thread_list)
+            return
+        # TODO: Catch a permission denied exception and add a proper message
+        #       for it.
+
+        thread_list.insert(0, message)
+        if message.parent:
+            self._thread(thread_list, message.parent, network)
+        else:
+            self._print_thread(thread_list)
+        return
+
+    def _print_thread(self, thread_list):
+        """Print the conversation thread."""
+        pos = 0
+        _log.debug('%d messages in thread', len(thread_list))
+        for message in thread_list:
+            console_utils.print_messages(message, self._connection,
+                    show_numbers=False, indent=pos)
+            pos += 1
+        return
+
+    def _update(self, status, reply_to=None):
+        """Send the update to the server."""
+        try:
+            self._connection.update(status, reply_to=reply_to)
+        except (NetworksError, NetworkError):
+            # TODO: capture the proper exception.
+            # TODO: Also, NetworkError's should never get here. Networks
+            #       should catch that (leaving the status kinda messed.)
+            return False
+        except MessageTooLongWarning:
+            print 'Your message is too long. Update NOT send.'
+            return False
+
+        self._update_prompt()
+        return True
+
+    def _update_prompt(self):
+        """Update the command line prompt."""
+        # check the requests limits for every network
+        requests = self._connection.available_requests()
+        available = []
+        for network in requests:
+            if requests[network] >= 0:
+                # just show information for networks that count that
+                available.append('%s (%s): %d' % (
+                    self._connection.name(network),
+                    network,
+                    requests[network]))
+
+        if self._last_update:
+            update_text = self._last_update.strftime('%H:%M')
+        else:
+            update_text = 'Never'
+        self.prompt = ('Last update: %s [%s]\nMitter> ' %
+            (update_text, ', '.join(available)))
+        return
+
+
+    # -----------------------------------------------------------------------
+    # Methods required by the main Mitter code
+    # -----------------------------------------------------------------------
+
+    def __init__(self, connection, options):
+        """Class initialization."""
+
+        cmd.Cmd.__init__(self)
+        self._options = options
+        self._last_update = None
+        self._connection = connection
+        self._messages = []
+
+        intro = ['Welcome to Mitter %s.' % (mitterlib.constants.version),
+            '',
+            'To get a list of available commands, type "help".',
+            '',
+            "If you start a line with something that it's not a command, " \
+            'it will be considered ' \
+            "a status update (so you don't need to type any commands to " \
+            'just update your status.',
+            '',
+            'An empty line will retrieve the latest updates from your ' \
+            'friends.',
+            '',
+            '']
+
+        import textwrap
+        wrapper = textwrap.TextWrapper()
+
+        intros = []
+
+        for line in intro:
+            if not line:
+                intros.append('')   # textwrap doesn't like empty lines
+            else:
+                for reident in wrapper.wrap(line):
+                    intros.append(reident)
+
+        self.intro = '\n'.join(intros)
+        self.prompt = 'Mitter> '
+
+        return
+
+    def __call__(self):
+        """Make the object callable; that's the only requirement for
+        Mitter."""
+        warnings.simplefilter('error')  # Warnings are exceptions
+        self.cmdloop()
+        return

mitterlib/ui/ui_mh.py

@@ -0,0 +1,163 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, micro-blogging client
+# Copyright (C) 2007, 2008  the Mitter contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+import cmd
+import mitterlib.ui.console_utils as console_utils
+import mitterlib.constants
+import datetime
+import warnings
+
+from mitterlib.network import NetworksNoNetworkSetupError, NetworksError
+from mitterlib.network.networkbase import NetworkError, \
+    NetworkPermissionDeniedError
+
+namespace = 'cmd' # TODO: rename this var to NAMESPACE (check other files too)
+_log = logging.getLogger('ui.cmd')
+
+
+def options(options):
+    # no options for this interface
+    return
+
+
+class Interface(cmd.Cmd):
+    """A MH-like interface to Mitter."""
+
+    # -----------------------------------------------------------------------
+    # Commands
+    # -----------------------------------------------------------------------
+
+    def do_config(self, line=None):
+        """Setup the networks."""
+        options = self._connection.settings()
+        console_utils.authorization(options, self._options)
+        return
+
+    def do_fetch(self, line=None):
+        """Retrieve the list of latest messages."""
+        try:
+            data = self._connection.messages()
+        except NetworksNoNetworkSetupError:
+            # call the config
+            self.do_config()
+        except NetworkError:
+            print 'Network failure. Try again in a few minutes.'
+
+        data.reverse()
+        self._messages.extend(data)
+        print '%d new messages, %d total messages now' % (len(data),
+                len(self._messages))
+
+    def do_next(self, line=None):
+        """Get the next message in the top of the list. The message is marked
+        as read and removed from the list."""
+
+        try:
+            self._current_message = self._messages.pop(0)
+        except IndexError:
+            print 'There are no unread messages.'
+            return
+
+        console_utils.print_messages(self._current_message, self._connection)
+        return
+
+    def do_print(self, line=None):
+        """Print the message in the current pointer."""
+        if self._current_message is None:
+            print 'There is no current message.'
+            return
+        console_utils.print_messages(self._current_message, self._connection)
+
+    def do_list(self, line=None):
+        """Print a summary of the messages in the list."""
+        for message in self._messages:
+            long_line = '%s: %s' % (message.username, message.message)
+
+            if len(long_line) > 75:
+                last_space = long_line.rfind(' ', 0, 76)
+                long_line = long_line[:last_space] + '...'
+
+            print long_line
+        return
+
+    def do_reply(self, line):
+        """Make a reply to the current message."""
+        if self._current_message is None:
+            print 'There is no current message.'
+            return
+
+        if self._update(line, reply_to=self._current_message):
+            print 'Reply send.'
+            self.lastcmd = None
+
+    def do_update(self, line):
+        """Update your status."""
+        if self._update(line):
+            print 'Status updated'
+            self.lastcmd = None 
+            # So we don't send the same message if the user pressed enter
+            # again
+
+    def do_exit(self, line):
+        """Quit the application."""
+        _log.debug('Exiting application')
+        return True
+
+    # -----------------------------------------------------------------------
+    # Helper functions
+    # -----------------------------------------------------------------------
+
+    def _update(self, status, reply_to=None):
+        """Send the update to the server."""
+        try:
+            self._connection.update(status, reply_to=reply_to)
+        except (NetworksError, NetworkError):
+            # TODO: capture the proper exception.
+            # TODO: Also, NetworkError's should never get here. Networks
+            #       should catch that (leaving the status kinda messed.)
+            print 'Network error. Try again in a few minutes.'
+            return False
+        except MessageTooLongWarning:
+            print 'Your message is too long. Update NOT send.'
+            return False
+        return True
+
+    # -----------------------------------------------------------------------
+    # Methods required by the main Mitter code
+    # -----------------------------------------------------------------------
+
+    def __init__(self, connection, options):
+        """Class initialization."""
+
+        cmd.Cmd.__init__(self)
+        self._options = options
+        self._last_update = None
+        self._connection = connection
+        self._messages = []
+        self._current_message = None
+
+        self.prompt = '> '
+        return
+
+    def __call__(self):
+        """Start the interface."""
+        warnings.simplefilter('error')  # Warnings are exceptions
+        self.cmdloop()
+        return

mitterlib/ui/ui_tty.py

@@ -0,0 +1,130 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason, Deepak Sarda
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+NAMESPACE = 'tty'
+
+import mitterlib.ui.console_utils as console_utils
+import logging
+from mitterlib.network.networkbase import NetworkError
+from mitterlib.network import NetworksNoNetworkSetupError, NetworksError
+
+_log = logging.getLogger('ui.tty')
+
+
+def options(options):
+    """Add command line options for this interface."""
+    options.add_group(NAMESPACE, 'TTY interface')   # This surely needs a
+                                                    # better description
+    options.add_option('--messages',
+            group=NAMESPACE,
+            option='messages',
+            help='Display the latest messages.',
+            default=False,
+            action='store_true',
+            is_config_option=False,
+            conflict_group='interface')
+    options.add_option('--update',
+            group=NAMESPACE,
+            option='update',
+            default=None,
+            help='Update your status',
+            metavar='STATUS',
+            type='str',
+            is_config_option=False,
+            conflict_group='interface')
+    options.add_option('--replies',
+            group=NAMESPACE,
+            option='replies',
+            help='Get a list of replies instead of the friends timeline',
+            default=False,
+            action='store_true',
+            is_config_option=False,
+            conflict_group='interface')
+    return
+
+
+class Interface(object):
+    """The console/tty interface for Mitter."""
+
+    # -----------------------------------------------------------------------
+    # Private functions
+    # -----------------------------------------------------------------------
+
+    def _config(self):
+        """Set up the networks."""
+        options = self._connection.settings()
+        console_utils.authorization(options, self._options)
+        return
+
+    def _messages(self):
+        """Show the latest messages."""
+        try:
+            data = self._connection.messages()
+            console_utils.print_messages(data, self._connection)
+        except NetworksNoNetworkSetupError:
+            # call the config
+            self._config()
+        except NetworkError:
+            print 'Network failure. Try again in a few minutes.'
+        return
+
+    def _replies(self):
+        """Show the replies to you."""
+        try:
+            data = self._connection.replies()
+            console_utils.print_messages(data, self._connection)
+        except NetworksNoNetworkSetupError:
+            # call the config
+            self._config()
+        except NetworkError:
+            print 'Network failure. Try again in a few minutes.'
+        return
+
+    def _update(self, message):
+        """Update your status."""
+        try:
+            self._connection.update(message)
+        except (NetworksError, NetworkError):
+            print 'Error updating your status. Try again in a few minutes.'
+
+        return
+
+
+    # -----------------------------------------------------------------------
+    # Methods required by the main Mitter code
+    # -----------------------------------------------------------------------
+
+    def __init__(self, connection, options):
+        """Class initialization."""
+        self._connection = connection
+        self._options = options
+
+    def __call__(self):
+        """The callable function, used by mitter to start the interface."""
+        status_message = self._options[NAMESPACE]['update']
+        if status_message:
+            self._update(status_message)
+            return
+
+        if self._options[NAMESPACE]['replies']:
+            self._replies()
+            return
+
+        self._messages()
+        return

mitterlib/ui/utils.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Mitter, a Maemo client for Twitter.
+# Copyright (C) 2007, 2008  Julio Biason, Deepak Sarda
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+def str_len(s):
+    """Get length of string which may be unicode or encoded"""
+
+    return len(to_unicode(s))
+
+
+def to_unicode(s, encoding='utf-8'):
+    """Converts string to unicode if it isn't one already"""
+
+    if not isinstance(s, unicode):
+        return unicode(s, encoding)

setup.py

@@ -0,0 +1,42 @@
+from mitterlib.constants import version
+
+params = {
+        'name': 'mitter',
+        'version': version,
+        'description': 'Update your Twitter status',
+        'author': 'Julio Biason',
+        'author_email': 'julio@juliobiason.net',
+        'url': 'http://code.google.com/p/mitter/',
+        'scripts': ['mitter'],
+        'packages': [
+            'mitterlib',
+            'mitterlib.ui'],
+        'data_files': [
+            ('share/pixmaps',
+                ['pixmaps/mitter.png',
+                 'pixmaps/mitter-new.png',
+                 'pixmaps/unknown.png'])],
+        'license': 'GPL3',
+        'download_url': \
+            'http://mitter.googlecode.com/files/mitter-%s.tar.gz' % (version),
+        'classifiers': [
+            'Development Status :: 4 - Beta',
+            'Environment :: Console',
+            'Environment :: X11 Applications :: GTK',
+            'Intended Audience :: End Users/Desktop',
+            'License :: OSI Approved :: GNU General Public License (GPL)',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python',
+            'Topic :: Communications :: Chat']}
+
+from distutils.core import setup
+from distutils.version import StrictVersion
+
+import sys
+version_number = '.'.join([str(a) for a in sys.version_info[:3]])
+
+if StrictVersion(version_number) < StrictVersion('2.6'):
+    params['requires'] = ['simplejson']
+
+# this bit should be the same for both systems
+setup(**params)

tests.py

@@ -0,0 +1,72 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import unittest
+import logging
+import cgi
+
+from mitterlib.network import twitter
+from mitterlib.configopt import ConfigOpt
+
+
+def _request(self, resource, headers=None, body=None):
+    logging.debug('Resource: %s')
+    logging.debug('Headers: %s')
+    logging.debug('body: %s')
+
+    return {}
+
+
+def _request_update(self, resource, headers=None, body=None):
+    """Monkey-patch request for update. Returns a random dictionary for
+    NetworkData."""
+    # body = urllib.urlencode(dict)
+    body = cgi.parse_qs(body)
+    result = {
+        'id': 1,
+        'user': {
+            'name': 'Test',
+            'screen_name': 'test',
+            'profile_image_url': None},
+        'created_at': 'Tue Mar 13 00:12:41 +0000 2007',
+        'text': body['status'][0]} # Go figure...
+    return result
+
+
+class TwitterEncodingTests(unittest.TestCase):
+
+    def setUp(self):
+        # Generate a set of options required for starting the Twitter
+        # connection.
+        options = ConfigOpt()
+        twitter.Connection.options(options)
+        self.connection = twitter.Connection(options)
+        # we don't call options(), so it won't load the options in the config
+        # file. If tests need to test specific options, they can change
+        # options directly.
+
+    def test_twitter_unhtml(self):
+        """Test the _unhtml() function inside the Twitter."""
+
+
+        text = u'RT @fisl10: Abertas as inscrições para o ' \
+                'fisl10 http://tinyurl.com/cqrdsc'
+        result = u'RT @fisl10: Abertas as inscrições para o fisl10 ' \
+                'http://tinyurl.com/cqrdsc'
+
+        self.assertEqual(result, twitter._unhtml(text))
+
+    def test_unicode(self):
+        """Test if sending unicode messages breaks the system."""
+        text = 'fisl10: Abertas as inscrições para o fisl10 ' \
+                'http://tinyurl.com/cqrdsc'
+
+        twitter.Connection._request = _request_update
+        try:
+            self.connection.update(text)
+        except UnicodeEncodeError:
+            self.fail('UnicodeEncodeError')
+
+
+if __name__ == '__main__':
+    unittest.main()

utils/pep8.py

@@ -0,0 +1,863 @@
+#!/usr/bin/python
+# pep8.py - Check Python source code formatting, according to PEP 8
+# Copyright (C) 2006 Johann C. Rocholl <johann@browsershots.org>
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""
+Check Python source code formatting, according to PEP 8:
+http://www.python.org/dev/peps/pep-0008/
+
+For usage and a list of options, try this:
+$ python pep8.py -h
+
+This program and its regression test suite live here:
+http://svn.browsershots.org/trunk/devtools/pep8/
+http://trac.browsershots.org/browser/trunk/devtools/pep8/
+
+Groups of errors and warnings:
+E errors
+W warnings
+100 indentation
+200 whitespace
+300 blank lines
+400 imports
+500 line length
+600 deprecation
+700 statements
+
+You can add checks to this program by writing plugins. Each plugin is
+a simple function that is called for each line of source code, either
+physical or logical.
+
+Physical line:
+- Raw line of text from the input file.
+
+Logical line:
+- Multi-line statements converted to a single line.
+- Stripped left and right.
+- Contents of strings replaced with 'xxx' of same length.
+- Comments removed.
+
+The check function requests physical or logical lines by the name of
+the first argument:
+
+def maximum_line_length(physical_line)
+def extraneous_whitespace(logical_line)
+def blank_lines(logical_line, blank_lines, indent_level, line_number)
+
+The last example above demonstrates how check plugins can request
+additional information with extra arguments. All attributes of the
+Checker object are available. Some examples:
+
+lines: a list of the raw lines from the input file
+tokens: the tokens that contribute to this logical line
+line_number: line number in the input file
+blank_lines: blank lines before this one
+indent_char: first indentation character in this file (' ' or '\t')
+indent_level: indentation (with tabs expanded to multiples of 8)
+previous_indent_level: indentation on previous line
+previous_logical: previous logical line
+
+The docstring of each check function shall be the relevant part of
+text from PEP 8. It is printed if the user enables --show-pep8.
+
+"""
+
+import os
+import sys
+import re
+import time
+import inspect
+import tokenize
+from optparse import OptionParser
+from keyword import iskeyword
+from fnmatch import fnmatch
+
+__version__ = '0.2.0'
+__revision__ = '$Rev$'
+
+default_exclude = '.svn,CVS,*.pyc,*.pyo'
+
+indent_match = re.compile(r'([ \t]*)').match
+raise_comma_match = re.compile(r'raise\s+\w+\s*(,)').match
+
+operators = """
++  -  *  /  %  ^  &  |  =  <  >  >>  <<
++= -= *= /= %= ^= &= |= == <= >= >>= <<=
+!= <> :
+in is or not and
+""".split()
+
+options = None
+args = None
+
+
+##############################################################################
+# Plugins (check functions) for physical lines
+##############################################################################
+
+
+def tabs_or_spaces(physical_line, indent_char):
+    """
+    Never mix tabs and spaces.
+
+    The most popular way of indenting Python is with spaces only.  The
+    second-most popular way is with tabs only.  Code indented with a mixture
+    of tabs and spaces should be converted to using spaces exclusively.  When
+    invoking the Python command line interpreter with the -t option, it issues
+    warnings about code that illegally mixes tabs and spaces.  When using -tt
+    these warnings become errors.  These options are highly recommended!
+    """
+    indent = indent_match(physical_line).group(1)
+    for offset, char in enumerate(indent):
+        if char != indent_char:
+            return offset, "E101 indentation contains mixed spaces and tabs"
+
+
+def tabs_obsolete(physical_line):
+    """
+    For new projects, spaces-only are strongly recommended over tabs.  Most
+    editors have features that make this easy to do.
+    """
+    indent = indent_match(physical_line).group(1)
+    if indent.count('\t'):
+        return indent.index('\t'), "W191 indentation contains tabs"
+
+
+def trailing_whitespace(physical_line):
+    """
+    JCR: Trailing whitespace is superfluous.
+    """
+    physical_line = physical_line.rstrip('\n') # chr(10), newline
+    physical_line = physical_line.rstrip('\r') # chr(13), carriage return
+    physical_line = physical_line.rstrip('\x0c') # chr(12), form feed, ^L
+    stripped = physical_line.rstrip()
+    if physical_line != stripped:
+        return len(stripped), "W291 trailing whitespace"
+
+
+def trailing_blank_lines(physical_line, lines, line_number):
+    """
+    JCR: Trailing blank lines are superfluous.
+    """
+    if physical_line.strip() == '' and line_number == len(lines):
+        return 0, "W391 blank line at end of file"
+
+
+def missing_newline(physical_line):
+    """
+    JCR: The last line should have a newline.
+    """
+    if physical_line.rstrip() == physical_line:
+        return len(physical_line), "W292 no newline at end of file"
+
+
+def maximum_line_length(physical_line):
+    """
+    Limit all lines to a maximum of 79 characters.
+
+    There are still many devices around that are limited to 80 character
+    lines; plus, limiting windows to 80 characters makes it possible to have
+    several windows side-by-side.  The default wrapping on such devices looks
+    ugly.  Therefore, please limit all lines to a maximum of 79 characters.
+    For flowing long blocks of text (docstrings or comments), limiting the
+    length to 72 characters is recommended.
+    """
+    length = len(physical_line.rstrip())
+    if length > 79:
+        return 79, "E501 line too long (%d characters)" % length
+
+
+##############################################################################
+# Plugins (check functions) for logical lines
+##############################################################################
+
+
+def blank_lines(logical_line, blank_lines, indent_level, line_number,
+                previous_logical):
+    """
+    Separate top-level function and class definitions with two blank lines.
+
+    Method definitions inside a class are separated by a single blank line.
+
+    Extra blank lines may be used (sparingly) to separate groups of related
+    functions.  Blank lines may be omitted between a bunch of related
+    one-liners (e.g. a set of dummy implementations).
+
+    Use blank lines in functions, sparingly, to indicate logical sections.
+    """
+    if line_number == 1:
+        return # Don't expect blank lines before the first line
+    if previous_logical.startswith('@'):
+        return # Don't expect blank lines after function decorator
+    if (logical_line.startswith('def ') or
+        logical_line.startswith('class ') or
+        logical_line.startswith('@')):
+        if indent_level > 0 and blank_lines != 1:
+            return 0, "E301 expected 1 blank line, found %d" % blank_lines
+        if indent_level == 0 and blank_lines != 2:
+            return 0, "E302 expected 2 blank lines, found %d" % blank_lines
+    if blank_lines > 2:
+        return 0, "E303 too many blank lines (%d)" % blank_lines
+
+
+def extraneous_whitespace(logical_line):
+    """
+    Avoid extraneous whitespace in the following situations:
+
+    - Immediately inside parentheses, brackets or braces.
+
+    - Immediately before a comma, semicolon, or colon.
+    """
+    line = logical_line
+    for char in '([{':
+        found = line.find(char + ' ')
+        if found > -1:
+            return found + 1, "E201 whitespace after '%s'" % char
+    for char in '}])':
+        found = line.find(' ' + char)
+        if found > -1 and line[found - 1] != ',':
+            return found, "E202 whitespace before '%s'" % char
+    for char in ',;:':
+        found = line.find(' ' + char)
+        if found > -1:
+            return found, "E203 whitespace before '%s'" % char
+
+
+def missing_whitespace(logical_line):
+    """
+    JCR: Each comma, semicolon or colon should be followed by whitespace.
+    """
+    line = logical_line
+    for index in range(len(line) - 1):
+        char = line[index]
+        if char in ',;:' and line[index + 1] != ' ':
+            before = line[:index]
+            if char == ':' and before.count('[') > before.count(']'):
+                continue # Slice syntax, no space required
+            return index, "E231 missing whitespace after '%s'" % char
+
+
+def indentation(logical_line, previous_logical, indent_char,
+                indent_level, previous_indent_level):
+    """
+    Use 4 spaces per indentation level.
+
+    For really old code that you don't want to mess up, you can continue to
+    use 8-space tabs.
+    """
+    if indent_char == ' ' and indent_level % 4:
+        return 0, "E111 indentation is not a multiple of four"
+    indent_expect = previous_logical.endswith(':')
+    if indent_expect and indent_level <= previous_indent_level:
+        return 0, "E112 expected an indented block"
+    if indent_level > previous_indent_level and not indent_expect:
+        return 0, "E113 unexpected indentation"
+
+
+def whitespace_before_parameters(logical_line, tokens):
+    """
+    Avoid extraneous whitespace in the following situations:
+
+    - Immediately before the open parenthesis that starts the argument
+      list of a function call.
+
+    - Immediately before the open parenthesis that starts an indexing or
+      slicing.
+    """
+    prev_type = tokens[0][0]
+    prev_text = tokens[0][1]
+    prev_end = tokens[0][3]
+    for index in range(1, len(tokens)):
+        token_type, text, start, end, line = tokens[index]
+        if (token_type == tokenize.OP and
+            text in '([' and
+            start != prev_end and
+            prev_type == tokenize.NAME and
+            (index < 2 or tokens[index - 2][1] != 'class') and
+            (not iskeyword(prev_text))):
+            return prev_end, "E211 whitespace before '%s'" % text
+        prev_type = token_type
+        prev_text = text
+        prev_end = end
+
+
+def whitespace_around_operator(logical_line):
+    """
+    Avoid extraneous whitespace in the following situations:
+
+    - More than one space around an assignment (or other) operator to
+      align it with another.
+    """
+    line = logical_line
+    for operator in operators:
+        found = line.find('  ' + operator)
+        if found > -1:
+            return found, "E221 multiple spaces before operator"
+        found = line.find(operator + '  ')
+        if found > -1:
+            return found, "E222 multiple spaces after operator"
+        found = line.find('\t' + operator)
+        if found > -1:
+            return found, "E223 tab before operator"
+        found = line.find(operator + '\t')
+        if found > -1:
+            return found, "E224 tab after operator"
+
+
+def whitespace_around_comma(logical_line):
+    """
+    Avoid extraneous whitespace in the following situations:
+
+    - More than one space around an assignment (or other) operator to
+      align it with another.
+
+    JCR: This should also be applied around comma etc.
+    """
+    line = logical_line
+    for separator in ',;:':
+        found = line.find(separator + '  ')
+        if found > -1:
+            return found + 1, "E241 multiple spaces after '%s'" % separator
+        found = line.find(separator + '\t')
+        if found > -1:
+            return found + 1, "E242 tab after '%s'" % separator
+
+
+def imports_on_separate_lines(logical_line):
+    """
+    Imports should usually be on separate lines.
+    """
+    line = logical_line
+    if line.startswith('import '):
+        found = line.find(',')
+        if found > -1:
+            return found, "E401 multiple imports on one line"
+
+
+def compound_statements(logical_line):
+    """
+    Compound statements (multiple statements on the same line) are
+    generally discouraged.
+    """
+    line = logical_line
+    found = line.find(':')
+    if -1 < found < len(line) - 1:
+        before = line[:found]
+        if (before.count('{') <= before.count('}') and # {'a': 1} (dict)
+            before.count('[') <= before.count(']') and # [1:2] (slice)
+            not re.search(r'\blambda\b', before)):     # lambda x: x
+            return found, "E701 multiple statements on one line (colon)"
+    found = line.find(';')
+    if -1 < found:
+        return found, "E702 multiple statements on one line (semicolon)"
+
+
+def python_3000_has_key(logical_line):
+    """
+    The {}.has_key() method will be removed in the future version of
+    Python. Use the 'in' operation instead, like:
+    d = {"a": 1, "b": 2}
+    if "b" in d:
+        print d["b"]
+    """
+    pos = logical_line.find('.has_key(')
+    if pos > -1:
+        return pos, "W601 .has_key() is deprecated, use 'in'"
+
+
+def python_3000_raise_comma(logical_line):
+    """
+    When raising an exception, use "raise ValueError('message')"
+    instead of the older form "raise ValueError, 'message'".
+
+    The paren-using form is preferred because when the exception arguments
+    are long or include string formatting, you don't need to use line
+    continuation characters thanks to the containing parentheses.  The older
+    form will be removed in Python 3000.
+    """
+    match = raise_comma_match(logical_line)
+    if match:
+        return match.start(1), "W602 deprecated form of raising exception"
+
+
+##############################################################################
+# Helper functions
+##############################################################################
+
+
+def expand_indent(line):
+    """
+    Return the amount of indentation.
+    Tabs are expanded to the next multiple of 8.
+
+    >>> expand_indent('    ')
+    4
+    >>> expand_indent('\\t')
+    8
+    >>> expand_indent('    \\t')
+    8
+    >>> expand_indent('       \\t')
+    8
+    >>> expand_indent('        \\t')
+    16
+    """
+    result = 0
+    for char in line:
+        if char == '\t':
+            result = result / 8 * 8 + 8
+        elif char == ' ':
+            result += 1
+        else:
+            break
+    return result
+
+
+##############################################################################
+# Framework to run all checks
+##############################################################################
+
+
+def message(text):
+    """Print a message."""
+    # print >> sys.stderr, options.prog + ': ' + text
+    # print >> sys.stderr, text
+    print text
+
+
+def find_checks(argument_name):
+    """
+    Find all globally visible functions where the first argument name
+    starts with argument_name.
+    """
+    checks = []
+    function_type = type(find_checks)
+    for name, function in globals().iteritems():
+        if type(function) is function_type:
+            args = inspect.getargspec(function)[0]
+            if len(args) >= 1 and args[0].startswith(argument_name):
+                checks.append((name, function, args))
+    checks.sort()
+    return checks
+
+
+def mute_string(text):
+    """
+    Replace contents with 'xxx' to prevent syntax matching.
+
+    >>> mute_string('"abc"')
+    '"xxx"'
+    >>> mute_string("'''abc'''")
+    "'''xxx'''"
+    >>> mute_string("r'abc'")
+    "r'xxx'"
+    """
+    start = 1
+    end = len(text) - 1
+    # String modifiers (e.g. u or r)
+    if text.endswith('"'):
+        start += text.index('"')
+    elif text.endswith("'"):
+        start += text.index("'")
+    # Triple quotes
+    if text.endswith('"""') or text.endswith("'''"):
+        start += 2
+        end -= 2
+    return text[:start] + 'x' * (end - start) + text[end:]
+
+
+class Checker:
+    """
+    Load a Python source file, tokenize it, check coding style.
+    """
+
+    def __init__(self, filename):
+        self.filename = filename
+        self.lines = file(filename).readlines()
+        self.physical_checks = find_checks('physical_line')
+        self.logical_checks = find_checks('logical_line')
+        options.counters['physical lines'] = \
+            options.counters.get('physical lines', 0) + len(self.lines)
+
+    def readline(self):
+        """
+        Get the next line from the input buffer.
+        """
+        self.line_number += 1
+        if self.line_number > len(self.lines):
+            return ''
+        return self.lines[self.line_number - 1]
+
+    def readline_check_physical(self):
+        """
+        Check and return the next physical line. This method can be
+        used to feed tokenize.generate_tokens.
+        """
+        line = self.readline()
+        if line:
+            self.check_physical(line)
+        return line
+
+    def run_check(self, check, argument_names):
+        """
+        Run a check plugin.
+        """
+        arguments = []
+        for name in argument_names:
+            arguments.append(getattr(self, name))
+        return check(*arguments)
+
+    def check_physical(self, line):
+        """
+        Run all physical checks on a raw input line.
+        """
+        self.physical_line = line
+        if self.indent_char is None and len(line) and line[0] in ' \t':
+            self.indent_char = line[0]
+        for name, check, argument_names in self.physical_checks:
+            result = self.run_check(check, argument_names)
+            if result is not None:
+                offset, text = result
+                self.report_error(self.line_number, offset, text, check)
+
+    def build_tokens_line(self):
+        """
+        Build a logical line from tokens.
+        """
+        self.mapping = []
+        logical = []
+        length = 0
+        previous = None
+        for token in self.tokens:
+            token_type, text = token[0:2]
+            if token_type in (tokenize.COMMENT, tokenize.NL,
+                              tokenize.INDENT, tokenize.DEDENT,
+                              tokenize.NEWLINE):
+                continue
+            if token_type == tokenize.STRING:
+                text = mute_string(text)
+            if previous:
+                end_line, end = previous[3]
+                start_line, start = token[2]
+                if end_line != start_line: # different row
+                    if self.lines[end_line - 1][end - 1] not in '{[(':
+                        logical.append(' ')
+                        length += 1
+                elif end != start: # different column
+                    fill = self.lines[end_line - 1][end:start]
+                    logical.append(fill)
+                    length += len(fill)
+            self.mapping.append((length, token))
+            logical.append(text)
+            length += len(text)
+            previous = token
+        self.logical_line = ''.join(logical)
+        assert self.logical_line.lstrip() == self.logical_line
+        assert self.logical_line.rstrip() == self.logical_line
+
+    def check_logical(self):
+        """
+        Build a line from tokens and run all logical checks on it.
+        """
+        options.counters['logical lines'] = \
+            options.counters.get('logical lines', 0) + 1
+        self.build_tokens_line()
+        first_line = self.lines[self.mapping[0][1][2][0] - 1]
+        indent = first_line[:self.mapping[0][1][2][1]]
+        self.previous_indent_level = self.indent_level
+        self.indent_level = expand_indent(indent)
+        if options.verbose >= 2:
+            print self.logical_line[:80].rstrip()
+        for name, check, argument_names in self.logical_checks:
+            if options.verbose >= 3:
+                print '   ', name
+            result = self.run_check(check, argument_names)
+            if result is not None:
+                offset, text = result
+                if type(offset) is tuple:
+                    original_number, original_offset = offset
+                else:
+                    for token_offset, token in self.mapping:
+                        if offset >= token_offset:
+                            original_number = token[2][0]
+                            original_offset = (token[2][1]
+                                               + offset - token_offset)
+                self.report_error(original_number, original_offset,
+                                  text, check)
+        self.previous_logical = self.logical_line
+
+    def check_all(self):
+        """
+        Run all checks on the input file.
+        """
+        self.file_errors = 0
+        self.line_number = 0
+        self.indent_char = None
+        self.indent_level = 0
+        self.previous_logical = ''
+        self.blank_lines = 0
+        self.tokens = []
+        parens = 0
+        for token in tokenize.generate_tokens(self.readline_check_physical):
+            # print tokenize.tok_name[token[0]], repr(token)
+            self.tokens.append(token)
+            token_type, text = token[0:2]
+            if token_type == tokenize.OP and text in '([{':
+                parens += 1
+            if token_type == tokenize.OP and text in '}])':
+                parens -= 1
+            if token_type == tokenize.NEWLINE and not parens:
+                self.check_logical()
+                self.blank_lines = 0
+                self.tokens = []
+            if token_type == tokenize.NL and not parens:
+                self.blank_lines += 1
+                self.tokens = []
+            if token_type == tokenize.COMMENT:
+                source_line = token[4]
+                token_start = token[2][1]
+                if source_line[:token_start].strip() == '':
+                    self.blank_lines = 0
+        return self.file_errors
+
+    def report_error(self, line_number, offset, text, check):
+        """
+        Report an error, according to options.
+        """
+        if options.quiet == 1 and not self.file_errors:
+            message(self.filename)
+        self.file_errors += 1
+        code = text[:4]
+        options.counters[code] = options.counters.get(code, 0) + 1
+        options.messages[code] = text[5:]
+        if options.quiet:
+            return
+        if options.testsuite:
+            base = os.path.basename(self.filename)[:4]
+            if base == code:
+                return
+            if base[0] == 'E' and code[0] == 'W':
+                return
+        if ignore_code(code):
+            return
+        if options.counters[code] == 1 or options.repeat:
+            message("%s:%s:%d: %s" %
+                    (self.filename, line_number, offset + 1, text))
+            if options.show_source:
+                line = self.lines[line_number - 1]
+                message(line.rstrip())
+                message(' ' * offset + '^')
+            if options.show_pep8:
+                message(check.__doc__.lstrip('\n').rstrip())
+
+
+def input_file(filename):
+    """
+    Run all checks on a Python source file.
+    """
+    if excluded(filename) or not filename_match(filename):
+        return {}
+    if options.verbose:
+        message('checking ' + filename)
+    options.counters['files'] = options.counters.get('files', 0) + 1
+    errors = Checker(filename).check_all()
+    if options.testsuite and not errors:
+        message("%s: %s" % (filename, "no errors found"))
+
+
+def input_dir(dirname):
+    """
+    Check all Python source files in this directory and all subdirectories.
+    """
+    dirname = dirname.rstrip('/')
+    if excluded(dirname):
+        return
+    for root, dirs, files in os.walk(dirname):
+        if options.verbose:
+            message('directory ' + root)
+        options.counters['directories'] = \
+            options.counters.get('directories', 0) + 1
+        dirs.sort()
+        for subdir in dirs:
+            if excluded(subdir):
+                dirs.remove(subdir)
+        files.sort()
+        for filename in files:
+            input_file(os.path.join(root, filename))
+
+
+def excluded(filename):
+    """
+    Check if options.exclude contains a pattern that matches filename.
+    """
+    basename = os.path.basename(filename)
+    for pattern in options.exclude:
+        if fnmatch(basename, pattern):
+            # print basename, 'excluded because it matches', pattern
+            return True
+
+
+def filename_match(filename):
+    """
+    Check if options.filename contains a pattern that matches filename.
+    If options.filename is unspecified, this always returns True.
+    """
+    if not options.filename:
+        return True
+    for pattern in options.filename:
+        if fnmatch(filename, pattern):
+            return True
+
+
+def ignore_code(code):
+    """
+    Check if options.ignore contains a prefix of the error code.
+    """
+    for ignore in options.ignore:
+        if code.startswith(ignore):
+            return True
+
+
+def get_error_statistics():
+    """Get error statistics."""
+    return get_statistics("E")
+
+
+def get_warning_statistics():
+    """Get warning statistics."""
+    return get_statistics("W")
+
+
+def get_statistics(prefix=''):
+    """
+    Get statistics for message codes that start with the prefix.
+
+    prefix='' matches all errors and warnings
+    prefix='E' matches all errors
+    prefix='W' matches all warnings
+    prefix='E4' matches all errors that have to do with imports
+    """
+    stats = []
+    keys = options.messages.keys()
+    keys.sort()
+    for key in keys:
+        if key.startswith(prefix):
+            stats.append('%-7s %s %s' %
+                         (options.counters[key], key, options.messages[key]))
+    return stats
+
+
+def print_statistics(prefix=''):
+    """Print overall statistics (number of errors and warnings)."""
+    for line in get_statistics(prefix):
+        print line
+
+
+def print_benchmark(elapsed):
+    """
+    Print benchmark numbers.
+    """
+    print '%-7.2f %s' % (elapsed, 'seconds elapsed')
+    keys = ['directories', 'files',
+            'logical lines', 'physical lines']
+    for key in keys:
+        if key in options.counters:
+            print '%-7d %s per second (%d total)' % (
+                options.counters[key] / elapsed, key,
+                options.counters[key])
+
+
+def process_options(arglist=None):
+    """
+    Process options passed either via arglist or via command line args.
+    """
+    global options, args
+    usage = "%prog [options] input ..."
+    parser = OptionParser(usage)
+    parser.add_option('-v', '--verbose', default=0, action='count',
+                      help="print status messages, or debug with -vv")
+    parser.add_option('-q', '--quiet', default=0, action='count',
+                      help="report only file names, or nothing with -qq")
+    parser.add_option('--exclude', metavar='patterns', default=default_exclude,
+                      help="skip matches (default %s)" % default_exclude)
+    parser.add_option('--filename', metavar='patterns',
+                      help="only check matching files (e.g. *.py)")
+    parser.add_option('--ignore', metavar='errors', default='',
+                      help="skip errors and warnings (e.g. E4,W)")
+    parser.add_option('--repeat', action='store_true',
+                      help="show all occurrences of the same error")
+    parser.add_option('--show-source', action='store_true',
+                      help="show source code for each error")
+    parser.add_option('--show-pep8', action='store_true',
+                      help="show text of PEP 8 for each error")
+    parser.add_option('--statistics', action='store_true',
+                      help="count errors and warnings")
+    parser.add_option('--benchmark', action='store_true',
+                      help="measure processing speed")
+    parser.add_option('--testsuite', metavar='dir',
+                      help="run regression tests from dir")
+    parser.add_option('--doctest', action='store_true',
+                      help="run doctest on myself")
+    options, args = parser.parse_args(arglist)
+    if options.testsuite:
+        args.append(options.testsuite)
+    if len(args) == 0:
+        parser.error('input not specified')
+    options.prog = os.path.basename(sys.argv[0])
+    options.exclude = options.exclude.split(',')
+    for index in range(len(options.exclude)):
+        options.exclude[index] = options.exclude[index].rstrip('/')
+    if options.filename:
+        options.filename = options.filename.split(',')
+    if options.ignore:
+        options.ignore = options.ignore.split(',')
+    else:
+        options.ignore = []
+    options.counters = {}
+    options.messages = {}
+
+    return options, args
+
+
+def _main():
+    """
+    Parse options and run checks on Python source.
+    """
+    options, args = process_options()
+    if options.doctest:
+        import doctest
+        return doctest.testmod()
+    start_time = time.time()
+    for path in args:
+        if os.path.isdir(path):
+            input_dir(path)
+        else:
+            input_file(path)
+    elapsed = time.time() - start_time
+    if options.statistics:
+        print_statistics()
+    if options.benchmark:
+        print_benchmark(elapsed)
+
+
+if __name__ == '__main__':
+    _main()