Add ability to change name of the root item in the catalog.

Also, clean up setup things and imports.

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.coverage
+.tox
+tags
+MANIFEST
+.cache
+pycatalog.egg-info

LICENCE

@@ -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>.

README.rst

@@ -0,0 +1,90 @@
+pycatalog
+==========
+
+Pycatalog is a commandline Linux/FreeBSD program for indexing CD, DVD, BR or
+directories on filesystem. It is similar to `gtktalog`_ or `gwhere`_. There is
+no coincidence in name of application, because it's meant to be replacement
+(in some way) for gtktalog, which seems to be dead project for years.
+
+Note, that even if it share same code base with pyGTKtalog, which was meant to
+be desktop application, now pycatalog is pure console app, just for use with
+commandline. You can find last version of pyGTKtalog under ``pyGTKtalog``
+branch, although bear in mind, that it was written with `python 2.7`_ and
+pyGTK_, which both are dead now.
+
+Current version is 3.0.
+
+Features
+--------
+
+* Scan for files in selected media
+* Support for grouping files depending on file name (expected patterns in file
+  names)
+* Store selected EXIF tags
+* Add/edit description and notes
+* Fetch comments for images made in `gThumb`_
+* `Tagging files`_
+* And more :)
+
+Requirements
+------------
+
+pycatalog requires python and following libraries:
+
+* `python 3.10`_ and up
+* `sqlalchemy 1.4`_
+* `exifread`_ for parse EXIF information
+
+Pycatalog extensively uses external programs in unix spirit, however there is
+small possibility of using it Windows (probably with limitations) and quite big
+possibility to run it on other sophisticated unix-like systems (i.e.
+BeOS/ZETA/Haiku, QNX or MacOSX).
+
+Programs that are used:
+* ``midentify`` (provided by `mplayer`_ package)
+
+For development process following programs are used:
+
+* `nose`_
+* `coverage`_
+* `tox`_
+
+Instalation
+-----------
+
+You don't have to install it if you don't want to. You can just change current
+directory to pycatalog and simply run::
+
+    $ paver run
+
+That's it. Alternatively, if you like to put it in more system wide place, all
+you have to do is:
+
+#. put pycatalog directory into your destination of choice (/usr/local/share,
+   /opt or ~/ is typical bet)
+
+#. copy pycatalog shell script to /usr/bin, /usr/local/bin or in
+   other place, where PATH variable is pointing or you feel like.
+
+#. then modify pycatalog line 6 to match right ``pycatalog.py`` directory
+
+Then, just run pycatalog script.
+
+LICENSE
+=======
+
+This work is licensed under the terms of the GNU GPL, version 3. See the LICENCE
+file in top-level directory.
+
+
+.. _coverage: http://nedbatchelder.com/code/coverage/
+.. _exifread: https://github.com/ianare/exif-py
+.. _gthumb: http://gthumb.sourceforge.net
+.. _gtktalog: http://www.nongnu.org/gtktalog/
+.. _gwhere: http://www.gwhere.org/home.php3
+.. _mplayer: http://mplayerhq.hu
+.. _nose: http://code.google.com/p/python-nose/
+.. _python 3.10: http://www.python.org/
+.. _sqlalchemy 1.4: http://www.sqlalchemy.org
+.. _tagging files: http://en.wikipedia.org/wiki/tag_%28metadata%29
+.. _tox: https://testrun.org/tox

config.py

@@ -1,97 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-"""
-config parser object
-"""
-
-#{{{ podstawowe importy i sprawdzenia
-import sys
-import os
-from ConfigParser import ConfigParser
-
-class Ini(object):
-    def __init__(self):
-        self.ini = []
-        
-    def add_section(self, section):
-        self.ini.append("[%s]" % section)
-        
-    def add_key(self, key, value):
-        self.ini.append("%s=%s" % (key, value))
-        
-    def add_comment(self, comment):
-        self.ini.append(";%s" % comment)
-        
-    def add_verb(self, verb):
-        self.ini.append(verb)
-
-    def show(self):
-        return "\n".join(self.ini)
-        
-
-class Config:
-    ini = Ini()
-    
-    confd = {
-        'wx' : 800,
-        'wy' : 600,
-        'h' : 200,
-        'v' : 300,
-        'exportxls' : False,
-        'cd' : '/cdrom',
-    }
-    
-    dictconf = {
-        "main window width" : "wx",
-        "main window height": "wy",
-        "horizontal panes": "h",
-        "vertical panes":"v",
-        "export xls":"exportxls",
-        "cd drive":"cd",
-    }
-    
-    dbool = ('exportxls')
-    dstring = ('cd')
-    
-    try:
-        path = os.environ['HOME']
-    except:
-        path = "/tmp"
-    
-    def __init__(self):
-        self.load()
-        
-    def save(self):
-        self.confd
-        newIni = Ini()
-        newIni.add_section("pyGTKtalog conf")
-        for opt in self.dictconf:
-            newIni.add_key(opt,self.confd[self.dictconf[opt]])
-        try:
-            f = open("%s/.pygtktalog" % self.path,"w")
-        except:
-            print "Cannot open config file %s for writing." % (self.path, "/.pygtktalog") 
-        f.write(newIni.show())
-        f.close()
-        
-    def load(self):
-        try:
-            # try to read config file
-            parser = ConfigParser()
-            parser.read("%s/.pygtktalog" % self.path)
-            for sec in parser.sections():
-                if sec == 'pyGTKtalog conf':
-                    for opt in parser.options(sec):
-                        try:
-                            if self.dictconf[opt] in self.dbool:
-                                self.confd[self.dictconf[opt]] = parser.getboolean(sec,opt)
-                            elif self.dictconf[opt] in self.dstring:
-                                self.confd[self.dictconf[opt]] = parser.get(sec,opt)
-                            else:
-                                self.confd[self.dictconf[opt]] = parser.getint(sec,opt)
-                        except:
-                            pass
-        except:
-            print "No config file"
-            pass
-

deviceHelper.py

@@ -1,28 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-"""
-device (cd, dvd) helper
-"""
-
-import string
-import os
-
-def volname(dev):
-    """read volume name from cd/dvd"""
-    try:
-        a = open(dev,"rb")
-        a.seek(32808)
-        b = a.read(32).strip()
-        a.close()
-    except:
-        return None
-    return b
-    
-def volmount(dev):
-    """mount device, return True/False"""
-    stout,stin,sterr = popen3("mount %s" % dev)
-    error = sterr.readline()
-    stout.close()
-    stin.close()
-    sterr.close()
-    return len(error) == 0

glade/main.glade

@@ -1,394 +0,0 @@
-<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->
-<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.0.dtd">
-
-<glade-interface>
-
-<widget class="GtkWindow" id="main">
-  <property name="title" translatable="yes">mainW</property>
-  <property name="type">GTK_WINDOW_TOPLEVEL</property>
-  <property name="window_position">GTK_WIN_POS_NONE</property>
-  <property name="modal">False</property>
-  <property name="resizable">True</property>
-  <property name="destroy_with_parent">False</property>
-  <property name="decorated">True</property>
-  <property name="skip_taskbar_hint">False</property>
-  <property name="skip_pager_hint">False</property>
-  <property name="type_hint">GDK_WINDOW_TYPE_HINT_NORMAL</property>
-  <property name="gravity">GDK_GRAVITY_NORTH_WEST</property>
-  <signal name="destroy" handler="on_main_destroy_event" last_modification_time="Tue, 22 Aug 2006 19:12:49 GMT"/>
-
-  <child>
-    <widget class="GtkVBox" id="vbox1">
-      <property name="visible">True</property>
-      <property name="homogeneous">False</property>
-      <property name="spacing">0</property>
-
-      <child>
-	<widget class="GtkMenuBar" id="mainMenubar">
-	  <property name="visible">True</property>
-
-	  <child>
-	    <widget class="GtkMenuItem" id="menuitem1">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">_File</property>
-	      <property name="use_underline">True</property>
-
-	      <child>
-		<widget class="GtkMenu" id="menuitem1_menu">
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="new1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-new</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_new1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="open1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-open</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_open1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="save1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-save</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_save1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="save_as1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-save-as</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_save_as1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkSeparatorMenuItem" id="separator1">
-		      <property name="visible">True</property>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkMenuItem" id="recent_files1">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">Recent files</property>
-		      <property name="use_underline">True</property>
-		      <signal name="activate" handler="on_recent_files1_activate" last_modification_time="Thu, 23 Nov 2006 18:29:26 GMT"/>
-
-		      <child>
-			<widget class="GtkMenu" id="recent_files1_menu">
-			</widget>
-		      </child>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkSeparatorMenuItem" id="separatormenuitem1">
-		      <property name="visible">True</property>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="quit1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-quit</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_quit1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-		</widget>
-	      </child>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkMenuItem" id="menuitem2">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">_Edit</property>
-	      <property name="use_underline">True</property>
-
-	      <child>
-		<widget class="GtkMenu" id="menuitem2_menu">
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="properties1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-properties</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_properties1_activate" last_modification_time="Wed, 09 Aug 2006 17:14:08 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="cut1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-cut</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_cut1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="copy1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-copy</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_copy1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="paste1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-paste</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_paste1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkImageMenuItem" id="delete1">
-		      <property name="visible">True</property>
-		      <property name="label">gtk-delete</property>
-		      <property name="use_stock">True</property>
-		      <signal name="activate" handler="on_delete1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-		</widget>
-	      </child>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkMenuItem" id="catalog1">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">_Catalog</property>
-	      <property name="use_underline">True</property>
-
-	      <child>
-		<widget class="GtkMenu" id="catalog1_menu">
-
-		  <child>
-		    <widget class="GtkMenuItem" id="add_cd">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">Add CD/DVD</property>
-		      <property name="use_underline">True</property>
-		      <signal name="activate" handler="on_add_cd_activate" last_modification_time="Fri, 24 Nov 2006 14:12:30 GMT"/>
-		    </widget>
-		  </child>
-
-		  <child>
-		    <widget class="GtkMenuItem" id="add_directory1">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">Add Directory</property>
-		      <property name="use_underline">True</property>
-		      <signal name="activate" handler="on_add_directory1_activate" last_modification_time="Fri, 24 Nov 2006 14:12:30 GMT"/>
-		    </widget>
-		  </child>
-		</widget>
-	      </child>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkMenuItem" id="menuitem3">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">_View</property>
-	      <property name="use_underline">True</property>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkMenuItem" id="menuitem4">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">_Help</property>
-	      <property name="use_underline">True</property>
-
-	      <child>
-		<widget class="GtkMenu" id="menuitem4_menu">
-
-		  <child>
-		    <widget class="GtkMenuItem" id="about1">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">_About</property>
-		      <property name="use_underline">True</property>
-		      <signal name="activate" handler="on_about1_activate" last_modification_time="Wed, 09 Aug 2006 17:12:54 GMT"/>
-		    </widget>
-		  </child>
-		</widget>
-	      </child>
-	    </widget>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">False</property>
-	</packing>
-      </child>
-
-      <child>
-	<widget class="GtkHPaned" id="hpaned1">
-	  <property name="visible">True</property>
-	  <property name="can_focus">True</property>
-	  <property name="position">0</property>
-
-	  <child>
-	    <widget class="GtkScrolledWindow" id="scrolledwindow1">
-	      <property name="visible">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
-	      <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
-	      <property name="shadow_type">GTK_SHADOW_IN</property>
-	      <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
-
-	      <child>
-		<widget class="GtkTreeView" id="discs">
-		  <property name="visible">True</property>
-		  <property name="can_focus">True</property>
-		  <property name="headers_visible">False</property>
-		  <property name="rules_hint">False</property>
-		  <property name="reorderable">False</property>
-		  <property name="enable_search">True</property>
-		</widget>
-	      </child>
-	    </widget>
-	    <packing>
-	      <property name="shrink">True</property>
-	      <property name="resize">False</property>
-	    </packing>
-	  </child>
-
-	  <child>
-	    <widget class="GtkVPaned" id="vpaned1">
-	      <property name="visible">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="position">0</property>
-
-	      <child>
-		<widget class="GtkScrolledWindow" id="scrolledwindow2">
-		  <property name="visible">True</property>
-		  <property name="can_focus">True</property>
-		  <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
-		  <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
-		  <property name="shadow_type">GTK_SHADOW_IN</property>
-		  <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
-
-		  <child>
-		    <widget class="GtkTreeView" id="files">
-		      <property name="visible">True</property>
-		      <property name="can_focus">True</property>
-		      <property name="headers_visible">True</property>
-		      <property name="rules_hint">False</property>
-		      <property name="reorderable">False</property>
-		      <property name="enable_search">True</property>
-		    </widget>
-		  </child>
-		</widget>
-		<packing>
-		  <property name="shrink">True</property>
-		  <property name="resize">False</property>
-		</packing>
-	      </child>
-
-	      <child>
-		<widget class="GtkScrolledWindow" id="detailplace">
-		  <property name="visible">True</property>
-		  <property name="can_focus">True</property>
-		  <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
-		  <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
-		  <property name="shadow_type">GTK_SHADOW_IN</property>
-		  <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
-
-		  <child>
-		    <widget class="GtkTextView" id="details">
-		      <property name="visible">True</property>
-		      <property name="can_focus">True</property>
-		      <property name="editable">False</property>
-		      <property name="overwrite">False</property>
-		      <property name="accepts_tab">False</property>
-		      <property name="justification">GTK_JUSTIFY_LEFT</property>
-		      <property name="wrap_mode">GTK_WRAP_NONE</property>
-		      <property name="cursor_visible">False</property>
-		      <property name="pixels_above_lines">0</property>
-		      <property name="pixels_below_lines">0</property>
-		      <property name="pixels_inside_wrap">0</property>
-		      <property name="left_margin">0</property>
-		      <property name="right_margin">0</property>
-		      <property name="indent">0</property>
-		      <property name="text" translatable="yes"></property>
-		    </widget>
-		  </child>
-		</widget>
-		<packing>
-		  <property name="shrink">True</property>
-		  <property name="resize">True</property>
-		</packing>
-	      </child>
-	    </widget>
-	    <packing>
-	      <property name="shrink">True</property>
-	      <property name="resize">True</property>
-	    </packing>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">True</property>
-	  <property name="fill">True</property>
-	</packing>
-      </child>
-
-      <child>
-	<widget class="GtkHBox" id="hbox1">
-	  <property name="visible">True</property>
-	  <property name="homogeneous">False</property>
-	  <property name="spacing">0</property>
-
-	  <child>
-	    <widget class="GtkStatusbar" id="mainStatus">
-	      <property name="visible">True</property>
-	      <property name="has_resize_grip">False</property>
-	    </widget>
-	    <packing>
-	      <property name="padding">0</property>
-	      <property name="expand">True</property>
-	      <property name="fill">True</property>
-	    </packing>
-	  </child>
-
-	  <child>
-	    <widget class="GtkProgressBar" id="progressbar1">
-	      <property name="visible">True</property>
-	      <property name="orientation">GTK_PROGRESS_LEFT_TO_RIGHT</property>
-	      <property name="fraction">0</property>
-	      <property name="pulse_step">0.10000000149</property>
-	    </widget>
-	    <packing>
-	      <property name="padding">0</property>
-	      <property name="expand">False</property>
-	      <property name="fill">False</property>
-	    </packing>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">False</property>
-	</packing>
-      </child>
-    </widget>
-  </child>
-</widget>
-
-</glade-interface>

