Merge lp:~ahayzen/htd/3.0-directory-restructure into lp:htd/3.0

[Andrew Hayzen]

[Andrew Hayzen (ahayzen)]

review: Approve

=== added file 'COPYING.LESSER.txt'
--- COPYING.LESSER.txt	1970-01-01 00:00:00 +0000
+++ COPYING.LESSER.txt	2012-07-18 20:53:21 +0000
@@ -0,0 +1,165 @@
+GNU LESSER 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.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

=== added file 'COPYING.txt'
--- COPYING.txt	1970-01-01 00:00:00 +0000
+++ COPYING.txt	2012-07-18 20:53:21 +0000
@@ -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>.

=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2012-07-18 20:53:21 +0000
@@ -0,0 +1,1 @@
+include COPYING.txt COPYING.LESSER.txt

=== added file 'README.txt'
--- README.txt	1970-01-01 00:00:00 +0000
+++ README.txt	2012-07-18 20:53:21 +0000
@@ -0,0 +1,49 @@
+OVERVIEW
+
+HTD (HayzenTech Database) is a pure python library which acts as a simple
+database engine, licenced under LGPLv3.
+
+For more information please refer to http://www.hayzentech.co.uk/htd
+
+
+FEATURES
+
+- Intuitive API
+    The API is very easy to understand as has been made consistant through all
+    the functions.
+- Variable-length records
+    When the data is stored in the table it only takes up the space required.
+- Thread safety
+    Multiple threads can use the same module at the same time safely.
+- File locking
+    So multiple processes can use the same table at the same time.
+- Add your own file or data types
+    HTD has the ability for the developer to ‘register’ a file or data type
+    into HTD.
+- No Configuration required
+    If using the core library HTD doesn’t require any configuration, just
+    import and start using HTD. 
+
+
+INSTALLING
+
+1. Open up terminal or command prompt and cd to the directory containing
+   setup.py
+
+2. *NIX users run 'python setup.py install', where python is you target python
+   interpreter. This command may need admin rights to run, for example in
+   Ubuntu run 'sudo python setup.py install'.
+   
+   Windows users run 'c:\python\python.exe setup.py install', where
+   'c:\python\python.exe' is you target python interpreter.
+   
+3. Open you interpreter and the following code should run successfully.
+   >>> import htdXY
+   Where XY is the version of your HTD engine, for example version 3.0 is 30
+   
+
+DOCUMENTATION
+
+Documentation is avaliable at http://www.hayzentech.co.uk/htd/documentation.php
+Refer to the package 'htd-core' and the series which you have downloaded.
+

=== added directory 'htd30'
=== added file 'htd30/__init__.py'
--- htd30/__init__.py	1970-01-01 00:00:00 +0000
+++ htd30/__init__.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,266 @@
+#!/usr/bin/env python
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+This document conforms to the PEP 8 Style Guide
+
+Version 3.00 PRE-ALPHA-3
+'''
+
+# Import built-in modules
+from os import path as _path
+
+
+#--------------------------------------------------------------------- Settings
+__build_id__ = 300039
+__version__ = 3.00
+
+
+class _Config():
+    debug = True
+    errors = True
+    force_sync = False
+    tracing = False
+
+Config = _Config()
+
+
+#------------------------------------------------------------------- Exceptions
+class AuthenticationError(Exception):
+    pass
+
+
+class ConnectionError(Exception):
+    pass
+
+
+class VersionError(Exception):
+    pass
+
+
+#-------------------------------- Create containers for datatypes and filetypes
+class _RegisterContainer():
+    pass
+
+DataTypes = _RegisterContainer()
+FileTypes = _RegisterContainer()
+
+
+#--------------------------------------------------------------- Register Class
+class _Register(object):
+    def __init__(self):
+        self.dtype_codes = {}
+        self.dtypes = {}
+        self._default_dtype = None
+
+        self.fhandlers = {}
+        self._default_fhandler = None
+
+    @property
+    def default_dtype(self):
+        return self._default_dtype
+
+    @default_dtype.setter
+    def default_dtype(self, dtype):
+        if dtype.__name__ not in self.dtypes:
+            raise ValueError("Default dtype must be a registered dtype.")
+
+        self._default_dtype = dtype.__name__
+
+    @property
+    def default_fhandler(self):
+        return self._default_fhandler
+
+    @default_fhandler.setter
+    def default_fhandler(self, fhandler):
+        if fhandler not in self.fhandlers:
+            raise ValueError("Default fhandler must be a registered fhandler.")
+
+        self._default_fhandler = fhandler
+
+    def register_dtype(self, dtype):
+        setattr(DataTypes, dtype.__name__, dtype())
+
+        self.dtype_codes[dtype.c] = dtype.__name__
+        self.dtypes[dtype.__name__] = dtype.c
+
+        return True
+
+    def register_fhandler(self, fhandler, is_location, is_file=None):
+        setattr(FileTypes, fhandler.__name__, fhandler)
+
+        self.fhandlers[fhandler] = {"is_loc": is_location, "is_file": is_file}
+
+        return True
+
+    def resolve_fhandler(self, location):
+        """ File Handler resolver - determins file type """
+
+        # Filter fhandlers by location
+        fhandlers = [f for f in self.fhandlers if
+                     self.fhandlers[f]["is_loc"](location)]
+
+        # Filter fhandlers by file
+        output = []
+
+        for f in fhandlers:
+            # if file_format exists then uses File and Header standard
+            if f.file_format is not None:
+                if not _path.exists(location):
+                    raise ConnectionError("No HTD file found (%s)" % location)
+
+                # Open file and get fhandler code
+                tmp = open(location, "rb")
+                tmp.seek(8)
+                if tmp.read(1) == f.file_format:
+                    output.append(f)
+                tmp.close()
+
+            elif self.fhandlers[f]["is_file"] is not None:
+                if self.fhandlers[f]["is_file"](location):
+                    output.append(f)
+
+        fhandlers = output
+
+        # Load fhandler
+        if len(fhandlers) == 0:
+            raise ConnectionError("Unknown File Format")
+        elif len(fhandlers) > 1:
+            raise ConnectionError("Could not determine File Format either (%s)"
+                                  % fhandlers)
+        else:
+            return fhandlers[0]
+
+Register = _Register()
+
+#---------------------------------------------------------------------- Imports
+
+# Load base objects
+from ._base import Progress
+
+from . import _base
+from . import _workers
+
+# Load HTD Objects
+from ._objects import Attribute, User, Connection as connect
+
+
+#------------------------------------------------------ Top level HTD functions
+@_base._trace()
+def create(name, location, user=None, identifier=None, htd_file=None,
+           login_user=None):
+    """
+    Create a new HTD File
+    To create a table parse the identifier for the table otherwise leave
+    the identifier blank to create a db
+    """
+
+    atts = {}
+
+    # Check for identifier
+    if identifier is not None:
+        # Convert single into a list
+        if not isinstance(identifier, list):
+            identifier = [identifier]
+
+        # Create ids
+        for k, i in enumerate(identifier):
+            atts[i.name] = i
+            atts[i.name]._id = k
+
+        # Loop through identifier(s)
+        for i in identifier:
+            # Error if not an Attribute object
+            if not isinstance(i, Attribute):
+                raise ValueError("Identifier(s) must be an Attribute object.")
+
+        table = None  # Set TABLE mode
+    else:
+        # Create db attributes
+        name_att = Attribute(DataTypes.STRING, name="name")
+        name_att._id = 0
+        loc_att = Attribute(DataTypes.STRING)
+        loc_att._id = 1
+
+        # Load attribute and identifier
+        atts = {"name": name_att, "location": loc_att}
+        identifier = [name_att]
+        table = False  # Set DB mode master file
+
+    # Check for user
+    if user is not None and user != []:
+        # Convert single into a list
+        if not isinstance(user, list):
+            user = [user]
+
+        # Store users for resorting
+        tmp = user[:]
+        user = {}
+
+        # Check 1 user has full access
+        acc = False
+
+        # Loop through user(s)
+        for i in tmp:
+            # Error if not a User Object
+            if not isinstance(i, User):
+                raise ValueError("User(s) must be an User object.")
+
+            user[i.username] = i
+
+            # Check for full access
+            if i.access == "roadx":
+                acc = True
+
+        # raise error if no access
+        if not acc:
+            raise ValueError("One User must have full access (roadx)")
+
+        # Check login user
+        if login_user is None:
+            # Check for multi users
+            if len(user) > 1:
+                raise ValueError("A login_user must be specified")
+            else:
+                # select only user
+                login_user = [user[i] for i in user][0]
+        else:
+            # Check login user is in users
+            if login_user not in user:
+                raise ValueError("login_user must be in users")
+            else:
+                login_user = user[login_user]
+    else:
+        # Load guest account
+        user = {"guest": User("guest", None)}
+        login_user = User("guest", None)
+
+    if htd_file is None:
+        htd_file = Register.default_fhandler
+
+    # Build Header
+    header = {"TAB": table, "ATT": atts, "USR": user, "KEY": identifier,
+              "VER": __version__}
+
+    # Load and set header
+    f = htd_file(_path.sep.join([location, name]), header)
+
+    # Return con obj
+    return connect(_path.sep.join([location, name]), login_user, file_obj=f)
+
+_base._t.names.extend(dir())  # Load methods/class etc into tracing

=== added directory 'htd30/_base'
=== added file 'htd30/_base/__init__.py'
--- htd30/_base/__init__.py	1970-01-01 00:00:00 +0000
+++ htd30/_base/__init__.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,64 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+'''
+
+from .file import File
+from .trace import Progress, ProgressItem, _t, _trace, _access_check
+from . import types
+
+from os import path
+import threading
+
+
+def convert_location(location, add):
+    folder = location.split(path.sep)
+    name = "".join([add, folder[-1]])  # create new filename
+
+    folder.pop()  # remove name
+    folder.append(name)
+
+    return path.sep.join(folder)
+
+
+def location_is_file(location):
+    if not path.isabs(location):
+        return False
+
+    directory, name = path.split(location)
+
+    if not path.isdir(directory):
+        return False
+
+    return True
+
+
+class ThreadLock(object):
+    def __init__(self):
+        self._threading_lock = threading.Lock()
+
+    def _acquire(self):
+        """ Acquire threading lock """
+        return self._threading_lock.acquire()
+
+    def _release(self):
+        """ Release threading lock """
+        return self._threading_lock.release()
+
+    @property
+    def _t_locked(self):
+        return self._threading_lock.locked()

