TimberBot – commitdiff

+                    GNU GENERAL PUBLIC LICENSE

+                       Version 3, 29 June 2007

+

+ Copyright (C) 2007 Free Software Foundation, Inc. <https://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 <https://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

+<https://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

+<https://www.gnu.org/licenses/why-not-lgpl.html>.

+Copyright Mathias Bynens <https://mathiasbynens.be/>

+

+Permission is hereby granted, free of charge, to any person obtaining

+a copy of this software and associated documentation files (the

+"Software"), to deal in the Software without restriction, including

+without limitation the rights to use, copy, modify, merge, publish,

+distribute, sublicense, and/or sell copies of the Software, and to

+permit persons to whom the Software is furnished to do so, subject to

+the following conditions:

+

+The above copyright notice and this permission notice shall be

+included in all copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+# TimberBot

+

+*TimberBot* is a chat bot written in Python that features a plugin-based architecture and is geared towards use on the Twitch.tv platform.

+

+This is a project that has grown and diminished slowly over the years. It started in 2014 as a small query-response bot for one specific Twitch channel, then grew to a flexible bot service framework spanning two handfuls of channels across Twitch, Hitbox, Picarto and Discord, before contracting back down to a simplified version that's reasonably easy to self-host for your own Twitch chat. If you are looking for a technical reason to choose this bot over competing products, there probably isn't any. I just want to publish the code I've written to allow people to reuse it. It never achieved the stability it needed to become a full-fledged service, but maybe it'll find its niche as a self-hostable open source project that's easy to extend. Use at your own risk.

+

+Basic things you should know if you want to self-host TimberBot:

+

+* The main way to configure it is through the chat itself. Chat commands are used to enable and disable functionality, to change configuration settings, and virtually all other admin tasks. There is no graphical interface.

+* Almost all user-facing functionality is contained in plugins that can be enabled and disabled individually.

+

+Project website: <https://fietkau.software/timberbot>

+

+## Requirements

+

+TimberBot requires a reasonably recent Python 3 along with the `websocket` package. More packages may be required depending on the plugins you choose to enable. It feels at home on Linux, but should be OS-agnostic (albeit untested).

+

+## Installation

+

+From a fresh copy of the repository, you should be able to run `timberbot.py` through Python 3 to check whether your Python environment is supported. If you are missing any required packages, it'll tell you right away. If not, it will try (and fail) to connect to the Twitch chat from the example configuration. Whenever it hangs, it can be interrupted using Ctrl+C.

+

+### Connecting to Chat

+