mainWindow.py

@@ -1,172 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-"""
-GUI, main window class and correspondig methods for pyGTKtalog app.
-"""
-import sys
-import os
-import mimetypes
-import popen2
-
-import pygtk
-import gtk
-import gtk.glade
-from config import Config
-
-class PyGTKtalog:
-    def __init__(self):
-        
-        self.conf = Config()
-        
-        self.gladefile = "glade/main.glade"
-        self.pygtkcat = gtk.glade.XML(self.gladefile,"main")
-        
-        self.window = self.pygtkcat.get_widget("main")
-        self.window.set_title("pyGTKtalog")
-        icon = gtk.gdk.pixbuf_new_from_file("pixmaps/mainicon.png")
-        self.window.set_icon_list(icon)
-        
-        self.progress = self.pygtkcat.get_widget("progressbar1")
-        
-        self.status = self.pygtkcat.get_widget("mainStatus")
-        self.sbSearchCId = self.status.get_context_id('detailed res')
-        self.sbid = self.status.push(self.sbSearchCId, "Idle")
-        
-        self.detailplaceholder = self.pygtkcat.get_widget("detailplace")
-        self.detailplaceholder.set_sensitive(False)
-        self.details = self.pygtkcat.get_widget("details")
-        self.details.hide()
-        
-        self.widgets = ("discs","files","details",'save1','save_as1','cut1','copy1','paste1','delete1','add_cd','add_directory1')
-        for w in self.widgets:
-            a = self.pygtkcat.get_widget(w)
-            a.set_sensitive(False)
-        
-        a = self.pygtkcat.get_widget('hpaned1')
-        a.set_position(self.conf.confd['h'])
-        a = self.pygtkcat.get_widget('vpaned1')
-        a.set_position(self.conf.confd['v'])
-        self.window.resize(self.conf.confd['wx'],self.conf.confd['wy'])
-        
-        # sygnały:
-        dic = {"on_main_destroy_event"  :self.doQuit,
-               "on_quit1_activate"      :self.doQuit,
-               "on_new1_activate"       :self.newDB,
-               "on_add_cd_activate"     :self.addCD,
-        }
-        
-        # connect signals
-        self.pygtkcat.signal_autoconnect(dic)
-        self.window.connect("delete_event", self.deleteEvent)
-    
-    def storeSettings(self):
-        """Store window size and pane position in config file (using config object)"""
-        hpan = self.pygtkcat.get_widget('hpaned1')
-        vpan = self.pygtkcat.get_widget('vpaned1')
-        
-        self.conf.confd['wx'], self.conf.confd['wy'] = self.window.get_size()
-        self.conf.confd['h'],self.conf.confd['v'] = hpan.get_position(), vpan.get_position()
-        
-        self.conf.save()
-        
-        return
-        
-    def doQuit(self, widget):
-        """quit and save window parameters to config file"""
-        try:
-            if widget.title:
-                pass
-        except:
-            self.storeSettings()
-        gtk.main_quit()
-        return False
-        
-    def newDB(self,widget):
-        """create database in temporary place"""
-        self.window.set_title("untitled - pyGTKtalog")
-        for w in self.widgets:
-            try:
-                a = self.pygtkcat.get_widget(w)
-                a.set_sensitive(True)
-                # PyGTK FAQ entry 23.20
-            except:
-                pass
-            while gtk.events_pending():
-                gtk.main_iteration()
-                
-        #self.details.set_sensitive(True)
-        #self.details.destroy()
-        
-        #self.details = gtk.Button("Press mi or daj");
-        #self.details.set_name("details")
-        
-        #self.detailplaceholder.add_with_viewport(self.details)
-        #self.details.show()
-        return
-    
-    def deleteEvent(self, widget, event, data=None):
-        """checkout actual database changed. If so, do the necessary ask."""
-        self.storeSettings()
-        return False
-   
-    def run(self):
-        self.window.show();
-        gtk.main()
-        
-    def addCD(self,widget):
-        self.scan(self.conf.confd['cd'])
-        
-    def scan(self,path):
-        mime = mimetypes.MimeTypes()
-        extensions = ('mkv','avi','ogg','mpg','wmv','mp4')
-        
-        count = 0
-        for root,kat,plik in os.walk(path):
-            for p in plik:
-                count+=1
-        
-        frac = 1.0/count
-        count = 1
-        #self.progress.set_pulse_step(0)
-        for root,kat,plik in os.walk(path):
-            for p in plik:
-                if p[-3:].lower() in extensions or \
-                mime.guess_type(p)!= (None,None) and \
-                mime.guess_type(p)[0].split("/")[0] == 'video':
-                    # video only
-                    # TODO: parametrize this loop!
-                    info = popen2.popen4('midentify "' + os.path.join(root,p)+'"')[0].readlines()
-                    video_format = ''
-                    audio_codec = ''
-                    video_codec = ''
-                    video_x = ''
-                    video_y = ''
-                    for line in info:
-                        l = line.split('=')
-                        val = l[1].split('\n')[0]
-                        if l[0] == 'ID_VIDEO_FORMAT':
-                            video_format = val
-                        elif l[0] == 'ID_AUDIO_CODEC':
-                            audio_codec = val
-                        elif l[0] == 'ID_VIDEO_CODEC':
-                            video_codec = val
-                        elif l[0] == 'ID_VIDEO_WIDTH':
-                            video_x = val
-                        elif l[0] == 'ID_VIDEO_HEIGHT':
-                            video_y = val
-                if self.sbid != 0:
-                    """jeśli jest jakiś mesedż, usuń go"""
-                    self.status.remove(self.sbSearchCId, self.sbid)
-                self.sbid = self.status.push(self.sbSearchCId, "Scannig: %s" % (os.path.join(root,p)))
-                
-                self.progress.set_fraction(frac * count)
-                count+=1
-                
-                # PyGTK FAQ entry 23.20
-                while gtk.events_pending(): gtk.main_iteration()
-        if self.sbid != 0:
-            self.status.remove(self.sbSearchCId, self.sbid)
-        self.sbid = self.status.push(self.sbSearchCId, "Idle")
-        
-        self.progress.set_fraction(0)
-

pyGTKtalog

@@ -1,32 +0,0 @@
-#!/bin/sh
-##      gajim
-##
-## Contributors for this file:
-##      - Yann Le Boulanger <asterix@lagaule.org>
-##	- Nikos Kouremenos <kourem@gmail.com>
-##
-## Copyright (C) 2003-2004 Yann Le Boulanger <asterix@lagaule.org>
-##                         Vincent Hanquez <tab@snarc.org>
-## Copyright (C) 2005 Yann Le Boulanger <asterix@lagaule.org>
-##                    Vincent Hanquez <tab@snarc.org>
-##                    Nikos Kouremenos <nkour@jabber.org>
-##                    Dimitur Kirov <dkirov@gmail.com>
-##                    Travis Shirk <travis@pobox.com>
-##                    Norman Rasmussen <norman@rasmussen.co.za>
-##
-## 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; version 2 only.
-##
-## 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.
-
-if [ `id -u` -eq 0 ]; then
-	echo "You must not launch Gajim as root, it is INSECURE"
-fi
-
-cd /mnt/data/Python/moviedb
-#export PYTHONPATH="$PYTHONPATH:/usr/lib/gajim"
-exec python -OO pyGTKtalog.py $@

pyGTKtalog.py