=== added file 'htd30/_base/file.py'
--- htd30/_base/file.py	1970-01-01 00:00:00 +0000
+++ htd30/_base/file.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,177 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+Base File for HTD
+Provides slicing and file locking support for files
+'''
+
+import os
+
+if os.name == "posix":
+    import fcntl
+elif os.name == "nt":
+    import win32con
+    import win32file
+    import pywintypes
+    __overlapped = pywintypes.OVERLAPPED()
+else:
+    print("HTD Warning: Unknown operating system, FileLock unavailable.")
+
+
+class File(object):
+    """ HTD File that provides slicing and file locking """
+    def __init__(self, location):
+        self.__file = open(location, "rb+")
+        self.__lkcur = False
+
+        # Add file methods to self
+        for i in [i for i in dir(self.__file) if '_' not in i and
+                  i != "close"]:
+            setattr(self, i, getattr(self.__file, i))
+
+    def __delitem__(self, key):
+        # Delete Slice (MUST be a slice)
+        self.seek(key.stop)
+        text = self.read()
+        self.seek(key.start)
+        self.write(text)
+        self.truncate()
+        self.flush()
+
+    def __getitem__(self, key):
+        # Return slice (MUST be a slice)
+        self.seek(key.start, 0)
+        return self.read((key.stop - key.start))
+
+    def __len__(self):
+        self.seek(0, 2)
+        return self.tell()
+
+    def __setitem__(self, key, value):
+        # Slice (MUST be a slice)
+        i = key.start
+        e = key.stop
+        diff = e - i
+        if (diff != len(value)):
+            self.seek(e)
+            text = self.read()
+            self.seek(i)
+            self.write(value)
+            self.write(text)
+            self.truncate()
+        else:
+            self.seek(i)
+            self.write(value)
+        self.flush()
+
+    if os.name == "posix":
+        def _lock_reading(self):
+            """ Lock file for reading """
+
+            fcntl.flock(self.__file, fcntl.LOCK_SH | fcntl.LOCK_NB)
+            self.__lkcur = None
+
+            return True
+
+    elif os.name == "nt":
+        def _lock_reading(self):
+            """ Lock file for reading """
+
+            self._unlock()  # NT requires unlock first
+            f = win32file._get_osfhandle(self.fileno())
+            try:
+                win32file.LockFileEx(f, 0 | win32con.LOCKFILE_FAIL_IMMEDIATELY,
+                                      0, -0x10000, pywintypes.OVERLAPPED())
+            except pywintypes.error as exc_value:
+                if exc_value[0] == 33:  # File locked exception
+                    raise IOError("File is locked")
+                else:
+                    raise IOError("Unknown Error")
+
+            self.__lkcur = None
+
+            return True
+
+    if os.name == "posix":
+        def _lock_writing(self):
+            """ Lock file for writing """
+
+            fcntl.flock(self.__file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            self.__lkcur = True
+
+            return True
+
+    elif os.name == "nt":
+        def _lock_writing(self):
+            """ Lock file for writing """
+
+            self._unlock()  # NT requires unlock first
+            f = win32file._get_osfhandle(self.fileno())
+            try:
+                win32file.LockFileEx(f, win32con.LOCKFILE_EXCLUSIVE_LOCK |
+                                     win32con.LOCKFILE_FAIL_IMMEDIATELY, 0,
+                                     - 0x10000, pywintypes.OVERLAPPED())
+            except pywintypes.error as exc_value:
+                if exc_value[0] == 33:  # File locked exception
+                    raise IOError("File is locked")
+                else:
+                    raise IOError("Unknown Error")
+
+            self.__lkcur = True
+
+            return True
+
+    if os.name == "posix":
+        def _unlock(self):
+            """ Unlock file """
+
+            fcntl.flock(self.__file, fcntl.LOCK_UN)
+            self.__lkcur = False
+
+            return True
+
+    elif os.name == "nt":
+        def _unlock(self):
+            """ Unlock file """
+
+            f = win32file._get_osfhandle(self.fileno())
+            try:
+                win32file.UnlockFileEx(f, 0, -0x10000, pywintypes.OVERLAPPED())
+            except pywintypes.error as exc_value:
+                if exc_value[0] == 158:  # Don't raise already locked
+                    pass
+                else:
+                    raise
+
+            self.__lkcur = False
+
+            return True
+
+    def close(self):
+        self.flush()
+        try:
+            self._unlock()
+        except IOError:
+            pass
+        self.__file.close()
+
+        return True
+
+    @property
+    def lock_type(self):
+        return self.__lkcur

=== added file 'htd30/_base/trace.py'
--- htd30/_base/trace.py	1970-01-01 00:00:00 +0000
+++ htd30/_base/trace.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,213 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+Tracing for HTD
+Captures progress, logging, triggers, errors and permission levels
+'''
+
+from functools import wraps
+from .. import AuthenticationError, Config
+from copy import copy
+from threading import current_thread
+
+
+#-------------------------------------------------------------- Progress object
+class ProgressItem():
+    def __init__(self, thread, length, func):
+        self.thread = thread
+        self.length = length
+        self.func = func
+        self.counter = 0
+
+    def count(self, n=1):
+        self.counter += n
+        return True
+
+
+class Manage():
+    def __init__(self):
+        self.tasks = []
+        self.threads = {}
+
+    def add(self, progress):
+        if not isinstance(progress, ProgressItem):
+            raise ValueError("Must be a ProgressItem instance")
+
+        self.tasks.append(progress)
+
+        if progress.thread not in self.threads:
+            self.threads[progress.thread] = []
+
+        self.threads[progress.thread].append(progress)
+
+        return True
+
+    def progress(self):
+        """ Return all running tasks """
+        return [{"length":job.length, "count":job.counter, "name":job.func,
+                "fraction":job.counter / job.length, "thread":job.thread}
+                for job in copy(self.tasks)]
+
+    def remove(self, progress):
+        if not isinstance(progress, ProgressItem):
+            raise ValueError("Must be a ProgressItem instance")
+
+        try:
+            self.tasks.remove(progress)
+            self.threads[progress.thread].remove(progress)
+        except (ValueError, KeyError):
+            pass
+
+        return True
+
+    def thread_progress(self, thread):
+        """ Return the running tasks for a specific thread """
+        if thread not in self.threads:
+            raise KeyError("Thread does not exist")
+
+        return [{"length":job.length, "count":job.counter, "name":job.func,
+                "fraction":job.counter / job.length} for job in
+               copy(self.threads[thread])]
+
+Progress = Manage()
+
+
+class Tracing():
+    """
+    Tracing class that manages tracing of function calls
+    | Permission | Progress | Logging | Triggers |
+    """
+    def __init__(self):
+        self._perms = {"r": "read", "o": "overwrite", "a": "append",
+                            "d": "delete", "x": "admin"}
+
+        self.names = ["Attributes", "Auth", "Connection", "Cursor"]
+
+    def access_check(self, level, module):
+        """ Run access test """
+
+        if level == "" or not hasattr(module, "_access"):
+            return True
+
+        perm = [i for i in level if i not in module._access]
+
+        if len(perm) == 0:
+            return True
+
+        err = ", ".join(['(%s - %s)' % (i, self._perms[i]) for i in perm])
+
+        err = 'User doesn\'t have to permission [%s]' % err
+
+        raise AuthenticationError(AuthenticationError, err)  # Raise exception
+
+        return False
+
+    def trace(self, level=""):
+        """ Trace function """
+
+        def wrapper(func):
+            """ Wrapper function """
+
+            @wraps(func)
+            def callf(*args, **kwargs):
+                if len(args) > 0:
+                    tmp = args[0]
+                else:
+                    tmp = None
+
+                # Check that object isn't closed
+                if hasattr(tmp, "alive") and not tmp.alive:
+                    return None
+
+                # Acquire lock
+                locked = False
+                if hasattr(tmp, "_t_locked") and not tmp._t_locked:
+                    tmp._acquire()
+                    locked = True
+
+                # Trace before
+                func_name = func.__name__
+
+                if len(args) > 0 and type(args[0]).__name__ in self.names:
+                    func_name = ".".join([args[0].__class__.__name__,
+                                          func_name])
+
+                func_name = ".".join(["htd30", func_name])
+                calling = "Calling %s" % (func_name)
+
+                if Config.tracing:
+                    # Build parameters
+                    tmp = [str(i) for i in args]
+                    tmp.extend(["%s=%s" % (i, str(kwargs[i])) for i in kwargs])
+                    param = ", ".join(tmp)
+
+                    print("HTD TRACE: %s(%s)" % (calling, param))
+
+                # Add to progress
+                prog = ProgressItem(current_thread(), 1, calling)
+
+                Progress.add(prog)
+
+                try:
+                    self.access_check(level, tmp)  # Run access check
+                    result = func(*args, **kwargs)  # Call the function
+                except Exception as e:  # Catch errors
+                    result = False
+
+                    # run unlocked
+                    if hasattr(tmp, "_file"):
+                        if (hasattr(args[0]._file, "_t_locked") and
+                            tmp._file._t_locked):
+                            tmp._file.unlock()
+
+                    if hasattr(tmp, "_t_locked") and tmp._t_locked:
+                        tmp._release()
+
+                    txt = "%s, %s (%s)" % (type(e).__name__, e, calling)
+
+                    if Config.tracing:
+                        print("HTD TRACE: %s" % txt)
+
+                    if Config.debug:
+                        print("HTD DEBUG: %s" % txt)
+
+                    if Config.errors:
+                        raise
+                finally:
+                    prog.count()
+
+                    if Config.tracing:
+                        print("HTD TRACE: %s returned %s" % (func_name,
+                                                             result))
+
+                    Progress.remove(prog)
+
+                # Release lock
+                if hasattr(tmp, "_t_locked") and tmp._t_locked and locked:
+                    tmp._release()
+
+                return result
+
+            return callf
+
+        return wrapper
+
+# Start tracing
+_t = Tracing()
+_trace = _t.trace
+_access_check = _t.access_check

=== added file 'htd30/_base/types.py'
--- htd30/_base/types.py	1970-01-01 00:00:00 +0000
+++ htd30/_base/types.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,273 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Data Types
+Data types and (un)sanisite functions are managed here
+'''
+
+from datetime import date, datetime, time, timedelta
+from .. import __version__, DataTypes, Register
+import sys
+
+
+#-------------------------------------------------------------------- HTD Types
+# C = identifier F = Type check, R = range, S = sanitise, U = unsanitise
+class Dtype(object):
+    def __repr__(self):
+        return ("<HTD%s Data Type (%s)>" %
+                (__version__, self.__class__.__name__))
+
+reg_dtype = Register.register_dtype  # Register dtypes
+
+
+class BOOL(Dtype):
+    c = "\x01"
+
+    def f(self, d):
+        return type(d) is bool
+    r = False
+
+    def s(self, d):
+        if d:
+            return b"1"
+        else:
+            return b"0"
+
+    def u(self, d):
+        if d == b"1":
+            return True
+        else:
+            return False
+
+reg_dtype(BOOL)
+
+
+class BYTES(Dtype):
+    c = "\x02"
+
+    def f(self, d):
+        return type(d) is bytes
+    r = False
+    s = bytes
+    u = bytes
+
+reg_dtype(BYTES)
+
+
+class INTEGER(Dtype):
+    c = "\x04"
+
+    def f(self, d):
+        return type(d) is int
+    r = True
+
+    def s(self, d):
+        return str(d).encode("ISO-8859-1")
+    u = int
+
+reg_dtype(INTEGER)
+
+if sys.version_info < (3, 0):
+    class LONG(Dtype):
+        c = "\x05"
+
+        def f(self, d):
+            return type(d) is long
+        r = True
+
+        def s(self, d):
+            return str(d).encode("ISO-8859-1")
+        u = long
+
+    reg_dtype(LONG)
+
+
+class FLOAT(Dtype):
+    c = "\x08"
+
+    def f(self, d):
+        return type(d) is float
+    r = True
+
+    def s(self, d):
+        return str(d).encode("ISO-8859-1")
+    u = float
+
+reg_dtype(FLOAT)
+
+if sys.version_info < (3, 0):
+    class STRING(Dtype):
+        c = "\x11"
+
+        def f(self, d):
+            return type(d) is str
+        r = False
+        s = str
+        u = str
+
+    reg_dtype(STRING)
+
+    class UTF8(Dtype):
+        c = "\x14"
+
+        def f(self, d):
+            return type(d) is unicode
+        r = False
+
+        def s(self, raw):
+            return raw.encode("utf8")
+
+        def u(self, rawstr):
+            return rawstr.decode("utf8")
+
+    reg_dtype(UTF8)
+
+    class UTF16(Dtype):
+        c = "\x15"
+
+        def f(self, d):
+            return type(d) is unicode
+        r = False
+
+        def s(self, raw):
+            return raw.encode("utf16")
+
+        def u(self, rawstr):
+            return rawstr.decode("utf16")
+
+    reg_dtype(UTF16)
+
+    class UTF32(Dtype):
+        c = "\x16"
+
+        def f(self, d):
+            return type(d) is unicode
+        r = False
+
+        def s(self, raw):
+            return raw.encode("utf32")
+
+        def u(self, rawstr):
+            return rawstr.decode("utf32")
+
+    reg_dtype(UTF32)
+else:
+    class STRING(Dtype):
+        c = "\x12"
+
+        def f(self, d):
+            return type(d) is str
+        r = False
+
+        def s(self, raw):
+            return raw.encode("ISO-8859-1")
+
+        def u(self, rawstr):
+            return rawstr.decode("ISO-8859-1")
+
+    reg_dtype(STRING)
+
+
+class DATE(Dtype):
+    c = "\x21"
+
+    def f(self, d):
+        return type(d) is date
+    r = False
+
+    def s(self, raw):
+        return raw.isoformat().encode("ISO-8859-1")
+
+    def u(self, rawstr):
+        data = rawstr.decode("ISO-8859-1").split("-")
+        return date(int(data[0]), int(data[1]), int(data[2]))
+
+reg_dtype(DATE)
+
+
+class TIME(Dtype):
+    c = "\x24"
+
+    def f(self, d):
+        return type(d) is time
+    r = False
+
+    def s(self, raw):
+        return raw.isoformat().encode("ISO-8859-1")
+
+    def u(self, rawstr):
+        data = rawstr.decode("ISO-8859-1").split(":")
+        data[2] = data[2].split(".")
+        data[2].append(0)
+        return time(int(data[0]), int(data[1]), int(data[2][0]),
+                    int(data[2][1]))
+
+reg_dtype(TIME)
+
+
+class DATETIME(Dtype):
+    c = "\x28"
+
+    def f(self, d):
+        return type(d) is datetime
+    r = False
+
+    def s(self, raw):
+        return raw.isoformat().encode("ISO-8859-1")
+
+    def u(self, rawstr):
+        data = rawstr.decode("ISO-8859-1").split(".")
+        dt = datetime.strptime(data[0], "%Y-%m-%dT%H:%M:%S")
+        if len(data) > 1:
+            us = int(data[1].rstrip("Z"), 10)
+        else:
+            us = 0
+        return dt + timedelta(microseconds=us)
+
+reg_dtype(DATETIME)
+
+
+class PRESERVE(Dtype):
+    c = "\x31"
+
+    def f(self, *args):
+        return True
+
+    r = False
+
+    def s(self, raw):
+        for ty in Register.dtype_codes:
+            x = getattr(DataTypes, Register.dtype_codes[ty])
+            if x.f(raw) and isinstance(x, PRESERVE) is False:
+                return b"".join([x.s(raw), ty.encode("ISO-8859-1")])
+
+        raise ValueError("Unknown type to preserve (%s)" % type(raw))
+
+    def u(self, rawstr):
+        ty = rawstr.decode("ISO-8859-1")[-1]
+        rawstr = rawstr[:-1]
+
+        if ty in Register.dtype_codes:
+            x = getattr(DataTypes, Register.dtype_codes[ty])
+        else:
+            raise TypeError("Could not restore type.")
+
+        return x.u(rawstr)
+
+reg_dtype(PRESERVE)
+Register.default_dtype = PRESERVE

=== added directory 'htd30/_objects'
=== added file 'htd30/_objects/__init__.py'
--- htd30/_objects/__init__.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/__init__.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,26 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+'''
+
+from .attribute import Attribute
+from .attributes import Attributes
+from .auth import Auth
+from .connection import Connection
+from .cursor import Cursor
+from .record import Record
+from .user import User

