commit 971de14356a5497f9878f40594cb5dc1a28d196d Author: jimmy Date: Sat Oct 24 17:10:05 2026 +1300 Add cashbook web app for importing ANZ statements Local web app and CLI that fill a NZ cashbook spreadsheet (one sheet per month, April-March) from ANZ CSV exports and PDF statements, via a headless LibreOffice. - Import with preview; duplicates matched on date and amount so CSV and PDF versions of the same period don't double up - Statement upload (drag and drop), view, download, rename and remove, with per-book import status - Month review with GST and category editing, year summary and six-monthly GST returns - Docker Compose setup; books and statements live in data/ (ignored) - Blank cashbook template (NZ Government, CC BY 4.0); code under AGPL-3.0 Co-Authored-By: Claude Opus 5.5 diff --git a/.claude/launch.json b/.claude/launch.json new file mode 100644 index 0000000..ec79c8e --- /dev/null +++ b/.claude/launch.json @@ -0,0 +1,11 @@ +{ + "version": "0.0.1", + "configurations": [ + { + "name": "cashbook", + "runtimeExecutable": "python3", + "runtimeArgs": ["src/webapp.py", "--port", "8765"], + "port": 8765 + } + ] +} diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..4d6e8c9 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,3 @@ +* +!src/ +**/__pycache__ diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..191e773 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +__pycache__/ +*.bak +.~lock.*# + +# your books and bank statements stay local +data/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..61050f4 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,18 @@ +FROM debian:bookworm-slim + +# LibreOffice (headless Calc) + its Python bridge, and pdftotext for PDF statements +RUN apt-get update \ + && apt-get install -y --no-install-recommends \ + python3 python3-uno libreoffice-calc-nogui poppler-utils fonts-dejavu-core \ + && rm -rf /var/lib/apt/lists/* + +WORKDIR /app +COPY src ./src + +# LibreOffice needs a writable home; the container may run as any user +ENV HOME=/tmp +EXPOSE 8765 + +# /data holds the cashbooks and statements/; +# /statements holds ANZ statement folders mounted read-only +CMD ["python3", "src/webapp.py", "--host", "0.0.0.0", "--data", "/data", "--statements", "/statements"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..be3f7b2 --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are 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. + + 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. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + 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 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 work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero 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 Affero 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 Affero 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 Affero 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. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + 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 AGPL, see +. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ef454bf --- /dev/null +++ b/README.md @@ -0,0 +1,154 @@ +# Accounts + +A small local web app for keeping a New Zealand business cashbook from ANZ bank +statements. It fills in a LibreOffice/Excel cashbook spreadsheet (one sheet per +month, April–March), so the spreadsheet stays the record and can still be opened +and edited directly. + +- Import ANZ statements: **CSV exports** from internet banking or **PDF statements** + (including a PDF holding several monthly statements). +- Upload statements by drag-and-drop, then view, download, rename or remove them. + Each one shows how much of it is already in the selected book. +- Preview an import before it happens. Transactions already in the book are skipped, + matched on date and amount, so a CSV and a PDF of the same period don't double up. +- Review each month and set GST (incl/excl) and the income or expense category per + transaction. +- See the year at a glance, with a six-monthly GST summary (Apr–Sep, Oct–Mar) and + IRD due dates. + +Everything runs on your machine; nothing is sent anywhere. + +## Running it + +### Docker Compose (recommended) + +```bash +docker compose up -d --build +``` + +Open . Stop it with `docker compose down`. + +The compose file mounts: + +| Host | Container | Purpose | +|---|---|---| +| `./data` | `/data` | cashbooks and `statements/` (uploads go here) | +| `~/Downloads/anz` | `/statements` (read-only) | ANZ CSV exports to pick from | + +The app is only published on `127.0.0.1`. With rootless Docker the container runs as +root, which maps to your user, so saved files stay yours. With rootful Docker, set +`CASHBOOK_USER=$(id -u):$(id -g)` before `docker compose up`. + +### Without Docker + +Needs Python 3 with LibreOffice's UNO bridge and `pdftotext`. On Debian/Ubuntu: + +```bash +sudo apt install libreoffice-calc python3-uno poppler-utils +``` + +```bash +python3 src/webapp.py +``` + +Options: `--port 8765`, `--host 127.0.0.1`, `--data DIR` (default `./data`), and +`--statements DIR` (repeatable) for extra folders to list statements from. + +## Using it + +1. **New book…** creates `data/cashbook-YYYY-YY.ods` from the template for a + financial year. If you've ticked a PDF statement covering 31 March, the opening + balance is filled in from it. +2. Add statements (drop them on the page, or **Add…**), tick them, and **Preview import**. +3. Check the preview: new rows, rows already in the book, and rows outside the book's + year. Then import. The book is backed up to `.ods.bak` first. +4. Go through each month: fix GST settings and allocate categories. **Only unallocated** + filters to what still needs doing. +5. Check the GST table on the Year page before filing. + +Close a book in LibreOffice before changing it in the app; the app refuses to save +while LibreOffice has it open. + +### How transactions are classified + +These are starting guesses to review, not tax advice: + +- NZ card purchases and payments out: **Incl GST**, unallocated. +- Overseas purchases (with a foreign currency amount), bank fees, transfers and money + in: **Excl GST**. +- Bank fees go to *Bank fees*. +- Transfers to and from your own accounts (`OWN_ACCOUNT_PREFIX` in + `src/statements.py`) go to *Drawings* (out) or *Funds Intr.* (in). + +Income that is a GST-able sale needs changing to **Incl GST** by hand, otherwise it +won't count in the GST summary. + +## Command line + +```bash +python3 src/new_book.py data/cashbook-2026-27.ods --year 2026 --opening-balance 74.70 +``` + +```bash +python3 src/anz_import.py data/cashbook-2026-27.ods data/statements/statement.pdf +``` + +`anz_import.py` refuses transactions outside the book's year unless you pass `--force`. + +## Layout + +``` +src/ + webapp.py web server and JSON API (stdlib only) + static/ the web page + statements.py reads ANZ CSV and PDF statements, GST/category guesses + cashbook.py reads and writes the spreadsheet + office.py runs a private headless LibreOffice + new_book.py creates a book from the template (also a CLI) + anz_import.py imports statements (CLI) + template.ods blank cashbook template +data/ your books and statements (git-ignored) +``` + +`data/` is in `.gitignore`: books, backups and bank statements are never committed. +Removed statements go to `data/statements/.trash`. + +## Licence + +### Cashbook template + +`src/template.ods` is adapted from a free cashbook spreadsheet published by the +New Zealand Government. Its instructions refer to downloading it "from our website" +and to newzealand.govt.nz, and it was created in 2008. It appears to be the Inland +Revenue (IRD) cashbook template, but the original download page couldn't be confirmed. + +Inland Revenue publishes its Crown copyright material under the +[Creative Commons Attribution 4.0 International licence](https://creativecommons.org/licenses/by/4.0/) +([IRD copyright statement](https://www.ird.govt.nz/about-this-site/conditions-of-use/copyright)). +You may reuse and adapt it, including commercially, if you: + +- acknowledge the source and its Crown copyright status, +- reproduce it accurately and say what was changed, +- don't use it in a misleading or derogatory way. + +The licence excludes logos, emblems, trademarks, design elements and photography. +The template contains none of these. + +Attribution: *Cashbook template © Crown copyright, New Zealand Government (Inland +Revenue), licensed under CC BY 4.0. Modified: all transaction data and the opening +balance cleared.* + +If you confirm the template came from a different agency, check that agency's terms. +Some, such as business.govt.nz, use the non-commercial +[CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) licence instead. + +### Code + +Copyright (C) 2026 jimmy + +The code is licensed under the GNU Affero General Public License v3.0; see +[LICENSE](LICENSE). It's free software: you can redistribute and modify it under +the AGPL. If you run a modified version as a network service, you must offer its +source code to the people who use it. It comes with no warranty. + +The template is covered by its own CC BY 4.0 licence above, not the AGPL. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..7c8e160 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,15 @@ +services: + cashbook: + build: . + init: true + # Rootless Docker maps container root to you, so files stay owned by you. + # With rootful Docker, set CASHBOOK_USER=1000:1000 (your uid:gid) instead. + user: "${CASHBOOK_USER:-0:0}" + ports: + - "127.0.0.1:8765:8765" + volumes: + # cashbooks and statements/ (uploads go there too) + - ./data:/data + # ANZ CSV exports, read-only + - ${HOME}/Downloads/anz:/statements:ro + restart: unless-stopped diff --git a/src/anz_import.py b/src/anz_import.py new file mode 100644 index 0000000..e574450 --- /dev/null +++ b/src/anz_import.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Import ANZ (NZ) statements (CSV exports or PDF statements) into a cashbook. + +Each transaction is written to the month sheet (APR..MAR) matching its date, +appended after any rows already filled in. Rows that are already present +(same date, reference and amount) are skipped, so re-importing is safe. + +Usage: + anz_import.py BOOK.ods STATEMENT [STATEMENT ...] [--force] + +Needs LibreOffice (uses its bundled Python UNO bridge); the book must not be +open in LibreOffice while this runs. +""" +import argparse +import os +import shutil +import sys + +from cashbook import YearMismatch, import_transactions +from office import BookLocked, open_book +from statements import read_statement + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + ap.add_argument("book", help="cashbook .ods to fill in") + ap.add_argument("statements", nargs="+", help="ANZ statement(s): .csv export or .pdf") + ap.add_argument("--force", action="store_true", + help="import even if the transaction year doesn't match the sheet's year") + args = ap.parse_args() + + txns = [t for path in args.statements for t in read_statement(path)] + book = os.path.abspath(args.book) + shutil.copy2(book, book + ".bak") + try: + with open_book(book) as doc: + result = import_transactions(doc, txns, args.force) + doc.store() + except YearMismatch as e: + sys.exit(f"{e}; set the start year on 'Summary report' or use --force") + except BookLocked as e: + sys.exit(str(e)) + for name, (added, total) in result.items(): + print(f"{name}: added {added} of {total} transactions") + print(f"Saved {book} (backup at {book}.bak)") + + +if __name__ == "__main__": + main() diff --git a/src/cashbook.py b/src/cashbook.py new file mode 100644 index 0000000..6c5edfb --- /dev/null +++ b/src/cashbook.py @@ -0,0 +1,287 @@ +"""Read and write the cashbook spreadsheet (template.ods layout) via UNO.""" +from collections import Counter +from datetime import date, timedelta + +import uno # noqa: F401 (enables the com.sun.star imports) +from com.sun.star.lang import Locale + +from statements import ORIGIN, classify, describe + +SHEETS = {1: "JAN", 2: "FEB", 3: "MAR", 4: "APR", 5: "MAY", 6: "JUN", + 7: "JUL", 8: "AUG", 9: "SEPT", 10: "OCT", 11: "NOV", 12: "DEC"} +FY_ORDER = ["APR", "MAY", "JUN", "JUL", "AUG", "SEPT", "OCT", "NOV", "DEC", "JAN", "FEB", "MAR"] + +# Month sheet layout (0-based columns / rows) +HEADER_ROW = 13 # row 14: column headings +TOTALS_ROW = 11 # row 12: totals for month +FIRST_ROW, LAST_ROW = 14, 503 # rows 15..504 are summed in the totals row +COL_REC, COL_DATE, COL_REF, COL_GST, COL_ORIGIN = 2, 3, 4, 5, 6 # C..G +COL_INCOME, COL_GST_IN, COL_EXPENSE, COL_GST_OUT = 7, 8, 9, 10 # H..K +COL_UNALLOC_IN, COL_UNALLOC_OUT = 12, 19 # M, T +COL_INCOME_CATS = range(13, 18) # N..R +COL_EXPENSE_CATS = range(20, 32) # U..AF +LAST_COL = 31 + +EPOCH = date(1899, 12, 30) + + +class YearMismatch(Exception): + pass + + +def serial(d): + return (d - EPOCH).days + + +def from_serial(n): + return EPOCH + timedelta(days=int(n)) + + +def col_name(c): + return chr(65 + c) if c < 26 else "A" + chr(65 + c - 26) + + +def _grid(sheet, values=True): + rng = sheet.getCellRangeByPosition(0, FIRST_ROW, LAST_COL, LAST_ROW) + return rng.DataArray if values else rng.FormulaArray + + +def _is_entry(formulas): + return any(formulas[c] for c in (COL_DATE, COL_REF, COL_INCOME, COL_EXPENSE)) + + +def categories(sheet): + head = sheet.getCellRangeByPosition(0, HEADER_ROW, LAST_COL, HEADER_ROW).DataArray[0] + clean = lambda c: " ".join(str(head[c]).split()) + return ({clean(c): c for c in COL_INCOME_CATS if clean(c)}, + {clean(c): c for c in COL_EXPENSE_CATS if clean(c)}) + + +def sheet_year(sheet): + return int(sheet.getCellByPosition(4, 6).Value) # E7 + + +# --- importing ------------------------------------------------------------ + +def _existing(sheet): + """Count of rows already entered per (date, amount), and the first free row.""" + keys, next_row = Counter(), FIRST_ROW + for i, (v, f) in enumerate(zip(_grid(sheet), _grid(sheet, values=False))): + if _is_entry(f): + next_row = FIRST_ROW + i + 1 + amt = (v[COL_INCOME] or 0) or -(v[COL_EXPENSE] or 0) + day = int(v[COL_DATE]) if isinstance(v[COL_DATE], float) else 0 + keys[(day, round(amt, 2))] += 1 + return keys, next_row + + +def _key(t): + return serial(t["date"]), round(t["amount"], 2) + + +def find_new(doc, txns): + """Split transactions into those not yet in the book, and those already there. + + Matching is on date and amount, so a CSV export and a PDF statement of the + same period are recognised as the same transactions. Each statement is + matched against the book plus the statements before it; repeats within one + statement (e.g. two equal transfers on a day) are kept. + """ + existing = {} + for name in {SHEETS[t["date"].month] for t in txns}: + existing[name] = _existing(doc.Sheets.getByName(name))[0] + new, dups = [], [] + by_source = {} + for t in txns: + by_source.setdefault(t.get("source"), []).append(t) + for group in by_source.values(): + seen = Counter() + for t in sorted(group, key=lambda t: t["date"]): + k, have = _key(t), existing[SHEETS[t["date"].month]] + seen[k] += 1 + (dups if seen[k] <= have[k] else new).append(t) + for t in group: # the book now effectively holds this statement too + have = existing[SHEETS[t["date"].month]] + have[_key(t)] = max(have[_key(t)], seen[_key(t)]) + return new, dups + + +def count_imported(doc, txns): + """How many of one statement's transactions are already in the book.""" + return len(find_new(doc, txns)[1]) + + +def plan_import(doc, txns): + """Work out where each transaction would go without changing anything.""" + new, _ = find_new(doc, txns) + new_ids = {id(t) for t in new} + years = {} + out = [] + for t in sorted(txns, key=lambda t: t["date"]): + name = SHEETS[t["date"].month] + if name not in years: + years[name] = sheet_year(doc.Sheets.getByName(name)) + gst, category = classify(t) + status = "duplicate" if id(t) not in new_ids else \ + "wrong year" if t["date"].year != years[name] else "new" + out.append({"date": t["date"].isoformat(), "sheet": name, "reference": describe(t), + "amount": t["amount"], "gst": gst, "category": category or "", + "origin": ORIGIN.get(t["Type"], ""), "status": status}) + return out + + +def import_transactions(doc, txns, force=False): + """Append new transactions to their month sheets. Returns {sheet: (added, total)}.""" + by_sheet = {} + for t in txns: + by_sheet.setdefault(SHEETS[t["date"].month], []).append(t) + new, _ = find_new(doc, txns) + if not force: + for name in {SHEETS[t["date"].month] for t in new}: + year = sheet_year(doc.Sheets.getByName(name)) + wrong = sorted({t["date"].year for t in new if SHEETS[t["date"].month] == name} - {year}) + if wrong: + raise YearMismatch(f"{name} sheet is for {year} but statement has {wrong}") + + fmts = doc.NumberFormats + date_fmt = fmts.queryKey("DD/MM/YYYY", Locale(), False) + if date_fmt == -1: + date_fmt = fmts.addNew("DD/MM/YYYY", Locale()) + + result = {} + for name in sorted(by_sheet, key=FY_ORDER.index): + sheet = doc.Sheets.getByName(name) + to_add = [t for t in new if SHEETS[t["date"].month] == name] + _fill_sheet(sheet, to_add, date_fmt) + result[name] = (len(to_add), len(by_sheet[name])) + doc.calculateAll() + return result + + +def _fill_sheet(sheet, txns, date_fmt): + next_row = _existing(sheet)[1] + if next_row + len(txns) - 1 > LAST_ROW: + raise RuntimeError(f"{sheet.Name}: not enough empty rows left") + income_cats, expense_cats = categories(sheet) + for r, t in enumerate(sorted(txns, key=lambda t: t["date"]), start=next_row): + gst, category = classify(t) + d = sheet.getCellByPosition(COL_DATE, r) + d.Value = serial(t["date"]) + d.NumberFormat = date_fmt + sheet.getCellByPosition(COL_REF, r).String = describe(t) + sheet.getCellByPosition(COL_GST, r).String = gst + sheet.getCellByPosition(COL_ORIGIN, r).String = ORIGIN.get(t["Type"], "") + amount_col = COL_INCOME if t["amount"] > 0 else COL_EXPENSE + sheet.getCellByPosition(amount_col, r).Value = abs(t["amount"]) + if category: + _allocate(sheet, r, t["amount"] > 0, category, income_cats, expense_cats) + + +def _allocate(sheet, r, income, category, income_cats, expense_cats): + """Put the whole net amount of row r in one category column ("" = unallocated).""" + cats = income_cats if income else expense_cats + for c in cats.values(): + sheet.getCellByPosition(c, r).setString("") + if category in cats: + net = "=H{0}-I{0}" if income else "=J{0}-K{0}" + sheet.getCellByPosition(cats[category], r).Formula = net.format(r + 1) + + +# --- new books ------------------------------------------------------------ + +def setup_book(doc, year, opening_balance=None): + summary = doc.Sheets.getByName("Summary report") + summary.getCellRangeByName("D6").String = "April" + summary.getCellRangeByName("D7").Value = year + # APR's year is typed in rather than linked; later months follow it + doc.Sheets.getByName("APR").getCellRangeByName("E7").Value = year + if opening_balance is not None: + summary.getCellRangeByName("G6").Value = opening_balance + doc.calculateAll() + + +# --- reading / editing ---------------------------------------------------- + +def read_summary(doc): + summary = doc.Sheets.getByName("Summary report") + income_cats, expense_cats = categories(doc.Sheets.getByName("APR")) + months = [] + for name in FY_ORDER: + sheet = doc.Sheets.getByName(name) + tot = sheet.getCellRangeByPosition(0, TOTALS_ROW, LAST_COL, TOTALS_ROW).DataArray[0] + entries = [v for v, f in zip(_grid(sheet), _grid(sheet, values=False)) if _is_entry(f)] + incl = [v for v in entries if v[COL_GST] == "Incl GST"] + months.append({ + "sheet": name, + "label": f"{sheet.getCellByPosition(3, 6).String} {sheet_year(sheet)}", + "opening": sheet.getCellByPosition(6, 5).Value, + "closing": sheet.getCellByPosition(6, 6).Value, + "count": len(entries), + # GST-inclusive amounts, as entered on a GST return + "sales_incl": sum(v[COL_INCOME] or 0 for v in incl), + "purchases_incl": sum(v[COL_EXPENSE] or 0 for v in incl), + "income": tot[COL_INCOME], "gst_in": tot[COL_GST_IN], + "expenses": tot[COL_EXPENSE], "gst_out": tot[COL_GST_OUT], + "unallocated_in": tot[COL_UNALLOC_IN], "unallocated_out": tot[COL_UNALLOC_OUT], + "income_cats": {k: tot[c] for k, c in income_cats.items()}, + "expense_cats": {k: tot[c] for k, c in expense_cats.items()}, + }) + return { + "year": int(summary.getCellRangeByName("D7").Value), + "opening": summary.getCellRangeByName("G6").Value, + "closing": summary.getCellRangeByName("G7").Value, + "income_categories": list(income_cats), + "expense_categories": list(expense_cats), + "months": months, + } + + +def read_month(doc, name): + sheet = doc.Sheets.getByName(name) + income_cats, expense_cats = categories(sheet) + rows = [] + for i, (v, f) in enumerate(zip(_grid(sheet), _grid(sheet, values=False))): + if not _is_entry(f): + continue + income = bool(v[COL_INCOME]) + cats = income_cats if income else expense_cats + used = [k for k, c in cats.items() if isinstance(v[c], float) and abs(v[c]) > 0.004] + unalloc = v[COL_UNALLOC_IN] if income else v[COL_UNALLOC_OUT] + rows.append({ + "row": FIRST_ROW + i + 1, + "date": from_serial(v[COL_DATE]).isoformat() if isinstance(v[COL_DATE], float) and v[COL_DATE] else str(v[COL_DATE]), + "reference": f[COL_REF], "gst": v[COL_GST], "origin": v[COL_ORIGIN], + "income": v[COL_INCOME] or 0, "gst_in": v[COL_GST_IN] or 0, + "expense": v[COL_EXPENSE] or 0, "gst_out": v[COL_GST_OUT] or 0, + "category": used[0] if len(used) == 1 and abs(unalloc) < 0.005 else + "split" if used else "", + "unallocated": unalloc or 0, + }) + return { + "sheet": name, + "label": f"{sheet.getCellByPosition(3, 6).String} {sheet_year(sheet)}", + "opening": sheet.getCellByPosition(6, 5).Value, + "closing": sheet.getCellByPosition(6, 6).Value, + "income_categories": list(income_cats), + "expense_categories": list(expense_cats), + "rows": rows, + } + + +def update_row(doc, name, row, gst=None, category=None): + """Change a row's GST setting and/or allocate it to a category (1-based row).""" + sheet = doc.Sheets.getByName(name) + r = row - 1 + if not FIRST_ROW <= r <= LAST_ROW: + raise ValueError("row out of range") + if gst is not None: + if gst not in ("Incl GST", "Excl GST"): + raise ValueError("gst must be 'Incl GST' or 'Excl GST'") + sheet.getCellByPosition(COL_GST, r).String = gst + if category is not None: + income_cats, expense_cats = categories(sheet) + income = bool(sheet.getCellByPosition(COL_INCOME, r).Value) + if category and category not in (income_cats if income else expense_cats): + raise ValueError(f"unknown category {category!r}") + _allocate(sheet, r, income, category, income_cats, expense_cats) + doc.calculateAll() diff --git a/src/new_book.py b/src/new_book.py new file mode 100644 index 0000000..8100885 --- /dev/null +++ b/src/new_book.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +"""Create a new cashbook for a financial year by copying src/template.ods. + +Sets the starting year (April) and, optionally, the opening bank balance on +the 'Summary report' sheet so the month sheets pick them up. + +Usage: + new_book.py OUT.ods [--year 2025] [--opening-balance 1234.56] +""" +import argparse +import os +import shutil +import sys +from datetime import date + +from cashbook import setup_book +from office import open_book + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) +TEMPLATE = os.path.join(HERE, "template.ods") + + +def current_fy_start(): + today = date.today() + return today.year if today.month >= 4 else today.year - 1 + + +def create_book(out, year, opening_balance=None, open_fn=open_book, template=TEMPLATE): + if os.path.exists(out): + raise FileExistsError(f"{out} already exists") + shutil.copy2(template, out) + try: + with open_fn(out) as doc: + setup_book(doc, year, opening_balance) + doc.store() + except Exception: + os.remove(out) + raise + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + ap.add_argument("out", help="new cashbook .ods to create") + ap.add_argument("--year", type=int, default=current_fy_start(), + help="calendar year the financial year starts in (default: current)") + ap.add_argument("--opening-balance", type=float, + help="bank balance at 1 April (default: 0)") + args = ap.parse_args() + + try: + create_book(args.out, args.year, args.opening_balance) + except FileExistsError as e: + sys.exit(str(e)) + print(f"Created {args.out} for April {args.year} - March {args.year + 1}") + + +if __name__ == "__main__": + main() diff --git a/src/office.py b/src/office.py new file mode 100644 index 0000000..cffe6bc --- /dev/null +++ b/src/office.py @@ -0,0 +1,104 @@ +"""Run a private headless LibreOffice and open spreadsheets through its UNO bridge.""" +import os +import shutil +import subprocess +import tempfile +import threading +import time +from contextlib import contextmanager + +import uno +from com.sun.star.beans import PropertyValue + + +class BookLocked(Exception): + pass + + +def prop(name, value): + p = PropertyValue() + p.Name, p.Value = name, value + return p + + +def lock_file(path): + d, name = os.path.split(os.path.abspath(path)) + return os.path.join(d, f".~lock.{name}#") + + +class Office: + """One headless LibreOffice process, reused for every document opened.""" + + def __init__(self): + self._proc = None + self._profile = None + self._desktop = None + self._lock = threading.Lock() + + def _start(self): + self.stop() + self._profile = tempfile.mkdtemp(prefix="accounts_lo_") + pipe = f"accounts_{os.getpid()}_{id(self)}" + self._proc = subprocess.Popen( + ["soffice", "--headless", "--invisible", "--norestore", "--nologo", + f"-env:UserInstallation=file://{self._profile}", + f"--accept=pipe,name={pipe};urp;"], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + local = uno.getComponentContext() + resolver = local.ServiceManager.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", local) + for _ in range(150): + try: + ctx = resolver.resolve(f"uno:pipe,name={pipe};urp;StarOffice.ComponentContext") + break + except Exception: + time.sleep(0.2) + else: + raise RuntimeError("Could not start LibreOffice") + self._desktop = ctx.ServiceManager.createInstanceWithContext( + "com.sun.star.frame.Desktop", ctx) + + def _load(self, path, read_only): + url = uno.systemPathToFileUrl(os.path.abspath(path)) + return self._desktop.loadComponentFromURL( + url, "_blank", 0, (prop("Hidden", True), prop("ReadOnly", read_only))) + + @contextmanager + def open(self, path, read_only=False): + """Open a document; yields it and closes it afterwards (without saving).""" + if not read_only and os.path.exists(lock_file(path)): + raise BookLocked(f"{os.path.basename(path)} is open in LibreOffice; close it first") + with self._lock: + try: + if self._desktop is None: + self._start() + doc = self._load(path, read_only) + except Exception: + # the office process may have died; start a fresh one and retry once + self._start() + doc = self._load(path, read_only) + if doc is None: + raise RuntimeError(f"Could not open {path}") + try: + yield doc + finally: + doc.close(True) + + def stop(self): + if self._proc: + self._proc.terminate() + self._proc.wait() + if self._profile: + shutil.rmtree(self._profile, ignore_errors=True) + self._proc = self._profile = self._desktop = None + + +@contextmanager +def open_book(path, read_only=False): + """Open a single document with a short-lived LibreOffice (for the CLI scripts).""" + office = Office() + try: + with office.open(path, read_only) as doc: + yield doc + finally: + office.stop() diff --git a/src/statements.py b/src/statements.py new file mode 100644 index 0000000..23114fb --- /dev/null +++ b/src/statements.py @@ -0,0 +1,192 @@ +"""Read ANZ (NZ) statements — CSV exports or PDF statements — into transactions. + +Each transaction is a dict with the CSV export's fields (Type, Details, +Particulars, Code, Reference, ForeignCurrencyAmount) plus `date` and `amount` +(negative for money out). +""" +import csv +import hashlib +import os +import re +import subprocess +from datetime import date, datetime + +# ANZ "Type" -> cashbook "Payment origin" dropdown value +ORIGIN = { + "Visa Purchase": "Eftpos", + "Visa Refund": "Eftpos", + "Eft-Pos": "Eftpos", + "Bank Fee": "Direct Debit", + "Transfer": "Transfer", + "Direct Credit": "Direct credit", + "Direct Debit": "Direct Debit", + "Automatic Payment": "Auto payment", + "Payment": "Internet banking", + "Deposit": "Bank Deposit", + "Cash": "Cash", + "Cheque": "Cheque", +} + +# Your own accounts (any suffix): transfers in are funds introduced, out are drawings +OWN_ACCOUNT_PREFIX = "01-0822-0082180-" + +CARD_TYPES = ("Visa Purchase", "Visa Refund", "Eft-Pos") + + +def classify(t): + """Return (gst, category heading or None) for a transaction.""" + typ, amount = t["Type"], t["amount"] + if typ == "Bank Fee": + return "Excl GST", "Bank fees" + if t["Details"].strip().startswith(OWN_ACCOUNT_PREFIX): + return "Excl GST", ("Funds Intr." if amount > 0 else "Drawings") + if t["ForeignCurrencyAmount"].strip(): + # Overseas purchases: no NZ GST to claim on the statement amount + return "Excl GST", None + if amount < 0: + return "Incl GST", None + return "Excl GST", None + + +def describe(t): + details = t["Details"].strip() + if t["Type"] in CARD_TYPES: + # Details is the card number; the merchant is in Code + details = t["Code"].strip() or details + if t["Type"] == "Visa Refund": + details += " (refund)" + extra = [t[k].strip() for k in ("Particulars", "Reference") + if t["Type"] not in CARD_TYPES + ("Transfer",) and t[k].strip()] + if t["ForeignCurrencyAmount"].strip(): + extra.append(t["ForeignCurrencyAmount"].split(" converted")[0]) + return " ".join([details] + ([f"({', '.join(extra)})"] if extra else [])) + + +def read_statement(path): + if path.lower().endswith(".pdf"): + return read_pdf(path)[0] + return read_csv(path) + + +def read_csv(path): + with open(path, newline="", encoding="utf-8-sig") as f: + rows = list(csv.DictReader(f)) + if rows and not {"Type", "Details", "Amount", "Date"} <= set(rows[0]): + raise ValueError("not an ANZ CSV export (missing Type/Details/Amount/Date columns)") + for t in rows: + t["date"] = datetime.strptime(t["Date"].strip(), "%d/%m/%Y").date() + t["amount"] = float(t["Amount"]) + t["source"] = path + return rows + + +# --- PDF statements ------------------------------------------------------- + +PDF_TYPES = { + "VT": "Visa Purchase", "EP": "Eft-Pos", "IP": "Eft-Pos", + "BP": "Payment", "IF": "Payment", "DC": "Direct Credit", + "AP": "Automatic Payment", "DD": "Direct Debit", "CQ": "Cheque", + "AT": "Cash", "IA": "Cash", "FX": "Foreign Exchange", "ED": "Dishonour", +} +MONTHS = {m: i for i, m in enumerate( + "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(), 1)} + +MONEY = r"-?[\d,]+\.\d{2}" +RE_PERIOD = re.compile(r"Statement period\s+(\d{1,2} \w{3} \d{4}) - (\d{1,2} \w{3} \d{4})") +RE_ACCOUNT = re.compile(r"Account number\s+([\d-]+)") +RE_TXN = re.compile(rf"^(\d{{2}}) ([A-Z][a-z]{{2}})\s+(?:([A-Z]{{2}})\s+)?(.*?)\s{{2,}}({MONEY})\s+({MONEY})(-|\s*OD)?\s*$") +RE_BALANCE = re.compile(rf"(?:Opening balance|Balance brought forward).*?\s({MONEY})(-|\s*OD)?\s*$") +RE_FOREIGN = re.compile(r"\s*\(([A-Z]{3} [\d,]+\.\d{2}) @ [\d.]+ ?\)") + + +def _money(s, overdrawn=None): + v = float(s.replace(",", "")) + return -v if overdrawn and overdrawn.strip() else v + + +def read_pdf(path): + """Return (transactions, statement periods) from an ANZ PDF statement. + + A file can hold several statements. Withdrawal vs deposit is taken from the + running balance, so it doesn't depend on column positions. + """ + text = subprocess.run(["pdftotext", "-layout", path, "-"], check=True, + capture_output=True, text=True).stdout + txns, periods = [], [] + period_end = balance = None + seen_periods = set() + for line in text.splitlines(): + m = RE_PERIOD.search(line) + if m: + start, end = (datetime.strptime(s, "%d %b %Y").date() for s in m.groups()) + period_end = end + if (start, end) not in seen_periods: + seen_periods.add((start, end)) + periods.append({"start": start, "end": end, "opening": None, "closing": None}) + continue + m = RE_BALANCE.search(line) + if m: + balance = _money(*m.groups()) + if "Opening balance" in line and periods and periods[-1]["opening"] is None: + periods[-1]["opening"] = balance + continue + m = RE_TXN.match(line) + if not m or period_end is None or balance is None: + continue + day, mon, code, details, amount, new_balance, od = m.groups() + new_balance = _money(new_balance, od) + change = round(new_balance - balance, 2) + if abs(abs(change) - _money(amount)) > 0.005: + raise ValueError(f"{path}: amount doesn't match balance on line: {line.strip()}") + balance = new_balance + periods[-1]["closing"] = balance + + year = period_end.year if MONTHS[mon] <= period_end.month else period_end.year - 1 + t = {"Type": PDF_TYPES.get(code, code or ""), "Details": "", "Particulars": "", + "Code": "", "Reference": "", "ForeignCurrencyAmount": "", + "date": date(year, MONTHS[mon], int(day)), "amount": change, "source": path} + fx = RE_FOREIGN.search(details) + if fx: + t["ForeignCurrencyAmount"] = fx.group(1) + details = RE_FOREIGN.sub("", details) + fields = re.split(r"\s{2,}", details.strip()) + if t["Type"] in CARD_TYPES: + t["Code"] = fields[0] + if change > 0 and t["Type"] == "Visa Purchase": + t["Type"] = "Visa Refund" + else: + fields += [""] * 4 + t["Details"], t["Particulars"], t["Code"], t["Reference"] = fields[:4] + if not code and "FEE" in details.upper(): + t["Type"], t["Details"] = "Bank Fee", details.strip().capitalize() + elif t["Code"].upper() == "TRANSFER": + t["Type"] = "Transfer" + txns.append(t) + return txns, periods + + +RE_ACCOUNT_NO = re.compile(r"\d{2}-\d{4}-\d{7}-\d{2,3}") + + +def statement_info(path): + """Summary of a statement file for listing: account, date range, count, balances.""" + with open(path, "rb") as f: + sha = hashlib.sha256(f.read()).hexdigest() + if path.lower().endswith(".pdf"): + txns, periods = read_pdf(path) + text = subprocess.run(["pdftotext", "-l", "1", path, "-"], + capture_output=True, text=True).stdout + m = RE_ACCOUNT_NO.search(text) + else: + txns, periods = read_csv(path), [] + m = RE_ACCOUNT_NO.search(os.path.basename(path)) + dates = [t["date"] for t in txns] + return { + "sha256": sha, + "account": m.group(0) if m else None, + "count": len(txns), + "first": min(dates).isoformat() if dates else None, + "last": max(dates).isoformat() if dates else None, + "periods": [{k: (v.isoformat() if isinstance(v, date) else v) for k, v in p.items()} + for p in periods], + } diff --git a/src/static/index.html b/src/static/index.html new file mode 100644 index 0000000..4e49580 --- /dev/null +++ b/src/static/index.html @@ -0,0 +1,578 @@ + + + + + +Cashbook + + + +
+