@@ -1,64 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-"""
-pytGTKtalog.
-
-A wannabe replacement for excellent gtktalog application.
-
-pyGTKtalog is an application for catalogue/index files on removable media such
-a CD or DVD discs, directories on hard disks or network shares.
-
-"""
-#{{{ try to import all necessary modules
-import sys
-import os
-
-try:
-    from config import Config
-except:
-    print "Some fundamental files are missing. try runnig pyGTKtalog in his root directory"
-    sys.exit(1)
-
-conf = Config()
-
-try:
-    import pygtk
-    #tell pyGTK, if possible, that we want GTKv2
-    pygtk.require("2.0")
-except:
-    #Some distributions come with GTK2, but not pyGTK
-    pass
-try:
-    import gtk
-    import gtk.glade
-except:
-    print "You need to install pyGTK or GTKv2 ",
-    print "or set your PYTHONPATH correctly."
-    print "try: export PYTHONPATH=",
-    print "/usr/local/lib/python2.2/site-packages/"
-    sys.exit(1)
-
-try:
-    from pysqlite2 import dbapi2 as sqlite
-except:
-    print "pyGTKtalog uses SQLite DB.\nYou'll need to get it and the python bindings as well.\nhttp://www.sqlite.org\nhttp://initd.org/tracker/pysqlite"
-    sys.exit(1)
-
-if conf.confd['exportxls']:
-    try:
-        import pyExcelerator
-    except:
-        print "You'll need pyExcelerator, if you want to export DB to XLS format.\nhttp://sourceforge.net/projects/pyexcelerator"
-        sys.exit(1)
-    
-# project modules
-from mainWindow import PyGTKtalog
-
-if __name__ == "__main__":
-    app=PyGTKtalog()
-    try:
-        app.run()
-    except KeyboardInterrupt:
-        app.storeSettings()
-        gtk.main_quit
-

pycatalog/__init__.py

@@ -0,0 +1,360 @@
+"""
+Fast and ugly CLI interface
+"""
+import argparse
+import os
+import re
+
+from sqlalchemy import or_
+
+from pycatalog import scan
+from pycatalog import misc
+from pycatalog import dbobjects as dbo
+from pycatalog import dbcommon
+from pycatalog import logger
+
+LOG = logger.get_logger()
+TYPE_MAP = {0: 'd', 1: 'd', 2: 'f', 3: 'l'}
+
+
+class Iface(object):
+    """Main class which interacts with the pyGTKtalog modules"""
+    def __init__(self, dbname, pretend=False, debug=False):
+        """Init"""
+        self.engine = dbcommon.connect(dbname)
+        self.sess = dbcommon.Session()
+        self.dry_run = pretend
+        self.root = None
+        self._dbname = dbname
+        if debug:
+            scan.LOG.setLevel('DEBUG')
+            LOG.setLevel('DEBUG')
+
+    def _resolve_path(self, path):
+        """Identify path in the DB"""
+        if not path.startswith("/"):
+            raise AttributeError('Path have to start with slash (/)')
+
+        last_node = self.root
+        for part in path.split('/'):
+            if not part.strip():
+                continue
+
+            for node in last_node.children:
+                if node.filename == part:
+                    last_node = node
+                    break
+            else:
+                raise AttributeError('No such path: %s' % path)
+
+        return last_node
+
+    def _get_full_path(self, file_object):
+        """given the file object, return string with full path to it"""
+        parent = file_object.parent
+        path = [file_object.filename]
+
+        while parent.type:
+            path.insert(0, parent.filename)
+            parent = parent.parent
+
+        return u'/' + u'/'.join(path)
+
+    def _make_path(self, node):
+        """Make the path to the item in the DB"""
+        orig_node = node
+        if node.parent == node:
+            return {u'/': (u' ', 0, u' ')}
+
+        ext = ''
+        if node.parent.type == dbo.TYPE['root']:
+            ext = misc.colorize(' (%s)' % node.filepath, 'white')
+
+        path = []
+        path.append(node.filename)
+        while node.parent != self.root:
+            path.append(node.parent.filename)
+            node = node.parent
+
+        path = '/'.join([''] + path[::-1]) + ext
+
+        return {path: (TYPE_MAP[orig_node.type],
+                       orig_node.size,
+                       orig_node.date)}
+
+    def _walk(self, dirnode):
+        """Recursively go through the leaves of the node"""
+        items = {}
+
+        for node in dirnode.children:
+            if node.type == dbo.TYPE['dir']:
+                items.update(self._walk(node))
+
+            items.update(self._make_path(node))
+
+        return items
+
+    def _list(self, node):
+        """List only current node content"""
+        items = {}
+        for node in node.children:
+            if node != self.root:
+                items.update(self._make_path(node))
+
+        return items
+
+    def close(self):
+        """Close the session"""
+        self.sess.commit()
+        self.sess.close()
+
+    def list(self, path=None, recursive=False, long_=False):
+        """Simulate ls command for the provided item path"""
+        self.root = self.sess.query(dbo.File)
+        self.root = self.root.filter(dbo.File.type == dbo.TYPE['root']).first()
+        if path:
+            node = self._resolve_path(path)
+            msg = "Content of path `%s':" % path
+        else:
+            node = self.root
+            msg = "Content of path `/':"
+
+        print(misc.colorize(msg, 'white'))
+
+        if recursive:
+            items = self._walk(node)
+        else:
+            items = self._list(node)
+
+        if long_:
+            filenames = []
+            format_str = (u'{} {:>%d,} {} {}' %
+                          _get_highest_size_length(items))
+            for fname in sorted(items.keys()):
+                type_, size, date = items[fname]
+                filenames.append(format_str.format(type_, size, date, fname))
+        else:
+            filenames = sorted(items.keys())
+
+        print('\n'.join(filenames))
+
+    def update(self, path, dir_to_update=None):
+        """
+        Update the DB against provided path and optionally directory on the
+        real filesystem
+        """
+        self.root = self.sess.query(dbo.File)
+        self.root = self.root.filter(dbo.File.type == dbo.TYPE['root']).first()
+        node = self._resolve_path(path)
+        if node == self.root:
+            print(misc.colorize('Cannot update entire db, since root was '
+                                'provided as path.', 'red'))
+            return
+
+        if not dir_to_update:
+            dir_to_update = os.path.join(node.filepath, node.filename)
+
+        if not os.path.exists(dir_to_update):
+            raise OSError("Path to updtate doesn't exists: %s", dir_to_update)
+
+        print(misc.colorize("Updating node `%s' against directory "
+                            "`%s'" % (path, dir_to_update), 'white'))
+        if not self.dry_run:
+            scanob = scan.Scan(dir_to_update)
+            # scanob.update_files(node.id)
+            scanob.update_files(node.id, self.engine)
+
+    def create(self, dir_to_add, label=None):
+        """Create new database"""
+        self.root = dbo.File()
+        self.root.id = 1
+        self.root.filename = 'root'
+        self.root.size = 0
+        self.root.source = 0
+        self.root.type = 0
+        self.root.parent_id = 1
+
+        if not self.dry_run:
+            self.sess.add(self.root)
+            self.sess.commit()
+
+        print(misc.colorize("Creating new db against directory `%s'" %
+                            dir_to_add, 'white'))
+        if not self.dry_run:
+            scanob = scan.Scan(dir_to_add)
+            scanob.add_files(label=label)
+
+    def add(self, dir_to_add, label=None):
+        """Add new directory to the db"""
+        self.root = self.sess.query(dbo.File)
+        self.root = self.root.filter(dbo.File.type == 0).first()
+
+        if not os.path.exists(dir_to_add):
+            raise OSError("Path to add doesn't exists: %s", dir_to_add)
+
+        print(misc.colorize("Adding directory `%s'" % dir_to_add, 'white'))
+        if not self.dry_run:
+            scanob = scan.Scan(dir_to_add)
+            scanob.add_files(label=label)
+
+    def _annotate(self, item, search_words):
+        """
+        Find ranges to be highlighted in item, provide them and return result
+        string
+        """
+        indexes = []
+        for word in search_words:
+            for match in re.finditer(re.escape(word.lower()), item.lower()):
+                for index in range(match.start(), match.end()):
+                    indexes.append(index)
+
+        highlight = False
+        result = []
+
+        for idx, char in enumerate(item):
+            if idx in indexes:
+                if not highlight:
+                    highlight = True
+                    result.append(misc.COLOR_SEQ % misc.WHITE)
+                result.append(char)
+            else:
+                if highlight:
+                    highlight = False
+                    result.append(misc.RESET_SEQ)
+                result.append(char)
+
+        return "".join(result)
+
+    def find(self, search_words):
+        query = self.sess.query(dbo.File).filter(or_(dbo.File.type == 2,
+                                                     dbo.File.type == 3))
+        result = []
+
+        for word in search_words:
+            phrase = u'%%%s%%' % word
+            query = query.filter(dbo.File.filename.like(phrase))
+
+        for item in query.all():
+            result.append(self._get_full_path(item))
+
+        if not result:
+            print("No results for `%s'" % ' '.join(search_words))
+            return
+
+        result.sort()
+        for item in result:
+            print(self._annotate(item, search_words))
+
+
+def _get_highest_size_length(item_dict):
+    highest = len(str(sorted([i[1] for i in item_dict.values()])[-1]))
+    return highest + highest / 3
+
+
+@misc.asserdb
+def list_db(args):
+    """List"""
+    obj = Iface(args.db, False, args.debug)
+    obj.list(path=args.path, recursive=args.recursive, long_=args.long)
+    obj.close()
+
+
+@misc.asserdb
+def update_db(args):
+    """Update"""
+    obj = Iface(args.db, args.pretend, args.debug)
+    obj.update(args.path, dir_to_update=args.dir_to_update)
+    obj.close()
+
+
+@misc.asserdb
+def add_dir(args):
+    """Add"""
+    obj = Iface(args.db, args.pretend, args.debug)
+    obj.add(args.dir_to_add, args.label)
+    obj.close()
+
+
+def create_db(args):
+    """List"""
+    obj = Iface(args.db, args.pretend, args.debug)
+    obj.create(args.dir_to_add, args.label)
+    obj.close()
+
+
+@misc.asserdb
+def search(args):
+    """Find"""
+    obj = Iface(args.db, False, args.debug)
+    obj.find(args.search_words)
+    obj.close()
+
+
+def main():
+    """Main"""
+    parser = argparse.ArgumentParser()
+
+    subparser = parser.add_subparsers()
+    list_ = subparser.add_parser('list')
+    list_.add_argument('db')
+    list_.add_argument('path', nargs='?')
+    list_.add_argument('-l', '--long', help='Show size, date and type',
+                       action='store_true', default=False)
+    list_.add_argument('-r', '--recursive', help='list items in '
+                       'subdirectories', action='store_true', default=False)
+    list_.add_argument('-d', '--debug', help='Turn on debug',
+                       action='store_true', default=False)
+    list_.set_defaults(func=list_db)
+
+    update = subparser.add_parser('update')
+    update.add_argument('db')
+    update.add_argument('path')
+    update.add_argument('dir_to_update', nargs='?')
+    update.add_argument('-p', '--pretend', help="Don't do the action, just "
+                        "give the info what would gonna to happen.",
+                        action='store_true', default=False)
+    update.add_argument('-d', '--debug', help='Turn on debug',
+                        action='store_true', default=False)
+    update.set_defaults(func=update_db)
+
+    create = subparser.add_parser('create')
+    create.add_argument('db')
+    create.add_argument('dir_to_add')
+    create.add_argument('-l', '--label', help='Add label as the root item of '
+                        'the added directory')
+    create.add_argument('-p', '--pretend', help="Don't do the action, just "
+                        "give the info what would gonna to happen.",
+                        action='store_true', default=False)
+    create.add_argument('-d', '--debug', help='Turn on debug',
+                        action='store_true', default=False)
+    create.set_defaults(func=create_db)
+
+    add = subparser.add_parser('add')
+    add.add_argument('db')
+    add.add_argument('dir_to_add')
+    add.add_argument('-p', '--pretend', help="Don't do the action, just "
+                     "give the info what would gonna to happen.",
+                     action='store_true', default=False)
+    add.add_argument('-d', '--debug', help='Turn on debug',
+                     action='store_true', default=False)
+    add.add_argument('-l', '--label', help='Add label as the root item of the '
+                     'added directory')
+    add.set_defaults(func=add_dir)
+
+    find = subparser.add_parser('find')
+    find.add_argument('db')
+    find.add_argument('search_words', nargs='+')
+    find.add_argument('-d', '--debug', help='Turn on debug',
+                      action='store_true', default=False)
+    find.set_defaults(func=search)
+
+    args = parser.parse_args()
+
+    if 'func' in args:
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