=== added file 'htd30/_objects/attribute.py'
--- htd30/_objects/attribute.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/attribute.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,179 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Attribute
+'''
+
+from .. import __version__, Register, DataTypes
+from .._workers import sanitise, unsanitise
+from struct import pack
+from sys import version_info
+
+
+class Attribute(object):
+    """ Class that manages a specific attribute """
+    def __init__(self, dtype=None, size=None, name=None):
+        # Save variables
+        self.dtype = dtype
+        self.name = name
+        self.size = size
+
+        # Set extra options
+        self.range = False
+        self.reg_expr = None
+        self.limit_list = [False, []]
+        self.required = False
+        self._id = None
+        self._default = None
+
+    def __repr__(self):
+        return ("<HTD%s Attribute (<name '%s'> <type '%s'> <len %s>)>" %
+                (__version__, self.name, self.dtype.__class__.__name__,
+                 self.size))
+
+    @property
+    def default(self):
+        return unsanitise({"val": self._default}, {"val": self})["val"]
+
+    @default.setter
+    def default(self, value):
+        value = sanitise({"val": value}, {"val": self})
+        if not value:
+            self._default = None
+        else:
+            self._default = value["val"]
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @dtype.setter
+    def dtype(self, dtype):
+        # Check type
+        if dtype is None:
+            dtype = Register.default_dtype
+        else:
+            dtype = dtype.__class__.__name__
+
+        try:
+            dtype = getattr(DataTypes, dtype)
+        except AttributeError:
+            raise ValueError("Attribute type must be a valid HTD data type")
+
+        self._dtype = dtype
+
+    @property
+    def limit_list(self):
+        return self._limit_list
+
+    @limit_list.setter
+    def limit_list(self, limits):
+        if limits is False or limits == [False, []]:
+            self._limit_list = [False, []]
+        elif isinstance(limits, (list, tuple)) is False:
+            raise ValueError("Limits must be list type")
+        else:
+            self._limit_list = [True, limits]
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        # Check name
+        if name is None:
+            self._name = None
+            return
+
+        if "." in name:
+            raise ValueError("Attribute name must not contain '.'")
+
+        if isinstance(name, str) is False:
+            raise ValueError("Attribute name must be str type.")
+
+        self._name = name
+
+    @property
+    def range(self):
+        return self._range
+
+    @range.setter
+    def range(self, ran):
+        if ran is False or ran == [False, False]:
+            self._range = ran
+            return
+
+        if isinstance(ran, (list, tuple)) is False:
+            raise ValueError("Range must be list type")
+
+        lower, upper = ran
+
+        if lower >= upper:
+            raise ValueError("The lower value must be less than the upper.")
+
+        self._range = [lower, upper]
+
+    @property
+    def reg_expr(self):
+        return self._re
+
+    @reg_expr.setter
+    def reg_expr(self, expr):
+        if type(expr) is not bytes and not not expr:
+            expr = str(expr).encode("ISO-8859-1")
+        self._re = expr
+
+    @property
+    def required(self):
+        return self._required
+
+    @required.setter
+    def required(self, required):
+        if required in [True, False]:
+            self._required = required
+        else:
+            raise ValueError("Required must be either True or False")
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, size):
+        # Check size
+        if size is None:
+            self._size = 255
+            return
+
+        if isinstance(size, int) is False:
+            raise ValueError("Attribute size must be an Integer")
+        else:
+            if not 1 <= size <= 4294967295:
+                raise ValueError("Attribute size must be greater than or " \
+                                 "equal to 1")
+
+        self._size = size
+
+    def to_dict(self):
+        """ Convert to string """
+
+        return {"dtype": self.dtype.c, "id": self._id,
+                "limit_list": self.limit_list, "default": self._default,
+                "range": self.range, "reg_expr": self.reg_expr,
+                "required": self.required, "size": pack("I", self.size)}

=== added file 'htd30/_objects/attributes.py'
--- htd30/_objects/attributes.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/attributes.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,212 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Attributes
+'''
+
+from .. import __version__
+from .._base import _access_check, _trace, ThreadLock
+from .._objects.attribute import Attribute
+from .._workers import sanitise, unsanitise
+from weakref import ref
+
+
+class Attributes(ThreadLock):
+    """ Class that manages attribute settings in a table """
+    def __init__(self, parent):
+        # Set vars
+        self.alive = True
+        self._parent = ref(parent)
+        self._parent()._children.append(self)
+        self._file = self._parent()._file
+
+        self._access = self._parent()._access  # Load user access
+
+        self._index = 0  # var for loop
+
+        ThreadLock.__init__(self)
+
+    @_trace("r")
+    def __contains__(self, key):
+        """ Return True if attribute exists in db """
+
+        self._file.lock_reading()
+
+        out = False
+        if key in self._file.header["ATT"]:
+            out = True
+
+        self._file.unlock()
+
+        return out
+
+    @_trace("d")
+    def __delitem__(self, key):
+        """ Delete attribute and data from db """
+
+        self._file.lock_writing()
+
+        # Confirm att exists
+        if key not in self._file.header["ATT"]:
+            raise KeyError('Could not find attribute to delete. (%s)' % key)
+
+        if key in self._file.header["KEY"]:
+            raise ValueError('Cannot remove attribute that is an identifier')
+
+        self._file.delete_attribute(key)
+
+        # Delete attribute, rebuild header
+        header = self._file.header
+
+        i = header["ATT"][key]._id
+
+        del header["ATT"][key]
+
+        # resort IDs
+        for a in header["ATT"]:
+            att = header["ATT"][a]
+            if att._id > i:
+                att._id -= 1
+
+        self._file.header_update(header)
+
+        self._file.unlock()
+
+    @_trace("r")
+    def __getitem__(self, key):
+        """ Return attributes settings """
+
+        self._file.lock_reading()
+
+        attributes = self._file.header["ATT"]
+
+        if key not in attributes:
+            raise KeyError('Failed to find sanitise settings for attribute ' \
+                           '(%s)' % (key))
+
+        self._file.unlock()
+
+        return attributes[key]
+
+    def __iter__(self):
+        self._index = 0
+
+        return self
+
+    @_trace("r")
+    def __len__(self):
+        """ The number of attributes in the table """
+
+        self._file.lock_reading()
+
+        leng = len(self._file.header["ATT"])
+
+        self._file.unlock()
+
+        return leng
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        tmp = None
+
+        self._file.lock_reading()
+        try:
+            tmp = self._file.header["ATTBYID"][self._index][1]
+        except KeyError:
+            raise StopIteration
+        else:
+            out = self._file.header["ATT"][tmp]
+            self._index += 1
+
+            return out
+        finally:
+            self._file.unlock()
+
+    def __repr__(self):
+        return "<HTD%s Attributes (%s)>" % (__version__,
+                                            self._parent()._location)
+
+    @_trace()
+    def __setitem__(self, key, v):
+        if isinstance(v, Attribute) is False:
+            raise ValueError("Attribute must be a Attribute instance.")
+
+        self._file.lock_writing()
+
+        header = self._file.header
+        v.name = key
+
+        if v.required and v.default is None and self._file.get_length() > 0:
+            raise ValueError("Table must be empty to set an attribute if it " \
+                             "is required or have a default value (%s)" % key)
+
+        new = False
+        if key in header["ATT"]:
+            _access_check("o", self)
+            v._id = header["ATT"][key]._id
+            old = header["ATT"][key]
+
+            # Confirm old data
+            for i in self._file.select(key):
+                sanitise(unsanitise(i, {key: v}), {key: v})
+        else:
+            _access_check("a", self)
+            v._id = len(header["ATT"])
+            new = True
+
+        header["ATT"][key] = v
+
+        self._file.header_update(header)
+
+        if new:
+            self._file.add_attribute(key)
+        else:
+            # Iter through elements
+            gen = self._file.modify_attribute(key, old, v)
+
+            run = True
+
+            try:
+                nxt = next(gen)
+            except StopIteration:
+                run = False
+
+            while run:
+                try:
+                    nxt = gen.send(sanitise(unsanitise(nxt, {key: v}), {key:
+                                   v}))
+                except StopIteration:
+                    break
+
+            gen.close()
+
+        self._file.unlock()
+
+    @_trace()
+    def close(self):
+        self.alive = False
+
+        self._file = None
+
+        # Remove from parent
+        if self._parent() is not None and self in self._parent()._children:
+            self._parent()._children.remove(self)
+
+        return True