+To connect your bot to Twitch chat, you will need an OAuth access token. The process to create one is a bit of a pain in the rear. First you need to [register your bot as a new Twitch app](https://dev.twitch.tv/docs/authentication/register-app). Unless you coincidentally have a self-hosted Twitch app token generator ready to go, you can set the redirect URL to `https://localhost:3000` as [this tutorial](https://dev.twitch.tv/docs/irc/authenticate-bot) recommends at the time of writing. Mainly you need to acquire your bot's **Client ID** before you can proceed. With the Client ID in hand, you can follow the second tutorial I just linked (the "for testing chat functionality" part) to acquire your OAuth token from your redirect URL. It will look like a long-ish random alphanumeric string. Whatever Twitch account you are logged into when you do this, that will be the Twitch account that the bot will appear as. If you want to register a custom Twitch account for it, you can, or you can just use your streamer account.

+

+Next, edit `config.ini` in a text editor of your choice. In the `[main]` section, change `nick` to the name of the Twitch account you want to use for your bot. This must match the account that owns the OAuth token you just created. Change `password` to your OAuth token, keeping the `oauth:` prefix. Change `channel` to your Twitch channel name, i.e. the chat where you want the bot to appear, and `admins` to your own Twitch account name (and a space-separated list of other bot admins if desired). Everything else can be left as-is for now.

+

+Now run `timberbot.py` again. If everything is correct, the bot should log in and appear in your chat. Any chat messages you type should appear in the Python window. You can use the "!about" command to test whether it can post messages of its own.

+

+### Enabling and Disabling Plugins

+

+**Note: Never edit `config.ini` while your bot is running. It will almost certainly overwrite your changes. TimberBot makes changes to the config file as needed while it is running and keeps an internal copy for that purpose.**

+

+You should be good to go to test some basic functionality now. Try putting `!plugins` in chat to get a list of plugins that are currently enabled as well as a list of the ones that are additionally available. Type `!enable announcements` to enable the announcements plugin. If you get any errors here, they should be investigated and fixed before you proceed.

+

+You'll find that the current list matches the `plugins` entry in your config file. As you make changes to the configuration, you should see your `config.ini` file update itself. When the bot is not running, you can also edit the list of enabled plugins through the config file. Please note that the order may matter: some plugins depend on others, for example the `stream_tracking` plugin depends on the `stream_platform_twitch` one. If you want to make sure you enable them in a working order, you need to do it one by one through the chat interface, which will respond with an error message if something does not work.

+

+What you do from here on is up to you. Most of the plugins are not documented, so your best bet is probably to experiment with whatever seems interesting, especially at the beginning when you have nothing to lose yet. Plugins should generally not be able crash the entire bot, even if you do something wrong.

+

+### Optional: Connect Your Bot to the Twitch API

+

+So far your bot can interact with chat messages, but not much else. To access more Twitch integration functionality, such as follower alerts or stream game tracking, we're going to need to mess with more access tokens. If your bot is still running, shut it down for this.

+

+In the default `config.ini`, there is a pre-populated section for the `stream_platform_twitch` plugin. Change `channel` to your channel name, `client_id` to your bot's Client ID from earlier, and `client_secret` to your bot's client secret. We have not needed that last one so far, but you can access it [in the developer portal](https://dev.twitch.tv/console/apps) alongside the Client ID. As the website notes, you can generate a new secret whenever you want (invalidating any previous ones), but the website will only show it one time, so make sure to store it safely and never expose it to the public.

+

+With the changes to the configuration made, start your bot and enable the `stream_platform_twitch` plugin. Watch the Python console window for any errors. If there are none, you should see some added configuration parameters in your config file afterwards. Your bot is now connected to the Twitch API and you can enable plugins like `stream_tracking` and `stream_game`.

+

+## Valuable Knowledge

+

+This is a list of unsorted bits of information that seem worth knowing, but do not have a good place in the above introduction.

+

+* In the config file, you can change the data directory from the default to a different path anywhere on your system. The data directory is where plugins will save all their persistent files.

+* The bot provides a `!help` command that lists all currently enabled commands. You can get help text for a specific command by typing `!help commandname`.

+* The default command prefix is the exclamation mark "!" but you can change this to whatever you want, including multi-character words, in the config file. Spaces act as separators for multiple alternatives.

+* From practical experience, the bot seems to sometimes silently lose the connection to the chat and miss out on messages. The only way I ever came up with to fix this is to kill and restart the `timberbot.py` script. If you run your bot as a 24/7 service, consider implementing an automatic kill switch every 24 hours at some time you are unlikely to be streaming.

+* Instead of editing the config file while the bot is stopped, you can also use the `!conf` command (restricted to bot admins) to read or write any configuration setting including plugin settings by specifying a section name, a setting name, and optionally a new value.

+* Plugins are Python files that can be modified and shared between TimberBot users. **Plugins are not sandboxed, they have full access to your system and may take any action on your behalf. Do not install or use plugins provided by people you would not trust with your computer.**

+* If you'd like to separate the config file from the bot's Python code, you can provide a path to a different config file as a command line parameter to the `timberbot.py` script. This way you can use the same copy of the bot code to run multiple bot instances.

+

+## License

+

+*TimberBot* (c) 2014-2022 [Julian Fietkau](https://fietkau.me)

+

+The bot itself consisting of all Python files in the root directory is using the GPLv3 (or later) license. The plugins inside their directory are all using the MIT license to make it easier to create derivative works.

+

+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. See LICENSE-GPLv3 for details.

+[main]

+data_directory = ./data

+nick = YourBotNickname

+password = oauth:...

+channel = YourChannelName

+admins = YourChannelName SecondAdmin ThirdAdmin

+plugins = coinflip dice raffle

+command_prefixes = !

+mute = false

+on_error = resume

+

+[stream_platform_twitch]

+channel = YourChannelName

+client_id = your client ID here

+client_secret = your client secret here

+

+This is the default directory for bot runtime data stored by plugins. Make sure the python process running the bot can write to this directory. You can also change the path via the config.ini file.

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: GPL-3.0-or-later

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2014-2022 Julian Fietkau

+

+import plugin_manager

+

+class Parser:

+    def __init__(self, data_dir, send_callback, reply_callback, config_calls, special_action_call):

+        self.data_dir = data_dir

+        self.send_callback = send_callback

+        self.reply_callback = reply_callback

+        self.config_calls = config_calls

+        self.special_action = special_action_call

+

+        self.storage = {'names': {}, 'ignore_list': []}

+        self.storage['ignore_list'] = self.get_conf('main', 'ignore_list', '').split(' ')

+

+        self.bot_name = self.get_conf('main', 'nick')

+        plugins = self.get_conf('main', 'plugins')

+        if plugins == None:

+            plugins = 'names'

+        plugins = plugins.split(' ')

+        self.command_prefixes = self.get_conf('main', 'command_prefixes').split(' ')

+        if not self.command_prefixes:

+            self.command_prefixes = ['!']

+            self.set_conf('main', 'command_prefixes', '!')

+        self.plugin_manager = plugin_manager.PluginManager(self.data_dir, lambda message: self.send(message), lambda user, message: self.reply(user, message), self.config_calls, self.special_action, lambda: self.get_users())

+        self.plugin_manager.enable_plugins(*plugins)

+

+    def get_users(self, including_offline = False):

+        if including_offline:

+            names = [self.storage['names'][n]['name'] for n in self.storage['names']]

+        else:

+            names = [self.storage['names'][n]['name'] for n in self.storage['names'] if self.storage['names'][n]['status'] in ['online', 'prelim-online']]

+        if self.bot_name in names:

+            names.remove(self.bot_name)

+        return names

+

+    def get_conf(self, category, key, default = None):

+        if not isinstance(default, str):

+            default = str(default).lower()

+        value = self.config_calls['get'](category, key, default)

+        if category == 'main' and key in ['admins']:

+            result = [name.strip() for name in value.split(' ') if name != 'none']

+            return result

+        result = value

+        if value.lower() == 'none':

+            result = None

+        if value.lower() in ['true', 'yes', 'on']:

+            result = True

+        if value.lower() in ['false', 'no', 'off']:

+            result = False

+        return result

+

+    def set_conf(self, category, key, value):

+        if category == 'main' and key in ['admins']:

+            value.sort()

+            value = ' '.join(value)

+        if value in [None, '']:

+            value = 'none'

+        if value == True:

+            value = 'true'

+        if value == False:

+            value = 'false'

+        value = self.config_calls['set'](category, key, value)

+

+    def send(self, message, to_user = None):

+        if not self.get_conf('main', 'mute'):

+            self.send_callback(message)

+

+    def reply(self, user, message):

+        if not self.get_conf('main', 'mute'):

+            self.reply_callback(user, message)

+

+    def split_command(self, message):

+        result = []

+        is_command = False

+        for command_prefix in self.command_prefixes:

+            if message.startswith(command_prefix):

+                is_command = True

+                message = message[len(command_prefix):]

+                break

+        if not is_command:

+            return result

+        current = ''

+        index = 0

+        protected = False

+        while index < len(message):

+            char = message[index]

+            if char == ' ' and not protected:

+                if len(current) > 0:

+                    if current[-1] == ',':

+                        current = current[:-1]

+                    result.append(current)

+                    current = ''

+            elif char in ['"', '\''] and not protected:

+                protected = char

+            elif char == protected:

+                protected = False

+            else:

+                current = current + char

+            index = index + 1

+        if len(current) > 0:

+            if current[-1] == ',':

+                current = current[:-1]

+            result.append(current)

+        return result

+

+    def display_name(self, user):

+        if user.lower() not in self.storage['names'] or (user.lower() in self.storage['names'] and user.lower() == self.storage['names'][user.lower()]['name']):

+            if user.lower() not in self.storage['names']:

+                self.storage['names'][user.lower()] = {'name': user, 'status': None}

+            else:

+                self.storage['names'][user.lower()]['name'] = user

+        if user != user.lower() and user != self.storage['names'][user.lower()]['name']:

+            self.storage['names'][user.lower()]['name'] = user

+        return self.storage['names'][user.lower()]['name']

+

+    def special_event(self, event_type, params):

+        if event_type == 'ME':

+            user = params['user']

+            message = params['message']

+            if user.lower() == self.bot_name.lower() or len(message) == 0:

+                return

+            user = self.display_name(user)

+            params['user'] = user

+            self.plugin_manager.special_event(event_type, params)

+

+    def is_admin(self, user, params):

+        result = False

+        if self.get_conf('main', 'mods_as_admins') and params['mod']:

+            result = True

+        if user.lower() in self.get_conf('main', 'admins'):

+            result = True

+        return result

+

+    def parse(self, user, message, params):

+

+        if user.lower() == self.bot_name.lower() or len(message) == 0:

+            return

+        self.channel_join(user, False, 'prelim-online')

+

+        user = self.display_name(user)

+

+        is_command = False

+        for command_prefix in self.command_prefixes:

+            if message.startswith(command_prefix):

+                is_command = True

+                break

+

+        if not is_command:

+            if self.is_admin(user, params):

+                self.plugin_manager.admin_message_read(user, message)

+            self.plugin_manager.message_priority_read(user, message)

+            if user.lower() not in self.storage['ignore_list']:

+                self.plugin_manager.message_read(user, message)

+

+        if is_command:

+

+            reserved_commands = ['about', 'help']

+            all_commands = reserved_commands + self.plugin_manager.get_provided_commands()

+            all_commands.sort()

+

+            command = self.split_command(message)

+

+            raw_params = ''

+            if message.find(' ') != -1:

+                raw_params = message[message.index(' ')+1:]

+

+            self.plugin_manager.command_priority_read(user, command, raw_params)

+            if user.lower() in self.storage['ignore_list']:

+                return

+            if command[0] in self.plugin_manager.get_provided_commands() and command[0] not in reserved_commands:

+                self.plugin_manager.command_read(user, command, raw_params)

+                return

+

+            if command[0] == 'about':

+                if self.bot_name == 'TimberBot':

+                    about = 'I am TimberBot, a chat bot written in Python by Julian Fietkau.'

+                else:

+                    about = 'I am ' + self.bot_name + ', a chat bot based on TimberBot by Julian Fietkau.'

+                self.reply(user, about + ' See https://fietkau.software/timberbot for further information.')

+                return

+

+            if command[0] == 'help':

+                if len(command) == 1:

+                    command_list = ['help']

+                    command_list += list(self.plugin_manager.get_help_text().keys())

+                    command_list.sort()

+                    command_list_text = ' - '.join([self.command_prefixes[0] + cmd for cmd in command_list])

+                    self.reply(user, 'Main commands are: ' + command_list_text + '. Type "' + self.command_prefixes[0] + 'help commandname" for details (e.g. "' + self.command_prefixes[0] + 'help ' + command_list[0] + '"). Type "' + self.command_prefixes[0] + 'help commands" for a full command list.')

+                if len(command) >= 2:

+                    if command[1] == 'commands':

+                        command_list = ['about', 'help']

+                        command_list = command_list + self.plugin_manager.get_provided_commands()

+                        command_list.sort()

+                        command_list_text = ' - '.join([self.command_prefixes[0] + cmd for cmd in command_list])

+                        self.reply(user, command_list_text)

+                    elif command[1] == 'help':

+                        self.reply(user, 'The ' + self.command_prefixes[0] + 'help command provides usage directions for any active command provided by a plugin. Type "' + self.command_prefixes[0] + 'help commandname" for details, or just "' + self.command_prefixes[0] + 'help" to get a list of commands that have help text available.')

+                    elif command[1] in self.plugin_manager.get_help_text():

+                        self.reply(user, self.plugin_manager.get_help_text()[command[1]])

+                return

+

+            if command[0] == 'admin':

+                if self.is_admin(user, params):

+                    if len(command) > 1:

+                        command = command[1:]

+                        raw_params = raw_params[raw_params.index(' ')+1:]

+                    else:

+                        return

+                else:

+                    self.reply(user, 'Only ' + self.bot_name + ' admins can do that.')

+

+            if not self.is_admin(user, params):

+                return

+

+            # From this point onward, it is guaranteed that the user is a bot admin (else the method has already returned).

+

+            if command[0] in self.plugin_manager.get_provided_admin_commands():

+                if self.is_admin(user, params):

+                    self.plugin_manager.admin_command_read(user, command, raw_params)

+

+            core_admin_commands = ['add', 'remove', 'enable', 'disable', 'reload', 'flush_names', 'mute', 'unmute', 'ignore', 'conf', 'plugins']

+            if command[0] in core_admin_commands:

+

+                if command[0] == 'add' and len(command) >= 2:

+                    admins = self.get_conf('main', 'admins')

+                    successes = []

+                    for user_name in command[1:]:

+                        if user_name.lower() not in admins:

+                            admins.append(user_name.lower())

+                            successes.append(user_name)

+                        else:

+                            self.reply(user, self.display_name(user_name) + ' is already an administrator.')

+                    self.set_conf('main', 'admins', admins)

+                    if len(successes) == 1:

+                        self.reply(user, 'Added ' + successes[0] + ' as an administrator.')

+                    if len(successes) > 1:

+                        self.reply(user, 'Added ' + ', '.join(successes) + ' as administrators.')

+

+                if command[0] == 'remove' and len(command) >= 2:

+                    admins = self.get_conf('main', 'admins')

+                    successes = []

+                    for user_name in command[1:]:

+                        if user_name.lower() in admins and user_name.lower() != user.lower():

+                            admins.remove(user_name.lower())

+                            successes.append(user_name)

+                        elif user_name.lower() in admins and user_name.lower() == user.lower():

+                            self.reply(user, 'You cannot remove yourself.')

+                        else:

+                            self.reply(user, self.display_name(user_name) + ' is not an administrator.')

+                    self.set_conf('main', 'admins', admins)

+                    if len(successes) >= 1:

+                        self.reply(user, 'Removed ' + ', '.join(successes) + ' from administrator list.')

+

+                if command[0] == 'enable' and len(command) >= 2:

+                    for plugin_name in command[1:]:

+                        if plugin_name not in self.plugin_manager.active_plugins:

+                            self.plugin_manager.scan_plugins()

+                            if plugin_name in self.plugin_manager.available_plugins:

+                                try:

+                                    status = self.plugin_manager.enable_plugins(plugin_name)

+                                    if status == 0:

+                                        self.reply(user, 'Enabled ' + plugin_name + ' plugin.')

+                                except RuntimeError as error:

+                                    self.reply(user, str(error))

+                            else:

+                                self.reply(user, 'Plugin ' + plugin_name + ' not found.')

+                        else:

+                            self.reply(user, 'Plugin ' + plugin_name + ' is already enabled.')

+

+                if command[0] == 'disable' and len(command) >= 2:

+                    for plugin_name in command[1:]:

+                        if plugin_name in self.plugin_manager.active_plugins:

+                            try:

+                                status = self.plugin_manager.disable_plugins(plugin_name)

+                                if status == 0:

+                                    self.reply(user, 'Disabled ' + plugin_name + ' plugin.')

+                            except RuntimeError as error:

+                                self.reply(user, str(error))

+                        else:

+                            self.reply(user, 'Plugin ' + plugin_name + ' is not enabled.')

+

+                if command[0] == 'reload' and len(command) >= 2:

+                    for plugin_name in command[1:]:

+                        if plugin_name in self.plugin_manager.active_plugins:

+                            self.plugin_manager.reload_plugins(plugin_name)

+                            self.reply(user, 'Reloaded ' + plugin_name + ' plugin.')

+                        else:

+                            self.reply(user, 'Plugin ' + plugin_name + ' is not enabled.')

+

+                if command[0] == 'plugins':

+                    print_lists = ['active', 'additional']

+                    if len(command) >= 2 and command[1] == 'active':

+                        print_lists = ['active']

+                    if len(command) >= 2 and command[1] == 'additional':

+                        print_lists = ['additional']

+                    if len(command) >= 2 and command[1] == 'all':

+                        print_lists = ['all']

+                    if 'active' in print_lists:

+                        self.reply(user, 'Active plugins: ' + ', '.join(sorted(self.plugin_manager.active_plugins.keys())))

+                    if 'additional' in print_lists:

+                        additional_plugins = [plugin for plugin in self.plugin_manager.available_plugins if plugin not in self.plugin_manager.active_plugins]

+                        self.reply(user, 'Additionally available plugins: ' + ', '.join(sorted(additional_plugins)))

+                    if 'all' in print_lists:

+                        self.reply(user, 'All available plugins: ' + ', '.join(sorted(self.plugin_manager.available_plugins)))

+

+                if command[0] == 'mute':

+                    self.reply(user, 'The bot is now muted and will send no more messages until an admin uses the "unmute" command.')

+                    self.set_conf('main', 'mute', True)

+                if command[0] == 'unmute':

+                    self.set_conf('main', 'mute', False)

+                    self.reply(user, 'The bot is now unmuted and will send messages as normal.')

+

+                if command[0] == 'ignore':

+                    if len(command) > 1:

+                        additions = []

+                        removals = []

+                        for name in command[1:]:

+                            if name.lower() in self.storage['ignore_list']:

+                                self.storage['ignore_list'].remove(name)

+                                removals.append(name)

+                            else:

+                                self.storage['ignore_list'].append(name)

+                                additions.append(name)

+                        reply = ''

+                        if len(additions) > 0:

+                            reply += 'Added ' + ', '.join(additions) + ' to the ignore list. '

+                        if len(removals) > 0:

+                            reply += 'Removed ' + ', '.join(removals) + ' from the ignore list. '

+                        if len(reply) > 0:

+                            reply = reply[:-1]

+                            self.reply(user, reply)

+                            self.set_conf('main', 'ignore_list', self.storage['ignore_list'].join(' '))

+

+                if command[0] == 'flush_names':

+                    for name in self.storage['names']:

+                        if self.storage['names'][name]['status'] in ['online', 'prelim-online'] and name.lower() != self.bot_name:

+                            self.storage['names'][name]['status'] = 'offline'

+                    self.reply(user, 'Chatter list flushed.')

+

+                if command[0] == 'conf':

+                    if len(command) < 3:

+                        return

+                    if len(command) == 3:

+                        result = self.get_conf(command[1].lower(), command[2].lower())

+                        if type(result) == list:

+                            result = ', '.join(result)

+                        self.reply(user, 'Configuration for "' + command[1].lower() + ' -> ' + command[2].lower() + '" is "' + str(result) + '".')

+                        return

+                    if command[3].lower() in ['true', 'yes', 'on', '1']:

+                        command[3] = True

+                    elif command[3].lower() in ['false', 'no', 'off', '0']:

+                        command[3] = False

+                    self.set_conf(command[1].lower(), command[2].lower(), command[3])

+                    self.reply(user, 'Configuration for "' + command[1].lower() + ' -> ' + command[2].lower() + '" is now "' + str(command[3]) + '".')

+

+    def scheduled_update(self):

+        self.plugin_manager.check_schedule()

+

+    def channel_join(self, name, batch = False, newstatus = 'online'):

+        if len(name) > 0 and name[0] in ['@', '+', '!', '%']:

+            name = name[1:]

+

+        new_name = self.display_name(name)

+        if isinstance(new_name, str):

+            name = new_name

+        if name.lower() not in self.storage['names']:

+            self.storage['names'][name.lower()] = {}

+            self.storage['names'][name.lower()]['name'] = name

+            self.storage['names'][name.lower()]['status'] = None

+        if self.storage['names'][name.lower()]['status'] != newstatus:

+            if newstatus == 'prelim-online' and self.storage['names'][name.lower()]['status'] == 'online':

+                return

+            if self.storage['names'][name.lower()]['status'] in [None, 'offline']:

+                if name.lower() not in self.storage['ignore_list']:

+                    self.plugin_manager.user_join(name, batch)

+            self.storage['names'][name.lower()]['status'] = newstatus

+

+    def channel_part(self, name, batch = False):

+        if len(name) > 0 and name[0] in ['@', '+', '!', '%']:

+            name = name[1:]

+        if name.lower() == self.bot_name.lower():

+            return

+        if name.lower() not in self.storage['names']:

+            self.storage['names'][name.lower()] = {}

+            self.storage['names'][name.lower()]['name'] = None

+            self.storage['names'][name.lower()]['status'] = None

+        if self.storage['names'][name.lower()]['status'] in [None, 'online', 'prelim-online']:

+            new_name = self.display_name(name)

+            if isinstance(new_name, str):

+                name = new_name

+            self.storage['names'][name.lower()]['status'] = 'offline'

+            if name.lower() not in self.storage['ignore_list']:

+                self.plugin_manager.user_part(name, batch)

+

+    def update_names(self, names_list, silent, adding = False):

+        names = []

+        for name in names_list:

+            if len(name) > 0 and name[0] in ['@', '+', '!', '%']:

+                name = name[1:]

+            if len(name) > 0 and name.lower() != self.bot_name.lower():

+                names.append(name)

+        if len(names) <= 1 or adding:

+            return

+        for name in self.storage['names']:

+            if name.lower() not in [n.lower() for n in names]:

+                if self.storage['names'][name.lower()]['status'] in ['online', 'prelim-online']:

+                    self.channel_part(name, True)

+        for name in names:

+            if name.lower() in self.storage['names'] and 'status' in self.storage['names'][name.lower()] and self.storage['names'][name.lower()]['status'] == 'prelim-online':

+                self.storage['names'][name.lower()]['status'] = 'online'

+            else:

+                # At this point we know that name is someone currently in chat.

+                # self.channel_join does the check whether it is someone new itself.

+                self.channel_join(name, True)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: GPL-3.0-or-later

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2014-2022 Julian Fietkau

+

+import os

+

+class TimberBotPlugin:

+

+    # This class is the based that all plugins inherit from. Hence the following is

+    # the list of bot API methods usable by plugins.

+

+    def __init__(self, plugin_name, callback_helper):

+        self.name = plugin_name

+        self.callback_helper = callback_helper

+

+    def message(self, message):

+        self.callback_helper.message(message)

+

+    def reply(self, user, message):

+        self.callback_helper.reply(user, message)

+

+    def moderate(self, user, moderation_data):

+        self.callback_helper.reply(user, moderation_data)

+

+    def bot_name(self):

+        return self.callback_helper.get_bot_name()

+

+    def format_command(self, *command):

+        return self.callback_helper.format_command(*command)

+

+    def pretty_interval(self, seconds):

+        return self.callback_helper.pretty_interval(seconds)

+

+    def get_users(self):

+        return self.callback_helper.get_users()

+

+    def get_storage_directory(self):

+        return self.callback_helper.get_storage_directory(self.name)

+

+    def get_conf(self, option, default = None):

+        return self.callback_helper.get_conf(self.name, option, default)

+

+    def set_conf(self, option, value):

+        self.callback_helper.set_conf(self.name, option, value)

+

+    def load_data(self, key, default = None):

+        return self.callback_helper.load_data(self.name, key, default)

+

+    def save_data(self, key, data):

+        self.callback_helper.save_data(self.name, key, data)

+

+    def command_read(self, user, argv, raw):

+        pass

+

+    def command_priority_read(self, user, argv, raw):

+        pass

+

+    def admin_command_read(self, user, argv, raw):

+        pass

+

+    def special_event(self, event_type, params):

+        pass

+

+    def admin_message_read(self, user, message):

+        pass

+

+    def message_read(self, user, message):

+        pass

+

+    def message_priority_read(self, user, message):

+        pass

+

+    def user_join(self, user, batch_mode = False):

+        pass

+

+    def user_part(self, user, batch_mode = False):

+        pass

+

+    def startup(self):

+        pass

+

+    def shutdown(self):

+        pass

+

+    def scheduled_update(self):

+        pass

+

+    def request_scheduled_update(self, days = 0, hours = 0, minutes = 0, seconds = 0):

+        self.callback_helper.request_scheduled_update(self.name, days, hours, minutes, seconds)

+

+    def provides_commands(self):

+        return []

+

+    def provides_admin_commands(self):

+        return []

+

+    def provides_functions(self):

+        return []

+

+    def requires_functions(self):

+        return []

+

+    def call_function(self, function_name, *parameters):

+        return self.callback_helper.call_function(function_name, *parameters)

+

+    def special_action(self, action_type, parameters):

+        return self.callback_helper.special_action(action_type, parameters)

+

+    def filter_outgoing_message(self, message, user):

+        return None

+

+    def help_text(self):

+        return {}

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: GPL-3.0-or-later

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2014-2022 Julian Fietkau

+

+import codecs

+import configparser

+import datetime

+import imp

+import inspect

+import json

+import math

+import os

+import pytz

+import time

+

+class PluginCallbackHelper:

+

+    def __init__(self, data_dir, send_callback, reply_callback, plugin_config_callback, config_calls, special_action_call, schedule_callback, user_list_callback, call_function_callback):

+        self.send_callback = send_callback

+        self.reply_callback = reply_callback

+        self.data_dir = data_dir

+        self.plugin_config_callback = plugin_config_callback

+        self.schedule_callback = schedule_callback

+        self.user_list_callback = user_list_callback

+        self.call_function_callback = call_function_callback

+        self.special_action_call = special_action_call

+        self.config_calls = config_calls

+        self.bot_name = config_calls['get']('main', 'nick')

+        self.command_prefixes = config_calls['get']('main', 'command_prefixes')

+

+    def message(self, message):

+        self.send_callback(message)

+

+    def reply(self, user, message):

+        self.reply_callback(user, message)

+

+    def special_action(self, action_type, params = {}):

+        self.special_action_call(action_type, params)

+

+    def request_scheduled_update(self, plugin_name, days = 0, hours = 0, minutes = 0, seconds = 0):

+        self.schedule_callback(plugin_name, days, hours, minutes, seconds)

+

+    def call_function(self, function_name, *parameters):

+        return self.call_function_callback(function_name, *parameters)

+

+    def get_users(self):

+        return self.user_list_callback()

+

+    def get_storage_directory(self, plugin_name):

+        path = os.path.join(self.data_dir, plugin_name)

+        if not os.path.exists(path):

+            os.makedirs(path)

+        return path

+

+    def get_conf(self, plugin_name, option, default = None):

+        try:

+            cfg = self.plugin_config_callback(plugin_name, option)

+            default = cfg['default']

+        except ValueError:

+            pass

+        if not isinstance(default, str):

+            default = str(default).lower()

+        value = self.config_calls['get'](plugin_name, option, default)

+        result = value

+        if value.lower() == 'none':

+            result = None

+        if value.lower() in ['true', 'yes', 'on']:

+            result = True

+        if value.lower() in ['false', 'no', 'off']:

+            result = False

+        return result

+

+    def set_conf(self, plugin_name, option, value):

+        if value in [None, '']:

+            value = 'none'

+        if value == True:

+            value = 'true'

+        if value == False:

+            value = 'false'

+        value = self.config_calls['set'](plugin_name, option, value)

+

+    def load_data(self, plugin_name, key, default):

+        result = default

+        if os.path.exists(self.data_dir):

+            data_file_path = os.path.join(self.data_dir, plugin_name + '.json')

+            if os.path.isfile(data_file_path):

+                try:

+                    def deserialize(dct):

+                        if '_type' in dct and dct['_type'] == 'timberbot_datetime':

+                            return datetime.datetime.strptime(dct['_value'], '%Y-%m-%dT%H:%M:%SZ')

+                        return dct

+                    with codecs.open(data_file_path, 'r', 'utf-8') as json_fp:

+                        data = json.load(json_fp, object_hook = deserialize)

+                except ValueError:

+                    data = None

+                if data is not None and key in data:

+                    result = data[key]

+        return result

+

+    def save_data(self, plugin_name, key, data):

+        if not os.path.exists(self.data_dir):

+            os.makedirs(self.data_dir)

+        data_file_path = os.path.join(self.data_dir, plugin_name + '.json')

+        data_container = {}

+        if os.path.isfile(data_file_path):

+            try:

+                with codecs.open(data_file_path, 'r', 'utf-8') as json_fp:

+                    data_container = json.load(json_fp)

+            except ValueError:

+                data_container = {}

+        data_container[key] = data

+        def serialize(obj):

+            if isinstance(obj, datetime.datetime):

+                dt = obj

+                if dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None:

+                    dt = dt.astimezone(pytz.utc)

+                return {'_type': 'timberbot_datetime', '_value': dt.strftime('%Y-%m-%dT%H:%M:%SZ')}

+            else:

+                raise TypeError('Object of type %s with value of %s is not JSON serializable' % (type(obj), repr(obj)))

+        with codecs.open(data_file_path, 'w', 'utf-8') as json_fp:

+            json.dump(data_container, json_fp, indent = 4, default = serialize)

+

+    def format_command(self, *command):

+        result = self.command_prefixes[0] + command[0]

+        if len(command) >= 2:

+            for part in command[1:]:

+                if ' ' in part:

+                    result = result + ' "' + part + '"'

+                else:

+                    result = result + ' ' + part

+        return result

+

+    def get_bot_name(self):

+        return self.bot_name

+

+    def pretty_interval(self, seconds):

+        seconds = round(seconds)

+        days = int(math.floor(seconds / (60 * 60 * 24)))

+        seconds = seconds - (days * (60 * 60 * 24))

+        hours = int(seconds / (60 * 60))

+        seconds = seconds - (hours * (60 * 60))

+        minutes = int(seconds / 60)

+        seconds = int(seconds - (minutes * 60))

+        result = ''

+        if days > 0:

+            result = result + str(days) + ' %s' % ('day' if days == 1 else 'days')

+            if hours > 0:

+                result = result + ' and ' + str(hours) + ' %s' % ('hour' if hours == 1 else 'hours')

+            return result

+        if hours > 0:

+            result = result + str(hours) + ' %s' % ('hour' if hours == 1 else 'hours')

+            if minutes > 0:

+                result = result + ' and ' + str(minutes) + ' %s' % ('minute' if minutes == 1 else 'minutes')

+            return result

+        if minutes > 0:

+            result = result + str(minutes) + ' %s' % ('minute' if minutes == 1 else 'minutes')

+            if seconds > 0:

+                result = result + ' and ' + str(seconds) + ' %s' % ('second' if seconds == 1 else 'seconds')

+            return result

+        if seconds >= 0:

+            result = result + str(seconds) + ' %s' % ('second' if seconds == 1 else 'seconds')

+            return result

+        return result

+

+class PluginManager:

+

+    def __init__(self, data_dir, send_callback, reply_callback, config_calls, special_action_call, user_list_callback, plugin_dir = 'plugins'):

+        self.data_dir = data_dir

+        self.send_callback = send_callback

+        self.reply_callback = reply_callback

+        self.config_calls = config_calls

+        self.special_action = special_action_call

+        self.user_list_callback = user_list_callback

+        self.plugin_dir = plugin_dir

+        self.update_schedule = {}

+        self.update_schedule['interval'] = {}

+        self.update_schedule['last_update'] = {}

+

+        self.plugin_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), self.plugin_dir)

+        self.available_plugins = None

+        self.active_plugins = {}

+        self.provided_commands = []

+        self.provided_admin_commands = []

+        self.provided_functions = {}

+        self.callback_helper = PluginCallbackHelper(data_dir, self.send_message, self.send_reply, self.plugin_config_callback, config_calls, special_action_call, self.request_scheduled_update, user_list_callback, self.call_function_callback)

+        self.scan_plugins()

+

+    def scan_plugins(self):

+        self.available_plugins = []

+        for plugin_file_name in os.listdir(self.plugin_path):

+            plugin_file = os.path.join(self.plugin_path, plugin_file_name)

+            if os.path.isfile(plugin_file) and plugin_file.endswith('.py'):

+                self.available_plugins.append(plugin_file_name[:-3])

+

+    def enable_plugin(self, plugin_name):

+        plugin_file = os.path.join(self.plugin_path, plugin_name + '.py')

+        if os.path.isfile(plugin_file):

+            fp, pathname, description = imp.find_module(plugin_name, [self.plugin_path])

+            plugin_classes = []

+            try:

+                plugin_module = imp.load_module(plugin_name, fp, pathname, description)

+                plugin_classes = [ c for c in inspect.getmembers(plugin_module, inspect.isclass) if c[1].__module__ == plugin_name]

+            except Exception as e:

+                status = 'Plugin "' + plugin_name + '" crashed during module access and will not be enabled.'

+                raise RuntimeError(status)

+            for plugin_class in plugin_classes:

+                if plugin_class[0].endswith('Plugin'):

+                    try:

+                        plugin_object = plugin_class[1](plugin_name, self.callback_helper)

+                    except Exception as e:

+                        status = 'Plugin "' + plugin_name + '" crashed during instantiation and will not be enabled.'

+                        raise RuntimeError(status)

+                    conflict = None

+                    for provided_function in plugin_object.provides_functions():

+                        if provided_function in self.provided_functions:

+                            conflict = provided_function

+                            break

+                    if conflict != None:

+                        status = 'Cannot enable plugin "' + plugin_name + '" because its function "' + conflict

+                        status += '" conflicts with loaded plugin "' + self.provided_functions[conflict] + '".'

+                        raise RuntimeError(status)

+                    missing = None

+                    for required_function in plugin_object.requires_functions():

+                        if required_function not in self.provided_functions:

+                            missing = required_function

+                            break

+                    if missing != None:

+                        status = 'Cannot enable plugin "' + plugin_name + '" because it requires function "' + missing

+                        status += '" which is not provided by any loaded plugin.'

+                        raise RuntimeError(status)

+                    else:

+                        self.active_plugins[plugin_name] = plugin_object

+                        for provided_function in plugin_object.provides_functions():

+                            self.provided_functions[provided_function] = plugin_name

+                        try:

+                            plugin_object.startup()

+                        except Exception as e:

+                            del self.active_plugins[plugin_name]

+                            for provided_function in self.provided_functions:

+                                if self.provided_functions[provided_function] == plugin_name:

+                                    del self.provided_functions[provided_function]

+                            if plugin_name in self.update_schedule['interval']:

+                                del self.update_schedule['interval'][plugin_name]

+                            if plugin_name in self.update_schedule['last_update']:

+                                del self.update_schedule['last_update'][plugin_name]

+                            status = 'Plugin "' + plugin_name + '" crashed during startup and will not be enabled.'

+                            raise RuntimeError(e)

+

+    def disable_plugin(self, plugin_name):

+        if plugin_name in self.update_schedule['interval']:

+            del self.update_schedule['interval'][plugin_name]

+        if plugin_name in self.update_schedule['last_update']:

+            del self.update_schedule['last_update'][plugin_name]

+        if plugin_name in self.active_plugins:

+            for provided_function in self.provided_functions:

+                if self.provided_functions[provided_function] == plugin_name:

+                    del self.provided_functions[provided_function]

+            plugin_obj = self.active_plugins[plugin_name]

+            del self.active_plugins[plugin_name]

+            try:

+                plugin_obj.shutdown()

+            except Exception as e:

+                status = 'Plugin "' + plugin_name + '" crashed during shutdown.'

+                raise RuntimeError(status)

+

+    def enable_plugins(self, *plugins):

+        messages = []

+        for plugin_name in plugins:

+            try:

+                self.enable_plugin(plugin_name)

+            except RuntimeError as e:

+                messages.append(str(e))

+        for message in messages:

+            self.send_callback(message)

+        return len(messages)

+

+    def disable_plugins(self, *plugins):

+        messages = []

+        for plugin_name in plugins:

+            try:

+                self.disable_plugin(plugin_name)

+            except RuntimeError as e:

+                messages.append(str(e))

+        for message in messages:

+            self.send_callback(message)

+        return len(messages)

+

+    def reload_plugins(self, *plugins):

+        reload_list = []

+        for plugin_name in plugins:

+            if plugin_name in self.active_plugins:

+                reload_list.append(plugin_name)

+        if len(reload_list) > 0:

+            self.disable_plugins(*plugins)

+            self.enable_plugins(*plugins)

+

+    def get_provided_commands(self):

+        provided_commands = []

+        for plugin in self.active_plugins.values():

+            provided_commands += plugin.provides_commands()

+        return provided_commands

+

+    def get_provided_admin_commands(self):

+        provided_admin_commands = []

+        for plugin in self.active_plugins.values():

+            provided_admin_commands += plugin.provides_admin_commands()

+        return provided_admin_commands

+

+    def get_help_text(self):

+        help_text = {}

+        for plugin in self.active_plugins.values():

+            help_text.update(plugin.help_text())

+        return help_text

+

+    def plugin_config_callback(self, plugin_name, option_name):

+        props = type(self.active_plugins[plugin_name])

+        for option in props.config:

+            if option['name'] == option_name:

+                return option

+        raise ValueError('Invalid config option "' + option_name + '" requested for plugin "' + plugin_name + '".')

+

+    def request_scheduled_update(self, plugin_name, days, hours, minutes, seconds):

+        if not plugin_name in self.active_plugins:

+            return

+        interval = ((((days * 24) + hours) * 60) + minutes) * 60 + seconds

+        if interval == 0:

+            if plugin_name in self.update_schedule['interval']:

+                del self.update_schedule['interval'][plugin_name]

+            if plugin_name in self.update_schedule['last_update']:

+                del self.update_schedule['last_update'][plugin_name]

+        else:

+            self.update_schedule['interval'][plugin_name] = interval

+            self.update_schedule['last_update'][plugin_name] = time.time()

+

+    def check_schedule(self):

+        now = time.time()

+        for plugin_name in self.update_schedule['interval']:

+            if now - self.update_schedule['last_update'][plugin_name] >= self.update_schedule['interval'][plugin_name]:

+                self.update_schedule['last_update'][plugin_name] = now

+                self.active_plugins[plugin_name].scheduled_update()

+

+    def command_priority_read(self, user, argv, raw):

+        for plugin in self.active_plugins.values():

+            plugin.command_priority_read(user, argv, raw)

+

+    def command_read(self, user, argv, raw):

+        for plugin in self.active_plugins.values():

+            if argv[0] in plugin.provides_commands():

+                plugin.command_read(user, argv, raw)

+

+    def admin_command_read(self, user, argv, raw):

+        for plugin in self.active_plugins.values():

+            if argv[0] in plugin.provides_admin_commands():

+                plugin.admin_command_read(user, argv, raw)

+

+    def message_priority_read(self, user, message):

+        for plugin in self.active_plugins.values():

+            result = plugin.message_priority_read(user, message)

+

+    def message_read(self, user, message):

+        for plugin in self.active_plugins.values():

+            plugin.message_read(user, message)

+

+    def admin_message_read(self, user, message):

+        for plugin in self.active_plugins.values():

+            plugin.admin_message_read(user, message)

+

+    def special_event(self, event_type, params):

+        for plugin in self.active_plugins.values():

+            plugin.special_event(event_type, params)

+

+    def user_join(self, user, batch_mode):

+        for plugin in self.active_plugins.values():

+            plugin.user_join(user, batch_mode)

+

+    def user_part(self, user, batch_mode):

+        for plugin in self.active_plugins.values():

+            plugin.user_part(user, batch_mode)

+

+    def send_message(self, message):

+        for plugin in self.active_plugins.values():

+            updated = plugin.filter_outgoing_message(message, None)

+            if isinstance(updated, str):

+                message = updated

+        self.send_callback(message)

+

+    def send_reply(self, user, message):

+        message = str(message)

+        for plugin in self.active_plugins.values():

+            updated = plugin.filter_outgoing_message(message, user)

+            if isinstance(updated, str):

+                message = updated

+        self.reply_callback(user, message)

+

+    def call_function_callback(self, function_name, *parameters):

+        if function_name not in self.provided_functions:

+            return None

+        provided_by = self.provided_functions[function_name]

+        function = getattr(self.active_plugins[provided_by], function_name)

+        return function(*parameters)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Configure announcements that get posted to chat based on a timer.

+

+import datetime

+

+class AnnouncementsPlugin(TimberBotPlugin):

+

+    def provides_admin_commands(self):

+        return ['announce', 'announcement', 'announcements']

+

+    def startup(self):

+        self.min_messages_between_announcements = int(self.get_conf('min_messages_between_announcements'))

+        self.messages_since_announcement = 0

+        self.announcements = self.load_data('announcements', default = {})

+        self.last_announcement_timestamps = {}

+        self.request_scheduled_update(seconds = 1)

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] in ['announcement', 'announcements'] and len(argv) == 1:

+            announcements = self.announcements.keys()

+            if len(announcements) == 0:

+                self.reply(user, 'You currently do not have any active announcements.')

+            else:

+                self.reply(user, 'Your active announcements have the following IDs: ' + ', '.join(announcements))

+        if argv[0] == 'announcement' and len(argv) >= 2:

+            announcement_id = argv[1].lower()

+            if announcement_id in self.announcements:

+                if len(argv) >= 3 and argv[2] == 'delete':

+                    del self.announcements[announcement_id]

+                    self.save_data('announcements', self.announcements)

+                    self.reply(user, 'Deleted announcement "' + argv[1] + '".')

+                else:

+                    self.reply(user, 'Announcement "' + argv[1] + '" is posted every ' + self.announcements[announcement_id]['interval_pretty'] + ': "' + self.announcements[announcement_id]['text'] + '"')

+            else:

+                self.reply(user, 'No announcement found for ID "' + argv[1] + '".')

+        if argv[0] == 'announce' and len(argv) == 3:

+            if argv[1].isdigit() or (len(argv[1]) >= 2 and argv[1][-1] in ['s', 'm', 'h'] and argv[1][:-1].isdigit()):

+                if argv[1].isdigit():

+                    interval = int(argv[1])

+                    interval_pretty = argv[1] + ' seconds'

+                else:

+                    interval = int(argv[1][:-1])

+                    unit = argv[1][-1]

+                    interval_pretty = argv[1][:-1] + ' seconds'

+                    if unit == 'm':

+                        interval = interval * 60

+                        interval_pretty = argv[1][:-1] + ' minutes'

+                    if unit == 'h':

+                        interval = interval * 60 * 60

+                        interval_pretty = argv[1][:-1] + ' hours'

+                new_id = "1"

+                if len(self.announcements) > 0:

+                    new_id = str(max([int(k) for k in list(self.announcements.keys())]) + 1)

+                new_announcement = {}

+                new_announcement['interval_seconds'] = interval

+                new_announcement['interval_pretty'] = interval_pretty

+                new_announcement['text'] = argv[2]

+                self.announcements[new_id] = new_announcement

+                self.save_data('announcements', self.announcements)