pycatalog/dbcommon.py

@@ -0,0 +1,43 @@
+"""
+    Project: pyGTKtalog
+    Description: Common database operations.
+    Type: core
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-08-07
+"""
+from sqlalchemy import MetaData, create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+from pycatalog.logger import get_logger
+
+
+# Prepare SQLAlchemy objects
+Meta = MetaData()
+Base = declarative_base(metadata=Meta)
+Session = sessionmaker()
+DbFilename = None
+
+LOG = get_logger()
+
+
+def connect(filename=None):
+    """
+    create engine and bind to Meta object.
+    Arguments:
+        @filename - string with absolute or relative path to sqlite database
+                    file. If None, db in-memory will be created
+    """
+    global DbFilename
+
+    if not filename:
+        filename = ':memory:'
+
+    LOG.info("db filename: %s" % filename)
+    DbFilename = filename
+
+    connect_string = "sqlite:///%s" % filename
+    engine = create_engine(connect_string)
+    Meta.bind = engine
+    Meta.create_all(checkfirst=True)
+    return engine

pycatalog/dbobjects.py

@@ -0,0 +1,186 @@
+"""
+    Project: pyGTKtalog
+    Description: Definition of DB objects classes. Using SQLAlchemy.
+    Type: core
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-08-07
+"""
+import os
+import shutil
+
+from sqlalchemy import Column, Table, Integer, Text
+from sqlalchemy import DateTime, ForeignKey, Sequence
+from sqlalchemy.orm import relation, backref
+
+from pycatalog.dbcommon import Base
+from pycatalog.logger import get_logger
+
+
+LOG = get_logger()
+
+tags_files = Table("tags_files", Base.metadata,
+                   Column("file_id", Integer, ForeignKey("files.id")),
+                   Column("tag_id", Integer, ForeignKey("tags.id")))
+
+TYPE = {'root': 0, 'dir': 1, 'file': 2, 'link': 3}
+
+
+class File(Base):
+    """
+    File mapping. Instances of this object can reference other File object
+    which make the structure to be tree-like
+    """
+    __tablename__ = "files"
+    id = Column(Integer, Sequence("file_id_seq"), primary_key=True)
+    parent_id = Column(Integer, ForeignKey("files.id"), index=True)
+    filename = Column(Text)
+    filepath = Column(Text)
+    date = Column(DateTime)
+    size = Column(Integer)
+    type = Column(Integer, index=True)
+    source = Column(Integer)
+    note = Column(Text)
+    description = Column(Text)
+    # checksum = Column(Text)
+
+    children = relation('File',
+                        backref=backref('parent', remote_side="File.id"),
+                        order_by=[type, filename])
+    tags = relation("Tag", secondary=tags_files, order_by="Tag.tag")
+
+    def __init__(self, filename=None, path=None, date=None, size=None,
+                 ftype=None, src=None):
+        """Create file object with empty defaults"""
+        self.filename = filename
+        self.filepath = path
+        self.date = date
+        self.size = size
+        self.type = ftype
+        self.source = src
+
+    def __repr__(self):
+        return "<File('%s', %s)>" % (self.filename, str(self.id))
+
+    def get_all_children(self):
+        """
+        Return list of all node direct and indirect children
+        """
+        def _recursive(node):
+            children = []
+            if node.children:
+                for child in node.children:
+                    children += _recursive(child)
+            if node != self:
+                children.append(node)
+
+            return children
+
+        if self.children:
+            return _recursive(self)
+        else:
+            return []
+
+
+class Group(Base):
+    """TODO: what is this class for?"""
+    __tablename__ = "groups"
+    id = Column(Integer, Sequence("group_id_seq"), primary_key=True)
+    name = Column(Text)
+    color = Column(Text)
+
+    def __init__(self, name=None, color=None):
+        self.name = name
+        self.color = color
+
+    def __repr__(self):
+        return "<Group('%s', %s)>" % (str(self.name), str(self.id))
+
+
+class Tag(Base):
+    """Tag mapping"""
+    __tablename__ = "tags"
+    id = Column(Integer, Sequence("tags_id_seq"), primary_key=True)
+    group_id = Column(Integer, ForeignKey("groups.id"), index=True)
+    tag = Column(Text)
+    group = relation('Group', backref=backref('tags', remote_side="Group.id"))
+
+    files = relation("File", secondary=tags_files, back_populates="tags")
+
+    def __init__(self, tag=None, group=None):
+        self.tag = tag
+        self.group = group
+
+    def __repr__(self):
+        return "<Tag('%s', %s)>" % (str(self.tag), str(self.id))
+
+
+class Exif(Base):
+    """Selected EXIF information"""
+    __tablename__ = "exif"
+    id = Column(Integer, Sequence("exif_id_seq"), primary_key=True)
+    file_id = Column(Integer, ForeignKey("files.id"), index=True)
+    camera = Column(Text)
+    date = Column(Text)
+    aperture = Column(Text)
+    exposure_program = Column(Text)
+    exposure_bias = Column(Text)
+    iso = Column(Text)
+    focal_length = Column(Text)
+    subject_distance = Column(Text)
+    metering_mode = Column(Text)
+    flash = Column(Text)
+    light_source = Column(Text)
+    resolution = Column(Text)
+    orientation = Column(Text)
+
+    def __init__(self):
+        self.camera = None
+        self.date = None
+        self.aperture = None
+        self.exposure_program = None
+        self.exposure_bias = None
+        self.iso = None
+        self.focal_length = None
+        self.subject_distance = None
+        self.metering_mode = None
+        self.flash = None
+        self.light_source = None
+        self.resolution = None
+        self.orientation = None
+
+    def __repr__(self):
+        return "<Exif('%s', %s)>" % (str(self.date), str(self.id))
+
+
+class Gthumb(Base):
+    """Gthumb information"""
+    __tablename__ = "gthumb"
+    id = Column(Integer, Sequence("gthumb_id_seq"), primary_key=True)
+    file_id = Column(Integer, ForeignKey("files.id"), index=True)
+    note = Column(Text)
+    place = Column(Text)
+    date = Column(DateTime)
+
+    def __init__(self, note=None, place=None, date=None):
+        self.note = note
+        self.place = place
+        self.date = date
+
+    def __repr__(self):
+        return "<Gthumb('%s', '%s', %s)>" % (str(self.date), str(self.place),
+                                             str(self.id))
+
+
+class Config(Base):
+    """Per-database configuration"""
+    __tablename__ = "config"
+    id = Column(Integer, Sequence("config_id_seq"), primary_key=True)
+    key = Column(Text)
+    value = Column(Text)
+
+    def __init__(self, key=None, value=None):
+        self.key = key
+        self.value = value
+
+    def __repr__(self):
+        return "<Config('%s', '%s')>" % (str(self.key), str(self.value))

pycatalog/logger.py

@@ -0,0 +1,110 @@
+"""
+    Project: pyGTKtalog
+    Description: Logging functionality
+    Type: core
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-09-02
+"""
+import os
+import sys
+import logging
+
+LEVEL = {'DEBUG': logging.DEBUG,
+         'INFO': logging.INFO,
+         'WARN': logging.WARN,
+         'ERROR': logging.ERROR,
+         'CRITICAL': logging.CRITICAL}
+
+BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
+
+RESET_SEQ = "\033[0m"
+COLOR_SEQ = "\033[1;%dm"
+BOLD_SEQ = "\033[1m"
+
+COLORS = {'WARNING': YELLOW,
+          'INFO': GREEN,
+          'DEBUG': BLUE,
+          'CRITICAL': WHITE,
+          'ERROR': RED}
+
+
+def cprint(txt, color):
+    color_map = {"black": BLACK,
+                 "red": RED,
+                 "green": GREEN,
+                 "yellow": YELLOW,
+                 "blue": BLUE,
+                 "magenta": MAGENTA,
+                 "cyan": CYAN,
+                 "white": WHITE}
+    print(COLOR_SEQ % (30 + color_map[color]) + txt + RESET_SEQ)
+
+
+class DummyFormater(logging.Formatter):
+    """Just don't output anything"""
+    def format(self, record):
+        return ""
+
+
+class ColoredFormatter(logging.Formatter):
+    def __init__(self, msg, use_color=True):
+        logging.Formatter.__init__(self, msg)
+        self.use_color = use_color
+
+    def format(self, record):
+        levelname = record.levelname
+        if self.use_color and levelname in COLORS:
+            levelname_color = COLOR_SEQ % (30 + COLORS[levelname]) \
+                    + levelname + RESET_SEQ
+            record.levelname = levelname_color
+        return logging.Formatter.format(self, record)
+
+
+log_obj = None
+
+
+def get_logger(level='INFO', to_file=True, to_console=True):
+    """
+    Prepare and return log object. Standard formatting is used for all logs.
+    Arguments:
+        @level - Log level (as string), one of DEBUG, INFO, WARN, ERROR and
+                 CRITICAL.
+        @to_file - If True, additionally stores full log in file inside
+                   .pycatalog config directory and to stderr, otherwise log
+                   is only redirected to stderr.
+    Returns: object of logging.Logger class
+    """
+    global log_obj
+    if log_obj:
+        return log_obj
+
+    path = os.path.join(os.path.expanduser("~"), ".pycatalog", "app.log")
+
+    log = logging.getLogger("pycatalog")
+    log.setLevel(LEVEL[level])
+
+    if to_console:
+        console_handler = logging.StreamHandler(sys.stderr)
+        console_formatter = ColoredFormatter("%(filename)s:%(lineno)s - "
+                                             "%(levelname)s - %(message)s")
+        console_handler.setFormatter(console_formatter)
+
+        log.addHandler(console_handler)
+
+    elif to_file:
+        file_handler = logging.FileHandler(path)
+        file_formatter = logging.Formatter("%(asctime)s %(levelname)6s "
+                                           "%(filename)s: %(lineno)s - "
+                                           "%(message)s")
+        file_handler.setFormatter(file_formatter)
+        file_handler.setLevel(LEVEL[level])
+        log.addHandler(file_handler)
+    else:
+        devnull = open(os.devnull, "w")
+        dummy_handler = logging.StreamHandler(devnull)
+        dummy_formatter = DummyFormater("")
+        dummy_handler.setFormatter(dummy_formatter)
+        log.addHandler(dummy_handler)
+
+    log_obj = log
+    return log

pycatalog/misc.py