=== added file 'htd30/_objects/auth.py'
--- htd30/_objects/auth.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/auth.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,201 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+'''
+
+from .. import Register
+from .._base import _access_check, _trace, ThreadLock
+from .._objects.user import User
+from weakref import ref
+
+
+class Auth(ThreadLock):
+    """ Authentication object manages users and access for a table """
+    def __init__(self, parent, location, file_obj=None):
+        # Store variables
+        self.alive = True
+        self._parent = ref(parent)
+        self._parent()._children.append(self)
+        self._location = location
+
+        self._access = parent._access  # Load access
+
+        self._tlist = []
+        self._index = 0
+
+        ThreadLock.__init__(self)  # Start inherit
+
+        if file_obj is None:
+            htdfile = Register.resolve_fhandler(self.location)
+            self._file = htdfile(location)  # Open file
+            self._opened = True
+        else:
+            self._file = file_obj
+            self._opened = False
+
+    @_trace("rx")
+    def __contains__(self, key):
+        self._file.lock_reading()
+
+        out = key in self._file.header["USR"]
+
+        self._file.unlock()
+
+        return out
+
+    @_trace("dx")
+    def __delitem__(self, key):
+        self._file.lock_writing()
+
+        if key not in self._file.header["USR"]:
+            raise KeyError('No User, "%s", found to delete' % key)
+
+        if len(self._file.header["USR"]) == 1:
+            raise ValueError("Must be at least 2 users to delete a user")
+
+        if self._parent().user.username == key:
+            raise ValueError("Cannot delete your own user.")
+
+        users = self._file.header["USR"]
+        del users[key]
+
+        x = sum([1 for i in users if i.access == "roadx"])
+        if x < 1:
+            raise ValueError("At least 1 remaining user must have full access")
+
+        # Update header
+        header = self._file.header
+        header["USR"] = users
+        self._file.header_update(header)
+
+        self._file.unlock()
+
+    @_trace("rx")
+    def __getitem__(self, key):
+        self._file.lock_reading()
+
+        try:
+            out = self._file.header["USR"][key]
+        except KeyError:
+            out = False
+            raise KeyError('No User, "%s", found' % key)
+
+        self._file.unlock()
+
+        return out
+
+    @_trace("r")
+    def __iter__(self):
+        self._file.lock_reading()
+
+        self._tlist = [u for u in self._file.header["USR"]]
+        self._index = 0
+
+        self._file.unlock()
+
+        return self
+
+    @_trace("r")
+    def __len__(self):
+        self._file.lock_reading()
+
+        out = len(self._file.header["USR"])
+
+        self._file.unlock()
+
+        return out
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        try:
+            u = self._tlist[self._index]
+        except IndexError:
+            self._tlist = []
+            self._index = 0
+            raise StopIteration
+        else:
+            self._index += 1
+
+            self._file.lock_reading()
+
+            out = self._file.header["USR"][u]
+
+            self._file.unlock()
+
+            return out
+
+    def __repr__(self):
+        if self.alive is False:
+            return "<HTD%s Closed Auth>" % self.version
+
+        return "<HTD%s Auth (%s)>" % (self.version, self.location)
+
+    @_trace("x")
+    def __setitem__(self, key, v):
+        if isinstance(v, User) is False:
+            raise ValueError("User must be an User instance.")
+
+        self._file.lock_writing()
+
+        v.username = key
+
+        if key in self._file.header["USR"]:
+            _access_check("o", self)
+
+            if len(self._file.header["USR"]) == 1 and v.access != "roadx":
+                raise ValueError("At least one User must have full access")
+        else:
+            _access_check("a", self)
+
+        header = self._file.header
+        header["USR"][key] = v
+
+        self._file.header_update(header)
+
+        self._file.unlock()
+
+    @_trace()
+    def close(self):
+        """ Close the cursor """
+        self.alive = False  # Set closed
+
+        if self._opened:  # Close file if I opened it
+            self._file.close()
+
+        # Remove from parent
+        if self._parent() is not None and self in self._parent()._children:
+            self._parent()._children.remove(self)
+
+        return True
+
+    @property
+    def location(self):
+        """ The location of the table """
+        return "%s.htd" % self._location
+
+    @property
+    def version(self):
+        """ Version of the open table """
+        self._file.lock_reading()
+
+        out = self._file.header["VER"]
+
+        self._file.unlock()
+
+        return out

=== added file 'htd30/_objects/connection.py'
--- htd30/_objects/connection.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/connection.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,287 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Connection
+'''
+
+from .._objects.auth import Auth
+from .._objects.cursor import Cursor
+from .._objects.user import User
+from .._base import _trace, ThreadLock
+from .. import __version__, ConnectionError, AuthenticationError, Register
+from copy import copy
+
+
+@_trace()
+class Connection(ThreadLock):
+    """ Class that provides a connection to a table or db """
+    def __init__(self, location, user=None, file_obj=None):
+        ThreadLock.__init__(self)  # Load subclasses
+
+        # Set vars
+        self.alive = True
+        self._children = []
+        self._location = location
+
+        # Load user
+        if user is None:
+            user = User("guest", None)
+        self.user = user
+
+        # Generator for __iter__
+        self._gen = None
+        self._gen_cur = None
+
+        if file_obj is None:  # Open file if not passed
+            self.htdfile = Register.resolve_fhandler(self.location)
+            file_obj = self.htdfile(location)
+
+        self._file = file_obj
+
+        # Load db mode
+        self._isdb = False
+
+        if self._file.header["TAB"] is False:
+            self._isdb = True
+        elif self._file.header["TAB"]:
+            raise ConnectionError("This table is part of a db, please " \
+                                  "connect to the db")
+
+        # Load and check auth
+        if user.username not in self._file.header["USR"]:
+            raise AuthenticationError()
+
+        u = self._file.header["USR"][user.username]
+
+        if user.password != u.password:
+            raise AuthenticationError()
+
+        # Load access
+        self._access = u.access
+
+    @_trace('xd')
+    def __delitem__(self, name):
+        """ Split table with parent - returns connection to child """
+
+        if not self.is_db:
+            raise ValueError("This feature requires a connection to a " \
+                             "database")
+
+        cur = self[None]
+
+        if name in cur:
+            # Split table from parent
+            data = cur[name]  # get loc
+            del cur[name]
+            cur.close()
+
+            con = load_connection(data['location'])  # Connect
+            cur = con[None]
+
+            # Update header
+            cur._file.lock_reading()
+
+            header = cur._file.header
+            header["TAB"] = None
+
+            cur._file.header_update(header)
+
+            cur._file.unlock()
+
+            cur.close()
+        else:
+            cur.close()
+            raise KeyError("No table to split named '%s'." % name)
+
+    @_trace()
+    def __getitem__(self, key):
+        """ Open a cursor on the table """
+
+        if key is None:
+            return Cursor(self, self._location, None, file_obj=self._file)
+
+        # Get table data from db
+        cur = Cursor(self, self._location, None, file_obj=self._file)
+        tbd = cur[key]
+        cur.close()
+
+        return Cursor(self, tbd['location'], key)
+
+    @_trace('r')
+    def __iter__(self):
+        """ If a db - return the tables """
+        # Check connections is DB
+        if not self._isdb:
+            self._gen = None
+            return self
+
+        # Open cursor, list table, close
+        self._gen_cur = self[None]
+        self._gen = self._gen_cur.select(["name", "location"])
+
+        return self
+
+    def __len__(self):
+        # Check for db mode
+        if self._isdb:
+            cur = self[None]
+            leng = len(cur)
+            cur.close()
+            return leng
+        else:
+            return 1
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        if not self._gen:
+            raise StopIteration
+
+        try:
+            tmp = next(self._gen)
+        except StopIteration:
+            self._gen_cur.close()  # Close cursor
+            raise StopIteration
+        else:
+            return tmp
+
+    def __repr__(self):
+        if self.alive is False:
+            return "<HTD%s Closed Connection>" % __version__
+
+        return ("<HTD%s Connection (%s@%s), DB Mode %s>" %
+                (__version__, self.user.username, self.location,
+                self.is_db))
+
+    @_trace('xa')
+    def __setitem__(self, name, child):
+        """ Join table (connection) with parent """
+
+        if not self.is_db:
+            return False
+
+        if isinstance(child, self.__class__) is False:
+            raise ValueError("Child must be a Connection instance")
+
+        cur = child[None]
+
+        # Check that child is a table
+        cur._file.lock_reading()
+        header = cur._file.header
+
+        if header["TAB"] is not None:
+            cur._file.unlock()
+            cur.close()
+            raise ValueError("Child must be a table")
+
+        # Add location to parent
+        cur = self[None]
+        cur[name] = {"location": child._location}
+        cur.close()
+
+        child.close()
+
+        cur = self[name]
+
+        # Update child header
+        cur._file.lock_writing()
+
+        header = cur._file.header
+        header["TAB"] = True
+
+        # Clear users
+        header["USR"] = {"guest": User("guest", None, "roadx")}
+
+        cur._file.header_update(header)
+
+        cur._file.unlock()
+
+        cur.close()
+
+        return self
+
+    @property
+    @_trace('x')
+    def authentication(self):
+        """ Create a new authentication object """
+
+        return Auth(self, self._location, file_obj=self._file)
+
+    @property
+    @_trace()
+    def children(self):
+        """ Open children """
+
+        for cur in copy(self._children):
+            if cur is None:
+                self._children.remove(cur)
+            else:
+                if not cur.alive:
+                    del self._children._parent
+                    self._children.remove(cur)
+
+        return self._children
+
+    @_trace()
+    def close(self):
+        """ Close the connection """
+
+        for cur in copy(self.children):
+            cur.close()  # Close children
+
+        self._file.close()
+
+        self.alive = False
+
+        return True
+
+    @_trace('d')
+    def delete(self, children=False):
+        """ Delete connection db (and tables) and disconnect """
+
+        for cur in copy(self.children):
+            cur.close()  # Close cursors
+
+        if self.is_db:
+            for i in list(self):
+                # Delete children
+                htdfile = Register.resolve_fhandler("%s.htd" % i["location"])
+                f = htdfile(i["location"])
+                f.delete_files()
+
+        # Delete main file
+        self._file.delete_files()
+
+        self.alive = False
+
+        return True
+
+    @property
+    def is_db(self):
+        """ Is the connection to a DB or table """
+        return self._isdb
+
+    @property
+    def location(self):
+        """ The location of the table """
+        return "%s.htd" % self._location
+
+
+def load_connection(*args, **kwargs):
+    return Connection(*args, **kwargs)