+                self.reply(user, 'Saved new announcement as #' + new_id + ', to be posted every ' + interval_pretty + ': "' + argv[2] + '"')

+            else:

+                self.reply(user, 'Unable to parse your announcement interval.')

+

+    def message_read(self, user, message):

+        self.messages_since_announcement += 1

+

+    def scheduled_update(self):

+        if not self.messages_since_announcement >= self.min_messages_between_announcements:

+            return

+        for announcement in self.announcements:

+            last_time = self.last_announcement_timestamps.get(announcement)

+            if last_time == None:

+                last_time = datetime.datetime.utcnow()

+                self.last_announcement_timestamps[announcement] = last_time

+            since_last_time = (datetime.datetime.utcnow() - self.last_announcement_timestamps[announcement]).total_seconds()

+            if since_last_time >= self.announcements[announcement]['interval_seconds']:

+                self.messages_since_announcement = 0

+                self.last_announcement_timestamps[announcement] = datetime.datetime.utcnow()

+                self.message(self.announcements[announcement]['text'])

+                return

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Simulate a random coin flip or a simple die throw. See the dice plugin for a more complex option.

+

+import random

+

+class CoinflipPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['coinflip']

+

+    def help_text(self):

+        return {'coinflip': 'Flips a coin ("' + self.format_command('coinflip') + '"), throws a die ("' + self.format_command('coinflip', '6') + '") or makes a random selection ("' + self.format_command('coinflip', 'Red', 'Purple', 'White') + '").'}

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            coin_sides = self.get_conf('coin_sides')

+            coin_sides = [side.strip() for side in coin_sides.split(',')]

+            self.reply(user, 'Your coin flip result: ' + random.choice(coin_sides))

+        elif len(argv) == 2 and (argv[1].isdigit() or (argv[1].startswith('-') and argv[1][1:].isdigit())):

+            if int(argv[1]) >= 1:

+                self.reply(user, 'Your die roll result: ' + str(random.choice(range(1, int(argv[1])))))

+            else:

+                self.reply(user, 'Sorry, can\'t roll a die with ' + argv[1] + ' sides.')

+        else:

+            # user supplied a list of possible outcomes

+            self.reply(user, 'Your random result: ' + random.choice(argv[1:]))

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows you to save numbered collections of things such as fan art, quotes, etc.

+

+import random

+

+class CollectionsPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return self.load_data('_collections', default = [])

+

+    def provides_admin_commands(self):

+        return ['collection']

+

+    def help_text(self):

+        result = {}

+        for c in self.load_data('_collections', default = []):

+            result[c] = 'Displays a ' + c + ' randomly ("' + self.format_command(c) + '"), by number ("' + self.format_command(c, '2') + '") or name ("' + self.format_command(c, 'name') + '"). You can also add a new ' + c + ' ("' + self.format_command(c + ' add Your ' + c + ' here.') + '").'

+        return result

+

+    def admin_command_read(self, user, argv, raw):

+        collections = self.load_data('_collections', default = [])

+        if len(argv) == 3:

+            if argv[1] in ['new', 'add']:

+                if argv[2].lower() not in collections:

+                    collections.append(argv[2].lower())

+                    self.save_data('_collections', collections)

+                    self.reply(user, 'Created a new empty collection, accessible via the "' + argv[2].lower() + '" command.')

+                else:

+                    self.reply(user, 'Collection "' + argv[2].lower() + '" already exists.')

+            if argv[1] in ['delete', 'remove']:

+                if argv[2].lower() in collections:

+                    collections.remove(argv[2].lower())

+                    self.save_data('_collections', collections)

+                    self.save_data(argv[2].lower(), {})

+                    self.reply(user, 'Deleted collection "' + argv[2].lower() + '".')

+                else:

+                    self.reply(user, 'Collection "' + argv[2].lower() + '" does not exist.')

+        if len(argv) == 4 and argv[1] == 'copy':

+            if argv[2].lower() not in collections:

+                self.reply(user, 'Source collection "' + argv[2].lower() + '" does not exist.')

+            elif argv[3].lower() in collections:

+                self.reply(user, 'Destination collection "' + argv[2].lower() + '" already exists.')

+            else:

+                collections.append(argv[3].lower())

+                self.save_data('_collections', collections)

+                self.save_data(argv[3].lower(), self.load_data(argv[2].lower(), default = {}))

+                self.reply(user, 'Copied collection "' + argv[2].lower() + '" to "' + argv[3].lower() + '".')

+

+    def command_read(self, user, argv, raw):

+        collection = self.load_data(argv[0], default = {})

+        if len(argv) == 1:

+            if len(collection) == 0:

+                self.reply(user, 'There is no ' + argv[0] + ' saved for this channel.')

+            else:

+                numerical_indexes = [k for k in list(collection.keys()) if k.isdigit()]

+                num_entries = max([int(k) for k in numerical_indexes])

+                index = random.choice(numerical_indexes)

+                entry_text = collection[index]

+                self.reply(user, '[Random ' + argv[0].title() + ': ' + str(index) + '/' + str(num_entries) + '] ' + entry_text)

+        elif len(argv) >= 3 and argv[1] == 'add':

+            if len(argv) >= 5 and argv[2] == 'alias' and argv[3].isdigit() and not argv[4].isdigit():

+                alias = argv[4].lower()

+                target = argv[3]

+                if alias in collection:

+                    self.reply(user, 'The alias "' + alias + '" already exists and points to ' + argv[0] + ' #' + str(collection[alias]) + '.')

+                else:

+                    collection[alias] = target

+                    self.save_data(argv[0], collection)

+                    self.reply(user, 'The alias "' + alias + '" has been added for ' + argv[0] + ' #' + str(target) + '.')

+            else:

+                num_entries = 0

+                if len(collection) > 0:

+                    num_entries = [k for k in list(collection.keys()) if k.isdigit()]

+                    num_entries = max([int(k) for k in num_entries])

+                new_index = str(num_entries + 1)

+                entry_text = raw[4:]

+                if self.get_conf('require_imgur') and entry_text.find('imgur.com/') == -1:

+                    self.reply(user, 'Your ' + argv[0] + ' does not seem to contain an imgur link. Please upload to imgur before adding it here.')

+                else:

+                    collection[new_index] = entry_text

+                    self.save_data(argv[0], collection)

+                    self.reply(user, 'Your ' + argv[0] + ' has been added as #' + str(new_index) + ': ' + entry_text)

+        elif argv[1] in ['last', 'latest', 'newest']:

+            if len(collection) == 0:

+                self.reply(user, 'There is no ' + argv[0] + ' saved for this channel.')

+            else:

+                num_entries = [k for k in list(collection.keys()) if k.isdigit()]

+                num_entries = max([int(k) for k in num_entries])

+                entry_text = collection[str(num_entries)]

+                self.reply(user, '[Latest ' + argv[0].title() + ': ' + str(num_entries) + '/' + str(num_entries) + '] ' + entry_text)

+        elif argv[1].lower() in collection:

+            index = argv[1]

+            while str(collection[index]).isdigit():

+                index = collection[index]

+            num_entries = [k for k in list(collection.keys()) if k.isdigit()]

+            num_entries = max([int(k) for k in num_entries])

+            entry_text = collection[index]

+            self.reply(user, '[' + argv[0].title() + ' ' + str(index) + '/' + str(num_entries) + '] ' + entry_text)

+        else:

+            index = argv[1]

+            if not index.isdigit():

+                index = '"' + index + '"'