@@ -0,0 +1,56 @@
+"""
+    Project: pyGTKtalog
+    Description: Misc functions used more than once in src
+    Type: lib
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-04-05
+"""
+import os
+import sys
+
+from pycatalog import logger
+
+BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(30, 38)
+
+RESET_SEQ = '\033[0m'
+COLOR_SEQ = '\033[1;%dm'
+BOLD_SEQ = '\033[1m'
+
+LOG = logger.get_logger()
+
+
+def colorize(txt, color):
+    """Pretty print with colors to console."""
+    color_map = {'black': BLACK,
+                 'red': RED,
+                 'green': GREEN,
+                 'yellow': YELLOW,
+                 'blue': BLUE,
+                 'magenta': MAGENTA,
+                 'cyan': CYAN,
+                 'white': WHITE}
+    return COLOR_SEQ % color_map[color] + txt + RESET_SEQ
+
+
+def float_to_string(float_length):
+    """
+    Parse float digit into time string
+    Arguments:
+        @number - digit to be converted into time.
+    Returns HH:MM:SS formatted string
+    """
+    hour = int(float_length / 3600)
+    float_length -= hour*3600
+    minutes = int(float_length / 60)
+    float_length -= minutes * 60
+    sec = int(float_length)
+    return f"{hour:02}:{minutes:02}:{sec:02}"
+
+
+def asserdb(func):
+    def wrapper(args):
+        if not os.path.exists(args.db):
+            print(colorize("File `%s' does not exists!" % args.db, 'red'))
+            sys.exit(1)
+        func(args)
+    return wrapper

pycatalog/scan.py

@@ -0,0 +1,442 @@
+"""
+    Project: pyGTKtalog
+    Description: Filesystem scan and file automation layer
+    Type: core
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2011-03-27
+"""
+import os
+import re
+from datetime import datetime
+import mimetypes
+
+from pycatalog.dbobjects import File, TYPE
+from pycatalog import dbcommon
+from pycatalog.logger import get_logger
+from pycatalog.video import Video
+
+
+LOG = get_logger()
+RE_FN_START = re.compile(r'(?P<fname_start>'
+                         r'(\[[^\]]*\]\s)?'
+                         r'([^(]*)\s'
+                         r'((\(\d{4}\))\s)?).*'
+                         r'(\[[A-Fa-f0-9]{8}\])\..*')
+
+
+class NoAccessError(Exception):
+    """No access exception"""
+
+
+class Scan(object):
+    """
+    Retrieve and identify all files recursively on given path
+    """
+    def __init__(self, path):
+        """
+        Initialize
+        @Arguments:
+            @path - string with path to be added to topmost node (root)
+        """
+        self.abort = False
+        self.path = path.rstrip(os.path.sep)
+        self._files = []
+        self._existing_files = []  # for re-use purpose in adding
+        self._existing_branch = []  # for branch storage, mainly for updating
+        self._session = dbcommon.Session()
+        self.files_count = self._get_files_count()
+        self.current_count = 0
+
+    def add_files(self, label=None):
+        """
+        Returns list, which contain object, modification date and file
+        size.
+        """
+        self._files = []
+        self._existing_branch = []
+        LOG.debug("given path: %s", self.path)
+
+        # See, if file exists. If not it would raise OSError exception
+        os.stat(self.path)
+
+        if not os.access(self.path, os.R_OK | os.X_OK) \
+                or not os.path.isdir(self.path):
+            raise NoAccessError("Access to %s is forbidden" % self.path)
+
+        directory = os.path.basename(self.path)
+        path = os.path.dirname(self.path)
+
+        if not self._recursive(None, directory, path, 0):
+            return None
+
+        # add only first item from _files, because it is a root of the other,
+        # so other will be automatically added aswell.
+        if label:
+            self._files[0].filename = label
+        self._session.add(self._files[0])
+        self._session.commit()
+        return self._files
+
+    def get_all_children(self, node_id, engine):
+        """
+        Get children by pure SQL
+
+        Starting from sqlite 3.8.3 it is possile to do this operation as a
+        one query using WITH statement. For now on it has to be done in
+        application.
+        """
+        query = "select id from files where parent_id=? and type=1"
+        query2 = "select id from files where parent_id in (%s)"
+
+        row = ((node_id,),)
+        all_ids = []
+
+        def req(obj):
+            """Requrisve function for gathering all child ids for given node"""
+            for line in obj:
+                all_ids.append(line[0])
+                res = engine.execute(query, (line[0],)).fetchall()
+                if res:
+                    req(res)
+
+        req(row)
+
+        sql = query2 % ",".join("?" * len(all_ids))
+        all_ids = [row_[0] for row_ in engine
+                   .execute(sql, tuple(all_ids))
+                   .fetchall()]
+
+        all_obj = []
+        # number of objects to retrieve at once. Limit is 999. Let's do a
+        # little bit below.
+        num = 900
+        steps = len(all_ids) // num + 1
+        for step in range(steps):
+            all_obj.extend(self._session
+                           .query(File)
+                           .filter(File.id
+                                   .in_(all_ids[step * num:step * num + num]))
+                           .all())
+        return all_obj
+
+    def update_files(self, node_id, engine=None):
+        """
+        Updtate DB contents of provided node.
+        """
+        self.current_count = 0
+        old_node = self._session.query(File).get(node_id)
+        if old_node is None:
+            LOG.warning("No such object in db: %s", node_id)
+            return
+        parent = old_node.parent
+
+        self._files = []
+
+        if engine:
+            LOG.debug("Getting all File objects via SQL")
+            self._existing_branch = self.get_all_children(node_id, engine)
+        else:
+            LOG.debug("Getting all File objects via ORM (yeah, it SLOW)")
+            self._existing_branch = old_node.get_all_children()
+
+        self._existing_branch.insert(0, old_node)
+
+        # Break the chain of parent-children relations
+        LOG.debug("Make them orphans")
+        for fobj in self._existing_branch:
+            fobj.parent = None
+
+        update_path = os.path.join(old_node.filepath, old_node.filename)
+        # gimme a string. unicode can't handle strange filenames in paths, so
+        # in case of such, better get me a byte string. It is not perfect
+        # though, since it WILL crash if the update_path would contain some
+        # unconvertable characters.
+        update_path = update_path
+
+        # refresh objects
+        LOG.debug("Refreshing objects")
+        self._get_all_files()
+
+        LOG.debug("path for update: %s", update_path)
+
+        # See, if file exists. If not it would raise OSError exception
+        os.stat(update_path)
+
+        if not os.access(update_path, os.R_OK | os.X_OK) \
+                or not os.path.isdir(update_path):
+            LOG.error("Access to %s is forbidden", update_path)
+            raise NoAccessError("Access to %s is forbidden" % update_path)
+
+        directory = os.path.basename(update_path)
+        path = os.path.dirname(update_path)
+
+        if not self._recursive(parent, directory, path, 0):
+            return None
+
+        # update branch
+        # self._session.merge(self._files[0])
+        LOG.debug("Deleting objects whitout parent: %s",
+                  str(self._session.query(File)
+                      .filter(File.parent.is_(None)).all()))
+        self._session.query(File).filter(File.parent.is_(None)).delete()
+
+        self._session.commit()
+        return self._files
+
+    def _gather_information(self, fobj):
+        """
+        Try to guess type and gather information about File object if possible
+        """
+        mimedict = {'audio': self._audio,
+                    'video': self._video,
+                    'image': self._image}
+        extdict = {'.mkv': 'video',  # TODO: move this to config/plugin(?)
+                   '.rmvb': 'video',
+                   '.ogm': 'video',
+                   '.ogv': 'video'}
+
+        fp = os.path.join(fobj.filepath, fobj.filename)
+
+        mimeinfo = mimetypes.guess_type(fp)
+        if mimeinfo[0]:
+            mimeinfo = mimeinfo[0].split("/")[0]
+
+        ext = os.path.splitext(fp)[1]
+
+        if mimeinfo and mimeinfo in mimedict:
+            mimedict[mimeinfo](fobj, fp)
+        elif ext and ext in extdict:
+            mimedict[extdict[ext]](fobj, fp)
+        else:
+            LOG.debug("Filetype not supported %s %s", str(mimeinfo), fp)
+            pass
+
+    def _audio(self, fobj, filepath):
+        # tags, depending on the format?
+        return
+
+    def _image(self, fobj, filepath):
+        # exif?
+        return
+
+    def _video(self, fobj, filepath):
+        """
+        Make captures for a movie. Save it under uniq name.
+        """
+        vid = Video(filepath)
+        fobj.description = vid.get_formatted_tags()
+
+    def _get_all_files(self):
+        """Gather all File objects"""
+        self._existing_files = self._session.query(File).all()
+
+    def _mk_file(self, fname, path, parent, ftype=TYPE['file']):
+        """
+        Create and return File object
+        """
+        fullpath = os.path.join(path, fname)
+
+        if ftype == TYPE['link']:
+            fname = fname + " -> " + os.readlink(fullpath)
+
+        fob = {'filename': fname,
+               'path': path,
+               'ftype': ftype}
+        try:
+            fob['date'] = datetime.fromtimestamp(os.stat(fullpath).st_mtime)
+            fob['size'] = os.stat(fullpath).st_size
+        except OSError:
+            # in case of dead softlink, we will have no time and size
+            fob['date'] = None
+            fob['size'] = 0
+
+        fobj = self._get_old_file(fob, ftype)
+
+        if fobj:
+            LOG.debug("found existing file in db: %s", str(fobj))
+            # TODO: update whole tree sizes (for directories/discs)
+            fobj.size = fob['size']
+            fobj.filepath = fob['path']
+            fobj.type = fob['ftype']
+        else:
+            fobj = File(**fob)
+            # SLOW. Don't do this. Checksums has no value eventually
+            # fobj.mk_checksum()
+
+        if parent is None:
+            fobj.parent_id = 1
+        else:
+            fobj.parent = parent
+
+        self._files.append(fobj)
+
+        return fobj
+
+    def _non_recursive(self, parent, fname, path, size):
+        """
+        Do the walk through the file system. Non recursively, since it's
+        slow as hell.
+        @Arguments:
+            @parent - directory File object which is parent for the current
+                      scope
+            @fname - string that hold filename
+            @path - full path for further scanning
+            @size - size of the object
+        """
+        fullpath = os.path.join(path, fname)
+        parent = self._mk_file(fname, path, parent, TYPE['dir'])
+        parent.size = 0
+        parent.type = TYPE['dir']
+
+        for root, dirs, files in os.walk(fullpath):
+            for dir_ in dirs:
+                pass
+
+            for file_ in files:
+                self.current_count += 1
+                stat = os.lstat(os.path.join(root, file_))
+                parent.size += stat.st_size
+
+        # TODO: finish that up
+
+    def _recursive(self, parent, fname, path, size):
+        """
+        Do the walk through the file system
+        @Arguments:
+            @parent - directory File object which is parent for the current
+                      scope
+            @fname - string that hold filename
+            @path - full path for further scanning
+            @size - size of the object
+        """
+        if self.abort:
+            return False
+
+        fullpath = os.path.join(path, fname)
+
+        parent = self._mk_file(fname, path, parent, TYPE['dir'])
+
+        parent.size = _get_dirsize(fullpath)
+        parent.type = TYPE['dir']
+
+        LOG.info("Scanning `%s' [%s/%s]", fullpath, self.current_count,
+                 self.files_count)
+
+        root, dirs, files = next(os.walk(fullpath))
+        for fname in files:
+            fpath = os.path.join(root, fname)
+            extension = os.path.splitext(fname)[1]
+            self.current_count += 1
+            LOG.debug("Processing %s [%s/%s]", fname, self.current_count,
+                      self.files_count)
+
+            result = RE_FN_START.match(fname)
+            test_ = False
+
+            if result and extension in ('.jpg', '.gif', '.png'):
+                startfrom = result.groupdict()['fname_start']
+                matching_files = []
+                for fn_ in os.listdir(root):
+                    if fn_.startswith(startfrom):
+                        matching_files.append(fn_)
+
+                if len(matching_files) > 1:
+                    LOG.debug('found image "%s" in group: %s, skipping', fname,
+                              str(matching_files))
+                    test_ = True
+            if test_:
+                continue
+
+            if os.path.islink(fpath):
+                fob = self._mk_file(fname, root, parent, TYPE['link'])
+            else:
+                fob = self._mk_file(fname, root, parent)
+                existing_obj = self._object_exists(fob)
+
+                if existing_obj:
+                    existing_obj.parent = fob.parent
+                    fob = existing_obj
+                else:
+                    LOG.debug("gather information for %s",
+                              os.path.join(root, fname))
+                    self._gather_information(fob)
+                size += fob.size
+            if fob not in self._existing_files:
+                self._existing_files.append(fob)
+
+        for dirname in dirs:
+            dirpath = os.path.join(root, dirname)
+
+            if not os.access(dirpath, os.R_OK | os.X_OK):
+                LOG.info("Cannot access directory %s", dirpath)
+                continue
+
+            if os.path.islink(dirpath):
+                fob = self._mk_file(dirname, root, parent, TYPE['link'])
+            else:
+                LOG.debug("going into %s", os.path.join(root, dirname))
+                self._recursive(parent, dirname, fullpath, size)
+
+        LOG.debug("size of items: %s", parent.size)
+        return True
+
+    def _get_old_file(self, fdict, ftype):
+        """
+        Search for object with provided data in dictionary in stored branch
+        (which is updating). Return such object on success, remove it from
+        list.
+        """
+        for index, obj in enumerate(self._existing_branch):
+            if ftype == TYPE['link'] and fdict['filename'] == obj.filename:
+                return self._existing_branch.pop(index)
+            elif fdict['filename'] == obj.filename and \
+                    fdict['date'] == obj.date and \
+                    ftype == TYPE['file'] and \
+                    fdict['size'] in (obj.size, 0):
+                obj = self._existing_branch.pop(index)
+                obj.size = fdict['size']
+                return obj
+            elif fdict['filename'] == obj.filename:
+                obj = self._existing_branch.pop(index)
+                obj.size = fdict['date']
+                return obj
+        return False
+
+    def _object_exists(self, fobj):
+        """
+        Perform check if current File object already exists in collection. If
+        so, return first matching one, None otherwise.
+        """
+        for efobj in self._existing_files:
+            if efobj.size == fobj.size \
+                    and efobj.type == fobj.type \
+                    and efobj.date == fobj.date \
+                    and efobj.filename == fobj.filename:
+                return efobj
+        return None
+
+    def _get_files_count(self):
+        """return size in bytes"""
+        count = 0
+        for _, _, files in os.walk(str(self.path)):
+            count += len(files)
+        LOG.debug("count of files: %s", count)
+        return count
+
+
+def _get_dirsize(path):
+    """
+    Returns sum of all files under specified path (also in subdirs)
+    """
+
+    size = 0
+
+    for root, _, files in os.walk(path):
+        for fname in files:
+            try:
+                size += os.lstat(os.path.join(root, fname)).st_size
+            except OSError:
+                LOG.warning("Cannot access file %s",
+                            os.path.join(root, fname))
+    LOG.debug("_get_dirsize, %s: %d", path, size)
+    return size