=== added file 'htd30/_objects/cursor.py'
--- htd30/_objects/cursor.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/cursor.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,380 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Cursor
+'''
+
+from .. import Register, __version__
+from .._base import _access_check, Progress, ProgressItem, _trace, ThreadLock
+from .._objects.attributes import Attributes
+from .._objects.record import Record
+from .._workers import sanitise, unsanitise
+from weakref import ref
+from threading import current_thread
+
+
+@_trace()
+class Cursor(ThreadLock):
+    """ Class that manages a cursor on a table """
+    def __init__(self, parent, location, table, header=None, file_obj=None):
+        # Store variables
+        self.alive = True
+        self.table = table
+        self._location = location
+        self._children = []
+        self._gen = None
+        self._parent = ref(parent)
+        self._parent()._children.append(self)
+
+        self._access = parent._access
+
+        ThreadLock.__init__(self)  # Start inherit
+
+        # Open file
+        if file_obj is None:
+            htdfile = Register.resolve_fhandler(self.location)
+            self._file = htdfile(location, header)
+            self._opened = True
+        else:
+            self._file = file_obj
+            self._opened = False
+
+    @_trace("r")
+    def __contains__(self, key):
+        self._file.lock_reading()  # Lock file
+
+        # Filter primarykey and get line
+        if len(self._file.header["KEY"]) == 1:
+            key = [key]
+
+        key = sanitise(dict(zip(self._file.header["KEY"], key)),
+                       self._file.header["ATT"])
+
+        line = self._file.get_line(key)
+
+        self._file.unlock()  # Unlock
+
+        return line[0] is not False  # Return True if key exists
+
+    @_trace("d")
+    def __delitem__(self, key):
+        self._file.lock_writing()
+
+        if isinstance(key, slice):  # delete a slice
+            start = key.start
+            if start is None:
+                start = 0
+
+            stop = key.stop
+            if stop is None:
+                stop = len(self._file)
+
+            if start >= stop:
+                raise ValueError("Stop index must be greater than start.")
+
+            self._file.delete_region(start=start, stop=stop)
+
+            self._file.unlock()
+        else:
+            # San data
+            if isinstance(key, (list, tuple)) is False:
+                key = [key]
+
+            key = sanitise(dict(zip(self._file.header["KEY"], key)),
+                           self._file.header["ATT"])
+
+            # Check if record exists and get line
+            pos, data, nline = self._file.get_line(key)
+
+            if pos is False:
+                raise KeyError('No record, %s, was found to delete.' % (key))
+
+            del self._file[pos]  # Delete i from file
+
+            self._file.unlock()
+
+    @_trace("r")
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            return self.select(start=key.start or 0, stop=key.stop or -1)
+
+        self._file.lock_reading()  # Lock file
+
+        # Convert key
+        if isinstance(key, (list, tuple)) is False:
+            key = [key]
+
+        key = sanitise(dict(zip(self._file.header["KEY"], key)),
+                       self._file.header["ATT"])
+
+        # Check key exists
+        pos, data, nline = self._file.get_line(key)
+
+        if pos is False:
+            raise KeyError("".join(['No key, ', str(key), ', found']))
+
+        data = unsanitise(data, self._file.header["ATT"])
+
+        self._file.unlock()  # Unlock
+
+        return Record(key, data, self._parent(), self.table,
+                      self._file.header["KEY"])
+
+    @_trace("r")
+    def __iter__(self):
+        """ If a db - return the tables """
+        # Open cursor, list table, close
+        self._gen = self.select(attribute=self._file.header["KEY"])
+
+        return self
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        try:
+            tmp = next(self._gen)
+        except StopIteration:
+            self._gen.close()  # Close cursor
+            raise StopIteration
+        else:
+            return tmp
+
+    @_trace()
+    def __len__(self):
+        """ The number of records in the table """
+
+        self._file.lock_reading()
+
+        length = len(self._file)  # Get length
+
+        self._file.unlock()
+
+        return length
+
+    def __repr__(self):
+        if self.alive is False:
+            return "<HTD%s Closed Cursor>" % __version__
+
+        return "<HTD%s Cursor (%s)>" % (__version__, self.location)
+
+    @_trace()
+    def __setitem__(self, key, data):
+        self._file.lock_writing()
+
+        # Filter primarykey
+        if isinstance(key, (list, tuple)) is False:
+            key = [key]
+
+        key = sanitise(dict(zip(self._file.header["KEY"], key)),
+                       self._file.header["ATT"])
+
+        # Check if record exists and get current att
+        pos, datatmp, nline = self._file.get_line(key)
+
+        # If record exists get current record
+        if pos is False:
+            datatmp = {}
+
+        data = sanitise(data, self._file.header["ATT"])  # Run filters
+
+        # Confirm data
+        for att in self._file.header["ATT"]:
+            if att not in data and att in datatmp:
+                data[att] = datatmp[att]
+            elif att not in data and att not in datatmp:
+                data[att] = None
+
+        # Add identifier to data
+        for att in self._file.header["KEY"]:
+            data[att] = key[att]
+
+        # Write to file
+        if pos is not False:
+            _access_check("o", self)
+            self._file[pos] = data
+        else:
+            _access_check("a", self)
+            self._file.insert_line(nline, data)
+
+        self._file.unlock()
+
+    @_trace()
+    def assign(self, generator):
+        """ Assign the contents of the generator to the table """
+
+        self._file.lock_writing()
+
+        gen = self._file.assign(app="a" in self._access, ovr="o" in
+                                self._access)
+
+        next(gen)
+
+        for data in generator:
+            key = [data[a] for a in self._file.header["KEY"]]
+            key = sanitise(dict(zip(self._file.header["KEY"], key)),
+                           self._file.header["ATT"])
+
+            gen.send([key, sanitise(data, self._file.header["ATT"])])
+
+        gen.close()
+
+        self._file.unlock()
+
+    @property
+    def attributes(self):
+        """ Manage the attribute settings """
+        return Attributes(self)
+
+    @_trace()
+    def close(self):
+        """ Close the cursor """
+        self.alive = False  # Set closed
+
+        # Close children
+        for child in self._children:
+            child.close()
+
+        if self._opened:  # Close file if I opened it
+            self._file.close()
+
+        # Remove from parent
+        if self._parent() is not None and self in self._parent()._children:
+            self._parent()._children.remove(self)
+
+        return True
+
+    @property
+    def composite(self):
+        """ Is the table using a composite key """
+
+        return isinstance(self.identifier, (list, tuple))
+
+    @property
+    @_trace("r")
+    def identifier(self):
+        """ The identifier for the table """
+
+        self._file.lock_reading()
+
+        key = self._file.header["KEY"]
+        output = [self._file.header["ATT"][att] for att in key]
+
+        if len(output) == 1:
+            output = output[0]
+
+        self._file.unlock()
+
+        return output
+
+    @identifier.setter
+    @_trace("o")
+    def identifier(self, key):
+        """ Set the identifier for the table """
+
+        self._file.lock_writing()
+
+        # Confirm data
+        if isinstance(key, str):
+            key = [key]
+
+        if isinstance(key, (list, tuple)) is False:
+            raise ValueError("Identifier must be a list or list of strings")
+
+        if len(self._file) > 0:
+            raise ValueError("The table must be empty before changing the" \
+                             " identifier.")
+
+        header = self._file.header
+        header["KEY"] = key
+
+        self._file.header_update(header)
+
+        self._file.unlock()
+
+    @property
+    def location(self):
+        """ The location of the table """
+        return "%s.htd" % self._location
+
+    @_trace("r")
+    def select(self, attribute=None, start=0, stop=-1):
+        """ List selected attribute(s) """
+
+        self._file.lock_reading()
+
+        if attribute is None:  # Select all atts
+            attbyid = self._file.header["ATTBYID"]
+            attribute = [attbyid[i][1] for i in attbyid]
+
+        if isinstance(attribute, str):
+            attribute = [attribute]
+
+        if not isinstance(attribute, (list, tuple)):
+            raise ValueError("Attribute must be a list, tuple or str.")
+
+        numatts = len(attribute)  # Count atts
+
+        # Check atts exist
+        if sum([1 for att in attribute if att not in
+                self._file.header["ATT"]]) > 0:
+            raise KeyError('No find attribute, %s, to list.' % attribute)
+
+        if stop == -1:  # load stop
+            stop = len(self._file)
+
+        if start > stop:
+            raise ValueError("Stop index must be greater than start.")
+
+        gen = self._file.select(attribute, start, stop)  # load generator
+
+        # Load progress
+        calling = "Calling htd.Cursor.select(%s, %s, %s)" % (attribute, start,
+                                                             stop)
+        prog = ProgressItem(current_thread(), stop - start, calling)
+        Progress.add(prog)
+
+        for i in gen:
+            tmp = unsanitise(i, self._file.header["ATT"])
+
+            self._file.unlock()
+
+            prog.count()
+
+            if numatts == 1:
+                yield tmp[attribute[0]]
+            else:
+                yield tmp
+
+            self._file.lock_reading()
+
+        Progress.remove(prog)
+
+        self._file.unlock()
+
+    @property
+    @_trace("r")
+    def version(self):
+        """ Version of the open table """
+        self._file.lock_reading()
+
+        out = self._file.header["VER"]
+
+        self._file.unlock()
+
+        return out

=== added file 'htd30/_objects/record.py'
--- htd30/_objects/record.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/record.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,109 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD Record
+'''
+
+from .. import ConnectionError
+from weakref import ref
+
+
+class Record(object):
+    """ Class that provides read-only record and foreign key support """
+    def __init__(self, key, data={}, con=None, table=None, identifier=[]):
+        # Set data
+        self.key = key
+        self.data = data
+
+        # Set references
+        if con is not None:
+            self._con = ref(con)
+        else:
+            self._con = None
+
+        self.table = table
+
+        # Load identifier
+        if identifier == [] and con is not None:
+            cur = self._con()[table]
+            identifier = cur.identifier
+            cur.close()
+
+        self.identifier = identifier
+
+        # Load composite
+        self.composite = False
+
+        leng = len(self.identifier)
+
+        # Copy identifer into data
+        if leng > 1:
+            self.composite = True
+
+            # Copy identifier into data
+            for i, k in enumerate(self.identifier):
+                if k not in self.data:
+                    self.data[k] = self.key[i]
+        elif leng == 1:
+            if self.identifier[0] not in self.data:
+                self.data[self.identifier[0]] = self.key
+
+            if isinstance(self.key, (list, tuple)):
+                self.key = self.key[0]
+
+    def __getitem__(self, key):
+        # Check if foreign key lookup needed
+        if "." in key:
+            table, key = key.split(".", 1)  # Split table and attribute
+
+            # Check the object exists
+            if self._con() is None:
+                raise ConnectionError("This connection has been closed")
+
+            cur = self._con()[table]  # Open cursor
+
+            # Generate foreign key from attributes
+            if cur.composite:
+                fkey = []
+                for a in cur.identifier:
+                    if a.name not in self.data:
+                        raise ValueError("%s could not be found in relation" %
+                                         a.name)
+
+                    fkey.append(self.data[a.name])
+
+            else:
+                if cur.identifier.name not in self.data:
+                    raise ValueError("%s could not be found in relation" %
+                                     cur.identifier.name)
+
+                fkey = self.data[cur.identifier.name]
+
+            data = cur[fkey][key]  # Get the required data
+            cur.close()  # Close cursor
+
+            return data  # Return data
+        else:
+            return self.data[key]  # Return key from data
+
+    def __len__(self):
+        """ Return number of non-NULL fields """
+        return len([i for i in self.data if i is not None])
+
+    def __repr__(self):
+        return str(self.data)