+            self.reply(user, 'I have no ' + argv[0] + ' saved for index ' + index + '.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Enable counters that can be increased and decreased in chat, e.g. for collectibles or a death counter.

+

+class CountersPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['counter']

+

+    def provides_admin_commands(self):

+        return ['counter']

+

+    def help_text(self):

+        return {'counter': 'Creates ("' + self.format_command('counter', 'countername') + '"), modifies or checks the status of a counter.'}

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            self.reply(user, 'Which counter do you want to check or create? Type "' + self.format_command('counter', 'countername') + '".')

+        if len(argv) == 2:

+            counter = argv[1].lower()

+            counter_info = self.load_data(counter)

+            if counter_info == None:

+                counter_info = {}

+                counter_info['name'] = argv[1]

+                counter_info['value'] = 0

+                counter_info['locked'] = False

+                counter_info['owner'] = user

+                self.save_data(counter, counter_info)

+                self.reply(user, 'The counter "' + argv[1] + '" has been created and set to 0.')

+            else:

+                self.check_counter(user, counter_info)

+        if len(argv) == 3 and argv[2] in ['decrease', 'increase', 'lock', 'unlock', 'delete']:

+            counter = argv[1].lower()

+            counter_info = self.load_data(counter)

+            if counter_info == None:

+                self.reply(user, 'There is no counter saved under the name "' + argv[1] + '".')

+            else:

+                if argv[2] == 'increase':

+                    if not counter_info['locked']:

+                        self.increase_counter(user, counter_info)

+                    else:

+                        self.reply(user, 'Cannot modify counter "' + argv[1] + '" because it is locked.')

+                if argv[2] == 'decrease':

+                    if not counter_info['locked']:

+                        self.decrease_counter(user, counter_info)

+                    else:

+                        self.reply(user, 'Cannot modify counter "' + argv[1] + '" because it is locked.')

+                if argv[2] == 'lock':

+                    if user == counter_info['owner']:

+                        self.lock_counter(user, counter_info)

+                    else:

+                        self.reply(user, 'You can only lock a counter that you own.')

+                if argv[2] == 'unlock':

+                    if user == counter_info['owner']:

+                        self.unlock_counter(user, counter_info)

+                    else:

+                        self.reply(user, 'You can only unlock a counter that you own.')

+                if argv[2] == 'delete':

+                    if user == counter_info['owner']:

+                        self.delete_counter(user, counter_info)

+                    else:

+                        self.reply(user, 'You can only delete a counter that you own.')

+        if len(argv) == 4 and argv[2] == 'set':

+            counter = argv[1].lower()

+            counter_info = self.load_data(counter)

+            if counter_info == None:

+                self.reply(user, 'There is no counter saved under the name "' + argv[1] + '".')

+            else:

+                if argv[3].isdigit() or (len(argv[3]) >= 2 and argv[3][0] == '-' and argv[3][1:].isdigit()):

+                    new_value = int(argv[3])

+                    if not counter_info['locked']:

+                        self.set_counter_to(user, counter_info, new_value)

+                    else:

+                        self.reply(user, 'Cannot modify counter "' + argv[1] + '" because it is locked.')

+                else:

+                    self.reply(user, 'The counter value must be a number.')

+

+    def message_read(self, user, message):

+        if len(message) >= 2 and message[0] in ['+', '-', '?']:

+            counter_info = self.load_data(message[1:])

+            if counter_info != None:

+                if message[0] == '+' and (user == counter_info['owner'] or not counter_info['locked']):

+                    self.increase_counter(user, counter_info)

+                if message[0] == '-' and (user == counter_info['owner'] or not counter_info['locked']):

+                    self.decrease_counter(user, counter_info)

+                if message[0] == '?':

+                    self.check_counter(user, counter_info)

+

+    def admin_command_read(self, user, argv, raw):

+        if len(argv) == 3 and argv[2] in ['decrease', 'increase', 'lock', 'unlock']:

+            counter = argv[1].lower()

+            counter_info = self.load_data(counter)

+            if counter_info != None:

+                if argv[2] == 'increase':

+                    self.increase_counter(user, counter_info)

+                if argv[2] == 'decrease':

+                    self.decrease_counter(user, counter_info)

+                if argv[2] == 'lock':

+                    self.lock_counter(user, counter_info)

+                if argv[2] == 'unlock':

+                    self.unlock_counter(user, counter_info)

+                if argv[2] == 'delete':

+                    self.delete_counter(user, counter_info)

+        if len(argv) == 4 and argv[2] == 'set':

+            counter = argv[1].lower()

+            counter_info = self.load_data(counter)

+            if counter_info == None:

+                self.reply(user, 'There is no counter saved under the name "' + argv[1] + '".')

+            else:

+                if argv[3].isdigit() or (len(argv[3]) >= 2 and argv[3][0] == '-' and argv[3][1:].isdigit()):

+                    new_value = int(argv[3])

+                    self.set_counter_to(user, counter_info, new_value)

+                else:

+                    self.reply(user, 'The counter value must be a number.')

+

+    def check_counter(self, user, counter_info):

+        self.reply(user, counter_info['name'] + ' = ' + str(counter_info['value']))

+

+    def set_counter_to(self, user, counter_info, new_value):

+        counter_info['value'] = new_value

+        self.save_data(counter_info['name'].lower(), counter_info)

+        self.check_counter(user, counter_info)

+

+    def increase_counter(self, user, counter_info):

+        counter_info['value'] += 1

+        self.save_data(counter_info['name'].lower(), counter_info)

+        self.check_counter(user, counter_info)

+

+    def decrease_counter(self, user, counter_info):

+        counter_info['value'] -= 1

+        self.save_data(counter_info['name'].lower(), counter_info)

+        self.check_counter(user, counter_info)

+

+    def lock_counter(self, user, counter_info):

+        counter_info['locked'] = True

+        self.save_data(counter_info['name'].lower(), counter_info)

+        self.reply(user, 'Counter "' + counter_info['name'] + '" is now locked.')

+

+    def unlock_counter(self, user, counter_info):

+        counter_info['locked'] = False

+        self.save_data(counter_info['name'].lower(), counter_info)

+        self.reply(user, 'Counter "' + counter_info['name'] + '" is now unlocked.')

+

+    def delete_counter(self, user, counter_info):

+        self.save_data(counter_info['name'].lower(), None)

+        self.reply(user, 'Counter "' + counter_info['name'] + '" has been deleted.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows the definition of custom commands, including limited NightBot compatibility for variables.

+

+import dateutil.parser

+import random

+import urllib.request, urllib.parse, urllib.error

+

+class CustomCommandsPlugin(TimberBotPlugin):

+

+    def startup(self):

+        self.custom_commands = self.load_data('commands', default = {})

+

+    def provides_commands(self):

+        return list(self.custom_commands.keys())

+

+    def provides_admin_commands(self):

+        return ['command']

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'command':

+            if len(argv) >= 3:

+                command = argv[1]

+                if command in self.custom_commands:

+                    if argv[2] in ['delete', 'remove'] and len(argv) == 3:

+                        del self.custom_commands[command]

+                        self.save_data('commands', self.custom_commands)

+                        self.reply(user, 'Command "' + command + '" has been deleted.')

+                    elif argv[2] == 'edit' and len(argv) > 3:

+                        command_reply = ' '.join(argv[3:])

+                        self.custom_commands[command] = command_reply

+                        self.save_data('commands', self.custom_commands)

+                        self.reply(user, 'Command "' + command + '" has been modified.')

+                    else:

+                        self.reply(user, 'Cannot add command "' + command + '" because it already exists. You may edit or delete it.')

+                else:

+                    if len(argv) > 3:

+                        command_reply = ' '.join(argv[2:])

+                    else:

+                        command_reply = argv[2]

+                    self.custom_commands[command] = command_reply

+                    if '$(count)' in command_reply:

+                        self.save_data('count_' + command.lower(), 0)

+                    self.save_data('commands', self.custom_commands)

+                    self.reply(user, 'Command "' + command + '" has been created.')

+            else:

+                self.reply(user, 'Which command do you want to create ("' + self.format_command('command', 'commandname', 'Command result') + '"), edit ("' + self.format_command('command', 'commandname', 'edit', 'Command result') + '") or delete ("' + self.format_command('command', 'commandname', 'delete') + '")?')

+

+    def command_read(self, user, argv, raw):

+        if argv[0] in self.custom_commands:

+            command_reply = self.custom_commands[argv[0]]

+            bracket_pairs = self.find_bracket_pairs(command_reply)

+            while len(bracket_pairs) > 0:

+                next_bracket_pair = bracket_pairs.pop(0)

+                sub_result = self.evaluate_segment(command_reply[next_bracket_pair[0]+2:next_bracket_pair[1]], user, argv, raw)

+                length_difference = len(sub_result) - (next_bracket_pair[1] - next_bracket_pair[0] + 1)

+                command_reply = command_reply[0:next_bracket_pair[0]] + sub_result + command_reply[next_bracket_pair[1]+1:]

+                new_bracket_pairs = []

+                for left, right in bracket_pairs:

+                    if left > next_bracket_pair[1]:

+                        left += length_difference

+                    if right > next_bracket_pair[1]:

+                        right += length_difference

+                    new_bracket_pairs.append((left, right))

+                bracket_pairs = new_bracket_pairs

+            self.message(command_reply)

+

+    def find_bracket_pairs(self, reply):

+        bracket_pairs = []

+        opening_brackets = []

+        current_index = 0

+        while current_index < len(reply):

+            if reply[current_index] == '$' and current_index < len(reply) - 1 and reply[current_index+1] == '(':

+                opening_brackets.append(current_index)

+            if reply[current_index] == ')' and len(opening_brackets) > 0:

+                bracket_pairs.append((opening_brackets.pop(), current_index))

+            current_index += 1

+        return bracket_pairs

+

+    def evaluate_segment(self, segment, user, argv, raw):

+        if segment.isdigit():

+            num = int(segment)

+            if num < len(argv):

+                return argv[num]

+            else:

+                return ''

+        if segment.lower() == 'count':

+            count = self.load_data('count_' + argv[0].lower(), default = 0)

+            count += 1

+            self.save_data('count_' + argv[0].lower(), count)

+            return str(count)

+        if segment.lower() == 'query':

+            return raw

+        if segment.lower() == 'querystring':

+            return urllib.parse.quote_plus(raw)

+        if segment.lower() == 'user':

+            return user

+        if segment.lower() == 'touser':

+            if len(argv) > 1:

+                return argv[1]

+            else:

+                return user

+        first_word = segment.split(' ')[0]

+        if first_word.lower() == 'countdown' and len(segment.split(' ')) > 1:

+            date = segment[segment.index(' ')+1:]

+            parsed_date = dateutil.parser.parse(date)

+            delta = parsed_date - datetime.datetime.utcnow()

+            return self.pretty_interval(delta.total_seconds())

+        if first_word.lower() == 'countup' and len(segment.split(' ')) > 1:

+            date = segment[segment.index(' ')+1:]

+            parsed_date = dateutil.parser.parse(date)

+            delta = datetime.datetime.utcnow() - parsed_date

+            return self.pretty_interval(delta.total_seconds())

+        if first_word.lower() in ['urlfetch', 'customapi'] and len(segment.split(' ')) > 1:

+            url = segment[segment.index(' ')+1:]

+            opener = urllib.request.build_opener()

+            try:

+                response = opener.open(url).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                return ''

+            return response[0:400]

+        if first_word.lower() == 'upper' and len(segment.split(' ')) > 1:

+            return segment[segment.index(' ')+1:].upper()

+        if first_word.lower() == 'lower' and len(segment.split(' ')) > 1:

+            return segment[segment.index(' ')+1:].lower()

+        if first_word.lower() == 'reverse' and len(segment.split(' ')) > 1:

+            return segment[segment.index(' ')+1:][::-1]

+        return segment

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows rolling various dice configurations typical for tabletop games. Aims for roll20 compatibility, but may be incomplete.

+

+import random

+import re

+

+class DicePlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['roll']

+

+    def help_text(self):

+        return {'roll': 'Roll one or more dice of various kinds ("' + self.format_command('roll', 'd6') + '", "' + self.format_command('roll', '4d20') + '"), throws a die ("' + self.format_command('coinflip', '6') + '") or makes a random selection ("' + self.format_command('coinflip', 'Red', 'Purple', 'White') + '").'}

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            self.reply(user, 'What kind of die do you want me to roll?')

+        else:

+            current_step = None

+            next_step = raw

+            print('\nInput:\n' + raw)

+            while next_step != current_step:

+                current_step = next_step

+                next_step = self.step_one(current_step)

+            intermediate = next_step

+            print('On to step two')

+            current_step = None

+            while next_step != current_step:

+                current_step = next_step

+                next_step = self.step_two(current_step)

+            self.reply(user, 'Your result: ' + intermediate + ' ==> ' + next_step)

+

+    def step_one(self, line):

+        result = line

+        if re.search('(\d+)\s*d((\d+|F)(!!?(<|>)?\d+|[!pr][!pr\d]*)?)', line):

+            for count, die_type, unused1, unused2, unused3 in re.findall('(\d+)\s*d((\d+|F)(!!?(<|>)?\d+|[\!pr][\!pr\d]*)?)', line):

+                result = line.replace(count + 'd' + die_type, '[' + ', '.join(['d' + die_type] * int(count)) + ']')

+        elif re.search('\+-', line):

+            match = re.search('\+-', line)

+            result = line[:match.start()]

+            result += '-'

+            result += line[match.end():]

+        elif re.search('\(\s*(-?\d+)\s*\)', line):

+            match = re.search('\(\s*(-?\d+)\s*\)', line)

+            result = line[:match.start()]

+            result += match.groups()[0]

+            result += line[match.end():]

+        elif re.search('(\d+)\s*\*\s*(-?\d+)', line):

+            match = re.search('(\d+)\s*\*\s*(-?\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) * int(match.groups()[1]))

+            result += line[match.end():]

+        elif re.search('(\d+)\s*\+\s*(\d+)', line):

+            match = re.search('(\d+)\s*\+\s*(\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) + int(match.groups()[1]))

+            result += line[match.end():]

+        elif re.search('(\d+)\s*-\s*(\d+)', line):

+            match = re.search('(\d+)\s*\-\s*(\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) - int(match.groups()[1]))

+            result += line[match.end():]

+        elif re.search('d(\d+|F)(!!|!p|!)((<|>)?\d+)?', line):

+            for sides, operator, explode_on, unused in re.findall('d(\d+|F)(!!|!p|!)((<|>)?\d+)?', line):

+                possible_rolls = []

+                if sides == 'F':

+                    possible_rolls = [-1, 0, 1]

+                else:

+                    possible_rolls = range(1, int(sides) + 1)

+                if len(explode_on) == 0:

+                    explode_on_set = [max(possible_rolls)]

+                elif explode_on[0].isdigit():

+                    explode_on_set = [int(explode_on)]

+                elif explode_on[0] == '<':

+                    explode_on_set = [roll for roll in possible_rolls if roll <= int(explode_on[1:])]

+                elif explode_on[0] == '>':

+                    explode_on_set = [roll for roll in possible_rolls if roll >= int(explode_on[1:])]

+                roll = random.choice(possible_rolls)

+                roll_sum = roll

+                if operator == '!':

+                    roll_sum = str(roll_sum)

+                    if roll in explode_on_set:

+                        roll_sum += ',d' + sides + '!' + explode_on

+                else:

+                    while roll in explode_on_set:

+                        roll = random.choice(possible_rolls)

+                        roll_sum += roll

+                        if operator == '!p':

+                            roll_sum -= 1

+                result = re.sub('d(\d+)(!!|!p|!)((<|>)?\d+)?', str(roll_sum), line, 1)

+                break

+        elif re.search('(?<!\])d(\d+)', line):

+            for sides in re.findall('(?<!\])d(\d+)', line):

+                result = re.sub('(?<!\])d(\d+)', str(random.choice(range(1, int(sides) + 1))), line, 1)

+                break

+        elif re.search('(?<!\])dF', line):

+            result = re.sub('(?<!\])dF', random.choice(['-1', '0', '1']), line, 1)

+        elif re.search('\[(-?\d+(, -?\d+)*)\](sa|sd|s)', line):

+            match = re.search('\[(-?\d+(, -?\d+)*)\](sa|sd|s)', line)

+            rolls = [int(roll) for roll in match.groups()[0].split(', ')]

+            operator = match.groups()[2]

+            rolls.sort()

+            if operator == 'sd':

+                rolls = reversed(rolls)

+            result = re.sub('\[(-?\d+(, -?\d+)*)\](sa|sd|s)', '[' + ', '.join([str(roll) for roll in rolls]) + ']', line, 1)

+        print(result)

+        return result

+

+    def step_two(self, line):

+        result = line

+        if re.search('\[(-?\d+(, -?\d+)*)\](d|k|dl|dh|kl|kh)(\d+)', line):

+            match = re.search('\[(-?\d+(, -?\d+)*)\](d|k|dl|dh|kl|kh)(\d+)', line)

+            result = line[:match.start()]

+            rolls = sorted([int(roll) for roll in match.groups()[0].split(', ')])

+            action = match.groups()[2]

+            number = int(match.groups()[3])

+            if number > len(rolls):

+                result += '[]'

+            else:

+                if action in ['d', 'dl']:

+                    rolls = rolls[number:]

+                if action in ['dh']:

+                    rolls = rolls[:len(rolls) - number]

+                if action in ['k', 'kh']:

+                    rolls = rolls[len(rolls) - number:]

+                if action in ['kl']:

+                    rolls = rolls[:number]

+                result += '[' + ', '.join([str(roll) for roll in rolls]) + ']'

+            result += line[match.end():]

+        elif re.search('\[(-?\d+(, -?\d+)*)\](<|>)(\d+)', line):

+            match = re.search('\[(-?\d+(, -?\d+)*)\](<|>)(\d+)', line)

+            result = line[:match.start()]

+            rolls = [int(roll) for roll in match.groups()[0].split(', ')]

+            operator = match.groups()[2]

+            limit = int(match.groups()[3])

+            success_on_set = []

+            if operator == '<':

+                success_on_set = range(1, limit + 1)

+            if operator == '>':

+                success_on_set = range(limit, max(rolls) + 1)

+            result += str(sum([1 for roll in rolls if roll in success_on_set]))

+            result += line[match.end():]

+        elif re.search('\[(-?\d+(, -?\d+)*)\]', line):

+            match = re.search('\[(-?\d+(, -?\d+)*)\]', line)

+            result = line[:match.start()]

+            result += str(sum([int(roll) for roll in match.groups()[0].split(', ')]))

+            result += line[match.end():]

+        elif re.search('\+-', line):

+            match = re.search('\+-', line)

+            result = line[:match.start()]

+            result += '-'

+            result += line[match.end():]

+        elif re.search('\(\s*(-?\d+)\s*\)', line):

+            match = re.search('\(\s*(-?\d+)\s*\)', line)

+            result = line[:match.start()]

+            result += match.groups()[0]

+            result += line[match.end():]

+        elif re.search('(\d+)\s*\*\s*(-?\d+)', line):

+            match = re.search('(\d+)\s*\*\s*(-?\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) * int(match.groups()[1]))

+            result += line[match.end():]

+        elif re.search('(\d+)\s*\+\s*(\d+)', line):

+            match = re.search('(\d+)\s*\+\s*(\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) + int(match.groups()[1]))

+            result += line[match.end():]

+        elif re.search('(\d+)\s*-\s*(\d+)', line):

+            match = re.search('(\d+)\s*\-\s*(\d+)', line)

+            result = line[:match.start()]

+            result += str(int(match.groups()[0]) - int(match.groups()[1]))

+            result += line[match.end():]

+        print(result)

+        return result

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Greets people who join chat, either when their name appears in the list or after their first message.

+

+import datetime

+import dateutil.parser

+import pytz

+import random

+

+class GreetingsPlugin(TimberBotPlugin):

+

+    def provides_admin_commands(self):

+        return ['snarkygreetings']

+

+    def admin_command_read(self, user, argv, raw):

+        snark_list = self.load_data('snark_list', default = [])

+        if len(argv) == 3:

+            if argv[1] in ['add']:

+                if argv[2].lower() not in snark_list:

+                    snark_list.append(argv[2].lower())

+                    self.save_data('snark_list', snark_list)

+                    self.reply(user, 'Added ' + argv[2] + ' to the list for snarky greetings.')

+                else:

+                    self.reply(user, argv[2] + ' is already on the list for snarky greetings.')

+            if argv[1] in ['delete', 'remove']:

+                if argv[2].lower() in snark_list:

+                    snark_list.remove(argv[2].lower())

+                    self.save_data('snark_list', snark_list)

+                    self.reply(user, 'Removed ' + argv[2].lower() + ' from the list for snarky greetings.')

+                else:

+                    self.reply(user, argv[2] + ' is not on the list for snarky greetings.')

+

+    def user_join(self, name, batch_mode = False):

+        if batch_mode:

+            return

+        if self.get_conf('greet_lurkers'):

+            already_greeted = self.load_data('already_greeted', default = [])

+            if name.lower() not in already_greeted:

+                already_greeted.append(name.lower())

+                self.save_data('already_greeted', already_greeted)

+                self.greet(name)

+

+    def message_read(self, user, message):

+        already_greeted = self.load_data('already_greeted', default = [])

+        if user.lower() not in already_greeted:

+            already_greeted.append(user.lower())

+            self.save_data('already_greeted', already_greeted)

+            self.greet(user)

+

+    def greet(self, name):

+        names = self.load_data('names', default = {})

+        if isinstance(names, list):

+            new_names = {}

+            for greeted_name in names:

+                new_names[greeted_name] = datetime.datetime(1970, 1, 1, 0, 0, 0)

+            names = new_names

+        if name in names:

+            last_seen = names[name]

+            seconds_passed = (datetime.datetime.utcnow() - last_seen).total_seconds()

+            greeting_cooldown = self.get_conf('greeting_cooldown')

+            greeting_cooldown = int(greeting_cooldown)

+            if seconds_passed > greeting_cooldown:

+                snark_list = self.load_data('snark_list', default = [])

+                if name.lower() in snark_list:

+                    snarks = [

+                        'Oh look, it\'s that {name} person again...',

+                        'By the way, {name} is in chat now. Not that anyone would care.',

+                        'I only greet people I like, but I feel obligated to point out that {name} is here now.',

+                        'Knock knock! Who\'s there? {name}! {name} who? IDGAF.',

+                        'FYI, {name} just started using up oxygen in here.',

+                        'Oh hey, looks like {name} decided to take some time out of their busy life and grace us with their presence.',

+                        'Thankfully we can have unlimited people in chat, otherwise {name} would be taking up a spot right now.',

+                        'Welcome back, {name}! And goodbye to everyone who is now leaving because {name} joined.',

+                        'Ugh... welcome back {name}, I guess...',

+                        '{name} is here now, but you don\'t have to talk to them if you don\'t want to.',

+                        '{name}, welcome ba... oh, why would I even bother.',

+                        '*silently rolls eyes at {name}*',

+                        'Some people may talk badly about {name}, but I have the utmost respect for waste collectors and their work.',

+                        'Oh hey {name}, I think you forgot something back where you just came from. Maybe you should go back there and check?',

+                        'I hope everyone is doing well! Except for {name}, who I don\'t really care about.',

+                        '{name}, you are here now but you\'re still largely irrelevant.',

+                        'Sorry {name}, we\'re not buying anything. Oh, you just want to be part of the chat? That\'s... well, if you insist...',

+                        'Welcome back, {name}! Please try not to say anything dumb today.',

+                        'Just saying, but I wouldn\'t want to be a member of a club that lets {name} in...',

+                        'Can we all agree to just ignore {name}? Might be for the better.'

+                    ]

+                    self.send_greeting(name, random.choice(snarks).replace('{name}', name))

+                else:

+                    self.send_greeting(name, self.get_conf('greeting').replace('{name}', name))

+        else:

+            self.send_greeting(name, self.get_conf('first_time_greeting').replace('{name}', name))

+        names[name] = datetime.datetime.utcnow()

+        self.save_data('names', names)

+

+    def send_greeting(self, user, message):

+        if self.get_conf('send_as_reply'):

+            self.reply(user, message)

+        else:

+            self.message(message)

+

+    def user_part(self, name, batch_mode = False):

+        already_greeted = self.load_data('already_greeted', default = [])

+        if name.lower() in already_greeted:

+            already_greeted.remove(name.lower())

+        self.save_data('already_greeted', already_greeted)

+        if batch_mode:

+            return

+        names = self.load_data('names', default = {})

+        if isinstance(names, list):

+            new_names = {}

+            for greeted_name in names:

+                new_names[greeted_name] = datetime.datetime(1970, 1, 1, 0, 0, 0)

+            names = new_names

+        names[name] = datetime.datetime.utcnow()

+        self.save_data('names', names)

+        

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Keeps track of the last thing any particular person has said in chat.

+

+class LastWordsPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['last_words']

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            last_message = self.load_data(user.lower(), default = None)

+            if last_message != None:

+                self.reply(user, 'You said: ' + last_message['text'])

+            else:

+                self.reply(user, 'I don\'t have a message recorded from you.')

+        if len(argv) >= 2:

+            last_message = self.load_data(argv[1].lower(), default = None)

+            if last_message != None:

+                self.reply(user, last_message['user'] + ' said: ' + last_message['text'])

+            else:

+                self.reply(user, 'I don\'t have a message recorded from ' + argv[1] + '.')

+

+    def message_read(self, user, message):

+        last_message = {'user': user, 'text': message}

+        self.save_data(user.lower(), last_message)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Uses moderator actions to block links in chat.

+

+import collections

+import configparser

+import copy

+import datetime

+import dateutil.parser

+import os

+import pytz

+import re

+import urllib.parse

+

+class LinkBlockerPlugin(TimberBotPlugin):

+

+    def provides_admin_commands(self):

+        return ['grant']

+

+    def startup(self):

+        self.temp_permissions = {}

+        self.current_admins = []

+

+    def admin_message_read(self, user, message):

+        if user.lower() not in self.current_admins:

+            self.current_admins.append(user.lower())

+

+    def message_priority_read(self, user, message):

+        link_found = None

+        match = re.match(r".*(http[s]?:\/\/[a-z\d_\-\.\/]+)[^a-z\d_\-\.].*", message)

+        if match != None:

+            link_found = match.group(1)

+        match = re.match(r".*[^a-z\d_\-\.](([a-z\d_\-]+\.)+\.[a-z]{2})\b.*", message)

+        if link_found == None and match != None:

+            link_found = match.group(1)

+        match = re.match(r".*(\S+\.(com|net|org|edu|gov|mil))\b.*", message)

+        if link_found == None and match != None:

+            link_found = match.group(1)

+        if link_found == None:

+            return

+        temp_allow_links = True

+        temp_permissions = self.temp_permissions.get(user.lower())

+        temp_link_permission = None

+        if temp_permissions != None:

+            temp_link_permission = temp_permissions.get('links')

+        if temp_link_permission != None:

+            if temp_link_permission.get('number') != None:

+                if temp_link_permission['number'] > 0:

+                    temp_allow_links = True

+                    self.temp_permissions[user.lower()]['links']['number'] -= 1

+            if temp_link_permission.get('deadline') != None:

+                if temp_link_permission['deadline'] > datetime.datetime.utcnow():

+                    temp_allow_links = True

+        if user.lower() not in self.current_admins and not temp_allow_links:

+            self.special_action('timeout', {'user': user, 'duration': 5})

+            self.reply(user, 'Sorry, but you are not allowed to post links in chat. Bot admins: type "' + self.format_command('grant', user.lower(), 'links') + '" to allow it for 5 minutes.')

+            return 'consume'

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'grant' and len(argv) >= 2:

+            perm = 'links'

+            if len(argv) >= 3:

+                perm = argv[2].lower()

+            perm_target = argv[1].lower()

+            if perm not in ['links']:

+                return

+            if self.temp_permissions.get(perm_target) == None:

+                self.temp_permissions[perm_target] = {}

+            if self.temp_permissions[perm_target].get(perm) == None:

+                self.temp_permissions[perm_target][perm] = {}

+            self.temp_permissions[perm_target][perm]['deadline'] = datetime.datetime.utcnow() + datetime.timedelta(0, 300)

+            if perm == 'links':

+                self.reply(user, 'User ' + argv[1] + ' may now post links in chat for 5 minutes.')

+            else:

+                self.reply(user, 'User ' + argv[1] + ' now has the permission "' + perm + '" for 5 minutes.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# When a link to a supported website is posted in chat, provides a summary of the content. 

+

+import re

+import urllib.request, urllib.error

+

+class LinkInfoPlugin(TimberBotPlugin):

+

+    def message_read(self, user, message):

+

+        match = re.match(r".*https?:\/\/(www\.)?youtu\.?be(\.com)?\/(watch\?(.+&)*v=)?([a-zA-Z0-9\-_]+).*", message)

+        if match != None and self.get_conf('youtube'):

+            video_id = match.group(5)

+            url = 'http://www.youtube.com/watch?v=' + video_id

+            opener = urllib.request.build_opener()

+            try:

+                video_html = opener.open(url).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                video_html = ''

+            video_title = self.find_between(video_html, '<title>', ' - YouTube</title>')

+            if video_title != None:

+                video_uploader = self.find_between(video_html, '<div class="yt-user-info">', '</a>')

+                if video_uploader != None:

+                    video_uploader = video_uploader[video_uploader.find('>')+1:]

+                video_duration = self.find_between(video_html, '<meta itemprop="duration" content="P', '">')

+                length = None

+                if video_duration != None:

+                    if video_duration[0] == 'T':

+                        video_duration = video_duration[1:]

+                    for unit in ['H', 'M', 'S']:

+                        if video_duration.find(unit) > -1:

+                            value = int(video_duration[0:video_duration.find(unit)])

+                            if length == None:

+                                length = str(value)

+                            else:

+                                length += ':' + str(value).rjust(2, '0')

+                            video_duration = video_duration[video_duration.find(unit)+1:]

+                msg = user + ' just posted a YouTube link to "' + video_title + '"'

+                if video_uploader != None:

+                    msg += ', uploaded by ' + video_uploader

+                msg += '. http://youtu.be/' + video_id

+                if length != None:

+                    msg += ' [' + length + ']'

+                self.message(msg)

+

+        match = re.match(r".*http:\/\/(.+)\.tumblr\.com\/post\/([0-9]+)\/.*", message)

+        if match != None and self.get_conf('tumblr'):

+            tumblr_url = match.group(1)

+            post_id = match.group(2)

+            url = 'http://' + tumblr_url + '.tumblr.com/post/' + post_id + '/'

+            opener = urllib.request.build_opener()

+            try:

+                tumblr_html = opener.open(url).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                tumblr_html = ''

+            title = self.find_between(tumblr_html, '<meta property="og:title" content="', '" />')

+            canon_url = self.find_between(tumblr_html, '<meta property="og:url" content="', '" />')

+            author = self.find_between(tumblr_html, '<meta name="twitter:title" content="', '" />')

+            msg = user + ' just posted a link to a Tumblr post by ' + author + ': "' + title + '" - ' + canon_url

+            self.message(msg)

+

+        match = re.match(r".*https?:\/\/(www\.)?nexusmods\.com\/skyrim\/mods\/([0-9]+)\/?\b.*", message)

+        if match != None and self.get_conf('nexusmods-skyrim'):

+            mod_id = match.group(2)

+            url = 'http://www.nexusmods.com/skyrim/mods/' + mod_id + '/'

+            opener = urllib.request.build_opener()

+            try:

+                mod_html = opener.open(url).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                mod_html = ''

+            mod_title = self.find_between(mod_html, '<span class="header-name">', '</span> ')

+            if mod_title != None:

+                mod_author = self.find_between(mod_html, '<span class="header-author">by <strong>', '</strong></span>')

+                msg = user + ' just posted a link to a Skyrim mod: "' + mod_title + '"'

+                if mod_author != None:

+                    msg += ', created by ' + mod_author

+                msg += '. ' + url

+                self.message(msg)

+

+    def find_between(self, string, left_delim, right_delim):

+        start_index = string.find(left_delim)

+        if start_index == -1:

+            return None

+        start_index += len(left_delim)

+        end_index = string.find(right_delim, start_index)

+        if end_index == -1:

+            return None

+        return string[start_index:end_index]

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows users to leave each other secret messages.

+

+class MessagesPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['msg']

+

+    def help_text(self):

+        return {'msg': 'Sends someone a message ("' + self.format_command('msg username Your message here.') + '"). You can only have one message stored per recipient.'}

+

+    def startup(self):

+        self.cached_recipients = {}

+        stored_messages = self.load_data('messages', default = {})

+        for sender in stored_messages:

+            for recipient in stored_messages[sender]:

+                if recipient not in self.cached_recipients:

+                    self.cached_recipients[recipient] = 0

+                self.cached_recipients[recipient] = self.cached_recipients[recipient] + 1

+        self.request_scheduled_update(seconds = 10)

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            self.reply(user, 'You need to supply a name. Who should I message on your behalf?')

+            return

+        stored_messages = self.load_data('messages', default = {})

+        user_messages = {}

+        if user in stored_messages:

+            user_messages = stored_messages[user]

+        if len(argv) == 2:

+            target = argv[1].lower()

+            if target in user_messages:

+                self.reply(user, 'You have the following message stored for ' + argv[1] + ': "' + user_messages[target] + '"')

+            else:

+                self.reply(user, 'You have no message stored for ' + argv[1] + '.')

+        if len(argv) >= 3:

+            target = argv[1].lower()

+            if argv[2].lower() in ['.', 'clear', 'none', 'nothing']:

+                if target in user_messages:

+                    del user_messages[target]

+                    self.reply(user, 'Alright, I\'ve deleted your message for ' + argv[1] + '.')

+                else:

+                    self.reply(user, 'You have no message stored for ' + argv[1] + '.')

+            else:

+                msg = raw[len(target)+1:]

+                user_messages[target] = msg

+                stored_messages[user] = user_messages

+                self.save_data('messages', stored_messages)

+                if target not in self.cached_recipients:

+                    self.cached_recipients[target] = 0

+                self.cached_recipients[target] = self.cached_recipients[target] + 1

+                self.reply(user, 'Okay, I\'ll tell ' + argv[1] + ' that at the next opportunity!')

+

+    def scheduled_update(self):

+        current_recipients = [name for name in self.cached_recipients if self.cached_recipients[name] > 0]

+        stored_messages = None

+        if len(current_recipients) > 0:

+            names = {}

+            for name in self.get_users():

+                names[name.lower()] = name

+            for recipient in current_recipients:

+                if recipient in names:

+                    if stored_messages == None:

+                        stored_messages = self.load_data('messages', default = {})

+                    for sender in stored_messages:

+                        messages = stored_messages[sender]

+                        if recipient in messages:

+                            message = messages[recipient]

+                            if message[0] == message[-1] and message[0] in ['"', '\''] and len(message) >= 3:

+                                message = message[1:-1]

+                            del stored_messages[sender][recipient]

+                            self.save_data('messages', stored_messages)

+                            self.cached_recipients[recipient] = self.cached_recipients[recipient] - 1

+                            self.reply(names[recipient], 'I have a message to you from ' + sender + ': "' + message + '"')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Developed in collaboration with a DID system, this plugin facilitates information on fronting identities in chat.

+

+import json

+import os

+import requests

+

+class MultiplicityPlugin(TimberBotPlugin):

+

+    def startup(self):

+        self.alters = self.load_data('alters', {})

+        self.fronting = None

+        self.coconscious = None

+

+    def provides_commands(self):

+        return ['alterlist', 'fronting', 'whois']

+

+    def provides_admin_commands(self):

+        return ['switch', 'multiplicity_data']

+

+    def help_text(self):

+        return {

+            'alterlist': 'Gives you a list of alters who are likely to front.',

+            'fronting': 'Tells you who is currently fronting. Unsure what this means? Try !multiplicity',

+            'whois': 'Gives a short info blurb on a given alter ("' + self.format_command('whois', 'name') + '").'

+        }

+

+    def __parse_list(self, text):

+        if text is None:

+            return None

+        text = text.replace('+', ',')

+        names = text.split(',')

+        result = []

+        for name in names:

+            name = name.strip()

+            if len(name) > 0:

+                for alter in self.alters:

+                    if name.lower() in self.alters[alter]['names_lowercase']:

+                        name = self.alters[alter]['name']

+                        break

+                result.append(name)

+        return None if len(result) == 0 else result

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'switch':

+            fronting = raw

+            coconscious = None

+            if fronting.find('(') > -1:

+                fronting = fronting[0:fronting.index('(')].strip()

+                coconscious = raw[raw.index('(')+1:]

+                if coconscious[-1] == ')':

+                    coconscious = coconscious[0:-1]

+                coconscious = coconscious.strip()

+            self.fronting = self.__parse_list(fronting)

+            self.coconscious = self.__parse_list(coconscious)

+            msg = 'Now fronting: ' + ', '.join(self.fronting)

+            if self.coconscious is not None:

+                msg += ' (co-conscious: ' + ', '.join(self.coconscious) + ')'

+            self.reply(user, msg)

+            external_output = { 'fronting': self.fronting, 'co-conscious': self.coconscious }

+            external_dir = self.get_conf('external_output_dir')

+            if external_dir is None:

+                external_dir = self.get_storage_directory()

+            exter

+            with open(os.path.join(external_dir, 'multiplicity.json'), 'w') as fp:

+                json.dump(external_output, fp, indent = 4)

+            #self.command_read(None, ['whois'], '')

+        if argv[0] == 'multiplicity_data':

+            if not raw.startswith('http'):

+                self.reply(user, 'This command needs a link to a text file.')

+                return

+            res = requests.get(raw)

+            if res.status_code != 200:

+                self.reply(user, 'Encountered HTTP error ' + str(res.status_code))

+                return

+            if res.headers.get('content-type').split(';')[0] != 'text/plain' and 'dropbox' not in raw:

+                self.reply(user, 'Expected a plain text document, found ' + str(res.headers.get('content-type')))

+                return

+            text = res.text

+            self.alters = {}

+            name = None

+            for line in res.text.split('\n'):

+                line = line.strip()

+                if len(line) == 0:

+                    continue

+                if line.find(':') == -1:

+                    name = line

+                    if name.lower() not in self.alters:

+                        self.alters[name.lower()] = {

+                            'name': name,

+                            'aka': None,

+                            'desc': None,

+                            'names_lowercase': [name.lower()]

+                        }

+                else:

+                    if name is None:

+                        continue

+                    keyword = line[0:line.index(':')].strip()

+                    content = line[line.index(':')+1:].strip()

+                    if keyword == 'desc':

+                        self.alters[name.lower()][keyword] = content

+                    elif keyword == 'aka':

+                        self.alters[name.lower()][keyword] = [alter_name.strip() for alter_name in content.split(',')]

+                        self.alters[name.lower()]['names_lowercase'] = [alter_name.strip().lower() for alter_name in content.split(',')]

+                        self.alters[name.lower()]['names_lowercase'] = [name.lower()] + self.alters[name.lower()]['names_lowercase']

+            self.save_data('alters', self.alters)

+            self.reply(user, 'Loaded multiplicity information for {} alters.'.format(len(self.alters.keys())))

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'fronting':

+            if self.fronting is None:

+                msg = 'Now fronting: unknown'

+            else:

+                msg = 'Now fronting: ' + ', '.join(self.fronting)

+                if self.coconscious is not None:

+                    msg += ' (co-conscious: ' + ', '.join(self.coconscious) + ')'

+            self.reply(user, msg)

+        if argv[0] == 'alterlist':

+            msg = 'Our most common fronters are: '

+            msg += ', '.join([self.alters[alter]['name'] for alter in self.alters])

+            self.reply(user, msg)

+        if argv[0] == 'whois':

+            name = raw.lower()

+            desc = None

+            if len(name) > 0:

+                for alter in self.alters:

+                    if name.lower() in self.alters[alter]['names_lowercase']:

+                        name = self.alters[alter]['name']

+                        desc = self.alters[alter].get('desc')

+                        break

+                if desc is None:

+                    self.reply(user, 'I don\'t have any information about ' + name + '.')

+                else:

+                    self.reply(user, name + ': ' + desc)

+            else:

+                if self.fronting is not None and len(self.fronting) > 0:

+                    for name in self.fronting:

+                        found = False

+                        for alter in self.alters:

+                            if name.lower() in self.alters[alter]['names_lowercase']:

+                                name = self.alters[alter]['name']

+                                desc = self.alters[alter].get('desc')

+                                found = True

+                                self.reply(user, name + ': ' + desc)

+                                break

+                        if not found:

+                            self.reply(user, 'I don\'t have any information about ' + name + '.')

+                else:

+                    self.reply(user, 'I don\'t know who is currently fronting.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Create and vote in polls.

+

+class PollPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['poll', 'polldelete', 'pollstatus', 'pollresults', 'vote']

+

+    def help_text(self):

+        return {'poll': 'Creates a poll ("' + self.format_command('poll', 'NAME', 'option1', 'option2', 'option3', '...') + '"). People can vote using ' + self.format_command('vote') + '. Check up on it later with ' + self.format_command('pollstatus') + ', end it with ' + self.format_command('pollresults') + ' or ' + self.format_command('polldelete') + '.',

+                'vote': 'Votes on a poll ("' + self.format_command('vote', 'youroption') + '"). You can only vote once per poll.'}

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'poll':

+            if len(argv) == 1:

+                self.reply(user, 'You need to tell me a name for your poll. Please retry.')

+            if len(argv) == 2:

+                self.reply(user, 'You need to tell me some voting options for your poll. Please retry.')

+            if len(argv) >= 3:

+                polls = self.load_data('polls', [])

+                user_polls = [poll for poll in polls if poll['owner'] == user]

+                if len(user_polls) == 0:

+                    new_poll = {}

+                    new_poll['title'] = argv[1]

+                    new_poll['owner'] = user

+                    new_poll['voters'] = []

+                    new_poll['options'] = {}

+                    for option in argv[2:]:

+                        new_poll['options'][option.lower()] = {}

+                        new_poll['options'][option.lower()]['title'] = option

+                        new_poll['options'][option.lower()]['votes'] = 0

+                    polls.append(new_poll)

+                    self.save_data('polls', polls)

+                    self.reply(user, 'Your poll "' + argv[1] + '" has been started. Everyone can now vote.')

+                else:

+                    self.reply(user, 'You are already running the poll "' + user_polls[0]['owner'] + '". You can only run one poll at a time.')

+        if argv[0] == 'pollstatus':

+            polls = self.load_data('polls', [])

+            user_polls = [poll for poll in polls if poll['owner'] == user]

+            if len(user_polls) == 0:

+                self.reply(user, 'You don\'t have any running polls.')

+            if len(user_polls) == 1:

+                self.reply(user, 'For the poll "' + user_polls[0]['title'] + '", ' + str(len(user_polls[0]['voters'])) + ' votes have been recorded.')

+        if argv[0] == 'polldelete':

+            polls = self.load_data('polls', [])

+            user_polls = [poll for poll in polls if poll['owner'] == user]

+            if len(user_polls) == 0:

+                self.reply(user, 'You don\'t have any running polls.')

+            if len(user_polls) == 1:

+                polls.remove(user_polls[0])

+                self.save_data('polls', polls)

+                self.reply(user, 'Your poll "' + user_polls[0]['title'] + '" has been deleted.')

+        if argv[0] == 'pollresults':

+            polls = self.load_data('polls', [])

+            user_polls = [poll for poll in polls if poll['owner'] == user]

+            if len(user_polls) == 0:

+                self.reply(user, 'You don\'t have any running polls.')

+            if len(user_polls) == 1:

+                polls.remove(user_polls[0])

+                options = list(user_polls[0]['options'].values())

+                options = sorted(options, key = lambda option : -option['votes'])

+                place = 1

+                result_message = 'Voting for "' + user_polls[0]['title'] + '" is over. Results: '

+                for option in options:

+                    result_message = result_message + str(place) + '. ' + option['title'] + ' (' + str(option['votes']) + '), '

+                    place = place + 1

+                self.save_data('polls', polls)

+                self.message(result_message[:-2])

+        if argv[0] == 'vote':

+            if len(argv) == 1:

+                self.reply(user, 'You need to tell me which option you\'d like to vote for. Please retry.')

+                return

+            polls = self.load_data('polls', [])

+            applicable_polls = [poll for poll in polls if argv[1].lower() in poll['options']]

+            if len(applicable_polls) == 0:

+                self.reply(user, 'There is no running poll where "' + argv[1] + '" is an option.')

+            if len(applicable_polls) == 1:

+                if user not in applicable_polls[0]['voters']:

+                    applicable_polls[0]['options'][argv[1].lower()]['votes'] = applicable_polls[0]['options'][argv[1].lower()]['votes'] + 1

+                    applicable_polls[0]['voters'].append(user)

+                    self.reply(user, 'Your vote for "' + argv[1] + '" in "' + applicable_polls[0]['title'] + '" has been recorded.')

+                    self.save_data('polls', polls)

+                else:

+                    self.reply(user, 'You already voted on "' + applicable_polls[0]['title'] + '".')

+            if len(applicable_polls) > 1:

+                if len(argv) <= 2:

+                    self.reply(user, 'Your vote for "' + argv[1] + '" could apply to several polls. Please specify one of the following poll names after your vote: "' + '", "'.join([poll['title'] for poll in applicable_polls]) + '"')

+                elif argv[2] in [poll['title'] for poll in applicable_polls]:

+                    the_poll = [poll for poll in applicable_polls if poll['title'] == argv[2]][0]

+                    if user not in the_poll['voters']:

+                        the_poll['options'][argv[1].lower()]['votes'] = the_poll['options'][argv[1].lower()]['votes'] + 1

+                        the_poll['voters'].append(user)

+                        self.save_data('polls', polls)

+                        self.reply(user, 'Your vote for "' + argv[1] + '" in "' + the_poll['title'] + '" has been recorded.')

+                    else:

+                        self.reply(user, 'You already voted on "' + the_poll['title'] + '".')

+                else:

+                    self.reply(user, 'I couldn\'t find a poll named "' + argv[2] + '". Please retry.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Runs raffles in chat.

+

+import datetime

+import random

+

+class RafflePlugin(TimberBotPlugin):

+

+    def provides_admin_commands(self):

+        return ['raffle', 'participants']

+

+    def startup(self):

+        self.current_raffle = None

+        self.for_followers = False

+        self.last_shoutout_count = 0

+        self.request_scheduled_update(seconds = 5)

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'participants':

+            if self.current_raffle is not None:

+                participants = ', '.join(self.current_raffle)

+                if len(participants) == 0:

+                    participants = 'none'

+                self.reply(user, 'Current raffle participants: ' + participants)

+            else:

+                self.reply(user, 'There is no a raffle in progress. You can start one with "' + self.format_command('raffle', 'start') + '".')

+            return

+        self.for_followers = False

+        if len(argv) >= 3 and argv[1].lower() == 'for' and argv[2].lower() == 'followers':

+            self.for_followers = True

+            del argv[2]

+            del argv[1]

+        if (len(argv) == 1 and self.current_raffle == None) or (len(argv) >= 2 and argv[1] == 'start'):

+            if self.current_raffle == None:

+                self.current_raffle = []

+                if self.for_followers:

+                    self.message('A raffle just for stream followers has just been started! Type "enter" to participate. :)')

+                else:

+                    self.message('A raffle has just been started! Type "enter" to participate. :)')

+            else:

+                self.reply(user, 'There is already a raffle in progress. End it with "' + self.format_command('raffle', 'end') + '" before you start the next one.')

+        elif (len(argv) == 1 and self.current_raffle != None) or (len(argv) >= 2 and argv[1] == 'end'):

+            if self.current_raffle is not None:

+                if len(self.current_raffle) > 0:

+                    winner = random.choice(self.current_raffle)

+                    num_participants = len(self.current_raffle)

+                    winners = self.load_data('winners', default = [])

+                    winners.append([user, datetime.datetime.utcnow()])

+                    self.save_data('winners', winners)

+                    self.current_raffle = None

+                    self.last_shoutout_count = 0

+                    fragment = 'participants'

+                    if num_participants == 1:

+                        fragment = 'participant'

+                    self.message('The raffle has ended! The winner is: ' + winner + '! (Picked randomly from ' + str(num_participants) + ' ' + fragment + '.)')

+                else:

+                    self.current_raffle = None

+                    self.last_shoutout_count = 0

+                    self.reply(user, 'The raffle has ended. There is no winner because there were no participants.')

+            else:

+                self.reply(user, 'There is no a raffle in progress. You can start one with "' + self.format_command('raffle', 'start') + '".')

+

+    def message_read(self, user, message):

+        if message.lower() == 'enter':

+            if self.current_raffle != None and user not in self.current_raffle:

+                if self.for_followers:

+                    if self.call_function('is_stream_follower', user):

+                        self.current_raffle.append(user)

+                    else:

+                        self.reply(user, 'Sorry, this raffle is just for followers of this stream. (Please note that it may take a few minutes for new followers to become eligible.)')

+                else:

+                    self.current_raffle.append(user)

+

+    def scheduled_update(self):

+        if self.current_raffle != None and len(self.current_raffle) != self.last_shoutout_count:

+            self.last_shoutout_count = len(self.current_raffle)

+            fragment = ' people have'

+            if len(self.current_raffle) == 1:

+                fragment = ' person has'

+            self.message(str(len(self.current_raffle)) + fragment + ' entered the current raffle.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows users to rise through ranks based on number of chat messages.

+

+import collections

+import configparser

+import copy

+import datetime

+import dateutil.parser

+import os

+import pytz

+import re

+import urllib.parse

+

+class RanksPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['rank', 'rankinfo']

+

+    def provides_admin_commands(self):

+        return ['grant', 'promote']

+

+    def help_text(self):

+        return {'rank': 'Display your current participation rank ("' + self.format_command('rank') + '") or that of someone else ("' + self.format_command('rank', 'username') + '").'}

+

+    def startup(self):

+        self.data = self.load_data('data')

+        self.data_changed = False

+        if self.data == None:

+            self.data =  {}

+            self.data_changed = True

+        self.temp_permissions = {}

+        self.load_ranks()

+        self.request_scheduled_update(seconds = 30)

+

+    def scheduled_update(self):

+        if self.data_changed:

+            self.save_data('data', self.data)

+            self.data_changed = False

+

+    def command_priority_read(self, user, argv, raw):

+        self.increase_message_count(user)

+        permissions = self.reevaluate_rank(user)

+        if permissions != None and argv[0] in permissions['all_commands'] and not argv[0] in permissions['commands']:

+            self.reply(user, 'Sorry, but your rank is not high enough to use this command.')

+            return 'consume'

+

+    def message_priority_read(self, user, message):

+        self.increase_message_count(user)

+        self.reevaluate_rank(user)

+

+        link_found = None

+        match = re.match(r".*(http[s]?:\/\/[a-z\d_\-\.\/]+)[^a-z\d_\-\.].*", message)

+        if match != None:

+            link_found = match.group(1)

+        match = re.match(r".*[^a-z\d_\-\.](([a-z\d_\-]+\.)+\.[a-z]{2})\b.*", message)

+        if link_found == None and match != None:

+            link_found = match.group(1)

+        match = re.match(r".*(\S+\.(com|net|org|edu|gov|mil))\b.*", message)

+        if link_found == None and match != None:

+            link_found = match.group(1)

+        temp_allow_links = True

+        temp_permissions = self.temp_permissions.get(user.lower())

+        temp_link_permission = None

+        if temp_permissions != None:

+            temp_link_permission = temp_permissions.get('links')

+        if temp_link_permission != None:

+            if temp_link_permission.get('number') != None:

+                if temp_link_permission['number'] > 0:

+                    temp_allow_links = True

+                    self.temp_permissions[user.lower()]['links']['number'] -= 1

+            if temp_link_permission.get('deadline') != None:

+                if temp_link_permission['deadline'] > datetime.datetime.utcnow():

+                    temp_allow_links = True

+        permissions = self.get_rank(user)

+        if link_found != None and permissions != None and not permissions['links'] and not temp_allow_links:

+            if link_found.find('://') == -1:

+                link_found = 'http://' + link_found

+            urldata = urllib.parse.urlparse(link_found)

+            link_host = urldata.netloc.lower()

+            if link_host.startswith('www.'):

+                link_host = link_host[4:]

+            if link_host.startswith('m.'):

+                link_host = link_host[2:]

+            link_whitelist = self.get_conf('link_whitelist')

+            if link_host not in link_whitelist.split(' '):

+                self.special_action('timeout', {'user': user, 'duration': 5})

+                self.reply(user, 'Sorry, but your rank is not high enough to post links in chat. TimberBot admins: type "' + self.format_command('grant', user.lower(), 'links') + '" to allow it for 5 minutes.')

+                return 'consume'

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'rank':

+            target = user.lower()

+            if len(argv) >= 2:

+                target = argv[1].lower()

+            user_rank_info = self.data.get(target)

+            if user_rank_info == None:

+                self.reply(user, 'I don\'t have any rank information about ' + argv[1] + '.')

+            else:

+                user_rank = self.ranks[user_rank_info['rank']]

+                if target == user.lower():

+                    self.reply(user, 'Your current rank is: ' + user_rank['name'])

+                else:

+                    self.reply(user, user_rank_info['name'] + '\'s current rank is: ' + user_rank['name'])

+        if argv[0] == 'rankinfo':

+            if len(argv) > 1:

+                target_rank = None

+                for k in self.ranks:

+                    if self.ranks[k]['name'].lower() == raw.lower():

+                        target_rank = self.ranks[k]

+                if target_rank != None:

+                    msg = 'To reach the rank of ' + target_rank['name'] + ', you need to send at least '

+                    msg += str(target_rank['prereq_min_messages']) + ' chat messages over a period of at minimum '

+                    msg += self.pretty_interval(target_rank['prereq_min_since_first_message']) + '. It allows you to '

+                    msg += 'use the following commands: ' + ', '.join(sorted(target_rank['privilege_commands']))

+                    self.reply(user, msg)

+                else:

+                    self.reply(user, 'There is no rank named "' + argv[1] + '".')

+            else:

+                rank_names = [self.ranks[i]['name'] for i in self.ranks]

+                self.reply(user, 'Which rank do you want to know about? The following ones are available: ' + ', '.join(rank_names))

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'grant' and len(argv) >= 2:

+            perm = 'links'

+            if len(argv) >= 3:

+                perm = argv[2].lower()

+            perm_target = argv[1].lower()

+            if perm not in ['links']:

+                return

+            if self.temp_permissions.get(perm_target) == None:

+                self.temp_permissions[perm_target] = {}

+            if self.temp_permissions[perm_target].get(perm) == None:

+                self.temp_permissions[perm_target][perm] = {}

+            self.temp_permissions[perm_target][perm]['deadline'] = datetime.datetime.utcnow() + datetime.timedelta(0, 300)

+            if perm == 'links':

+                self.reply(user, 'User ' + argv[1] + ' may now post links in chat for 5 minutes.')

+            else:

+                self.reply(user, 'User ' + argv[1] + ' now has the permission "' + perm + '" for 5 minutes.')

+        if argv[0] == 'promote':

+            if len(argv) >= 2:

+                target = argv[1].lower()

+                old_rank_info = self.data.get(target)

+                if old_rank_info != None:

+                    old_rank = old_rank_info['rank']

+                    new_rank = min(old_rank + 1, len(self.ranks))

+                    if new_rank != old_rank:

+                        self.data[target]['rank'] = new_rank

+                        self.data_changed = True

+                        if old_rank != None:

+                            target_display_name = old_rank_info['name']

+                            self.reply(target_display_name, 'You have been promoted to ' + self.ranks[new_rank]['name'] + ' by ' + user + '. Congratulations!')

+                            self.reply(user, 'Promoted ' + target_display_name + ' to ' + self.ranks[new_rank]['name'] + '.')

+

+    def increase_message_count(self, user):

+        target = user.lower()

+        if target not in self.data:

+            self.data[target] = {}

+            self.data[target]['first_message'] = datetime.datetime.utcnow()

+            self.data[target]['messages'] = 0

+            self.data[target]['name'] = user

+            self.data[target]['rank'] = None

+        self.data[target]['messages'] += 1

+        self.data_changed = True

+

+    def load_ranks(self):

+        self.ranks = collections.OrderedDict()

+        ranks_theme = self.get_conf('theme')

+        data_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ranks')

+        ranks_file = os.path.join(data_dir, ranks_theme + '.ini')

+        if not os.path.isfile(ranks_file):

+            return

+        ranks_cfg = configparser.SafeConfigParser()

+        ranks_cfg.read(ranks_file)

+        sections = ranks_cfg.sections()

+        ranks = collections.OrderedDict()

+        for section in sections:

+            items = dict(ranks_cfg.items(section))

+            ranks[int(items['index'])] = items

+        ranks = collections.OrderedDict(sorted(ranks.items()))

+        current_rank = {}

+        all_commands = []

+        links_for_everyone = True

+        for rank_index in ranks:

+            if 'privilege_links' not in current_rank:

+                current_rank['privilege_links'] = False

+            if 'privilege_streamrecognized' not in current_rank:

+                current_rank['privilege_streamrecognized'] = False

+            if 'privilege_commands' not in current_rank:

+                current_rank['privilege_commands'] = []

+            if 'prereq_min_messages' not in current_rank:

+                current_rank['prereq_min_messages'] = 0

+            if 'prereq_min_since_first_message' not in current_rank:

+                current_rank['prereq_min_since_first_message'] = 0

+            current_rank['index'] = int(ranks[rank_index]['index'])

+            current_rank['name'] = ranks[rank_index]['name']

+            if 'privilege_commands' in ranks[rank_index]:

+                new_commands = ranks[rank_index]['privilege_commands'].split(' ')

+                all_commands.extend(new_commands)

+                current_rank['privilege_commands'].extend(new_commands)

+            if 'privilege_links' in ranks[rank_index]:

+                    links_for_everyone = links_for_everyone and (ranks[rank_index]['privilege_links'] != 'true')  

+                    current_rank['privilege_links'] = current_rank['privilege_links'] or (ranks[rank_index]['privilege_links'] == 'true')

+            if 'privilege_streamrecognized' in ranks[rank_index]:

+                    current_rank['privilege_streamrecognized'] = current_rank['privilege_streamrecognized'] or (ranks[rank_index]['privilege_streamrecognized'] == 'true')

+            if 'prereq_min_messages' in ranks[rank_index]:

+                    current_rank['prereq_min_messages'] = max(current_rank['prereq_min_messages'], int(ranks[rank_index]['prereq_min_messages']))

+            if 'prereq_min_since_first_message' in ranks[rank_index]:

+                    current_rank['prereq_min_since_first_message'] = max(current_rank['prereq_min_since_first_message'], int(ranks[rank_index]['prereq_min_since_first_message']))

+            self.ranks[int(rank_index)] = copy.deepcopy(current_rank)

+        for rank_index in ranks:

+            self.ranks[int(rank_index)]['all_commands'] = all_commands

+            if links_for_everyone:

+                self.ranks[int(rank_index)]['privilege_links'] = True

+

+    def reevaluate_rank(self, user):

+        user_data = self.data.get(user.lower())

+        if user_data == None:

+            return None

+        first_message = user_data['first_message']

+        since_first_message = 0

+        if first_message != None:

+            since_first_message = (datetime.datetime.utcnow() - first_message).total_seconds()

+        num_messages = user_data['messages']

+        old_rank = user_data['rank']

+        if old_rank not in self.ranks:

+            old_rank = None

+        new_rank = old_rank

+        for rank_index in self.ranks:

+            current_rank = self.ranks[rank_index]

+            if since_first_message >= current_rank['prereq_min_since_first_message']:

+                if num_messages >= current_rank['prereq_min_messages']:

+                    if old_rank == None:

+                        target_rank = rank_index

+                    else:

+                        target_rank = max(rank_index, old_rank)

+                    new_rank = min(target_rank, len(self.ranks))

+        if new_rank != old_rank:

+            self.data[user.lower()]['rank'] = new_rank

+            self.data_changed = True

+            if old_rank != None:

+                self.reply(user, 'You have been promoted to ' + self.ranks[new_rank]['name'] + '. Congratulations!')

+        if new_rank == None:

+            return None

+        else:

+            result = {}

+            result['all_commands'] = self.ranks[new_rank]['all_commands']

+            result['commands'] = self.ranks[new_rank]['privilege_commands']

+            result['links'] = self.ranks[new_rank]['privilege_links']

+            result['streamrecognized'] = self.ranks[new_rank]['privilege_streamrecognized']

+            return result

+

+    def get_rank(self, user):

+        rank_info = self.data.get(user.lower())

+        result = None

+        if rank_info != None:

+            rank_index = rank_info['rank']

+            result = {}

+            result['all_commands'] = self.ranks[rank_index]['all_commands']

+            result['commands'] = self.ranks[rank_index]['privilege_commands']

+            result['links'] = self.ranks[rank_index]['privilege_links']

+            result['streamrecognized'] = self.ranks[rank_index]['privilege_streamrecognized']

+        return result

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Functions as a reddit feed that posts an alert whenever a specific subreddit receives a new post.

+

+import urllib.request, urllib.error

+import xml.etree.ElementTree

+

+class RedditPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['reddit']

+

+    def help_text(self):

+        subreddit = self.get_conf('reddit')

+        if subreddit != None:

+            return {'reddit': 'Finds the newest post on /r/' + subreddit + ' and posts the link in here.'}

+        else:

+            return {'reddit': 'I have no subreddit saved for this channel, so the "' + self.format_command('reddit') + '" command will do nothing.'}

+

+    def startup(self):

+        self.__check_subreddit()

+        self.request_scheduled_update(seconds = 60)

+

+    def command_read(self, user, argv, raw):

+        subreddit = self.get_conf('reddit')

+        if subreddit != None:

+            newest_post = self.load_data('newest_post')

+            known_posts = self.load_data('known_posts')

+            if newest_post == None or known_posts == None:

+                self.reply(user, 'No posts found on /r/' + subreddit + '.')

+            else:

+                self.reply(user, 'Newest post on /r/' + subreddit + ': ' + known_posts[newest_post])

+        else:

+            self.reply(user, 'There is no subreddit configured for this channel.')

+

+    def scheduled_update(self):

+        self.__check_subreddit()

+

+    def __check_subreddit(self, silent = False):

+        subreddit = self.get_conf('reddit')

+        if subreddit == None:

+            return

+        opener = urllib.request.build_opener()

+        opener.addheaders = [('User-agent', 'Mozilla/5.0')]

+        try:

+            subreddit_rss = opener.open('http://www.reddit.com/r/' + subreddit + '/new/.rss').read().decode('utf-8')

+        except (urllib.error.HTTPError, urllib.error.URLError):

+            return

+

+        rss_tree = xml.etree.ElementTree.fromstring(subreddit_rss)

+

+        item_id = rss_tree.find('{http://www.w3.org/2005/Atom}entry').find('{http://www.w3.org/2005/Atom}link').attrib['href'].split('/')[6]

+        old_item_id = self.load_data('newest_post')

+        if item_id != old_item_id:

+            self.save_data('newest_post', item_id)

+            known_posts = self.load_data('known_posts', {})

+            new_posts = []

+            for item in rss_tree.findall('{http://www.w3.org/2005/Atom}entry'):

+                item_id = item.find('{http://www.w3.org/2005/Atom}link').attrib['href'].split('/')[6]

+                if item_id not in known_posts:

+                    link = 'http://redd.it/' + item_id

+                    title = item.findtext('{http://www.w3.org/2005/Atom}title')

+                    username = item.find('{http://www.w3.org/2005/Atom}author').findtext('{http://www.w3.org/2005/Atom}name')[3:]

+                    announcement = '"' + title + '" submitted by ' + username + ' - ' + link

+                    known_posts[item_id] = announcement

+                    new_posts.append(announcement)

+            if len(new_posts) <= 2 and not silent:

+                for announcement in new_posts:

+                    self.message('New post on /r/' + subreddit + ': ' + announcement)

+            self.save_data('known_posts', known_posts)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Example plugin that provides a command which repeats its argument.

+

+class RepeatPlugin(TimberBotPlugin):

+

+    def provides_admin_commands(self):

+        return ['repeat']

+

+    def admin_command_read(self, user, argv, raw):

+        if len(argv) >= 2:

+            self.message(raw)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Simple art request queue for chat users.

+

+import re

+

+class RequestQueuePlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['requests']

+

+    def provides_admin_commands(self):

+        return ['requestdone', 'requestlist']

+

+    def help_text(self):

+        return {'requests': 'To enter your request, paste this message into chat and put in your info: "✎ [what you\'re requesting] ★ [further details]" (only one request per person at a time)'}

+

+    def startup(self):

+        self.current_queue = self.load_data('queue', default = [])

+        self.current_format = self.get_conf('request_format', default = '✎{1}★{2}')

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'requests':

+            self.reply(user, self.help_text()['requests'])

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'requestlist':

+            if len(argv) > 1 and argv[1] == 'clear':

+                self.current_queue = []

+                self.save_data('queue', self.current_queue)

+                self.reply(user, 'Cleared all requests.')

+                return

+            if len(argv) > 2 and argv[1] == 'format':

+                self.current_format = argv[2]

+                self.set_conf('request_format', self.current_format)

+                self.reply(user, 'Changed request format to: ' + argv[2])

+                return

+            if len(self.current_queue) == 0:

+                self.reply(user, 'There are currently no requests on the list.')

+            else:

+                n = 1

+                self.reply(user, 'There are currently ' + str(len(self.current_queue)) + ' requests on the list.')

+                for req in self.current_queue:

+                    self.message(str(n) + ': ' + req['request'] + ' (by ' + req['user'] + ')')

+                    n += 1

+        if argv[0] == 'requestdone':

+            request_number = 1

+            if len(argv) >= 2:

+                request_number_arg = argv[1]

+                if request_number_arg.startswith('#'):

+                    request_number_arg = request_number_arg[1:]

+                if request_number_arg.isdigit():

+                    request_number = int(request_number_arg)

+            if request_number <= 0 or request_number > len(self.current_queue):

+                self.reply(user, 'The request number ' + str(request_number) + ' does not seem to exist in the current queue.')

+                return

+            removed_req = self.current_queue[request_number - 1]

+            del self.current_queue[request_number - 1]

+            self.save_data('queue', self.current_queue)

+            self.reply(user, 'Request #' + str(request_number) + ' by ' + removed_req['user'] + ' has been removed from the queue.')

+

+    def message_read(self, user, message):

+        message = message.strip()

+        pattern = re.escape(self.current_format)

+        for i in range(10):

+            pattern = pattern.replace('\{' + str(i) + '\}', '(.+)')

+        mt = re.compile(pattern).match(message)

+        if mt is not None:

+            if user in [q['user'] for q in self.current_queue]:

+                self.current_queue = [q for q in self.current_queue if q['user'] != user]

+                self.current_queue.append({'user': user, 'request': message})

+                self.reply(user, 'Your previous request has been deleted and the new request has been recorded! You are now #' + str(len(self.current_queue)) + ' in the queue.')

+            else:

+                self.current_queue.append({'user': user, 'request': message})

+                self.reply(user, 'Your request has been recorded! You are #' + str(len(self.current_queue)) + ' in the queue.')

+            self.save_data('queue', self.current_queue)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Post a message in chat whenever a specific RSS feed receives a new post.

+

+import datetime

+import re

+import requests

+import urllib.parse

+import xml.etree.ElementTree

+

+class RssForwardPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['latest']

+

+    def provides_admin_commands(self):

+        return ['feed']

+

+    def help_text(self):

+        return {

+            'latest': 'For a given feed that the bot is subscribed to, show the latest item.'

+        }

+

+    def startup(self):

+        self.feeds = self.load_data('feeds', {})

+        self.rate_limit = {}

+        self.time_between_checks = 15 * 60

+        silent_start = self.get_conf('silent_start')

+        if silent_start == None:

+            silent_start = True

+        self.__check_feeds(silent = silent_start)

+        self.request_scheduled_update(seconds = 5)

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'latest':

+            feed = None

+            if len(argv) >= 2:

+                feed = argv[1]

+            elif len(self.feeds.keys()) == 1:

+                feed = list(self.feeds.keys())[0]

+            if feed is None:

+                if len(self.feeds.keys()) == 0:

+                    self.reply(user, 'There are currently no feeds configured.')

+                else:

+                    self.reply(user, 'Which newest item would you like to see? Available feeds: ' + ', '.join(self.feeds.keys()))

+                return

+            if feed not in self.feeds:

+                self.reply(user, 'There is no feed named "' + feed + '". Available feeds: ' + ', '.join(self.feeds.keys()))

+                return

+            if len(self.feeds[feed]['posted_items']) == 0:

+                self.reply(user, 'There are no items yet for feed "' + feed + '".')

+                return

+            newest_item = self.feeds[feed]['posted_items'][-1]

+            text = self.feeds[feed].get('template')

+            if text is None:

+                text = '{url}'

+            text = text.replace('{url}', newest_item)

+            self.reply(user, text)

+

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'feed':

+            if len(argv) >= 3:

+                feed_id = argv[1]

+                url = argv[2]

+                template = None

+                if len(argv) >= 4:

+                    template = argv[3]

+                if url in ['delete', 'remove'] and feed_id in self.feeds:

+                    del self.feeds[feed_id]

+                    self.reply(user, 'Feed "' + feed_id + '" has been deleted.')

+                else:

+                    already_existed = feed_id in self.feeds

+                    self.feeds[feed_id] = {}

+                    self.feeds[feed_id]['url'] = url

+                    self.feeds[feed_id]['template'] = template

+                    self.feeds[feed_id]['posted_items'] = []

+                    self.__check_feeds(silent = True, feeds = [feed_id])

+                    self.reply(user, 'Feed "' + feed_id + '" has been ' + ('edited' if already_existed else 'added') + '.')

+                self.save_data('feeds', self.feeds)

+            else:

+                self.reply(user, 'Format for adding or editing a feed: ' + self.format_command('feed', 'feed-name', 'feed-url', 'Feed text template {url}'))

+

+    def scheduled_update(self):

+        self.__check_feeds()

+

+    def __check_feeds(self, silent = False, feeds = None):

+        items_to_post = []

+        if feeds is None:

+            feeds = self.feeds

+        for feed in feeds:

+            url = self.feeds[feed]['url']

+            parsed = urllib.parse.urlparse(url)

+            if parsed.netloc not in self.rate_limit:

+                self.rate_limit[parsed.netloc] = {

+                    'delay': self.time_between_checks,

+                    'last_request': None

+                }

+            if self.rate_limit[parsed.netloc]['last_request'] is not None and self.rate_limit[parsed.netloc]['last_request'] + datetime.timedelta(seconds=self.rate_limit[parsed.netloc]['delay']) > datetime.datetime.utcnow():

+                continue

+            self.rate_limit[parsed.netloc]['last_request'] = datetime.datetime.utcnow()

+            try:

+                req = requests.get(url)

+                feed_contents = req.text

+            except requests.exceptions.ConnectionError:

+                print('Connection error fetching URL:', url)

+                if req.status_code == 429:

+                    self.rate_limit[parsed.netloc]['delay'] *= 2

+                    print('Registered rate limit, new delay time:', self.rate_limit[parsed.netloc]['delay'], parsed.netloc)

+                    self.rate_limit[parsed.netloc]['delay'] *= 2

+                continue

+            #print(req, url)

+            self.rate_limit[parsed.netloc]['delay'] = self.time_between_checks

+            #feed_contents = re.sub(' xmlns:dc="[^"]+"', '', feed_contents, count = 1)

+            feed_tree = xml.etree.ElementTree.fromstring(feed_contents)

+            items = []

+            if feed_tree.find('channel') is not None:

+                items = feed_tree.find('channel').findall('item')

+                for item in items:

+                    item_link = item.findtext('link')

+                    if item_link not in self.feeds[feed]['posted_items']:

+                        items_to_post.append({ 'feed': feed, 'url': item_link })

+            if feed_tree.findall('{http://www.w3.org/2005/Atom}entry') is not None:

+                items = feed_tree.findall('{http://www.w3.org/2005/Atom}entry')

+                for item in items:

+                    item_link = 'https://youtu.be/' + item.findtext('{http://www.youtube.com/xml/schemas/2015}videoId')

+                    if item_link not in self.feeds[feed]['posted_items']:

+                        items_to_post.append({ 'feed': feed, 'url': item_link })

+        items_to_post = list(reversed(items_to_post))

+        changes_made = False

+        for item in items_to_post:

+            text = self.feeds[item['feed']].get('template')

+            if text is None:

+                text = '{url}'

+            text = text.replace('{url}', item['url'])

+            if not silent:

+                self.message(text)

+            self.feeds[item['feed']]['posted_items'].append(item['url'])

+            changes_made = True

+        if changes_made:

+            self.save_data('feeds', self.feeds)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Allows you to schedule events in advance and have reminders posted to chat.

+

+import datetime

+import math

+

+class ScheduledEventsPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['next', 'when']

+

+    def help_text(self):

+        return {'next': 'Starts the next scheduled event immediately.',

+                'when': 'Gives information about the next scheduled event.',}

+

+    def startup(self):

+        self.events = self.load_data('events', default = [{'abc': 'def'}])

+        self.request_scheduled_update(seconds = 1)

+

+    def command_read(self, user, argv, raw):

+        next_event = None

+        for event in self.events:

+            if 'title' not in event:

+                continue

+            if 'date' not in event:

+                continue

+            if event['date'] > datetime.datetime.utcnow():

+                if next_event == None or event['date'] < next_event['date']:

+                    next_event = event

+        if next_event == None:

+            self.reply(user, 'There is currently nothing on the schedule.')

+        else:

+            if argv[0] == 'next':

+                next_event['date'] = datetime.datetime.utcnow() + datetime.timedelta(seconds = 7)

+                next_event['announcements'] = 2

+                self.save_data('events', self.events)

+            if argv[0] == 'when':

+                until_event = math.floor((next_event['date'] - datetime.datetime.utcnow()).total_seconds())

+                self.reply(user, 'Next event: ' + next_event['title'] + ', in ' + self.pretty_interval(until_event))

+

+    def scheduled_update(self):

+        changes_made = False

+        i = 0

+        for event in self.events:

+            if 'title' not in event:

+                continue

+            if 'date' not in event:

+                continue

+            if 'announcements' not in event:

+                event['announcements'] = 0

+            until_event = math.floor((event['date'] - datetime.datetime.utcnow()).total_seconds())

+            if event['announcements'] == 0 and until_event <= 30 * 60:

+                self.message('30 minutes until: ' + event['title'] + ' @here')

+                event['announcements'] = 1

+                changes_made = True

+            elif event['announcements'] == 1 and until_event <= 5 * 60:

+                self.message('5 minutes until: ' + event['title'] + ' @here')

+                event['announcements'] = 2

+                changes_made = True

+            elif event['announcements'] < 12 and until_event <= 5 and until_event > 0 and event['announcements'] < 3 + 10 - until_event:

+                self.message(str(until_event) + '...')

+                event['announcements'] = 3 + 10 - until_event

+                changes_made = True

+            elif event['announcements'] == 12 and until_event <= 0:

+                s = ' '.join(event['title'].upper())

+                self.message('Starting now: ' + s)

+                event['announcements'] = 13

+                changes_made = True

+            else:

+                continue

+            self.events[i] = event

+            i += 1

+        if changes_made:

+            self.save_data('events', self.events)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Plugin that shines a spotlight on someone or something when prompted.

+

+class SpotlightPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['spotlight']

+

+    def help_text(self):

+        return {'spotlight': 'Finds out who is currently in the spotlight ("' + self.format_command('spotlight') + '") or changes it ("' + self.format_command('spotlight', 'username') + '").'}

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1:

+            spotlight = self.load_data('spotlight', default = [None, None])

+            if spotlight[0] != None:

+                reason = ''

+                if spotlight[1] != None:

+                    reason = ' Reason: ' + spotlight[1]

+                self.reply(user, 'The spotlight is currently on ' + spotlight[0] + '.' + reason)

+            else:

+                self.reply(user, 'There is currently nobody in the spotlight.')

+        if len(argv) >= 2:

+            reason = None

+            if len(argv) >= 3:

+                reason = ' '.join(argv[2:])

+            self.save_data('spotlight', [argv[1], reason])

+            self.reply(user, 'You have set the spotlight on ' + argv[1] + '.')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Collects stats about each person's chat messages and command usage.

+

+class StatsPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['stats']

+

+    def help_text(self):

+        return {'stats': 'Report some general statistics about this chat ("' + self.format_command('stats') + '"), about a specific command ("' + self.format_command('stats', 'commandname') + '") or about a user ("' + self.format_command('stats', 'username') + '").'}

+

+    def startup(self):

+        self.stats = self.load_data('stats')

+        self.data_changed = False

+        if self.stats == None:

+            self.stats =  {}

+            self.stats['all'] =  {}

+            self.stats['all']['all'] = 0

+            self.stats['all']['messages'] = 0

+            self.data_changed = True

+        self.request_scheduled_update(seconds = 30)

+

+    def scheduled_update(self):

+        if self.data_changed:

+            self.save_data('stats', self.stats)

+            self.data_changed = False

+

+    def command_priority_read(self, user, argv, raw):

+        self.stats['all']['all'] += 1

+        command = argv[0].lower()

+        if command not in self.stats['all']:

+            self.stats['all'][command] = 0

+        self.stats['all'][command] += 1

+        if user not in self.stats:

+            if user.lower() in self.stats:

+                self.stats[user] = self.stats[user.lower()]

+                del self.stats[user.lower()]

+            else:

+                self.stats[user] = {}

+        if 'all' not in self.stats[user]:

+            self.stats[user]['all'] = 0

+        self.stats[user]['all'] += 1

+        if command not in self.stats[user]:

+            self.stats[user][command] = 0

+        self.stats[user][command] += 1

+        self.data_changed = True

+

+    def message_priority_read(self, user, message):

+        if user not in self.stats:

+            if user.lower() in self.stats:

+                self.stats[user] = self.stats[user.lower()]

+                del self.stats[user.lower()]

+            else:

+                self.stats[user] = {}

+        if 'all' not in self.stats[user]:

+            self.stats[user]['all'] = 0

+        self.stats[user]['all'] += 1

+        if 'messages' not in self.stats[user]:

+            self.stats[user]['messages'] = 0

+        self.stats[user]['messages'] += 1

+        self.stats['all']['all'] += 1

+        self.stats['all']['messages'] += 1

+        self.data_changed = True

+

+    def command_read(self, user, argv, raw):

+        if len(argv) == 1 or (len(argv) == 2 and argv[1].lower() == 'extended'):

+            users = [name for name in self.stats if name != 'all']

+            def get_count(n):

+                return -1 * self.stats[n]['all']

+            users.sort(key = get_count)

+            total_num = len(users)

+            top_num = 3

+            if len(argv) == 2:

+                top_num = 8

+            if len(users) > top_num:

+                users = users[0:top_num]

+            chatters = ''

+            for i in range(0, len(users)):

+                chatters += str(i+1) + '. ' + users[i] + ' (' + str(self.stats[users[i]]['all'])

+                if i == 0:

+                    chatters += ' messages'

+                chatters += '), '

+            chatters = chatters[:-2]

+            msg = 'I have counted ' + str(self.stats['all']['all']) + ' chat messages from ' + str(total_num) + ' different users. Our most talkative chatters are: ' + chatters + '.'

+            self.reply(user, msg)

+        elif len(argv) >= 2:

+            target = argv[1]

+            if target == 'me':

+                target = user

+            if target == self.bot_name():

+                self.reply(user, 'Oh, I don\'t keep count of my own messages.')

+                return

+            commands = []

+            for event in self.stats['all']:

+                if event in ['all', 'messages']:

+                    continue

+                if not event in commands:

+                    commands.append(event)

+            if target in commands:

+                users = {}

+                biggest_user = None

+                for stats_user in self.stats:

+                    if stats_user == 'all':

+                        continue

+                    user_data = self.stats[stats_user]

+                    use_count = 0

+                    for event in user_data:

+                        if event == target:

+                            use_count += user_data[event]

+                    users[stats_user] = use_count

+                    if biggest_user == None or users[stats_user] > users[biggest_user]:

+                        biggest_user = stats_user

+                self.reply(user, 'The "' + target + '" command has been used ' + str(users['all']) + ' times. Its most enthusiastic user is ' + biggest_user + ' (' + str(users[biggest_user]) + ' uses).')

+            else:

+                if target.lower() in self.stats and target not in self.stats:

+                    self.stats[target] = self.stats[target.lower()]

+                    del self.stats[target.lower()]

+                data = self.stats.get(target)

+                if data == None:

+                    self.reply(user, 'I don\'t have any data on ' + argv[1] + '.')

+                    return

+                all = data['all']

+                command_count = dict()

+                favorite = None

+                for event in data:

+                    count = data[event]

+                    if event in ['all', 'messages']:

+                        continue

+                    if ' ' in event:

+                        event = event.split(' ')[0]

+                    if event not in command_count:

+                        command_count[event] = 0

+                    command_count[event] += count

+                    if favorite == None or command_count[event] > command_count[favorite]:

+                        favorite = event

+                if argv[1].lower() == 'me':

+                    msg = 'You have sent ' + str(all) + ' chat messages since I started counting.'

+                    if favorite == None:

+                        msg += ' You have not used any of my commands yet. :('

+                    else:

+                        msg += ' Your favorite command is "' + favorite + '" (used ' + str(command_count[favorite]) + ' times).'

+                    self.reply(user, msg)

+                elif argv[1].lower() == 'all':

+                    self.reply(user, 'All in all, people have sent ' + str(all) + ' chat messages since I started counting. The most-used command is "' + favorite + '" (used ' + str(command_count[favorite]) + ' times).')

+                else:

+                    msg = target + ' has sent ' + str(all) + ' chat messages since I started counting.'

+                    if favorite == None:

+                        msg += ' ' + target + ' has not used any of my commands yet.'

+                    else:

+                        msg += ' ' + target + '\'s favorite command is "' + favorite + '" (used ' + str(command_count[favorite]) + ' times).'

+                    self.reply(user, msg)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Receive information about the game that is currently being streamed.

+

+import string

+

+class StreamGamePlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['game']

+

+    def provides_admin_commands(self):

+        return ['game']

+

+    def help_text(self):

+        return {'game': 'Gives basic information about the game that is currently being streamed.'}

+

+    def requires_functions(self):

+        return ['get_current_stream_game', 'get_stream_channel_name']

+

+    def command_read(self, user, argv, raw):

+        game_data = self.load_data('game_data', default = {})

+        msg = None

+        target_game = None

+        if len(argv) == 1:

+            target_game = self.call_function('get_current_stream_game')

+            owner = self.call_function('get_stream_channel_name')

+            if target_game == None:

+                msg = 'From what I can see, it seems like ' + owner + ' is currently not playing anything.'

+            else:

+                msg = owner + ' is currently playing ' + target_game + '.'

+        if len(argv) >= 2:

+            request = argv[1].lower()

+            punctuation = set(string.punctuation)

+            request = ''.join(ch for ch in request if ch not in punctuation).strip()

+            if argv[1] in game_data:

+                target_game = argv[1]

+            else:

+                aliases = self.load_data('game_aliases', default = {})

+                if request in aliases:

+                    target_game = aliases[request]

+            if target_game != None:

+                msg = 'Game: ' + target_game + '.'

+            else:

+                msg = 'I don\'t have any game stored under that name.'

+        if target_game != None and target_game in game_data:

+            msg += ' ' + game_data[target_game]['desc']

+        if msg != None:

+            self.reply(user, msg)

+

+    def admin_command_read(self, user, argv, raw):

+         if len(argv) == 3:

+             game_data = self.load_data('game_data', default = {})

+             game = argv[1]

+             desc = argv[2]

+             game_data[game] = {'desc': desc}

+             self.save_data('game_data', game_data)

+             self.reply(user, 'Description for "' + game + '" has been saved: "' + desc + '"')

+         elif len(argv) == 4 and argv[1] == 'alias':

+             alias_data = self.load_data('game_aliases', default = {})

+             alias = argv[2]

+             game = argv[3]

+             alias_data[alias] = game

+             self.save_data('alias_data', alias_data)

+             self.reply(user, 'Alias "' + alias + '" has been set to point to game "' + game + '".')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Plugin that provides integration with the Twitch API and offers functions that may be used by other plugins.

+

+import datetime

+import dateutil.parser

+import json

+import pytz

+import os

+import requests

+import time

+

+class StreamPlatformTwitchPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['twitch']

+

+    def provides_functions(self):

+        return ['get_current_stream_game', 'get_current_stream_data', 'get_stream_channel_name', 'is_stream_active', 'is_stream_follower']

+

+    def startup(self):

+        self.auth = None

+        self.base_url = 'https://api.twitch.tv/helix/'

+        if self.get_conf('user_id') is None and self.get_conf('channel') is not None:

+            path = 'users?login=' + self.get_conf('channel')

+            user_json = self.get_api_content(path)

+            user_info = json.loads(user_json)

+            user_id = user_info['data'][0]['id']

+            self.set_conf('user_id', user_id)

+        self.request_scheduled_update(seconds = 60)

+        self.current_stream = {}

+        self.known_games = self.load_data('known_games', {})

+        try:

+            self.check_twitch_stats(True)

+        except Exception: # probably a network connection error, pretty safe to ignore at this stage

+            pass

+

+    def scheduled_update(self):

+        self.check_twitch_stats(False)

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'twitch':

+            if self.get_conf('channel') != None:

+                owner = self.get_conf('channel')

+                self.reply(user, 'Check out ' + owner + '\'s Twitch channel at http://twitch.tv/' + self.get_conf('channel').lower())

+            else:

+                self.reply(user, 'There is no Twitch channel configured for this channel.')

+

+    def is_stream_active(self):

+        if 'active' in self.current_stream:

+            return self.current_stream['active']

+        else:

+            return False

+

+    def is_stream_follower(self, name):

+        if self.get_conf('channel') is None:

+            return False

+

+        twitch_followers_info = self.load_data('followers_info')

+        if twitch_followers_info is None:

+            return False

+

+        return name.lower() in [twitch_followers_info[k]['name'].lower() for k in twitch_followers_info]

+

+    def get_current_stream_game(self):

+        return self.current_stream.get('game')

+

+    def get_current_stream_data(self):

+        return self.current_stream

+

+    def get_stream_channel_name(self):

+        return self.get_conf('channel')

+

+    def json_datetime_to_naive_utc(self, timestamp):

+        ts = dateutil.parser.parse(timestamp)

+        ts = ts.astimezone(pytz.timezone('UTC'))

+        ts = ts.replace(tzinfo = None)

+        ts = ts.replace(microsecond = 0)

+        return ts

+

+    def check_twitch_stats(self, silent):

+        if self.get_conf('user_id') == None:

+            return

+

+        if self.current_stream == None:

+            self.current_stream = {}

+        self.current_stream['platform'] = 'twitch'

+

+        twitch_followers_info = self.load_data('followers_info')

+        if twitch_followers_info == None or type(twitch_followers_info[list(twitch_followers_info.keys())[0]]) is not dict:

+            twitch_followers_info = {}

+            self.save_data('followers', 0)

+            self.save_data('last_follower_date', None)

+

+        done = False

+        path = 'users/follows?to_id=' + self.get_conf('user_id')

+        new_follows_num = 0

+        new_follows_names = []

+        while not done:

+            follows_json = self.get_api_content(path)

+            if len(follows_json) == 0:

+                return

+            follows_info = json.loads(follows_json)

+            old_followers = self.load_data('followers', default = 0)

+            if follows_info['total'] > old_followers:

+                self.save_data('followers', follows_info['total'])

+            if 'data' in follows_info:

+                if self.load_data('last_follower_date') is None:

+                    if len(follows_info['data']) > 0:

+                        latest_follow_date = self.json_datetime_to_naive_utc(follows_info['data'][0]['followed_at'])

+                    else:

+                        latest_follow_date = datetime.datetime(1970, 1, 1, 0, 0, 0)

+                    self.save_data('last_follower_date', latest_follow_date)

+                follows = follows_info['data']

+                if len(follows) == 0:

+                    done = True

+                    break

+                for follow in follows:

+                    if follow['from_id'] not in twitch_followers_info:

+                        follow_data = {}

+                        follow_data['user_id'] = follow['from_id']

+                        follow_data['name'] = follow['from_name']

+                        follow_data['timestamp'] = self.json_datetime_to_naive_utc(follow['followed_at'])

+                        twitch_followers_info[follow_data['user_id']] = follow_data

+                        new_follows_num = new_follows_num + 1

+                        new_follows_names.append(follow_data['name'])

+                    else:

+                        # Reached the part of the follower list that was already known

+                        done = True

+                        break

+            if 'pagination' in follows_info and 'cursor' in follows_info['pagination']:

+                path = 'users/follows?to_id=' + self.get_conf('user_id') + '&after=' + follows_info['pagination']['cursor']

+            else:

+                done = True

+        if new_follows_num > 0:

+            self.save_data('followers_info', twitch_followers_info)

+

+        twitch_followers = self.load_data('followers', default = 0)

+        if self.get_conf('new_follower_shoutout') and new_follows_num > 0 and twitch_followers > 0 and not silent:

+            msg = None

+            channel_display_name = self.get_conf('channel')

+            new_follows_names.reverse()

+            new_follows_list = ', '.join(new_follows_names)

+            if len(new_follows_names) >= 2:

+                new_follows_list = ', '.join(new_follows_names[:-1]) + ' and ' + new_follows_names[-1]

+            if len(new_follows_names) >= 1:

+                msg = 'Thanks to ' + new_follows_list + ' for following the ' + channel_display_name + ' channel!'

+                msg += ' Woo! Now at ' + str(twitch_followers) + ' followers.'

+            if msg is not None:

+                self.message(msg)

+

+        stream_json = self.get_api_content('streams?user_id=' + self.get_conf('user_id'))

+        if len(stream_json) == 0:

+            return

+        stream_info = json.loads(stream_json)

+        if len(stream_info['data']) == 0:

+            self.current_stream['active'] = False

+            self.current_stream['game'] = None

+            self.current_stream['status'] = None

+            if 'start_date' in self.current_stream:

+                del self.current_stream['start_date']

+            if 'end_date' in self.current_stream:

+                del self.current_stream['end_date']

+        else:

+            self.current_stream['active'] = True

+            if 'started_at' in stream_info['data'][0]:

+                started_at = stream_info['data'][0]['started_at']

+                start_datetime = self.json_datetime_to_naive_utc(started_at)

+                self.current_stream['start_date'] = start_datetime

+            else:

+                if 'start_date' not in self.current_stream or self.current_stream['start_date'] is None:

+                    self.current_stream['start_date'] = datetime.datetime.utcnow()

+            self.current_stream['end_date'] = None

+            if 'viewer_count' in stream_info['data'][0]:

+                self.current_stream['viewers'] = stream_info['data'][0]['viewer_count']

+            else:

+                self.current_stream['viewers'] = 0

+            if 'title' in stream_info['data'][0]:

+                self.current_stream['status'] = stream_info['data'][0]['title']

+            else:

+                self.current_stream['status'] = None

+            if 'game_id' in stream_info['data'][0]:

+                game_id = stream_info['data'][0]['game_id']

+                if game_id not in self.known_games:

+                    game_json = self.get_api_content('games?id=' + game_id)

+                    if len(game_json) == 0:

+                        self.current_stream['game'] = None

+                    else:

+                        game_info = json.loads(game_json)

+                        if len(game_info['data']) == 0:

+                            self.current_stream['game'] = None

+                        else:

+                            self.known_games[game_id] = game_info['data'][0]['name']

+                self.current_stream['game'] = self.known_games[game_id]

+            else:

+                self.current_stream['game'] = None

+

+    def get_api_content(self, path):

+        if self.auth is None:

+            self.auth = {}

+            for param in ['client_id', 'client_secret', 'oauth_token', 'oauth_expiration']:

+                self.auth[param] = self.get_conf(param)

+            if self.auth['client_id'] is None or self.auth['client_secret'] is None:

+                print('Error: Twitch API credentials not present or incomplete!')

+                self.auth = None

+                return

+        headers = {

+            'Client-ID': self.auth['client_id'],

+            'Authorization': 'Bearer ' + (self.auth['oauth_token'] if self.auth['oauth_token'] is not None)

+        }

+        r = requests.get(self.base_url + path, headers=headers)

+        if r.status_code == requests.codes.unauthorized:

+            # Most likely reason for a 401: OAuth expiration

+            print('Twitch OAuth token expired, acquiring a new one...')

+            params = {

+                'client_id': self.auth['client_id'],

+                'client_secret': self.auth['client_secret'],

+                'grant_type': 'client_credentials'

+            }

+            r = requests.post('https://id.twitch.tv/oauth2/token', params=params)

+            if r.status_code == requests.codes.ok:

+                auth_data = json.loads(r.text)

+                self.auth['oauth_token'] = auth_data['access_token']

+                self.set_conf('oauth_token', self.auth['oauth_token'])

+                expiration = datetime.datetime.utcnow() + datetime.timedelta(seconds=auth_data['expires_in'])

+                self.auth['oauth_expiration'] = expiration.isoformat()

+                self.set_conf('oauth_expiration', self.auth['oauth_expiration'])

+                return self.get_api_content(path)

+            else:

+                print('Error: Twitch API token process failed! HTTP', r.status_code)

+                return

+        elif r.status_code == requests.codes.ok:

+            return r.text

+        else:

+             print('Error: Unknown error accessing Twitch API: ' + str(r.status_code))

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Provide information on a stream schedule.

+

+import datetime

+import dateutil.parser

+import json

+import pytz

+import urllib.request, urllib.error

+

+class StreamSchedulePlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['stream']

+

+    def provides_admin_commands(self):

+        return ['nextstream']

+

+    def requires_functions(self):

+        return ['get_stream_channel_name', 'is_stream_active']

+

+    def help_text(self):

+        return {'stream': 'Tells you when the next stream is about to start, provided that schedule data exists.'}

+

+    def startup(self):

+        self.request_scheduled_update(seconds = 60)

+        self.last_schedule_revision = None

+        self.schedule_data = {}

+        self.check_stream_schedule()

+

+    def scheduled_update(self):

+        self.check_stream_schedule()

+

+    def command_read(self, user, argv, raw):

+        stream_message = self.get_stream_command_result(user)[0]

+        self.reply(user, stream_message)

+

+    def admin_command_read(self, user, argv, raw):

+        if argv[0] == 'nextstream':

+            if len(argv) >= 2 and argv[1].lower() not in ['clear', 'delete']:

+                next_stream = command[1:]

+                weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']

+                utc_now = pytz.utc.localize(datetime.datetime.utcnow())

+                tz_name = self.get_conf('timezone')

+                tz = pytz.timezone(tz_name)

+                local_time = utc_now.astimezone(tz)

+                target_date = None

+                target_time = None

+                flags = []

+                for infobit in next_stream:

+                    infobit = infobit.lower()

+                    if infobit == 'today':

+                        target_date = local_time.date()

+                    elif infobit == 'tomorrow':

+                        target_date = local_time.date() + datetime.timedelta(days=1)

+                    elif infobit in weekdays:

+                        days_ahead = weekdays.index(infobit) - local_time.date().weekday()

+                        if days_ahead <= 0: # Target day already happened this week

+                            days_ahead += 7

+                        target_date = local_time.date() + datetime.timedelta(days=days_ahead)

+                    elif infobit in ['around', 'maybe', 'later']:

+                        flags.append(infobit)

+                    else: # assumed to be a time

+                        hour = 0

+                        minute = 0

+                        segment = '24h'

+                        if len(infobit) >= 3 and infobit[-2:] == 'am':

+                            segment = 'am'

+                            infobit = infobit[:-2]

+                        if len(infobit) >= 3 and infobit[-2:] == 'pm':

+                            segment = 'pm'

+                            infobit = infobit[:-2]

+                        hm = infobit.split(':')

+                        if len(hm) > 1:

+                            minute = int(hm[1].lstrip('0'))

+                        hour = int(hm[0].lstrip('0'))

+                        hour = hour % 24

+                        minute = minute % 60

+                        if hour == 12 and segment == 'am':

+                            hour = 0

+                        if hour != 12 and segment == 'pm':

+                            hour += 12

+                        target_time = datetime.time(hour, minute, 0)

+                if target_date == None:

+                    target_date = local_time.date()

+                    if target_time < local_time.time(): # date rollover?

+                        target_date = target_date + datetime.timedelta(days=1)

+                if target_time != None:

+                    target_datetime = tz.localize(datetime.datetime.combine(target_date, target_time))

+                    next_stream = {}

+                    next_stream['datetime'] = target_datetime

+                    next_stream['flags'] = ''.join(flags)

+                    next_stream['set_on'] = local_time

+                    next_stream['set_by'] = user

+                    self.save_data('next_stream', next_stream)

+                    flag_msg = ''

+                    if len(flags) > 0:

+                        flag_msg = ' [' + ','.join(flags) + ']'

+                    self.reply(user, 'Next stream has been set to ' + target_datetime.strftime('%Y-%m-%d %I:%M%p').lower() + ' ' + tz_name + flag_msg + '.')

+            else:

+                self.save_data('next_stream', None)

+                self.reply(user, 'Custom data for the next stream has been deleted, now going by schedule instead.')

+

+    def get_stream_command_result(self, user):

+        custom_stream_date = self.load_data('next_stream')

+        self.check_stream_schedule()

+        if len(self.schedule_data) == 0:

+            return ['Sorry, I don\'t currently have any schedule information.', None]

+        next_stream = None

+        utc_now = pytz.utc.localize(datetime.datetime.utcnow())

+        tz_name = self.get_conf('timezone')

+        tz = pytz.timezone(tz_name)

+        local_time = utc_now.astimezone(tz)

+        stream_date_candidates = [local_time.date() + datetime.timedelta(days=x) for x in range(-1, 14)]

+        stream_dates = {}

+        for date in stream_date_candidates:

+            stream_dates[date] = 'none'

+        if 'default' in self.schedule_data:

+            for date in stream_dates:

+                stream_dates[date] = self.schedule_data['default']

+        if 'weekdays' in self.schedule_data:

+            for date in stream_dates:

+                if date.weekday() <= 4: # mon tue wed thu fri

+                    stream_dates[date] = self.schedule_data['weekdays']

+        if 'weekends' in self.schedule_data:

+            for date in stream_dates:

+                if date.weekday() >= 5: # sat sun

+                    stream_dates[date] = self.schedule_data['weekends']

+        weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']

+        for day in weekdays:

+            if day in self.schedule_data:

+                for date in stream_dates:

+                    if date.weekday() == weekdays.index(day):

+                        stream_dates[date] = self.schedule_data[day]

+        for day in range(1, 32):

+            strday = str(day)

+            if strday in self.schedule_data:

+                for date in stream_dates:

+                    if date.day == day:

+                        stream_dates[date] = self.schedule_data[strday]

+        for month in range(1, 13):

+            for day in range(1, 32):

+                strday = str(month) + '-' + str(day)

+                strday = strday

+                if strday in self.schedule_data:

+                    for date in stream_dates:

+                        if str(date.month) + '-' + str(date.day) == strday:

+                            stream_dates[date] = self.schedule_data[strday]

+        real_stream_dates = []

+        if custom_stream_date != None:

+            custom_dt = custom_stream_date['datetime']

+            real_stream_dates.append(custom_dt)

+        date_flags = {}

+        for date in stream_dates:

+            the_time = stream_dates[date]

+            flags = []

+            if stream_dates[date].find('[') != -1 and stream_dates[date].find(']') != -1:

+                the_time = stream_dates[date][0:stream_dates[date].index('[')].strip(' ')

+                flag_data = stream_dates[date][stream_dates[date].index('[')+1:stream_dates[date].index(']')]

+                flags = [f.strip(' ').lower() for f in flag_data.split(',')]

+            if the_time == 'none':

+                continue

+            if the_time == 'unknown':

+                the_time = datetime.time(23, 59, 0)

+                flags.append('unknown')

+            else:

+                hour = 0

+                minute = 0

+                segment = '24h'

+                if len(the_time) >= 3 and the_time[-2:] == 'am':

+                    segment = 'am'

+                    the_time = the_time[:-2]

+                if len(the_time) >= 3 and the_time[-2:] == 'pm':

+                    segment = 'pm'

+                    the_time = the_time[:-2]

+                hm = the_time.split(':')

+                if len(hm) > 1:

+                    minute = int(hm[1].lstrip('0'))

+                hour = int(hm[0].lstrip('0'))

+                hour = hour % 24

+                minute = minute % 60

+                if hour == 12 and segment == 'am':

+                    hour = 0

+                if hour != 12 and segment == 'pm':

+                    hour += 12

+                the_time = datetime.time(hour, minute, 0)

+            real_date = tz.localize(datetime.datetime.combine(date, the_time))

+            if custom_stream_date != None:

+                custom_dt = custom_stream_date['datetime']

+                if real_date >= custom_dt:

+                    real_stream_dates.append(real_date)

+                    date_flags[real_date] = flags

+            else:

+                real_stream_dates.append(real_date)

+                date_flags[real_date] = flags

+        real_stream_dates.sort()

+        for candidate in real_stream_dates:

+            delta = candidate - local_time

+            seconds_until = delta.total_seconds()

+            according_to = 'my schedule data'

+            if custom_stream_date != None:

+                custom_dt = custom_stream_date['datetime']

+                if candidate == custom_dt:

+                    date_flags[candidate] = []

+                    if 'flags' in custom_stream_date:

+                        date_flags[candidate] = custom_stream_date['flags'].split(' ')

+                    owner = self.call_function('get_stream_channel_name')

+                    according_to = 'what ' + owner + ' said'

+            if seconds_until < -(2*60*60): # more than 2 hours ago: assumed irrelevant

+                continue

+            if seconds_until < 0 and self.call_function('is_stream_active') == False: # <2h in the past: late message

+                how_long = self.pretty_interval(-seconds_until)

+                msg = 'According to ' + according_to + ', the stream was planned to start ' + how_long + ' ago.'

+                if candidate in date_flags and len(date_flags[candidate]) > 0:

+                    flag_msgs = []

+                    if 'maybe' in date_flags[candidate]:

+                        flag_msgs.append('that it might not happen at all')

+                    if 'around' in date_flags[candidate]:

+                        flag_msgs.append('that it might be a little earlier or later')

+                    if 'later' in date_flags[candidate]:

+                        flag_msgs.append('that it might be a little later than that')

+                    owner = self.call_function('get_stream_channel_name')

+                    extra_msg = ' ' + owner + ' has also said '

+                    if len(flag_msgs) >= 2:

+                        extra_msg += ', '.join(flag_msgs[:-1])

+                        extra_msg += ' and ' + flag_msgs[-1]

+                    else:

+                        extra_msg += flag_msgs[0]

+                    extra_msg += '.'

+                    msg += extra_msg

+                if self.get_conf('announcement_url') != None and len(self.get_conf('announcement_url')) > 0:

+                    msg += ' Consider checking ' + self.get_conf('announcement_url') + ' for announcements, maybe something came up.'

+                return [msg, candidate, 4 * 60 * 60]

+            if seconds_until >= 0: # stream date in the future: announcement

+                how_long = self.pretty_interval(seconds_until)

+                if self.call_function('is_stream_active'):

+                    owner = self.call_function('get_stream_channel_name')

+                    if 'unknown' in date_flags[candidate]:

+                        msg = owner + ' is currently streaming. :) According to ' + according_to + ', the next stream after this one will happen'

+                    else:

+                        msg = owner + ' is currently streaming. :) According to ' + according_to + ', the next stream after this one will start at '

+                else:

+                    if 'unknown' in date_flags[candidate]:

+                        msg = 'According to ' + according_to + ', the next stream will happen'

+                    else:

+                        msg = 'According to ' + according_to + ', the next stream will start at '

+                timespec = ''

+                if 'unknown' not in date_flags[candidate]:

+                    if custom_stream_date != None:

+                        if candidate == custom_stream_date['datetime']:

+                            if candidate.minute == 0:

+                                timespec = candidate.strftime('%I%p').lower().lstrip('0')

+                            else:

+                                timespec = candidate.strftime('%I:%M%p').lower().lstrip('0')

+                        else:

+                            timespec = str(stream_dates[candidate.date()])

+                    else:

+                        timespec = str(stream_dates[candidate.date()])

+                day_addendum = ''

+                datediff = candidate.date() - local_time.date()

+                if datediff.days == 0:

+                    if self.call_function('is_stream_active') and 'unknown' in date_flags[candidate]:

+                        continue

+                    day_addendum = ' today'

+                if datediff.days == 1:

+                    day_addendum = ' tomorrow'

+                if datediff.days == 2:

+                    day_addendum = ' the day after tomorrow'

+                if datediff.days >= 3:

+                    day_addendum = ' on the '

+                    day_addendum += str(candidate.day)

+                    if candidate.day in [1, 21, 31]:

+                        day_addendum += 'st'

+                    elif candidate.day in [2, 22]:

+                        day_addendum += 'nd'

+                    elif candidate.day in [3, 23]:

+                        day_addendum += 'rd'

+                    else:

+                        day_addendum += 'th'

+                owner = self.call_function('get_stream_channel_name')

+                if 'unknown' in date_flags[candidate]:

+                    msg += day_addendum + ', but the starting time is 100% up in the air. Feel free to hang out, but please don\'t expect a predictable starting time.'

+                else:

+                    tz_name = self.get_conf('timezone')

+                    tad_id = '0'

+                    if tz_name == 'US/Central':

+                        tad_id = '134'

+                    if tz_name == 'Europe/London':

+                        tad_id = '136'

+                    if tz_name == 'Europe/Berlin':

+                        tad_id = '37'

+                    msg += timespec + ' ' + tz_name + ' time (' + owner + '\'s timezone)' + day_addendum + ', which is in ' + how_long + '.'

+                    msg += ' Here\'s a countdown: http://www.timeanddate.com/countdown/party?iso='

+                    msg += candidate.strftime('%Y%m%dT%H%M')

+                    msg += '&p0=' + tad_id + '&msg=Next+Stream'

+                announcing_hours = 4

+                if 'unknown' in date_flags[candidate]:

+                    announcing_hours = 24

+                return [msg, candidate, announcing_hours * 60 * 60]

+        return ['According to my schedule data, there are no streams planned in the next two weeks. :(', None, None]

+

+    def check_stream_schedule(self):

+        if not self.get_conf('schedule'):

+            return

+        opener = urllib.request.build_opener()

+        schedule_md = []

+        if self.get_conf('schedule').find('reddit.com/r/') >= 0:

+            opener.addheaders = [('User-agent', 'Mozilla/5.0')]

+            try:

+                schedule_json = opener.open(self.get_conf('schedule')).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                return

+            schedule_info = json.loads(schedule_json)

+            if 'kind' not in schedule_info:

+                return

+            if schedule_info['kind'] != 'wikipage':

+                return

+            if self.last_schedule_revision == schedule_info['data']['revision_date']:

+                return

+            self.last_schedule_revision = schedule_info['data']['revision_date']

+            schedule_md = schedule_info['data']['content_md']

+            schedule_md = schedule_md.replace('\r\n', '\n')

+            schedule_md = schedule_md.lower().split('\n')

+            schedule_md = schedule_md[schedule_md.index('begin')+1:schedule_md.index('end')]

+        else:

+            try:

+                schedule_text = opener.open(self.get_conf('schedule')).read().decode('utf-8')

+            except (urllib.error.HTTPError, urllib.error.URLError):

+                return

+            lines = schedule_text.split('\n')

+            schedule_md = [line.strip() for line in lines if len(line.strip()) > 0]

+

+        self.schedule_data = {}

+        for line in schedule_md:

+            if line.find('=') != -1:

+                data = line.split('=')

+                if len(data[0]) >= 3 and data[0][0] == '*':

+                    data[0] = data[0][1:]

+                data = [x.strip() for x in data]

+                self.schedule_data[data[0]] = data[1]

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Keep track of streams that happen on a Twitch channel including their viewer numbers.

+

+import datetime

+

+class StreamTrackingPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        if self.get_conf('enable_uptime'):

+            return ['uptime']

+        else:

+            return []

+

+    def help_text(self):

+        return {'uptime': 'Tells you how long the current stream has been ongoing.'}

+

+    def requires_functions(self):

+        return ['get_current_stream_data', 'get_stream_channel_name']

+

+    def startup(self):

+        self.stream_status = 'offline'

+        self.request_scheduled_update(seconds = 30)

+

+    def scheduled_update(self):

+        self.check_stream_status()

+

+    def command_read(self, user, argv, raw):

+        if argv[0] == 'uptime':

+            if not self.get_conf('enable_uptime'):

+                return

+            uptime = None

+            streams = self.load_data('streams', default = [])

+            if len(streams) > 0:

+                last_stream = streams[-1]

+                if last_stream['end_date'] == None:

+                    delta = datetime.datetime.utcnow() - last_stream['start_date']

+                    uptime = self.pretty_interval(delta.total_seconds())

+            owner = self.call_function('get_stream_channel_name')

+            if uptime != None:

+                self.reply(user, str(owner) + ' has been streaming for ' + uptime + '.')

+            else:

+                self.reply(user, str(owner) + ' is not currently streaming.')

+

+    def send_shoutout(self, message):

+        suffix = self.get_conf('shoutout_suffix')

+        if isinstance(suffix, str) and len(suffix) > 0:

+            message += ' ' + suffix

+        self.message(message)

+

+    def check_stream_status(self, silent = False):

+        current_stream = self.call_function('get_current_stream_data')

+        owner = self.call_function('get_stream_channel_name')

+

+        if current_stream != None:

+            if 'status' in current_stream:

+                msg_status = current_stream['status']

+                if 'game' in current_stream and current_stream['game'] != None:

+                    streamer = self.call_function('get_stream_channel_name')

+                    msg_status += ' /// ' + streamer + ' playing ' + current_stream['game']

+                last_status = self.load_data('current_stream_status')

+                if self.get_conf('stream_status_shoutout') and current_stream['status'] != None and current_stream['status'] != last_status and not silent:

+                    msg = 'New channel status: ' + msg_status

+                    self.send_shoutout(msg)

+                    self.save_data('current_stream_status', current_stream['status'])

+

+        streams = self.load_data('streams', default = [])

+        if current_stream == None or 'active' not in current_stream or not current_stream['active']:

+            self.stream_status = 'offline'

+            if len(streams) > 0 and streams[-1]['end_date'] == None:

+                streams[-1]['end_date'] = datetime.datetime.utcnow()

+                self.save_data('streams', streams)

+                if self.get_conf('stream_end_shoutout') and not silent:

+                    self.send_shoutout(str(owner) + ' has just finished streaming.')

+        else:

+            if self.stream_status != 'online':

+                self.stream_status = 'online'

+                new_stream = {}

+                if 'start_date' in current_stream:

+                    new_stream['start_date'] = current_stream['start_date']

+                else:

+                    new_stream['start_date'] = datetime.datetime.utcnow()

+                if len(streams) == 0 or streams[-1]['start_date'] != new_stream['start_date']:

+                    new_stream['end_date'] = None

+                    if 'game' in current_stream:

+                        new_stream['game'] = current_stream['game']

+                    if 'title' in current_stream:

+                        new_stream['title'] = current_stream['title']

+                    if 'status' in current_stream:

+                        new_stream['status'] = current_stream['status']

+                    new_stream['platform'] = current_stream['platform']

+                    new_stream['peak_viewers'] = 0

+                    if 'viewers' in current_stream:

+                        new_stream['peak_viewers'] = current_stream['viewers']

+                    streams.append(new_stream)

+                    self.save_data('streams', streams)

+                    if self.get_conf('stream_start_shoutout') and not silent:

+                        shoutout_msg = str(owner) + ' has just started streaming'

+                        if 'game' in new_stream:

+                            shoutout_msg += ' ' + new_stream['game']

+                        if 'status' in new_stream:

+                            shoutout_msg += ': ' + current_stream['status']

+                        else:

+                            shoutout_msg += '.'

+                        self.send_shoutout(shoutout_msg)

+            if 'viewers' in current_stream and len(streams) > 0:

+                internal_current_stream = streams[-1]

+                if current_stream['viewers'] > internal_current_stream['peak_viewers']:

+                    internal_current_stream['peak_viewers'] = current_stream['viewers']

+                    self.save_data('streams', streams)

+                peak_viewers = self.load_data('peak_viewers', default = {'count': 0, 'date': None, 'game': None, 'platform': None})

+                if internal_current_stream['peak_viewers'] > peak_viewers['count']:

+                    peak_viewers['count'] = internal_current_stream['peak_viewers']

+                    peak_viewers['date'] = datetime.datetime.utcnow()

+                    peak_viewers['game'] = internal_current_stream['game']

+                    peak_viewers['platform'] = 'twitch'

+                    self.save_data('peak_viewers', peak_viewers)

+                    if self.get_conf('peak_viewers_shoutout') and not silent:

+                        self.send_shoutout('Wow, ' + str(peak_viewers['count']) + ' people are currently watching the stream! That\'s a new record!')

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Makes the bot slightly more talkative when its name is mentioned in chat.

+

+import string

+

+class TalkativityPlugin(TimberBotPlugin):

+

+    def message_read(self, user, message):

+        bot_name_lower = self.bot_name().lower()

+        punctuation = set(string.punctuation)

+        message_no_punc = ''.join(ch for ch in message if ch not in punctuation)

+        if message_no_punc.lower() in [bot_name_lower + ' sucks', 'i hate ' + bot_name_lower, 'i hate you ' + bot_name_lower]:

+            self.reply(user, 'If bots had feelings, mine would be pretty hurt right now.')

+            return

+        if message_no_punc.lower() in ['hi ' + bot_name_lower, 'hello ' + bot_name_lower, 'hey ' + bot_name_lower]:

+            self.reply(user, 'Greetings to you too!')

+            return

+        if message_no_punc.lower() in [bot_name_lower + ' is awesome', 'i love ' + bot_name_lower, 'i love you ' + bot_name_lower]:

+            self.reply(user, 'I am immune to flattery, but your appreciation has been noted.')

+            return

+        if message_no_punc.lower() in [bot_name_lower, 'who is ' + bot_name_lower, 'whos ' + bot_name_lower, message_no_punc.lower() in 'what is ' + bot_name_lower, 'whats ' + bot_name_lower]:

+            self.reply(user, 'Yep, that\'s me! Try "' + self.format_command('help') + '" to find out how I work.')

+            return

+        if message_no_punc.lower() in ['thanks ' + bot_name_lower, 'thank you ' + bot_name_lower]:

+            self.reply(user, 'No problem! Whatever I did (please excuse my short-term memory), I hope it was helpful.')

+            return

+        if message_no_punc.lower() in [bot_name_lower + ' please', bot_name_lower + ' pls', bot_name_lower + ' plz']:

+            self.reply(user, 'What can I do for you? Try "' + self.format_command('help') + '" to find out how I work.')

+            return

+        if message[0:len(bot_name_lower)].lower() == bot_name_lower and message[-1] == '?':

+            self.reply(user, 'How can I help you? Try "' + self.format_command('help') + '" to find out how I work.')

+            return

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: MIT

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2022 Julian Fietkau

+

+from plugin_base import TimberBotPlugin

+

+# Post a message in chat whenever a specific Tumblr blog receives a new post.

+

+import re

+import urllib.request, urllib.error

+import xml.etree.ElementTree

+

+class TumblrPlugin(TimberBotPlugin):

+

+    def provides_commands(self):

+        return ['tumblr']

+

+    def help_text(self):

+        tumblr = self.get_conf('tumblr')

+        if tumblr != None:

+            return {'tumblr': 'Links this channel\'s tumblr and its newest post.'}

+        else:

+            return {'tumblr': 'I have no tumblr saved for this channel, so the "' + self.format_command('tumblr') + '" command will do nothing.'}

+

+    def startup(self):

+        self.__check_tumblr()

+        self.request_scheduled_update(seconds = 60)

+

+    def command_read(self, user, argv, raw):

+        tumblr = self.get_conf('tumblr')

+        if tumblr != None:

+            newest_post = self.load_data('newest_post')

+            known_posts = self.load_data('known_posts')

+            if newest_post == None or known_posts == None:

+                self.reply(user, 'No posts found on ' + tumblr + '.tumblr.com.')

+            else:

+                self.reply(user, 'Newest post on ' + tumblr + '.tumblr.com: ' + known_posts[newest_post])

+        else:

+            self.reply(user, 'There is no Tumblr configured for this channel.')

+

+    def scheduled_update(self):

+        self.__check_tumblr()

+

+    def __check_tumblr(self, silent = False):

+        tumblr = self.get_conf('tumblr')

+        if tumblr == None:

+            return

+        opener = urllib.request.build_opener()

+        try:

+            tumblr_rss = opener.open('http://' + tumblr + '.tumblr.com/rss').read().decode('utf-8')

+        except (urllib.error.HTTPError, urllib.error.URLError):

+            return

+        tumblr_rss = re.sub(' xmlns:dc="[^"]+"', '', tumblr_rss, count = 1)

+        rss_tree = xml.etree.ElementTree.fromstring(tumblr_rss)

+

+        item_id = rss_tree.find('channel').find('item').findtext('link')

+        old_item_id = self.load_data('newest_post')

+        if item_id != old_item_id:

+            self.save_data('newest_post', item_id)

+            known_posts = self.load_data('known_posts', {})

+            new_posts = []

+            for item in rss_tree.find('channel').findall('item'):

+                item_id = item.findtext('link')

+                if item_id not in known_posts:

+                    link = item_id

+                    title = item.findtext('title')

+                    announcement = '"' + title + '" - ' + link

+                    known_posts[item_id] = announcement

+                    new_posts.append(announcement)

+            if len(new_posts) <= 2 and not silent:

+                for announcement in new_posts:

+                    self.message('New post on ' + tumblr + '.tumblr.com: ' + announcement)

+            self.save_data('known_posts', known_posts)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: GPL-3.0-or-later

+# ================================================================================================

+# TimberBot

+# <https://fietkau.software/timberbot>

+#

+# Copyright (C) 2014-2022 Julian Fietkau

+#

+# 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 <https://www.gnu.org/licenses/>.

+# ================================================================================================

+

+import codecs

+import configparser

+import datetime

+import os

+import signal

+import sys

+import time

+import traceback

+import urllib.error

+

+from twitch import ConnectorTwitch

+from parser import Parser

+

+class TimberBot:

+

+    def __init__(self, config):

+        self.config = config

+        main_config = dict(config.items('main'))

+

+        self.bot_name = main_config['nick']

+        self.data_dir = os.path.abspath(main_config['data_directory'])

+        self.connector = ConnectorTwitch(main_config, False)

+

+        def cfg_get(category, attribute, default = 'none'):

+            try:

+                return self.config.get(category, attribute)

+            except (configparser.NoSectionError, configparser.NoOptionError):

+                return default

+        def cfg_set(category, attribute, value):

+            if not self.config.has_section(category):

+                self.config.add_section(category)

+            self.config.set(category, attribute, value)

+            with open(os.path.join(self.data_dir, 'config.ini'), 'w', encoding='utf8') as fp:

+                self.config.write(fp)

+

+        self.config_calls = {}

+        self.config_calls['get'] = cfg_get

+        self.config_calls['set'] = cfg_set

+

+        self.last_scheduled_update = 0

+

+        self.alive = True

+

+    def connect(self):

+        print('[' + self.config_calls['get']('main', 'channel') + '] CONNECT...')

+

+        self.parser = Parser(self.data_dir, self.send, self.reply, self.config_calls, self.connector.special_action)

+        self.connector.connect()

+

+    def send(self, message):

+        if self.connector.status == 'disconnected':

+            return

+        print('[' + self.config_calls['get']('main', 'channel') + '] <' + self.config_calls['get']('main', 'nick') + '> ' + message)

+        self.connector.send(message)

+

+    def reply(self, user, message):

+        if self.connector.status == 'disconnected':

+            return

+        print('[' + self.config_calls['get']('main', 'channel') + '][Reply: ' + user + '] <' + self.config_calls['get']('main', 'nick') + '> ' + message)

+        self.connector.reply(user, message)

+

+    def error_log(self, line, timestamp = True):

+        logstr = ''

+        if timestamp:

+            logstr = '[' + datetime.datetime.utcnow().strftime('%H:%M:%S') + '] '

+        logstr = logstr + line

+        print('[' + self.config_calls['get']('main', 'channel') + '] ' + logstr)

+        log_path = os.path.join(self.data_dir, 'error_logs', datetime.datetime.utcnow().strftime('%Y-%m-%d')+'.txt')

+        if not os.path.exists(os.path.dirname(log_path)):

+            os.makedirs(os.path.dirname(log_path))

+        with codecs.open(log_path, 'a', 'utf-8') as log_file:

+            log_file.write(logstr + '\n')

+

+    def quit(self):

+        self.connector.disconnect()

+        self.alive = False

+        self.error_log('HALT...')

+

+    def handle_error(self, e_info, serious_error):

+        self.error_log('ERROR: ' + str(e_info[1]))

+        if serious_error:

+            trace = traceback.format_exc()

+            for trace_line in trace.split('\n'):

+                self.error_log('TRACEBACK: ' + trace_line)

+            on_error = 'quit'

+            if self.parser != None:

+                on_error = self.config_calls['get']('main', 'on_error')

+            if on_error == 'quit':

+                self.error_log('Quitting execution after error.')

+                self.quit()

+            if on_error == 'resume':

+                self.error_log('Resuming execution after error. CAUTION: Internal state may be inconsistent.')

+

+    def main_loop(self):

+

+        if not hasattr(self, 'parser') or self.parser == None:

+            return

+

+        now = time.time()

+        if now - self.last_scheduled_update >= 1:

+            try:

+                self.parser.scheduled_update()

+            except urllib.error.URLError as e:

+                self.handle_error(sys.exc_info(), False)

+            except Exception:

+                self.handle_error(sys.exc_info(), True)

+

+            self.last_scheduled_update = now

+

+        events = None

+        try:

+            events = self.connector.poll()

+        except Exception:

+            self.handle_error(sys.exc_info(), True)

+

+        if self.connector.status == 'disconnected' or events == None:

+            self.alive = False

+            return

+

+        for event in events:

+

+            user = event[1]

+            message = event[2]

+            params = event[3]

+

+            if event[0] == 'MSG':

+                print('[' + self.config_calls['get']('main', 'channel') + '] <' + user + '> ' + message)

+                try:

+                    self.parser.parse(user, message, params)

+                except Exception:

+                    self.handle_error(sys.exc_info(), True)

+            if event[0] == 'ME':

+                print('[' + self.config_calls['get']('main', 'channel') + '] * ' + user + ' ' + message)

+                try:

+                    params['user'] = user

+                    params['message'] = message

+                    self.parser.special_event('ME', params)

+                except Exception:

+                    self.handle_error(sys.exc_info(), True)

+            if event[0] == 'NAMES':

+                self.parser.update_names(message, False)

+            if event[0] == 'JOIN':

+                self.parser.channel_join(user)

+            if event[0] == 'PART':

+                self.parser.channel_part(user)

+

+

+if __name__ == "__main__":

+

+    bot = None

+

+    def signal_handler(signal, frame):

+        print('')

+        print('Quitting execution after keyboard interrupt.')

+        if bot.alive:

+            bot.quit()

+        bot.alive = False

+        sys.exit(1)

+

+    os.chdir(os.path.dirname(sys.argv[0]))

+

+    config_path = './config.ini'

+    if len(sys.argv) > 1:

+        config_path = os.path.abspath(sys.argv[1])

+    if not os.path.isfile(config_path):

+        print('Configuration file does not exist:', config_path)

+        sys.exit(1)

+

+    nick = None

+    config = configparser.RawConfigParser()

+    config.read(config_path)

+

+    bot = TimberBot(config)

+    bot.connect()

+

+    signal.signal(signal.SIGINT, signal_handler)

+

+    while True:

+        if bot.alive:

+            bot.main_loop()

+            time.sleep(0.1)

+        else:

+            sys.exit(0)

+

+#!/usr/bin/env python3

+# -*- coding: utf-8 -*-

+

+# SPDX-License-Identifier: GPL-3.0-or-later

+# This file is part of TimberBot. <https://fietkau.software/timberbot>

+# Copyright (C) 2014-2022 Julian Fietkau

+

+import datetime

+import errno

+import os

+import time

+import websocket

+

+class ConnectorTwitch():

+

+    def __init__(self, config, verbose_print):

+        self.config = config

+        self.verbose_print = verbose_print

+

+        self.connection_attempts = 0

+        self.last_message = None

+        self.status = 'disconnected'

+

+        self.ws = None

+

+        self.sent_timestamps = []

+        self.scheduled_update_intervals = 0

+

+    def ws_send(self, msg):

+        self.ws.send(bytes(msg, 'utf-8'))

+

+    def connect(self):

+        self.ws = websocket.WebSocket()

+        self.ws.connect('wss://irc-ws.chat.twitch.tv:443')

+

+        self.ws_send('PASS ' + self.config['password'] + '\r\n')

+        self.ws_send('NICK ' + self.config['nick'] + '\r\n')

+        self.ws_send('CAP REQ :twitch.tv/commands twitch.tv/membership twitch.tv/tags' + '\r\n')

+        self.ws_send('JOIN #' + self.config['channel'].lower() + '\r\n')

+

+        self.status = 'connected'

+        self.connection_attempts = 0

+

+    def disconnect(self):

+        self.status = 'disconnected'

+

+    def split_message(self, message, max_message_length):

+        messages = []

+        words = message.split(' ')

+        current_word = ''

+        while current_word != None:

+            current_message = ''

+            while current_word != None and len(current_message) + 1 + len(current_word) <= max_message_length - 6:

+                current_message = current_message + ' ' + current_word

+                current_message = current_message.strip()

+                if len(words) > 0:

+                    current_word = words.pop(0)

+                else:

+                    current_word = None

+            messages.append(current_message)

+        counted_messages = []

+        message_number = 1

+        for msg in messages:

+            counted_messages.append(msg + ' [' + str(message_number) + '/' + str(len(messages)) + ']')

+            message_number = message_number + 1

+        return counted_messages

+

+    def send(self, message):

+        max_message_length = 350

+        if len(message) > max_message_length:

+            messages = self.split_message(message, max_message_length)

+        else:

+            messages = [message]

+        for msg in messages:

+            self.socket_send(msg)

+

+    def reply(self, user, message):

+        self.send(user + ': ' + message)

+

+    def special_action(self, action_type, params):

+        if action_type == 'timeout':

+            if 'user' in params:

+                command = '/timeout ' + params['user'].lower()

+                if 'duration' in params:

+                    command += ' ' + str(params['duration'])

+                self.send(command)

+            else:

+                raise RuntimeError('Special action "' + str(action_type) + '" requires parameter "' + 'user' + '".')

+        elif action_type in ['ban', 'unban', 'mod', 'unmod', 'host']:

+            if 'user' in params:

+                self.send('/' + action_type + ' ' + params['user'].lower())

+            else:

+                raise RuntimeError('Special action "' + str(action_type) + '" requires parameter "' + 'user' + '".')

+        elif action_type in ['slow', 'slowoff', 'subscribers', 'subscribersoff', 'clear', 'r9kbeta', 'r9kbetaoff', 'unhost']:

+            self.send('/' + action_type)

+        elif action_type == 'me':

+            if 'message' in params:

+                self.send('/me ' + params['message'])

+            else:

+                raise RuntimeError('Special action "' + str(action_type) + '" requires parameter "' + 'message' + '".')

+        else:

+            raise RuntimeError('Special action "' + str(action_type) + '" is unavailable on this chat service.')

+

+    def socket_send(self, message):

+        if self.ws == None:

+            return

+        while len(self.sent_timestamps) > 0 and self.sent_timestamps[0] + datetime.timedelta(seconds = 30) < datetime.datetime.utcnow():

+            self.sent_timestamps.pop(0)

+        if len(self.sent_timestamps) < 20: # ensures we do not send >20 msgs per 30 seconds.

+            msg = 'PRIVMSG #' + self.config['channel'].lower() + ' :' + message

+            if self.verbose_print:

+                print('[' + self.config['channel'] + '][SEND] ' + msg)

+            self.ws_send(msg + '\r\n')

+            time.sleep(0.5)

+            self.sent_timestamps.append(datetime.datetime.utcnow())

+        else:

+            raise IOError('Message queue full, outgoing message skipped: ' + message)

+

+    def socket_recv(self):

+        lines = []

+        if self.ws == None:

+            if self.connection_attempts < 10:

+                try:

+                    self.connect()

+                except TypeError:

+                    pass

+            elif self.connection_attempts >= 10:

+                self.status = 'disconnected'

+                return

+        data = self.ws.recv()

+        lines = data.splitlines()

+        return lines

+

+    def parse_line(self, line):

+        if self.verbose_print:

+            print('[' + self.config['channel'] + '][RECV] ' + line)

+

+        if line.find('PING') == 0: # respond to server PING

+            self.ws_send('PONG' + line[4:])

+            return None

+

+        if line[0] == ':':

+            without_tags = line[1:]

+        elif line.find(' :') > -1:

+            without_tags = line[line.index(' :')+2:]

+        else:

+            return None

+        user = without_tags.split(':')[0].split('!')[0]

+        if len(user) > 0 and user[0] in ['@', '+', '!', '%']:

+            user = user[1:]

+        message = None

+        if without_tags.find(':') > -1:

+            message = without_tags[without_tags.index(':')+1:]

+

+        params = {}

+

+        if ' ' in user or line.find('PRIVMSG') == -1:

+            if user.find(' 353 ') >= 0:

+                return ['NAMES', None, message.split(), params]

+            full_prefix = line.split(':')[1]

+            if full_prefix.find(' JOIN ') >= 0:

+                if user.lower() != self.config['nick'].lower():

+                    return ['JOIN', user, None, params]

+            if full_prefix.find(' PART ') >= 0:

+                if user.lower() != self.config['nick'].lower():

+                    return ['PART', user, None, params]

+        else:

+            if ord(message[0]) == 1 and ord(message[-1]) == 1:

+                message = message[1:-1]

+                if message[0:6] == 'ACTION':

+                    message = message[6:]

+                    if message[0] == ' ':

+                        message = message[1:]

+                    return ['ME', user, message, params]

+            else:

+                return ['MSG', user, message, params]

+

+    def poll(self):

+        if self.status == 'disconnected':

+            print('Disconnecting')

+            if self.ws != None:

+                print('Disconnecting inner')

+                self.ws_send('PART #' + self.config['channel'].lower() + '\r\n')

+                self.ws_send('QUIT :' + self.config['nick'] + ' out!\r\n')

+                print('1')

+                self.ws.close()

+                print('2')

+                self.ws = None

+                print('Disconnected inner')

+            print('Disconnected')

+            return

+        lines = self.socket_recv()

+

+        if self.ws == None:

+            return

+

+        self.scheduled_update_intervals += 1

+        if self.scheduled_update_intervals % 20 == 0:

+            self.ws_send('JOIN #' + self.config['channel'].lower() + '\r\n')

+

+        result = []

+

+        for line in lines:

+

+            parsed = self.parse_line(line)

+

+            if parsed == None or parsed[1] == 'jtv':

+                continue

+

+            tags = {}

+            if line[0] == '@': # IRCv3 twitch tags

+                tag_str = line[1:line.index(' :')]

+                for tag in tag_str.split(';'):

+                    split_tag = tag.split('=')

+                    tag_value = split_tag[1]

+                    tags[split_tag[0]] = split_tag[1]

+            if 'display-name' in tags and len(tags['display-name']) > 0:

+                parsed[1] = tags['display-name']

+            params = {}

+            for tag in tags:

+                params['twitch:' + tag] = tags[tag]

+            params['mod'] = False

+            if 'user-type' in tags and len(tags['user-type']) > 0:

+                params['mod'] = True

+            # It seems that the Twitch broadcaster does not have user-type set to anything.

+            if parsed[1] != None and parsed[1].lower() == self.config['channel'].lower():

+                params['mod'] = True

+

+            parsed[3] = parsed[3].copy()

+            parsed[3].update(params)

+

+            result.append(parsed)

+

+        return result

+