pycatalog/video.py

@@ -0,0 +1,283 @@
+"""
+    Project: pyGTKtalog
+    Description: Gather video file information, make "screenshot" with content
+                 of the movie file. Uses external tools like mplayer.
+    Type: lib
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-04-04
+"""
+import math
+import os
+import shutil
+import tempfile
+
+from PIL import Image
+
+from pycatalog.misc import float_to_string
+from pycatalog.logger import get_logger
+
+
+LOG = get_logger()
+
+
+class Video(object):
+    """Class for retrive midentify script output and put it in dict.
+    Usually there is no need for such a detailed movie/clip information.
+    Midentify script belongs to mplayer package.
+    """
+
+    def __init__(self, filename, out_width=1024):
+        """
+        Init class instance.
+        Arguments:
+            @filename - Filename of a video file (required).
+            @out_width - width of final image to be scaled to.
+        """
+        self.filename = filename
+        self.out_width = out_width
+        self.tags = {}
+
+        output = self._get_movie_info()
+
+        attrs = {'ID_VIDEO_WIDTH': ['width', int],
+                 'ID_VIDEO_HEIGHT': ['height', int],
+                 # length is in seconds
+                 'ID_LENGTH': ['length', lambda x: int(x.split(".")[0])],
+                 'ID_START_TIME': ['start', self._get_start_pos],
+                 'ID_DEMUXER': ['container', self._return_lower],
+                 'ID_VIDEO_FORMAT': ['video_format', self._return_lower],
+                 'ID_VIDEO_CODEC': ['video_codec', self._return_lower],
+                 'ID_AUDIO_CODEC': ['audio_codec', self._return_lower],
+                 'ID_AUDIO_FORMAT': ['audio_format', self._return_lower],
+                 'ID_AUDIO_NCH': ['audio_no_channels', int]}
+        # TODO: what about audio/subtitle language/existence?
+
+        for key in output:
+            if key in attrs:
+                self.tags[attrs[key][0]] = attrs[key][1](output[key])
+
+        if 'length' in self.tags and self.tags['length'] > 0:
+            start = self.tags.get('start', 0)
+            length = self.tags['length'] - start
+            hours = length // 3600
+            seconds = length - hours * 3600
+            minutes = seconds // 60
+            seconds -= minutes * 60
+            length_str = "%02d:%02d:%02d" % (hours, minutes, seconds)
+            self.tags['duration'] = length_str
+
+    def capture(self):
+        """
+        Extract images for given video filename and montage it into one, big
+        picture, similar to output from Windows Media Player thing, but without
+        captions and time (who need it anyway?).
+
+        Returns: image filename or None
+
+        NOTE: You should remove returned file manually, or move it in some
+        other place, otherwise it stays in filesystem.
+        """
+
+        if not ('length' in self.tags and 'width' in self.tags):
+            # no length or width
+            return None
+
+        if not (self.tags['length'] > 0 and self.tags['width'] > 0):
+            # zero length or wight
+            return None
+
+        # Calculate number of pictures. Base is equivalent 72 pictures for
+        # 1:30:00 movie length
+        scale = int(10 * math.log(self.tags['length'], math.e) - 11)
+
+        if scale < 1:
+            return None
+
+        no_pictures = self.tags['length'] // scale
+
+        if no_pictures > 8:
+            no_pictures = (no_pictures // 8) * 8  # only multiple of 8, please.
+        else:
+            # for really short movies
+            no_pictures = 4
+
+        tempdir = tempfile.mkdtemp()
+        file_desc, image_fn = tempfile.mkstemp(suffix=".jpg")
+        os.close(file_desc)
+        self._make_captures(tempdir, no_pictures)
+        self._make_montage(tempdir, image_fn, no_pictures)
+
+        shutil.rmtree(tempdir)
+        return image_fn
+
+    def get_formatted_tags(self):
+        """
+        Return formatted tags as a string
+        """
+        out_tags = ''
+        if 'container' in self.tags:
+            out_tags += "Container: %s\n" % self.tags['container']
+
+        if 'width' in self.tags and 'height' in self.tags:
+            out_tags += "Resolution: %sx%s\n" % (self.tags['width'],
+                                                 self.tags['height'])
+
+        if 'duration' in self.tags:
+            out_tags += "Duration: %s\n" % self.tags['duration']
+
+        if 'video_codec' in self.tags:
+            out_tags += "Video codec: %s\n" % self.tags['video_codec']
+
+        if 'video_format' in self.tags:
+            out_tags += "Video format: %s\n" % self.tags['video_format']
+
+        if 'audio_codec' in self.tags:
+            out_tags += "Audio codec: %s\n" % self.tags['audio_codec']
+
+        if 'audio_format' in self.tags:
+            out_tags += "Audio format: %s\n" % self.tags['audio_format']
+
+        if 'audio_no_channels' in self.tags:
+            out_tags += "Audio channels: %s\n" % self.tags['audio_no_channels']
+
+        return out_tags
+
+    def _get_movie_info(self):
+        """
+        Gather movie file information with midentify shell command.
+        Returns: dict of command output. Each dict element represents pairs:
+                 variable=value, for example output from midentify will be:
+
+                     ID_VIDEO_ID=0
+                     ID_AUDIO_ID=1
+                     ....
+                     ID_AUDIO_CODEC=mp3
+                     ID_EXIT=EOF
+
+                 so method returns dict:
+
+                     {'ID_VIDEO_ID': '0',
+                      'ID_AUDIO_ID': 1,
+                      ....
+                      'ID_AUDIO_CODEC': 'mp3',
+                      'ID_EXIT': 'EOF'}
+        """
+        output = os.popen('midentify "%s"' % self.filename).readlines()
+        return_dict = {}
+
+        for line in output:
+            line = line.strip()
+            key = line.split('=')
+            if len(key) > 1:
+                return_dict[key[0]] = line.replace("%s=" % key[0], "")
+        return return_dict
+
+    def _make_captures(self, directory, no_pictures):
+        """
+        Make screens with mplayer into given directory
+        Arguments:
+            @directory - full output directory name
+            @no_pictures - number of pictures to take
+        """
+        step = self.tags['length'] / (no_pictures + 1)
+        current_time = 0
+        for dummy in range(1, no_pictures + 1):
+            current_time += step
+            time = float_to_string(current_time)
+            cmd = ('mplayer "%s" -ao null -brightness 0 -hue 0 '
+                   '-saturation 0 -contrast 0 -mc 0 -vf-clr '
+                   '-vo jpeg:outdir="%s" -ss %s -frames 1 2>/dev/null')
+            os.popen(cmd % (self.filename, directory, time)).readlines()
+
+            try:
+                shutil.move(os.path.join(directory, "00000001.jpg"),
+                            os.path.join(directory, "picture_%s.jpg" % time))
+            except IOError as exc:
+                errno, strerror = exc.args
+                LOG.error('error capturing file from movie "%s" at position '
+                          '%s. Errors: %s, %s', self.filename, time, errno,
+                          strerror)
+
+    def _make_montage(self, directory, image_fn, no_pictures):
+        """
+        Generate one big image from screnshots and optionally resize it. Uses
+        PIL package to create output image.
+        Arguments:
+            @directory - source directory containing images
+            @image_fn - destination final image
+            @no_pictures - number of pictures
+        timeit result:
+            python /usr/lib/python2.6/timeit.py -n 1 -r 1 'from \
+            pycatalog.video import Video; v = Video("/home/gryf/t/a.avi"); \
+            v.capture()'
+            1 loops, best of 1: 18.8 sec per loop
+        """
+        row_length = 4
+        if no_pictures < 8:
+            row_length = 2
+
+        if not (self.tags['width'] * row_length) > self.out_width:
+            for i in [8, 6, 5]:
+                if ((no_pictures % i) == 0 and
+                        (i * self.tags['width']) <= self.out_width):
+                    row_length = i
+                    break
+
+        coef = (float(self.out_width - row_length - 1) /
+                (self.tags['width'] * row_length))
+        if coef < 1:
+            dim = (int(self.tags['width'] * coef),
+                   int(self.tags['height'] * coef))
+        else:
+            dim = int(self.tags['width']), int(self.tags['height'])
+
+        ifn_list = os.listdir(directory)
+        ifn_list.sort()
+        img_list = [Image.open(os.path.join(directory, fn)).resize(dim)
+                    for fn in ifn_list]
+
+        rows = no_pictures // row_length
+        cols = row_length
+        isize = (cols * dim[0] + cols + 1,
+                 rows * dim[1] + rows + 1)
+
+        inew = Image.new('RGB', isize, (80, 80, 80))
+
+        for irow in range(no_pictures * row_length):
+            for icol in range(row_length):
+                left = 1 + icol * (dim[0] + 1)
+                right = left + dim[0]
+                upper = 1 + irow * (dim[1] + 1)
+                lower = upper + dim[1]
+                bbox = (left, upper, right, lower)
+                try:
+                    img = img_list.pop(0)
+                except Exception:
+                    break
+                inew.paste(img, bbox)
+        inew.save(image_fn, 'JPEG')
+
+    def _return_lower(self, chain):
+        """
+        Return lowercase version of provided string argument
+        Arguments:
+            @chain string to be lowered
+        Returns:
+            @string with lowered string
+        """
+        return str(chain).lower()
+
+    def _get_start_pos(self, chain):
+        """
+        Return integer for starting point of the movie
+        """
+        try:
+            return int(chain.split(".")[0])
+        except Exception:
+            return 0
+
+    def __str__(self):
+        str_out = ''
+        for key in self.tags:
+            str_out += "%20s: %s\n" % (key, self.tags[key])
+        return str_out

requirements.txt

@@ -0,0 +1,3 @@
+Pillow
+exifread
+sqlalchemy

setup.cfg

@@ -0,0 +1,41 @@
+[metadata]
+name = pycatalog
+summary = Catalog application for keeping content list of disks and discs
+description_file = README.rst
+author = Roman Dobosz
+author_email = gryf73@gmail.com
+home_page = https://github.com/gryf/pycatalog
+license = BSD
+keywords = catalog, gwhere, collection
+classifier =
+    Development Status :: 4 - Beta
+    Environment :: Console
+    Intended Audience :: End Users/Desktop
+    License :: OSI Approved :: BSD License
+    Operating System :: POSIX :: Linux
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Topic :: Database
+    Topic :: Desktop Environment
+
+[install]
+record = install.log
+
+[options.entry_points]
+console_scripts =
+    pycatalog = pycatalog:main
+
+[files]
+packages =
+    pycatalog
+
+[options]
+install_requires =
+    pillow
+    sqlalchemy
+
+[bdist_wheel]
+universal = 1

setup.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+import setuptools
+
+
+setuptools.setup(setup_requires=['pbr>=2.0.0'], pbr=True)

test-requirements.txt

@@ -0,0 +1,4 @@
+pytest
+pytest-cov
+flake8
+coverage

tests/dbcommon_test.py

@@ -0,0 +1,28 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for DataBase class.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-07-19
+"""
+import unittest
+import os
+
+from pycatalog.dbcommon import connect
+
+
+class TestDataBase(unittest.TestCase):
+    """
+    Class responsible for database connection and schema creation
+    """
+
+    def test_connect(self):
+        """
+        Test connection to database. Memory and file method will be tested.
+        """
+        connect(":memory:")
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/misc_test.py

@@ -0,0 +1,33 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for misc functions.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-04-09
+"""
+import unittest
+import os
+
+import pycatalog.misc as pgtkmisc
+
+
+class TestMiscModule(unittest.TestCase):
+    """
+    Tests functions from misc module
+    """
+
+    def test_float_to_string(self):
+        """
+        test conversion between digits to formated output
+        """
+        self.assertEqual(pgtkmisc.float_to_string(10), '00:00:10')
+        self.assertEqual(pgtkmisc.float_to_string(76), '00:01:16')
+        self.assertEqual(pgtkmisc.float_to_string(22222), '06:10:22')
+        self.assertRaises(TypeError, pgtkmisc.float_to_string)
+        self.assertRaises(TypeError, pgtkmisc.float_to_string, None)
+        self.assertRaises(TypeError, pgtkmisc.float_to_string, '10')
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/scan_test.py

@@ -0,0 +1,192 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for scan files.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2011-03-26
+"""
+import os
+import shutil
+import tempfile
+import unittest
+
+from pycatalog import scan
+from pycatalog.dbobjects import File, Config, Image
+from pycatalog.dbcommon import connect, Session
+
+
+def populate_with_mock_files(dir_):
+    """Make some files under specified directory, return number of files"""
+    files1 = ['anim.mkv', 'text.txt', 'image.png', 'photoimage.jpg']
+    files2 = ['music.mp3', 'loseless.flac']
+
+    files_no = 0
+    for file_ in files1:
+        with open(os.path.join(dir_, file_), "wb") as fobj:
+            fobj.write(b"\xde\xad\xbe\xef" * len(file_))
+            files_no += 1
+
+    os.symlink(os.path.join(dir_, files1[-1]), os.path.join(dir_, 'link.jpg'))
+    files_no += 1
+
+    os.mkdir(os.path.join(dir_, 'directory'))
+    for file_ in files2:
+        with open(os.path.join(dir_, 'directory', file_), "wb") as fobj:
+            fobj.write(b"\xfe\xad\xfa\xce" * len(file_))
+            files_no += 1
+
+    return files_no
+
+
+# TODO: exchange this with mock module
+def _fake_video(obj, fobj, filepath):
+    fobj.images.append(Image())
+    fobj.images[0].filename = filepath + ".jpg"
+
+
+def _fake_audio(obj, fobj, filepath):
+    pass
+
+
+def _fake_image(obj, fobj, filepath):
+    pass
+
+
+scan.Scan._video = _fake_video
+scan.Scan._audio = _fake_audio
+scan.Scan._image = _fake_image
+
+
+class TestScan(unittest.TestCase):
+    """
+    Test cases for scan functionality
+
+    1. execution scan function:
+    1.1 simple case - should pass
+    1.2 non-existent directory passed
+    1.3 file passed
+    1.4 directory has permission that forbids file listing
+
+    2. rescan directory; looking for changes
+    2.0 don't touch records for changed files (same directories, same
+        filename, same type and size)
+    2.1 search for files of the same type, same size.
+    2.2 change parent node for moved files (don't insert new)
+
+    3. adding new directory tree which contains same files like already stored
+       in the database
+    """
+    def setUp(self):
+        self.image_path = tempfile.mkdtemp()
+        self.scan_dir = tempfile.mkdtemp()
+        self.no_of_files = populate_with_mock_files(self.scan_dir)
+
+        connect()
+        root = File()
+        root.id = 1
+        root.filename = 'root'
+        root.size = 0
+        root.source = 0
+        root.type = 0
+        root.parent_id = 1
+
+        config = Config()
+        config.key = 'image_path'
+        config.value = self.image_path
+
+        sess = Session()
+        sess.add(root)
+        sess.add(config)
+        sess.commit()
+
+    def tearDown(self):
+        shutil.rmtree(self.image_path)
+        shutil.rmtree(self.scan_dir)
+
+    def test_happy_scenario(self):
+        """
+        make scan, count items
+        """
+        scanob = scan.Scan(self.scan_dir)
+        result_list = scanob.add_files()
+
+        # the number of added objects (files/links only) + "directory" +
+        # topmost directory (self.scan_dir)
+        self.assertEqual(len(result_list), self.no_of_files + 2)
+
+        # all of topmost nide children - including "directory", but excluding
+        # its contents - so it is all_files + 1 (directory) - 2 files from
+        # subdir contents
+        self.assertEqual(len(result_list[0].children), self.no_of_files - 1)
+        # check soft links
+        self.assertEqual(len([x for x in result_list if x.type == 3]), 1)
+
+    def test_wrong_and_nonexistent(self):
+        """
+        Check for accessing non existent directory, regular file instead of
+        the directory.
+        """
+        scanobj = scan.Scan('/nonexistent_directory_')
+        self.assertRaises(OSError, scanobj.add_files)
+
+        scanobj.path = '/root'
+        self.assertRaises(scan.NoAccessError, scanobj.add_files)
+
+        scanobj.path = '/bin/sh'
+        self.assertRaises(scan.NoAccessError, scanobj.add_files)
+
+    def test_abort_functionality(self):
+        scanobj = scan.Scan(self.scan_dir)
+        scanobj.abort = True
+        self.assertEqual(None, scanobj.add_files())
+
+    def test_double_scan(self):
+        """
+        Do the scan twice.
+        """
+        ses = Session()
+        self.assertEqual(len(ses.query(File).all()), 1)
+
+        scanob = scan.Scan(self.scan_dir)
+        scanob.add_files()
+
+        # dirs: main one + "directory" subdir
+        self.assertEqual(len(ses.query(File).filter(File.type == 1).all()), 2)
+
+        # files: '-1' for existing link there, which have it's own type
+        self.assertEqual(len(ses.query(File).filter(File.type == 2).all()),
+                         self.no_of_files - 1)
+        # links
+        self.assertEqual(len(ses.query(File).filter(File.type == 3).all()), 1)
+
+        # all - sum of all of the above + root node
+        self.assertEqual(len(ses.query(File).all()), self.no_of_files + 2 + 1)
+
+        # it is perfectly ok, since we don't update collection, but just added
+        # same directory twice.
+        scanob2 = scan.Scan(self.scan_dir)
+        scanob2.add_files()
+        # we have twice as much of files (self.no_of_files), plus 2 * of
+        # topmost dir and subdir "directory" (means 4) + root element
+        self.assertEqual(len(ses.query(File).all()), self.no_of_files * 2 + 5)
+
+        # get some movie files to examine
+        file_ob = [x for x in scanob._files if x.filename == 'anim.mkv'][0]
+        file2_ob = [x for x in scanob2._files if x.filename == 'anim.mkv'][0]
+
+        # File objects are different
+        self.assertTrue(file_ob is not file2_ob)
+
+        # While Image objects points to the same file
+        self.assertTrue(file_ob.images[0].filename ==
+                        file2_ob.images[0].filename)
+
+        # they are different objects
+        self.assertTrue(file_ob.images[0] is not file2_ob.images[0])
+
+        ses.close()
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/video_test.py

@@ -0,0 +1,397 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for Video class.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2008-12-15
+"""
+import os
+import unittest
+from unittest import mock
+import io
+
+import PIL
+
+from pycatalog.video import Video
+
+
+DATA = {"m1.avi": """ID_VIDEO_ID=0
+ID_AUDIO_ID=1
+ID_FILENAME=m1.avi
+ID_DEMUXER=avi
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=46184
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=85
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=0.00
+ID_LENGTH=4.03
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=mpg123
+ID_EXIT=EOF
+""",
+        "m.avi": """ID_VIDEO_ID=0
+ID_AUDIO_ID=1
+ID_FILENAME=m.avi
+ID_DEMUXER=avi
+ID_VIDEO_FORMAT=XVID
+ID_VIDEO_BITRATE=313536
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=85
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=0.00
+ID_LENGTH=4.03
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffodivx
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=mpg123
+ID_EXIT=EOF""",
+        "m.mkv": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_CLIP_INFO_NAME0=title
+ID_CLIP_INFO_VALUE0=Avidemux
+ID_CLIP_INFO_NAME1=encoder
+ID_CLIP_INFO_VALUE1=Lavf51.12.1
+ID_CLIP_INFO_N=2
+ID_FILENAME=m.mkv
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=MP4V
+ID_VIDEO_BITRATE=0
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=8192
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_START_TIME=0.00
+ID_LENGTH=4.07
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffodivx
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_AUDIO_CODEC=ffac3
+ID_EXIT=EOF""",
+        "m.mpg": """ID_VIDEO_ID=0
+ID_FILENAME=m.mpg
+ID_DEMUXER=mpeges
+ID_VIDEO_FORMAT=0x10000001
+ID_VIDEO_BITRATE=2200000
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_START_TIME=0.00
+ID_LENGTH=0.97
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffmpeg1
+ID_EXIT=EOF""",
+        "m.ogm": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_FILENAME=m.ogm
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=0
+ID_VIDEO_WIDTH=160
+ID_VIDEO_HEIGHT=120
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=8192
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_START_TIME=0.00
+ID_LENGTH=4.00
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_AUDIO_CODEC=ffac3
+ID_EXIT=EOF""",
+        "m.wmv": """ID_AUDIO_ID=1
+ID_VIDEO_ID=2
+ID_FILENAME=m.wmv
+ID_DEMUXER=asf
+ID_VIDEO_FORMAT=WMV3
+ID_VIDEO_BITRATE=1177000
+ID_VIDEO_WIDTH=852
+ID_VIDEO_HEIGHT=480
+ID_VIDEO_FPS=1000.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=353
+ID_AUDIO_BITRATE=0
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=4.00
+ID_LENGTH=4656.93
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffwmv3
+ID_AUDIO_BITRATE=64028
+ID_AUDIO_RATE=48000
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=ffwmav2
+ID_EXIT=EOF""",
+        "m.mp4": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_AID_0_LANG=unk
+ID_CLIP_INFO_NAME0=major_brand
+ID_CLIP_INFO_VALUE0=isom
+ID_CLIP_INFO_NAME1=minor_version
+ID_CLIP_INFO_VALUE1=512
+ID_CLIP_INFO_NAME2=compatible_brands
+ID_CLIP_INFO_VALUE2=isomiso2avc1mp41
+ID_CLIP_INFO_NAME3=encoder
+ID_CLIP_INFO_VALUE3=Lavf56.25.101
+ID_CLIP_INFO_N=4
+ID_FILENAME=m.mp4
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=1263573
+ID_VIDEO_WIDTH=720
+ID_VIDEO_HEIGHT=404
+ID_VIDEO_FPS=25.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=MP4A
+ID_AUDIO_BITRATE=155088
+ID_AUDIO_RATE=44100
+ID_AUDIO_NCH=2
+ID_START_TIME=0.00
+ID_LENGTH=69.18
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=155082
+ID_AUDIO_RATE=44100
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=ffaac
+ID_EXIT=EOF"""}
+
+
+# TODO: exchange this with mock
+class Readlines(object):
+    def __init__(self, key=None):
+        self.data = DATA.get(key, "")
+
+    def readlines(self):
+        return self.data.split('\n')
+
+
+def mock_popen(command):
+    key = None
+    if 'midentify' in command:
+        key = command.split('"')[1]
+    elif 'jpeg:outdir' in command:
+        # simulate capture for mplayer
+        img_dir = command.split('"')[-2]
+        img = PIL.Image.new('RGB', (320, 200))
+        with open(os.path.join(img_dir, "00000001.jpg"), "wb") as fobj:
+            img.save(fobj)
+
+    return Readlines(key)
+
+
+# os.popen = mock_popen
+
+
+class TestVideo(unittest.TestCase):
+    """test class for retrive midentify script output"""
+
+    @mock.patch('os.popen')
+    def test_avi(self, popen):
+        """test mock avi file, should return dict with expected values"""
+        fname = "m.avi"
+        popen.return_value = io.StringIO(DATA[fname])
+        avi = Video(fname)
+        self.assertTrue(len(avi.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(avi.tags['audio_format'], '85')
+        self.assertEqual(avi.tags['width'], 128)
+        self.assertEqual(avi.tags['audio_no_channels'], 2)
+        self.assertEqual(avi.tags['height'], 96)
+        self.assertEqual(avi.tags['video_format'], 'xvid')
+        self.assertEqual(avi.tags['length'], 4)
+        self.assertEqual(avi.tags['audio_codec'], 'mpg123')
+        self.assertEqual(avi.tags['video_codec'], 'ffodivx')
+        self.assertEqual(avi.tags['duration'], '00:00:04')
+        self.assertEqual(avi.tags['container'], 'avi')
+
+    @mock.patch('os.popen')
+    def test_avi2(self, popen):
+        """test another mock avi file, should return dict with expected
+        values"""
+        fname = "m1.avi"
+        popen.return_value = io.StringIO(DATA[fname])
+        avi = Video(fname)
+        self.assertTrue(len(avi.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(avi.tags['audio_format'], '85')
+        self.assertEqual(avi.tags['width'], 128)
+        self.assertEqual(avi.tags['audio_no_channels'], 2)
+        self.assertEqual(avi.tags['height'], 96)
+        self.assertEqual(avi.tags['video_format'], 'h264')
+        self.assertEqual(avi.tags['length'], 4)
+        self.assertEqual(avi.tags['audio_codec'], 'mpg123')
+        self.assertEqual(avi.tags['video_codec'], 'ffh264')
+        self.assertEqual(avi.tags['duration'], '00:00:04')
+        self.assertEqual(avi.tags['container'], 'avi')
+
+    @mock.patch('os.popen')
+    def test_mkv(self, popen):
+        """test mock mkv file, should return dict with expected values"""
+        fname = "m.mkv"
+        popen.return_value = io.StringIO(DATA[fname])
+        mkv = Video(fname)
+        self.assertTrue(len(mkv.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(mkv.tags['audio_format'], '8192')
+        self.assertEqual(mkv.tags['width'], 128)
+        self.assertTrue(mkv.tags['audio_no_channels'] in (1, 2))
+        self.assertEqual(mkv.tags['height'], 96)
+        self.assertEqual(mkv.tags['video_format'], 'mp4v')
+        self.assertEqual(mkv.tags['length'], 4)
+        self.assertTrue(mkv.tags['audio_codec'] in ('a52', 'ffac3'))
+        self.assertEqual(mkv.tags['video_codec'], 'ffodivx')
+        self.assertEqual(mkv.tags['duration'], '00:00:04')
+        self.assertTrue(mkv.tags['container'] in ('mkv', 'lavfpref'))
+
+    @mock.patch('os.popen')
+    def test_mpg(self, popen):
+        """test mock mpg file, should return dict with expected values"""
+        fname = "m.mpg"
+        popen.return_value = io.StringIO(DATA[fname])
+        mpg = Video(fname)
+        self.assertTrue(len(mpg.tags) != 0, "result should have lenght > 0")
+        self.assertFalse('audio_format' in mpg.tags)
+        self.assertEqual(mpg.tags['width'], 128)
+        self.assertFalse('audio_no_channels' in mpg.tags)
+        self.assertEqual(mpg.tags['height'], 96)
+        self.assertEqual(mpg.tags['video_format'], '0x10000001')
+        self.assertFalse('lenght' in mpg.tags)
+        self.assertFalse('audio_codec' in mpg.tags)
+        self.assertEqual(mpg.tags['video_codec'], 'ffmpeg1')
+        self.assertFalse('duration' in mpg.tags)
+        self.assertEqual(mpg.tags['container'], 'mpeges')
+
+    @mock.patch('os.popen')
+    def test_ogm(self, popen):
+        """test mock ogm file, should return dict with expected values"""
+        fname = "m.ogm"
+        popen.return_value = io.StringIO(DATA[fname])
+        ogm = Video(fname)
+        self.assertTrue(len(ogm.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(ogm.tags['audio_format'], '8192')
+        self.assertEqual(ogm.tags['width'], 160)
+        self.assertTrue(ogm.tags['audio_no_channels'] in (1, 2))
+        self.assertEqual(ogm.tags['height'], 120)
+        self.assertEqual(ogm.tags['video_format'], 'h264')
+        self.assertEqual(ogm.tags['length'], 4)
+        self.assertTrue(ogm.tags['audio_codec'] in ('a52', 'ffac3'))
+        self.assertEqual(ogm.tags['video_codec'], 'ffh264')
+        self.assertEqual(ogm.tags['duration'], '00:00:04')
+        self.assertTrue(ogm.tags['container'] in ('ogg', 'lavfpref'))
+
+    @mock.patch('os.popen')
+    def test_wmv(self, popen):
+        """test mock wmv file, should return dict with expected values"""
+        fname = "m.wmv"
+        popen.return_value = io.StringIO(DATA[fname])
+        wmv = Video(fname)
+        self.assertTrue(len(wmv.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(wmv.tags['audio_format'], '353')
+        self.assertEqual(wmv.tags['width'], 852)
+        self.assertEqual(wmv.tags['audio_no_channels'], 2)
+        self.assertEqual(wmv.tags['height'], 480)
+        self.assertEqual(wmv.tags['video_format'], 'wmv3')
+        self.assertEqual(wmv.tags['length'], 4656)
+        self.assertEqual(wmv.tags['audio_codec'], 'ffwmav2')
+        self.assertEqual(wmv.tags['video_codec'], 'ffwmv3')
+        self.assertEqual(wmv.tags['duration'], '01:17:32')
+        self.assertEqual(wmv.tags['container'], 'asf')
+
+    @mock.patch('os.popen')
+    def test_mp4(self, popen):
+        """test mock mp4 file, should return dict with expected values"""
+        fname = "m.mp4"
+        popen.return_value = io.StringIO(DATA[fname])
+        mp4 = Video(fname)
+        self.assertTrue(len(mp4.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(mp4.tags['audio_format'], 'mp4a')
+        self.assertEqual(mp4.tags['width'], 720)
+        self.assertEqual(mp4.tags['audio_no_channels'], 2)
+        self.assertEqual(mp4.tags['height'], 404)
+        self.assertEqual(mp4.tags['video_format'], 'h264')
+        self.assertEqual(mp4.tags['length'], 69)
+        self.assertEqual(mp4.tags['audio_codec'], 'ffaac')
+        self.assertEqual(mp4.tags['video_codec'], 'ffh264')
+        self.assertEqual(mp4.tags['duration'], '00:01:09')
+        self.assertEqual(mp4.tags['container'], 'lavfpref')
+
+    @mock.patch('shutil.move')
+    @mock.patch('pycatalog.video.Image')
+    @mock.patch('os.listdir')
+    @mock.patch('shutil.rmtree')
+    @mock.patch('os.close')
+    @mock.patch('tempfile.mkstemp')
+    @mock.patch('tempfile.mkdtemp')
+    @mock.patch('os.popen')
+    def test_capture(self, popen, mkdtemp, mkstemp, fclose, rmtree, listdir,
+                     img, move):
+        """test capture with some small movie and play a little with tags"""
+        fname = 'm.avi'
+        popen.return_value = io.StringIO(DATA[fname])
+        mkdtemp.return_value = '/tmp'
+        mkstemp.return_value = (10, 'foo.jpg')
+        listdir.return_value = ['a.jpg', 'b.jpg', 'c.jpg', 'd.jpg']
+
+        avi = Video(fname)
+        filename = avi.capture()
+        self.assertIsNotNone(filename)
+
+        for length in (480, 380, 4):
+            avi.tags['length'] = length
+            filename = avi.capture()
+            self.assertTrue(filename is not None)
+
+        avi.tags['length'] = 3
+        self.assertTrue(avi.capture() is None)
+
+        avi.tags['length'] = 4
+
+        avi.tags['width'] = 0
+        self.assertTrue(avi.capture() is None)
+
+        avi.tags['width'] = 1025
+        filename = avi.capture()
+        self.assertTrue(filename is not None)
+
+        del avi.tags['length']
+        self.assertTrue(avi.capture() is None)
+
+        self.assertTrue(len(str(avi)) > 0)
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tox.ini

@@ -0,0 +1,24 @@
+[tox]
+envlist = cleanup,py3,pep8
+
+usedevelop = True
+
+[testenv]
+basepython = python3
+usedevelop=True
+setenv = COVERAGE_FILE = .coverage
+commands = py.test --cov=pycatalog --cov-report=term-missing
+deps = -r{toxinidir}/requirements.txt
+       -r{toxinidir}/test-requirements.txt
+
+[testenv:pep8]
+usedevelop=True
+commands = flake8
+deps = -r{toxinidir}/requirements.txt
+       -r{toxinidir}/test-requirements.txt
+
+[testenv:cleanup]
+setenv =
+COVERAGE_FILE = .coverage
+deps = coverage
+commands = coverage erase