=== added file 'htd30/_objects/user.py'
--- htd30/_objects/user.py	1970-01-01 00:00:00 +0000
+++ htd30/_objects/user.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,81 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD User
+'''
+
+from .. import __version__
+from hashlib import sha256
+
+
+class User(object):
+    """ User object """
+    def __init__(self, username=None, password=None, access="roadx"):
+        self.username = username
+        self.password = password
+        self.access = access
+
+    def __repr__(self):
+        return ("<HTD%s User (%s with '%s' permissions)>" %
+                (__version__, self.username, self.access))
+
+    @property
+    def access(self):
+        return self.__access
+
+    @access.setter
+    def access(self, access):
+        """
+        Set the access level for the user
+        NOTE: Only used for creating new users, not authenticating connections
+        """
+        for i in access:
+            if i not in "roadx":
+                raise ValueError("Invalid permission given, '%s'." % i)
+
+        self.__access = access
+
+    @property
+    def password(self):
+        return self.__password
+
+    @password.setter
+    def password(self, password):
+        """ Set the password for the user """
+        if password is None:
+            self.__password = None
+        else:
+            self.__password = sha256(password.encode("ISO-8859-1")).hexdigest()
+
+    def to_dict(self):
+        return {"pass": self.password, "acc": self.access}
+
+    @property
+    def username(self):
+        return self.__username
+
+    @username.setter
+    def username(self, username):
+        if username is None:
+            self.__username = None
+            return
+
+        if isinstance(username, str) is False:
+            raise ValueError("Username must a string")
+
+        self.__username = username

=== added directory 'htd30/_workers'
=== added file 'htd30/_workers/__init__.py'
--- htd30/_workers/__init__.py	1970-01-01 00:00:00 +0000
+++ htd30/_workers/__init__.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,333 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+Data Filter to import/export raw data
+Also loads default file handlers
+get_line alog and locking classes
+'''
+
+from .. import AuthenticationError
+from .._base import File, convert_location
+import os
+from random import choice
+from re import sub
+from struct import unpack, pack
+from sys import platform
+from time import time
+
+# Load fsync
+if platform == 'linux2':
+    fsync = os.fdatasync
+else:
+    fsync = os.fsync
+
+
+def sanitise(data, attributes):
+    """ Sanitise data so that it can be stored in the db """
+
+    if data is None:
+        return None
+
+    # Check data attributes exist
+    atts = [a for a in data if a not in attributes]
+
+    if len(atts) > 0:
+        raise AttributeError('Failed to find sanitise settings for ' \
+                                 'attribute %s' % atts)
+
+    for att in attributes:
+        if att in data:  # Load data
+            tmp = data[att]
+        else:
+            tmp = None
+
+        attr = attributes[att]  # load attribute
+
+        if tmp is None:
+            if attr._default is not None:
+                tmp = attr.default  # Load default value
+            elif attr.required:  # Check required
+                raise ValueError("Required attribute (%s) was NULL" % att)
+            else:
+                continue
+
+        typed = attr.dtype  # Load dtype
+
+        if typed.f(tmp) is False:  # Type check
+            name = ('%s, failed to  match preset pattern for %s. (%s)' %
+                    (att, typed, tmp))
+
+            raise ValueError(name)
+
+        if typed.r and attr.range is not False:  # Range check
+            if not (attr.range[1] < tmp < attr.range[0]):
+                raise ValueError('"%s" failed to match range for "%s". (%s)' %
+                                 (att, typed, tmp))
+
+        if attr.limit_list[0] and tmp not in attr.limit_list[1]:  # List check
+            raise KeyError('"%s" failed to match an item in list.' % att)
+
+        tmp = typed.s(tmp)  # Convert data
+
+        if len(tmp) > attr.size:  # Length Check
+            raise ValueError('String length check failed for "%s". (%s)' %
+                             (att, tmp))
+
+        data[att] = tmp  # Update data
+
+    return data
+
+
+def unsanitise(data, attributes):
+    """ Unsantise data so that it can be used by the client """
+    for att in data:
+        dtype = attributes[att].dtype
+        patt = attributes[att].reg_expr
+        if data[att] is not None:
+            if not not patt:  # Run reg expr
+                data[att] = sub(patt, b"", data[att])
+            data[att] = dtype.u(data[att])
+
+    return data
+
+
+class GetLineAlgorithm(object):
+    def assign(self, app=False, ovr=False):
+        leng = len(self)
+        pre = b""
+        end = leng == 0
+        err_str = 'User doesn\'t have to permission '
+        app_err = ''.join([err_str, '[a - append]'])
+        ovr_err = ''.join([err_str, '[o - overwrite]'])
+
+        while 1:
+            key, data = (yield)
+
+            skey = b"".join([key[att] for att in self.header["KEY"]])
+
+            if end and (skey > pre) - (skey < pre) == 1:
+                if app:
+                    self.insert_line(leng, data)
+                    pre = skey
+                else:
+                    raise AuthenticationError(app_err)
+            else:
+                pos, datal, nline = self.get_line(key, new=True)
+
+                if pos is False:
+                    if app:
+                        self.insert_line(nline, data)
+                    else:
+                        raise AuthenticationError(app_err)
+                else:
+                    if ovr:
+                        self[pos] = data
+                    else:
+                        raise AuthenticationError(ovr_err)
+
+                end = False
+
+            leng += 1
+
+    def get_line(self, key, new=False):
+        """ Find line for key """
+        # Set up att widths, order
+        atts = []
+        attwidth = {}
+        primarykey = []
+
+        for att in self.header["KEY"]:
+            atts.append(att)
+            attwidth[att] = self.header["ATT"][att].size
+            primarykey.append(key[att])
+
+        primarykey = b"".join(primarykey)  # Generate primarykey
+
+        # Calculate upper and lower  Will take log(2, numrecords)
+        size = len(self)
+
+        upper = size
+        lower = 0
+
+        # Find line
+        datal = None
+        datap = []
+        cline = upper // 2
+        nline = cline
+
+        if size == 0:
+            cline = False
+            nline = 0
+
+        while size > 0:
+            # Check if cline in index
+            datal = self[cline]
+
+            if datal is False:  # Fix for end of file
+                nline = cline
+                cline = False
+                break
+
+            # Build data
+            datap = []
+            for att in atts:
+                v = datal[att]
+                if type(v) is not bytes:
+                    v = str(v).encode("ISO-8859-1")
+                datap.append(v)
+
+            # Join, add to cache
+            datap = b"".join(datap)
+
+            # Check data not primarykey
+            if datap == primarykey:
+                nline = False
+                break
+            elif datap == b'':
+                nline = cline
+                break
+
+            # Compare
+            comp = (datap > primarykey) - (datap < primarykey)
+
+            # Calc movement
+            # upper 10 lower 0 cline 5
+            if comp > 0:
+                upper = cline
+                # upper 1 lower 0 cline 1 => 0
+                if (upper - lower) == 1:
+                    cline = lower
+                    continue
+                else:
+                    # upper 5 lower 0 cline 5 => 2.5
+                    cline = lower + int((upper - lower) // 2)
+            elif comp < 0:
+                # upper 1 lower 0 cline 0 => 1
+                if (upper - lower) == 1:
+                    cline = upper
+                    lower = upper
+                    continue
+                else:
+                    # upper 10 lower 0 cline 5 => 7.5
+                    lower = cline
+                    cline = lower + int((upper - lower) // 2)
+            else:
+                nline = False
+                break
+
+            if upper == lower:
+                nline = cline
+                cline = False
+                break
+
+        # Return result
+        return [cline, datal, nline]
+
+
+class LockFile():
+    def __init__(self, location):
+        self.__location = "%s.htd" % (convert_location(location, ".~lock_"))
+
+        if not os.path.exists(self.__location):
+            f = open(self.__location, "wb")
+            f.close()
+
+        self.__file = File(self.__location)
+
+        while 1:
+            try:
+                self.__file._lock_reading()
+                break
+            except IOError:
+                pass
+
+        self._files = [self.__file]
+
+        self._confirm_funcs = []
+
+    @property
+    def locked(self):
+        """ Return the locks on the cursor """
+        locked = True
+
+        try:
+            self.__file._lock_writing()
+            locked = False
+        except IOError:
+            pass
+        finally:
+            self.__file._lock_reading()
+
+        return locked
+
+    def lock_reading(self):
+        self._acquire()
+
+        while 1:
+            try:
+                self._file._lock_reading()
+                break
+            except IOError:
+                pass
+
+        for i in self._files:
+            i.flush()  # Flush files
+
+        for i in self._confirm_funcs:
+            i()
+
+        return
+
+    def lock_writing(self):
+        self._acquire()
+
+        while 1:
+            try:
+                self._file._lock_writing()
+                break
+            except IOError:
+                pass
+
+        for i in self._files:
+            i.flush()  # Flush files
+
+        for i in self._confirm_funcs:
+            i()
+
+        return
+
+    def unlock(self):
+        for i in self._files:
+            i.flush()  # Flush files
+
+        if self.force_sync and self._file.lock_type:
+            for i in self._files:
+                fsync(i)  # sync file if lock_writing
+
+        try:
+            self._file._unlock()
+        except IOError:
+            pass
+
+        self._release()
+
+        return
+
+# Import default file handlers
+from . import file_var
+from . import file_fix

=== added file 'htd30/_workers/file_fix.py'
--- htd30/_workers/file_fix.py	1970-01-01 00:00:00 +0000
+++ htd30/_workers/file_fix.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,317 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD_FILE_FIXED_WIDTH
+'''
+
+from .. import Config, Register
+from .._base import File, ThreadLock, convert_location, location_is_file
+from .._workers import GetLineAlgorithm, LockFile
+from .._workers.header import Header
+import os
+
+
+class FIXED_WIDTH_FILE(ThreadLock, Header, GetLineAlgorithm, LockFile):
+    file_format = b"\x05"
+
+    def __init__(self, location, header=None):
+        # Load settings
+        self.force_sync = Config.force_sync
+        self._rec_width = 0
+
+        # Load classes
+        ThreadLock.__init__(self)
+        Header.__init__(self)
+        GetLineAlgorithm.__init__(self)
+
+        # Check for file
+        if not os.path.exists("%s.htd" % location):
+            if header is None:
+                raise IOError("No HTD file found (%s.htd)" % location)
+
+            f = open("%s.htd" % location, "wb")
+            f.close()
+
+            self._file = File("%s.htd" % location)
+            self._Header__update(header, True)
+        else:
+            if header is not None:
+                raise IOError('File already exists (%s.htd)' % location)
+
+            self._file = File("%s.htd" % location)
+
+        self.header_update()  # Load header
+
+        # Set variables
+        self.location = location
+        self.escape_char = b"\x00"
+
+        LockFile.__init__(self, location)
+        self._files.append(self._file)
+        self._confirm_funcs.append(self.header_confirm)
+
+    def __delitem__(self, key):
+        # Delete record
+        pos = (self._rec_width * key) + self.header["SIZ"]
+
+        del self._file[pos:pos + self._rec_width]  # Delete from file
+
+    def __getitem__(self, key):
+        pos = (self._rec_width * key) + self.header["SIZ"]  # Find pos
+
+        # Loop through attributes
+        output = {}
+        atts = self.header["ATTBYID"]
+
+        self._file.seek(pos)
+
+        r = self._file.read
+
+        # Read atts
+        for att in atts:
+            data = r(atts[att][0] + 1)
+
+            if data == b"":
+                return False
+
+            data = data.rsplit(b".", 1)
+
+            if len(data[0]) == 0:
+                output[atts[att][1]] = None
+            else:
+                output[atts[att][1]] = data[0]
+
+        return output
+
+    def __len__(self):
+        pos = len(self._file) - self.header["SIZ"]
+        return pos // self._rec_width
+
+    def __setitem__(self, key, value):
+        # Write record
+        # Record MUST exist
+        pos = (self._rec_width * key) + self.header["SIZ"]
+
+        # Loop through attributes
+        string = []
+        atts = self.header["ATTBYID"]
+
+        for att in atts:
+            string.append(b"".join([value[atts[att][1]] or
+                                    b"", b"."]).ljust(atts[att][0] + 1,
+                                                      self.escape_char))
+
+        string = b"".join(string)
+
+        self._file[pos:pos + self._rec_width] = string
+
+    def _modify_attribute(self, attribute, mode):
+        if mode == 1:  # Calc old length
+            pos = len(self._file) - self.header["SIZ"]
+            leng = pos // (self._rec_width -
+                           self.header["ATT"][attribute].size)
+        elif mode == -1:
+            leng = len(self)
+
+        if leng == 0:
+            return True
+
+        atts = self.header["ATTBYID"]
+        self._file.seek(self.header["SIZ"])
+
+        x = 0
+        pos = self.header["SIZ"]
+        while x < leng:
+            for a in atts:
+                size = atts[a][0] + 1
+                if atts[a][1] == attribute:
+                    if mode == 1:
+                        self._file[pos:pos] = self.escape_char * size
+                        pos += size
+                    elif mode == -1:
+                        del self._file[pos:pos + size]
+                else:
+                    pos += atts[a][0] + 1
+            x += 1
+
+        return True
+
+    def add_attribute(self, attribute):
+        return self._modify_attribute(attribute, 1)
+
+    def close(self):
+        """ Close file and sub classes """
+        # Remove self from cache file
+        self._file._lock_writing()
+
+        locked = self.locked
+
+        # Close lock file
+        self._LockFile__file.close()
+
+        # Check for other locks
+        if not locked:
+            try:
+                os.remove(self._LockFile__location)
+            except IOError:
+                pass
+
+        # Close file
+        self._file._unlock()
+        self._file.close()
+
+        return True
+
+    def delete_attribute(self, attribute):
+        return self._modify_attribute(attribute, -1)
+
+    def delete_region(self, start=None, stop=None):
+        spos = (self._rec_width * start) + self.header["SIZ"]
+        epos = (self._rec_width * stop) + self.header["SIZ"]
+
+        del self._file[spos:epos]
+
+        return True
+
+    def delete_files(self):
+        # Close files
+        for f in self._files:
+            f.close()
+
+        # Delete table
+        os.unlink("%s.htd" % self.location)
+
+        lock_loc = "%s.htd" % (convert_location(self.location, ".~lock_"))
+        if os.path.exists(lock_loc):
+            os.unlink(lock_loc)
+
+        return True
+
+    def header_update(self, header=None):
+        if header is not None:
+            self._Header__update(header)
+        else:
+            self._Header__load()
+
+        self._rec_width = sum([self.header["ATT"][i].size + 1 for i in
+                               self.header["ATT"]])
+        return
+
+    def insert_line(self, key, data):
+        # Write record
+        # Record MUST NOT exist
+        pos = (self._rec_width * key) + self.header["SIZ"]
+
+        # Loop through attributes
+        string = []
+        atts = self.header["ATTBYID"]
+
+        for att in atts:
+            string.append(b"".join([data[atts[att][1]] or
+                                    b"", b"."]).ljust(atts[att][0] + 1,
+                                                      self.escape_char))
+
+        string = b"".join(string)
+
+        self._file[pos:pos] = string
+
+        return
+
+    def modify_attribute(self, attribute, old, new):
+        nsize = new.size + 1
+        osize = old.size + 1
+
+        # Calc old length
+        pos = len(self._file) - self.header["SIZ"]
+        leng = pos // (self._rec_width - (nsize - osize))
+
+        if leng == 0:
+            raise StopIteration
+
+        atts = self.header["ATTBYID"]
+        self._file.seek(self.header["SIZ"])
+
+        x = 0
+        pos = self.header["SIZ"]
+
+        while x < leng:
+            for a in atts:
+                if atts[a][1] == attribute:
+                    raw = self._file[pos:pos + osize]
+
+                    if raw == b"":  # break if end of file
+                        raise StopIteration
+
+                    raw = raw.rsplit(b".", 1)
+
+                    if len(raw[0]) == 0:
+                        raw = None
+                    else:
+                        raw = raw[0]
+
+                    tmp = (yield {attribute: raw})
+
+                    output = b"".join([tmp[attribute] or
+                                       b"", b"."]).ljust(nsize,
+                                                         self.escape_char)
+
+                    self._file[pos:pos + osize] = output
+
+                    pos += nsize
+                else:
+                    pos += atts[a][0] + 1
+            x += 1
+
+        raise StopIteration
+
+    def select(self, attribute, start=0, stop=-1):
+        pos = start
+        atts = self.header["ATTBYID"]
+        s = self._file.seek
+        r = self._file.read
+
+        while pos < stop:
+            output = {}
+            s((self._rec_width * pos) + self.header["SIZ"])
+
+            for att in atts:   # Read atts
+                if atts[att][1] not in attribute:
+                    s(atts[att][0] + 1, 1)
+                    continue
+
+                d = r(atts[att][0] + 1)
+
+                if d == b"":
+                    raise StopIteration
+
+                d = d.rsplit(b".", 1)
+
+                if len(d[0]) == 0:
+                    d = None
+                else:
+                    d = d[0]
+
+                output[atts[att][1]] = d
+
+            pos += 1
+            yield output
+
+        raise StopIteration
+
+
+Register.register_fhandler(FIXED_WIDTH_FILE, location_is_file)

=== added file 'htd30/_workers/file_var.py'
--- htd30/_workers/file_var.py	1970-01-01 00:00:00 +0000
+++ htd30/_workers/file_var.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,604 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+HTD_FILE_VARIABLE_WIDTH
+'''
+
+from .. import Config, Register
+from .._base import File, ThreadLock, convert_location, location_is_file
+from .._workers import GetLineAlgorithm, LockFile
+from .._workers.header import Header
+
+import os
+from struct import error, unpack, pack
+from time import time, sleep
+
+cache_size = 50
+
+
+class Index():
+    def __init__(self, location):
+        # Set vars
+        self.__cache = []
+        self.__cache_size = 53
+        self.__location = "%s.htd" % convert_location(location, ".~index_")
+        self.__file = None
+        self.__tms = (0, 0)
+
+        # Create and connect to index
+        if not os.path.exists(self.__location):
+            self.__create_file(self._file, self.header["SIZ"],
+                               len(self.header["ATT"]))
+        else:
+            self.__file = File(self.__location)
+            self.__create_cache()
+
+    def __close(self):
+        """ Disconnect from index """
+        if self.__file is not None:
+            self.__file.close()
+            self.__file = None
+
+        self.__cache = []
+        self.__cache_size = 50
+
+        return
+
+    def __create_cache(self, change=True):
+        """ Create cache from connected file """
+        # Calculate Cache Size
+        length = self.__get_length()
+        self.__cache_size = int((length * 0.01033) + 52.77)
+
+        # Work out how many items
+        length = length // self.__cache_size
+
+        # Set vars
+        x = 0
+        output = []
+        txt = "Q" * self.__cache_size
+        siz = self.__cache_size * 8
+
+        # Seek
+        self.__file.seek(9)
+
+        # Read file
+        while x < length:
+            tmp = self.__file.read(siz)
+            output.append(sum(unpack(txt, tmp)))
+            x += 1
+
+        # Set cache
+        self.__cache = output
+
+        if change:
+            self.__create_tms()
+
+        return True
+
+    def __create_file(self, fileobj, pos, numatts):
+        """ Create index file from fileobj """
+        # Create file
+        if not os.path.exists(self.__location):
+            f = open(self.__location, "wb+")
+            f.close()
+
+        if self.__file is None:
+            self.__file = File(self.__location)
+
+        self.__clear()  # Clear cache
+
+        # Get length of data and seek to start
+        fileobj.seek(0, 2)
+        end = fileobj.tell()
+        fileobj.seek(pos)
+
+        self.__file.seek(0)
+        self.__file.write(b"\x00" * 9)
+
+        # Loop through data
+        while pos < end:
+            length = 0
+            x = 0
+            while x < numatts:
+                d = fileobj.read(4)
+                wid = unpack("I", d)[0]
+                fileobj.seek(wid, 1)
+                wid += 4
+                pos += wid
+                length += wid
+                x += 1
+            self.__file.write(pack("Q", length))
+
+        # Create cache
+        self.__create_cache()
+        return True
+
+    def __create_tms(self):
+        # Load timestamp
+        while 1:
+            timestamp = int(time() * 10 ** 6)
+            if timestamp != self.__tms[0]:
+                time_id = 1
+                break
+            elif self.__tms[1] == 255:
+                sleep(0.1)
+                continue
+            else:
+                time_id = self.__tms[1]
+                break
+
+        self.__tms = (timestamp, time_id)
+        self.__file[0:9] = pack("QB", *self.__tms)
+
+        return
+
+    def index_confirm(self):
+        """ Check for changes in the header """
+        self._file.seek(0)
+
+        timestamp, time_id = unpack("QB", self._file.read(9))
+        otimestamp, otime_id = self.__tms  # Load old times
+
+        if otime_id != time_id or otimestamp != timestamp:
+            self.__create_cache()
+
+        return
+
+    def __clear(self):
+        """ Clear index """
+        if self.__file is not None:
+            self.__file.seek(9)
+            self.__file.truncate()
+
+        # Create cache
+        self.__create_cache()
+        return True
+
+    def __clear_slice(self, start, stop):
+        """ Clear index """
+        if self.__file is not None:
+            # Convert -1 to max
+            if stop == -1:
+                stop = self.__get_length()
+
+            # Clear slice
+            del self.__file[start * 8 + 9:stop * 8 + 9]
+
+        # Create cache
+        self.__create_cache()
+        return True
+
+    def __delete(self):
+        """ Delete index file """
+        if os.path.exists(self.__location) is False:
+            return False
+
+        self.__cache = []
+        os.unlink(self.__location)
+        return True
+
+    def __delete_key(self, key):
+        """ Delete a record from index """
+        key *= 8
+        del self.__file[key + 9:key + 17]
+
+        self.__create_cache()
+        return True
+
+    def __get_length(self):
+        """ Get length (number of records) of index """
+        return (len(self.__file) - 9) // 8
+
+    def __get_position(self, key):
+        """ Get position in db of key """
+        # Convert -1 to max
+        if key == -1:
+            key = self.__get_length()
+
+        # Load cache
+        cache = key // self.__cache_size
+        if cache == 0:
+            length = 0
+        else:
+            length = sum(self.__cache[0:cache])
+
+        key = key % self.__cache_size
+
+        self.__file.seek(cache * (self.__cache_size * 8) + 9)
+
+        # Read width
+        data = self.__file.read(key * 8)
+
+        if key == 1:
+            length += unpack("Q", data)[0]
+        elif key == 0:
+            pass
+        else:
+            try:
+                length += sum(unpack("Q" * key, data))
+            except error:
+                return False
+
+        return length + self.header["SIZ"]
+
+    def __get_width(self, key):
+        """ Get length of record """
+        self.__file.seek(8 * key + 9)
+        data = self.__file.read(8)
+
+        if len(data) == 0:
+            return 0
+        else:
+            return unpack("Q", data)[0]
+
+    def __insert(self, pos, value):
+        """ Insert record into position """
+        data = pack("Q", value)
+        pos *= 8
+        self.__file[pos + 9:pos + 9] = data
+
+        self.__create_cache()
+        return True
+
+    def __set(self, key, value):
+        """ Change record width to value """
+        key *= 8
+        data = pack("Q", value)
+        self.__file[key + 9:key + 17] = data
+
+        self.__create_cache()
+        return True
+
+
+class VARIABLE_WIDTH_FILE(ThreadLock, Header, Index, GetLineAlgorithm,
+                          LockFile):
+    file_format = b"\x01"
+
+    def __init__(self, location, header=None):
+        # Load settings
+        self.force_sync = Config.force_sync
+
+        # Load classes
+        ThreadLock.__init__(self)
+        Header.__init__(self)
+        GetLineAlgorithm.__init__(self)
+
+        # Check for file
+        if not os.path.exists("%s.htd" % location):
+            if header is None:
+                raise IOError("No HTD file found (%s.htd)" % location)
+
+            f = open("%s.htd" % location, "wb")
+            f.close()
+
+            self._file = File("%s.htd" % location)
+            self._Header__update(header, True)
+            new = True
+        else:
+            if header is not None:
+                raise IOError('File already exists (%s.htd)' % location)
+
+            self._file = File("%s.htd" % location)
+            new = False
+
+        self.header_update()  # Load header
+
+        # Set variables
+        self.location = location
+
+        LockFile.__init__(self, location)
+        self._files.append(self._file)
+        self._confirm_funcs.append(self.header_confirm)
+
+        Index.__init__(self, location)
+        self._files.append(self._Index__file)
+        self._confirm_funcs.append(self.index_confirm)
+
+        if new:
+            self._Index__clear()
+
+    def __delitem__(self, key):
+        # Delete record
+
+        # Find pos
+        pos = self._Index__get_position(key)
+        if pos is False:
+            raise IndexError("No record found to delete (%s)" % key)
+
+        wid = self._Index__get_width(key)  # Get width
+
+        del self._file[pos:pos + wid]  # Delete from file
+
+        self._Index__delete_key(key)  # Update index and cache
+
+    def __len__(self):
+        return self._Index__get_length()
+
+    def __getitem__(self, key):
+        # Find pos
+        pos = self._Index__get_position(key)
+
+        if pos is False:
+            return False
+
+        # Loop through attributes
+        output = {}
+        atts = self.header["ATTBYID"]
+
+        self._file.seek(pos)
+
+        r = self._file.read
+
+        # Read atts
+        for att in atts:
+            try:
+                wid = unpack("I", r(4))[0]
+            except error:
+                output = False
+                break
+
+            if wid == 0:
+                output[atts[att][1]] = None
+            else:
+                output[atts[att][1]] = r(wid)
+
+        return output
+
+    def __setitem__(self, key, value):
+        # Write record
+        # Record MUST exist
+        pos = self._Index__get_position(key)
+
+        if pos is False:
+            raise IndexError("No record found to set (%s)" % key)
+
+        # Get width
+        owid = self._Index__get_width(key)
+
+        # Loop through attributes
+        string = []
+        atts = self.header["ATTBYID"]
+
+        for att in atts:
+            val = value[atts[att][1]]
+            if val is None:
+                string.append(b"\x00" * 4)
+            else:
+                wid = pack("I", len(val))
+                string.extend([wid, val])
+
+        string = b"".join(string)
+
+        self._file[pos:pos + owid] = string
+
+        # Update index
+        wid = len(string)
+        if owid != wid:
+            self._Index__set(key, wid)
+
+    def _modify_attribute(self, attribute, mode):
+        leng = len(self)
+        if leng == 0:
+            return True
+
+        attributes = self.header["ATTBYID"]
+        self._file.seek(self.header["SIZ"])
+
+        x = 0
+        pos = self.header["SIZ"]
+
+        while x < leng:
+            for a in attributes:
+                if attributes[a][1] == attribute:
+                    if mode == 1:
+                        self._file[pos:pos] = b"\x00\x00\x00\x00"
+                        pos += 4
+                    elif mode == -1:
+                        wid = unpack("I", self._file.read(4))[0]
+                        del self._file[pos:pos + wid + 4]
+                    self._file.seek(pos)
+                else:
+                    wid = unpack("I", self._file.read(4))[0]
+                    self._file.seek(wid, 1)
+                    pos += wid + 4
+            x += 1
+
+        num_atts = len(self.header["ATT"])
+        if mode == -1:
+            num_atts -= 1
+
+        self._Index__create_file(self._file, self.header["SIZ"], num_atts)
+
+        return True
+
+    def add_attribute(self, attribute):
+        return self._modify_attribute(attribute, 1)
+
+    def close(self):
+        """ Close file and sub classes """
+        # Remove self from cache file
+        self._file._lock_writing()
+
+        self._Index__close()  # Close index
+
+        locked = self.locked
+
+        # Close lock file
+        self._LockFile__file.close()
+
+        # Check for other locks
+        if not locked:
+            try:
+                os.remove(self._LockFile__location)
+            except IOError:
+                pass
+
+        # Close file
+        self._file._unlock()
+        self._file.close()
+
+        return True
+
+    def delete_attribute(self, attribute):
+        return self._modify_attribute(attribute, -1)
+
+    def delete_files(self):
+        # Close files
+        for f in self._files:
+            f.close()
+
+        # Delete table
+        os.unlink("%s.htd" % self.location)
+
+        for i in [".~lock_", ".~index_"]:
+            loc = "%s.htd" % (convert_location(self.location, i))
+            if os.path.exists(loc):
+                os.unlink(loc)
+
+        return True
+
+    def delete_region(self, start=None, stop=None):
+        spos = self._Index__get_position(start)
+        epos = self._Index__get_position(stop)
+
+        del self._file[spos:epos]
+
+        self._Index__clear_slice(start, stop)
+
+        return True
+
+    def header_update(self, header=None):
+        if header is not None:
+            self._Header__update(header)
+        else:
+            self._Header__load()
+
+        return
+
+    def insert_line(self, key, data):
+        # Write record (Record MUST NOT exist)
+        pos = self._Index__get_position(key)
+
+        if pos is False:
+            return False
+
+        # Loop through attributes
+        string = []
+        atts = self.header["ATTBYID"]
+
+        for att in atts:
+            val = data[atts[att][1]]
+            if val is None:
+                string.append(b"\x00" * 4)
+            else:
+                wid = pack("I", len(val))
+                string.extend([wid, val])
+
+        string = b"".join(string)
+
+        wid = len(string)
+        self._file[pos:pos] = string
+
+        self._Index__insert(key, wid)  # Update index
+
+        return
+
+    def modify_attribute(self, attribute, old, new):
+        leng = len(self)
+
+        if leng == 0:
+            raise StopIteration
+
+        atts = self.header["ATTBYID"]
+        self._file.seek(self.header["SIZ"])
+        num_atts = len(self.header["ATT"])
+
+        x = 0
+        pos = self.header["SIZ"]
+
+        while x < leng:
+            for a in atts:
+                self._file.seek(pos)
+                if atts[a][1] == attribute:
+                    wid = unpack("I", self._file.read(4))[0]  # read old
+                    raw = self._file[pos + 4:pos + wid + 4]
+
+                    if raw == b"":  # break if end of file
+                        self._Index__create_file(self._file,
+                                                 self.header["SIZ"], num_atts)
+                        raise StopIteration
+
+                    output = (yield {attribute: raw})[attribute]
+                    nleng = len(output)
+                    nwid = pack("I", nleng)  # write new
+                    self._file[pos:pos + wid + 4] = b"".join([nwid, output])
+
+                    pos += nleng + 4
+                else:
+                    wid = unpack("I", self._file.read(4))[0]
+                    self._file.seek(wid, 1)
+                    pos += wid + 4
+            x += 1
+
+        self._Index__create_file(self._file, self.header["SIZ"], num_atts)
+
+        raise StopIteration
+
+    def select(self, attribute, start=0, stop=-1):
+        key = start
+        atts = self.header["ATTBYID"]
+        s = self._file.seek
+        r = self._file.read
+
+        pos = self._Index__get_position(key)  # Find pos
+
+        if pos is False:
+            raise IndexError("No key found for specified range")
+
+        while key < stop:
+            output = {}
+            s(pos)
+
+            # Read atts
+            for att in atts:
+                try:
+                    wid = unpack("I", r(4))[0]
+                    pos += 4
+                except error:
+                    raise StopIteration
+                    break
+
+                pos += wid
+
+                if atts[att][1] not in attribute:
+                    s(wid, 1)
+                    continue
+
+                if wid == 0:
+                    output[atts[att][1]] = None
+                else:
+                    output[atts[att][1]] = r(wid)
+
+            key += 1
+            yield output
+
+        raise StopIteration
+
+Register.register_fhandler(VARIABLE_WIDTH_FILE, location_is_file)
+Register.default_fhandler = VARIABLE_WIDTH_FILE

=== added file 'htd30/_workers/header.py'
--- htd30/_workers/header.py	1970-01-01 00:00:00 +0000
+++ htd30/_workers/header.py	2012-07-18 20:53:21 +0000
@@ -0,0 +1,186 @@
+'''
+This file is part of HTD (HayzenTech Database)
+
+Copyright (C) 2011 - 2012 Andrew Hayzen
+
+HTD is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+HTD 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with HTD. If not, see <http://www.gnu.org/licenses/>
+
+Header object - Manages the I/O for the header
+'''
+
+from .. import DataTypes, Register
+from .._objects import Attribute, User
+from copy import deepcopy
+from struct import pack, unpack
+from time import time, sleep
+
+
+class Header():
+    def __init__(self):
+        self.header = {"TMS": (0, 0)}
+
+    def __load(self):
+        """ Load header into cache """
+
+        # Check data exists
+        self._file.seek(0)
+        data = self._file.read(8)
+
+        if data == b"":
+            return False
+
+        # Read data
+        length = unpack("Q", data)[0]
+        file_format = self._file.read(1)
+        timestamp, time_id = unpack("QB", self._file.read(9))
+        header = {"FOR": file_format, "TMS": (timestamp, time_id)}
+        pos = self._file.tell()
+
+        while pos < length:
+            wid = unpack("Q", self._file.read(8))[0]
+            data = self._file.read(wid)
+            header[str(data[0:3].decode("ISO-8859-1"))] = data[3:]
+            pos += 8 + wid
+
+        # Convert data
+
+        # Convert Version
+        header["VER"] = float(header["HTD"])
+        del header["HTD"]
+
+        # Convert each
+        for att in header:
+            if att not in ["VER", "FOR", "TMS"]:
+                header[att] = eval(header[att])
+
+            if att == "ATT":
+                for a in deepcopy(header[att]):
+                    val = header[att][a]
+
+                    dtype = getattr(DataTypes,
+                                    Register.dtype_codes[val["dtype"]])
+
+                    tmp = Attribute(name=a, dtype=dtype)
+                    tmp._id = val["id"]
+                    size = val["size"]
+
+                    if not isinstance(size, bytes):
+                        size = size.encode("ISO-8859-1")
+
+                    tmp.size = unpack("I", size)[0]
+                    tmp.limit_list = val["limit_list"]
+                    tmp.range = val["range"]
+                    tmp.reg_expr = val["reg_expr"]
+                    tmp.required = val["required"]
+                    tmp._default = val["default"]
+
+                    header[att][a] = tmp
+
+            if att == "USR":
+                for a in deepcopy(header[att]):
+                    val = header[att][a]
+                    header[att][a] = User(username=a, password=val["pass"],
+                                          access=val["acc"])
+                    header[att][a]._User__password = val["pass"]  # sha256
+
+        # Add calculated
+        header["SIZ"] = length
+        header["ATTBYID"] = self._get_atts_by_id(header["ATT"])
+
+        # Update var
+        self.header = header
+
+        return self.header
+
+    def __update(self, header, blank=False):  # Convert from new objects to raw
+        """ Set new header """
+        # Get old header
+        if not blank:
+            oldheader = deepcopy(self.header)
+
+        # Build inital str
+        leng = pack("Q", len(str(header["VER"])) + 3)
+
+        write = [self.file_format]
+
+        # Load timestamp
+        while 1:
+            timestamp = pack("Q", int(time() * 10 ** 6))
+            if timestamp != self.header["TMS"][0]:
+                time_id = b"\x01"
+                break
+            elif self.header["TMS"][1] == 255:
+                sleep(0.1)
+                continue
+            else:
+                time_id = pack("B", self.header["TMS"][1] + 1)
+                break
+
+        write.extend([timestamp, time_id, leng, b"HTD",
+                      str(header["VER"]).encode("ISO-8859-1")])
+
+        # Add header atts
+        for att in ["KEY", "USR", "TAB", "ATT"]:
+            if att in ["ATT", "USR"]:
+                tmp = {}
+                for i in header[att]:
+                    tmp[i] = header[att][i].to_dict()
+            elif att == "KEY":
+                tmp = []
+                for i in header[att]:
+                    if isinstance(i, Attribute):
+                        i = i.name
+                    tmp.append(i)
+                header[att] = tmp
+            else:
+                tmp = header[att]
+
+            length = len(str(tmp)) + 3
+            write.extend([pack("Q", length), att.encode("ISO-8859-1"),
+                          str(tmp).encode("ISO-8859-1")])
+
+        write = b"".join(write)
+        write = b"".join([pack("Q", len(write) + 8), write])  # Add length
+
+        # Write to file
+        if blank:
+            self._file[0:1] = write
+        else:
+            self._file[0:oldheader["SIZ"]] = write
+
+        self.__load()
+
+        return True
+
+    def _get_atts_by_id(self, atts):
+        """ Sort attributes by id """
+        attributes = {}
+
+        for att in atts:
+            attr = atts[att]
+            attributes[attr._id] = [attr.size, att]
+
+        return attributes
+
+    def header_confirm(self):
+        """ Check for changes in the header """
+        self._file.seek(9)
+
+        timestamp, time_id = unpack("QB", self._file.read(9))
+        otimestamp, otime_id = self.header["TMS"]  # Load old times
+
+        if otime_id != time_id or otimestamp != timestamp:
+            self.header_update()
+
+        return

=== modified file 'setup.py'
--- setup.py	2012-07-13 19:52:47 +0000
+++ setup.py	2012-07-18 20:53:21 +0000
@@ -2,20 +2,26 @@
 from distutils.core import setup
 
 setup(name="htd30",
+      description="HTD (HayzenTech Database) is a pure python library which " \
+                  "acts as a simple database engine.",
       version="3.0",
       author="Andrew Hayzen",
+      author_email="[e-mail]",
       url="http://www.hayzentech.co.uk/htd",
       classifiers=["Development Status :: 4 - Beta",
                    "Intended Audience :: Developers",
-                   "License :: OSI Approved :: GNU Library or Lesser General" \
-                   " Public License (LGPL)",
+                   "License :: OSI Approved :: GNU Lesser General Public " \
+                   "License v3 (LGPLv3)",
                    "Programming Language :: Python",
+                   "Programming Language :: Python :: 3",
                    "Topic :: Database :: Database Engines/Servers",
-                   'Operating System :: POSIX',
-                   'Operating System :: Microsoft :: Windows'],
+                   "Topic :: Software Development :: Libraries :: Python " \
+                   "Modules",
+                   "Operating System :: POSIX",
+                   "Operating System :: Microsoft :: Windows"],
       packages=['htd30', 'htd30/_base', 'htd30/_objects', 'htd30/_workers'],
-      package_dir={'htd30': 'src/htd30',
-                   'htd30/_base': 'src/htd30/_base',
-                   'htd30/_objects': 'src/htd30/_objects',
-                   'htd30/_workers': 'src/htd30/_workers'}
+      package_dir={'htd30': 'htd30',
+                   'htd30/_base': 'htd30/_base',
+                   'htd30/_objects': 'htd30/_objects',
+                   'htd30/_workers': 'htd30/_workers'}
       )

=== removed directory 'src'
=== removed directory 'src/htd30'
=== removed file 'src/htd30/__init__.py'
--- src/htd30/__init__.py	2012-07-17 21:42:28 +0000
+++ src/htd30/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,266 +0,0 @@
-#!/usr/bin/env python
-'''
-This file is part of HTD (HayzenTech Database)
-
-Copyright (C) 2011 - 2012 Andrew Hayzen
-
-HTD is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-HTD 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 Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with HTD. If not, see <http://www.gnu.org/licenses/>
-
-This document conforms to the PEP 8 Style Guide
-
-Version 3.00 PRE-ALPHA-3
-'''
-
-# Import built-in modules
-from os import path as _path
-
-
-#--------------------------------------------------------------------- Settings
-__build_id__ = 300039
-__version__ = 3.00
-
-
-class _Config():
-    debug = True
-    errors = True
-    force_sync = False
-    tracing = False
-
-Config = _Config()
-
-
-#------------------------------------------------------------------- Exceptions
-class AuthenticationError(Exception):
-    pass
-
-
-class ConnectionError(Exception):
-    pass