Cashbook

+ + + + + +
+ +
+ + +
+
+ + +
+

New cashbook

+
Copies template.ods for a financial year (April to March).
+ + + + + + +
+
+ + +
+
+
+ +
+
Drop ANZ statements to add them
+
+ + + + diff --git a/src/template.ods b/src/template.ods new file mode 100644 index 0000000..1dce4b5 Binary files /dev/null and b/src/template.ods differ diff --git a/src/webapp.py b/src/webapp.py new file mode 100644 index 0000000..16082d4 --- /dev/null +++ b/src/webapp.py @@ -0,0 +1,383 @@ +#!/usr/bin/env python3 +"""Local web app for the cashbook: pick a book, import ANZ statements, review months. + +Usage: + webapp.py [--host 127.0.0.1] [--port 8765] [--data DIR] [--statements DIR ...] + +Books are the .ods files in --data (default: ../data); new ones are copied +from src/template.ods. Statements are .csv/.pdf files in DATA/statements +(where uploads go), DATA, ~/Downloads/anz and any --statements folders. +""" +import argparse +import json +import os +import re +import shutil +import signal +import subprocess +import sys +import threading +import traceback +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from urllib.parse import parse_qs, urlparse + +import cashbook +from new_book import ROOT, create_book +from office import BookLocked, Office, lock_file +from statements import describe, read_statement, statement_info + +HERE = os.path.dirname(os.path.abspath(__file__)) +BOOKS = os.path.join(ROOT, "data") +UPLOADS = os.path.join(BOOKS, "statements") +STATEMENT_DIRS = [UPLOADS, BOOKS, os.path.expanduser("~/Downloads/anz")] + +office = Office() +_info_cache = {} + + +class BadRequest(Exception): + pass + + +# --- books ------------------------------------------------------------------ + +def list_books(): + books = [] + for name in sorted(os.listdir(BOOKS)): + if name.endswith(".ods") and name != "template.ods": + path = os.path.join(BOOKS, name) + books.append({"name": name, "modified": os.path.getmtime(path), + "open_elsewhere": os.path.exists(lock_file(path))}) + return books + + +def book_path(name): + if not name or os.path.basename(name) != name or not name.endswith(".ods") \ + or name == "template.ods": + raise BadRequest("invalid book name") + path = os.path.join(BOOKS, name) + if not os.path.exists(path): + raise BadRequest(f"{name} not found") + return path + + +def backup(path): + shutil.copy2(path, path + ".bak") + + +# --- statements --------------------------------------------------------------- + +MAX_UPLOAD = 20 * 1024 * 1024 + + +def _parse(path): + """Statement info and transactions, cached until the file changes.""" + key = (path, os.path.getmtime(path)) + if key not in _info_cache: + try: + _info_cache[key] = {"info": statement_info(path), "txns": read_statement(path)} + except Exception as e: # not an ANZ statement, or unreadable + _info_cache[key] = {"info": {"error": str(e).splitlines()[0][:200]}, "txns": []} + return _info_cache[key] + + +def managed(path): + """Statements inside the data folder can be renamed and deleted.""" + return os.path.commonpath([path, os.path.realpath(BOOKS)]) == os.path.realpath(BOOKS) + + +def folder_label(d): + data = os.path.realpath(BOOKS) + d = os.path.realpath(d) + if os.path.commonpath([d, data]) == data: + rel = os.path.relpath(d, data) + return "data" if rel == "." else f"data/{rel}" + return d.replace(os.path.expanduser("~"), "~") + + +def list_statements(book=None): + out, seen = [], set() + for d in STATEMENT_DIRS: + if not os.path.isdir(d): + continue + for name in sorted(os.listdir(d)): + path = os.path.realpath(os.path.join(d, name)) + if path in seen or name.startswith(".") or not name.lower().endswith((".csv", ".pdf")) \ + or not os.path.isfile(path): + continue + seen.add(path) + st = os.stat(path) + out.append({"path": path, "name": name, "folder": folder_label(d), + "managed": managed(path), "size": st.st_size, "modified": st.st_mtime, + "kind": name.rsplit(".", 1)[1].lower(), **_parse(path)["info"]}) + # flag files that are byte-for-byte copies of one listed earlier + first = {} + for s in out: + if s.get("sha256"): + s["copy_of"] = first.get(s["sha256"]) + first.setdefault(s["sha256"], s["name"]) + if book: + with office.open(book_path(book), read_only=True) as doc: + for s in out: + txns = _parse(s["path"])["txns"] + s["imported"] = cashbook.count_imported(doc, txns) if txns else 0 + return out + + +def statement_path(path, must_manage=False): + for s in list_statements(): + if s["path"] == path: + if must_manage and not s["managed"]: + raise BadRequest(f"{s['name']} is in {s['folder']}, which is read-only here") + return path + raise BadRequest(f"unknown statement {path}") + + +def statement_paths(paths): + if not paths: + raise BadRequest("select at least one statement") + allowed = {s["path"] for s in list_statements()} + for p in paths: + if p not in allowed: + raise BadRequest(f"unknown statement {p}") + return paths + + +def safe_name(filename): + name = re.sub(r"[^\w.\-]+", "_", os.path.basename(filename)).strip("._") + if not name.lower().endswith((".csv", ".pdf")): + raise BadRequest("only .csv and .pdf statements") + return name + + +def unique_path(folder, name): + base, ext = os.path.splitext(name) + path, n = os.path.join(folder, name), 2 + while os.path.exists(path): + path, n = os.path.join(folder, f"{base}-{n}{ext}"), n + 1 + return path + + +def save_upload(filename, data): + name = safe_name(filename) + if len(data) > MAX_UPLOAD: + raise BadRequest("file is too large for a statement") + os.makedirs(UPLOADS, exist_ok=True) + tmp = os.path.join(UPLOADS, f".upload-{os.getpid()}-{threading.get_ident()}{os.path.splitext(name)[1]}") + with open(tmp, "wb") as f: + f.write(data) + try: + info = statement_info(tmp) + except Exception as e: + os.remove(tmp) + raise BadRequest(f"{filename} doesn't look like an ANZ statement ({str(e).splitlines()[0][:120]})") + if not info["count"]: + os.remove(tmp) + raise BadRequest(f"{filename} has no transactions") + for s in list_statements(): + if s.get("sha256") == info["sha256"]: + os.remove(tmp) + raise BadRequest(f"{filename} is already here as {s['name']}") + path = unique_path(UPLOADS, name) + os.replace(tmp, path) + return path + + +def rename_statement(path, new_name): + path = statement_path(path, must_manage=True) + name = safe_name(new_name) + if os.path.splitext(name)[1].lower() != os.path.splitext(path)[1].lower(): + raise BadRequest("keep the same file extension") + target = os.path.join(os.path.dirname(path), name) + if target != path and os.path.exists(target): + raise BadRequest(f"{name} already exists") + os.rename(path, target) + return target + + +def delete_statement(path): + """Move a statement into statements/.trash rather than deleting it outright.""" + path = statement_path(path, must_manage=True) + trash = os.path.join(UPLOADS, ".trash") + os.makedirs(trash, exist_ok=True) + target = unique_path(trash, os.path.basename(path)) + shutil.move(path, target) + return target + + +# --- API ---------------------------------------------------------------------- + +def api(method, path, query, body): + q = lambda k: (query.get(k) or [None])[0] + + if method == "GET" and path == "/api/config": + return {"can_open": shutil.which("xdg-open") is not None} + if method == "GET" and path == "/api/books": + return list_books() + if method == "POST" and path == "/api/books": + name = body.get("name", "").strip() + if not name.endswith(".ods"): + name += ".ods" + if os.path.basename(name) != name or name == "template.ods": + raise BadRequest("invalid book name") + balance = body.get("opening_balance") + try: + create_book(os.path.join(BOOKS, name), int(body["year"]), + float(balance) if balance not in (None, "") else None, + open_fn=office.open) + except FileExistsError as e: + raise BadRequest(str(e)) + return {"name": name} + + if method == "GET" and path == "/api/summary": + with office.open(book_path(q("book")), read_only=True) as doc: + return cashbook.read_summary(doc) + if method == "GET" and path == "/api/month": + sheet = q("sheet") + if sheet not in cashbook.FY_ORDER: + raise BadRequest("invalid sheet") + with office.open(book_path(q("book")), read_only=True) as doc: + return cashbook.read_month(doc, sheet) + if method == "POST" and path == "/api/row": + if body.get("sheet") not in cashbook.FY_ORDER: + raise BadRequest("invalid sheet") + book = book_path(body.get("book")) + with office.open(book) as doc: + try: + cashbook.update_row(doc, body["sheet"], int(body["row"]), + gst=body.get("gst"), category=body.get("category")) + except ValueError as e: + raise BadRequest(str(e)) + doc.store() + return cashbook.read_month(doc, body["sheet"]) + if method == "POST" and path == "/api/open": + subprocess.Popen(["xdg-open", book_path(body.get("book"))], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + return {"ok": True} + + if method == "GET" and path == "/api/statements": + return list_statements(q("book") or None) + if method == "GET" and path == "/api/statement": + p = statement_path(q("path")) + parsed = _parse(p) + if not parsed["txns"]: + raise BadRequest(parsed["info"].get("error") or "no transactions") + if q("book"): + with office.open(book_path(q("book")), read_only=True) as doc: + return {"info": parsed["info"], "transactions": cashbook.plan_import(doc, parsed["txns"])} + return {"info": parsed["info"], "transactions": [ + {"date": t["date"].isoformat(), "reference": describe(t), "amount": t["amount"]} + for t in sorted(parsed["txns"], key=lambda t: t["date"])]} + if method == "POST" and path == "/api/statement/rename": + return {"path": rename_statement(body.get("path"), body.get("name", ""))} + if method == "POST" and path == "/api/statement/delete": + delete_statement(body.get("path")) + return {"ok": True} + if method == "POST" and path == "/api/preview": + paths = statement_paths(body.get("statements")) + txns = [t for p in paths for t in read_statement(p)] + with office.open(book_path(body.get("book")), read_only=True) as doc: + return cashbook.plan_import(doc, txns) + if method == "POST" and path == "/api/import": + paths = statement_paths(body.get("statements")) + txns = [t for p in paths for t in read_statement(p)] + book = book_path(body.get("book")) + with office.open(book) as doc: + try: + result = cashbook.import_transactions(doc, txns, bool(body.get("force"))) + except cashbook.YearMismatch as e: + raise BadRequest(f"{e}. Tick 'import anyway' to import regardless.") + backup(book) + doc.store() + return [{"sheet": k, "added": a, "total": t} for k, (a, t) in result.items()] + + return None + + +class Handler(BaseHTTPRequestHandler): + def log_message(self, fmt, *args): + pass + + def _send(self, status, data, ctype="application/json"): + payload = data if isinstance(data, bytes) else json.dumps(data).encode() + self.send_response(status) + self.send_header("Content-Type", ctype) + self.send_header("Content-Length", str(len(payload))) + self.send_header("Cache-Control", "no-store") + self.end_headers() + self.wfile.write(payload) + + def _handle(self, method): + url = urlparse(self.path) + if method == "GET" and url.path in ("/", "/index.html"): + with open(os.path.join(HERE, "static", "index.html"), "rb") as f: + return self._send(200, f.read(), "text/html; charset=utf-8") + length = int(self.headers.get("Content-Length") or 0) + raw = self.rfile.read(length) if length else b"" + try: + if method == "GET" and url.path == "/api/statement/file": + p = statement_path(parse_qs(url.query).get("path", [""])[0]) + with open(p, "rb") as f: + data = f.read() + self.send_response(200) + self.send_header("Content-Type", "application/pdf" if p.lower().endswith(".pdf") else "text/csv") + self.send_header("Content-Disposition", f'attachment; filename="{os.path.basename(p)}"') + self.send_header("Content-Length", str(len(data))) + self.end_headers() + return self.wfile.write(data) + if method == "POST" and url.path == "/api/upload": + name = parse_qs(url.query).get("filename", [""])[0] + path = save_upload(name, raw) + return self._send(200, {"path": path}) + body = json.loads(raw or b"{}") if method == "POST" else {} + result = api(method, url.path, parse_qs(url.query), body) + if result is None: + return self._send(404, {"error": "not found"}) + self._send(200, result) + except (BadRequest, BookLocked, KeyError, ValueError) as e: + self._send(400, {"error": str(e)}) + except Exception as e: + traceback.print_exc() + self._send(500, {"error": str(e)}) + + def do_GET(self): + self._handle("GET") + + def do_POST(self): + # only accept requests from our own page + origin = self.headers.get("Origin") + if origin and urlparse(origin).hostname not in ("127.0.0.1", "localhost"): + return self._send(403, {"error": "forbidden"}) + self._handle("POST") + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + ap.add_argument("--host", default="127.0.0.1", + help="address to listen on (0.0.0.0 inside Docker)") + ap.add_argument("--port", type=int, default=8765) + ap.add_argument("--data", default=os.path.join(ROOT, "data"), + help="folder holding the cashbooks and statements/") + ap.add_argument("--statements", action="append", default=[], + help="extra folder to look for statements in") + args = ap.parse_args() + global BOOKS, UPLOADS + BOOKS = os.path.abspath(os.path.expanduser(args.data)) + UPLOADS = os.path.join(BOOKS, "statements") + STATEMENT_DIRS[:] = [UPLOADS, BOOKS, os.path.expanduser("~/Downloads/anz")] + STATEMENT_DIRS.extend(os.path.abspath(os.path.expanduser(d)) for d in args.statements) + + # stop LibreOffice too when the server is killed + signal.signal(signal.SIGTERM, lambda *_: sys.exit(0)) + server = ThreadingHTTPServer((args.host, args.port), Handler) + print(f"Cashbook running at http://{args.host}:{args.port}", flush=True) + try: + server.serve_forever() + except KeyboardInterrupt: + pass + finally: + office.stop() + + +if __name__ == "__main__": + main()