Share the rot() implementation between both Lambda and Flask implementations

This provides a model of how to do code sharing between the two
implementations we have, (with the expectation that the code in the
"turbot" package will be generic and that code in turbot_slack and
turbot_lambda will use that common code while doing whatever
additional marshalling is necessary for their particular application
environments).

Move top-level flask app from turbot/turbot.py to turbot_flask/turbot.py

This is a first baby step toward teasing apart true "library" code in
turbot, (which can be shared by both the Lambda and Flask
implementations), from code that is Flask-specific.

(For symmetry, the lambda directory is renamed turbot_lambda here as well.)

Add target to deploy our lambda code to AWS

The existing "make deploy" target now calls out to two targets:

make flask: Deploys code to Flask app at halibut.cworth.org

make lambda: Deploys code to AWS lambda function

Start implementing code intended to be deployed to AWS Lambda

Here, lambda/rot.py is a copy of the turbot/rot.py code, but massaged
into the calling conventions of AWS Lambda (and without yet any actual
code to integrate with Slack in either direction).

Use a thread for creating the Google Sheet when a new channel is created

This allows us to return quickly so that Slack doesn't retry sending the event.

As implemented in this commit, this code is a bit cheesy in that it
disables the debug mode and error handling in slack_send_message,
(since the prior implementation of that depended on having a current
Flask app, but now that we are calling this function from a thread we
don't have a current app context).

Add automatic refreshing of the Google Sheets token

Otherwise, the original token expires and becomes useless after 60
minutes.

Remove another stale file name from a comment

The documentation example used "token.pickle" but we are now using
".gsheets-token.pickle". Here we switch to just "token file" in the
code comment so the comment is immune to any renaming.

Copy template sheets to newly-created spreadsheets

The TEMPLATE_SHEET_ID here is that of a spreadsheet in Trubot's
account that is named "Template".

Fix a stale file name embedded in a comment

We renamed this file recently so the comment was wrong. Re-word
the comment here so that we don't need to keep tracking the latest
name of this file.

Set the name of newly-created sheets to match the channel name

Much better than having dozens of sheets all named "untitled".

Initial implement of auto-creation of Google sheets

This is implemented via a Slack event listener that's listening for
the "channel_created" event. So, whenever a new channel is created,
this code will create a new Google sheet and inject a message into
the new channel with the URL of the sheet.

Rename .turbot.env to .slack-creds.env

I had originally chosen a generic name hoping that I could cram all
of our various credentials into this one file. But, alas, the Google
docs. credentials really want to be in a JSON file so they will be
separate.

Given that, I'll give each file a specific name, starting with this
Slack-specific file.

Makefile: Fix DO_NOT_DEPLOY implementation to work with multiple files

The --exclude option to rsync expects a single file, so we need to
arrange to pass it multiple times if we have multiple files in the
value of the DO_NOT_DEPLOY variable. Fortunately, this is a perfect
job for patsubst.

Add a listener for the Slack "channel_created" event

Currently this just posts a simple message when a channel is
created. Eventually, we'll want to do something different such as
creating a puzzle sheet and linking/pinning it to the channel.

Break out rot.py and slack.py from turbot.py

Using separate modules to make the code more maintainable.

Make a top-level turbot package

This will be useful as we soon start splitting up the single turbot.py
file into multiple modules that want to include things from each
other.

Ignore the __pycache__ directory

Something keeps auto-creating this, so I know it's not source we would
ever want to commit to git.

Abstract out two slack-related functions

The two new functions are slack_is_valid_request and slack_send_reply.
These functions provide some shared code for dealing with slack to
avoid code duplication.

These functions also provide a debug mode (that doesn't use slack at
all). This is a convenience for testing the implementation of slash
commands in a local "make run" session without needing to touch Slack
endpoints at all. (Instead, all requests are considered valid and
slack replies are simply printed to stdout.)

Convert "make run" to use "flask run" instead of direct python script execution

This will simplify some future work (regarding reorganizing the code into
a package, etc.) so that we don't have to try to simultaneously support
running as both a script and as a module.

Use a raw string for a regular expression

Previously, the string had an unrecognized escape sequence ('\*').
With a non-raw string we could have doubled the backslash, but it's
much cleaner to just use a raw string instead, (so that backslashes
are used for regular-expression escaping, and not also for string
escaping).

Add missing include of flask.make_response

Revealing that I hadn't actually tested this error case (*blush*).

Fix some code style issues identified by flake8

Some of the things fixed include TAB based indentation of a
documentation string, some unneeded semicolons, a missing exception
name, and an excessively long line.

Add signature verification fo the /rot slash command

This prevents someone abusing our bot by spoofing messages appearing
to have come from Slack. This way we won't reply to any command
request unless it actually comes from Slack.

Add some documentation for the functions we have defined here

Since we want to have maintainable code.

Add requirements for using Google Sheets API

And update all other requirements while we're at it.

Add a route to implement a /rot slash command

This is to be used as follows:

/rot [count] String to rotate

The optional count indicates a number of positions to rotate every
letter in the string. If it is not provided, all rotations will be
printed.

Note: The count can also be provided as an '*' character to explicitly
request all possible rotations.

Restore handling of error events from Slack

This is better than what I had copied from the example a few commits
ago because this properly logs through the python logging system, (so
the error message will appear in the Apache log file).

Fix turbot.wsgi to be able to find its environment variables

We can't rely on the current working directory of the Apache process,
so we need to use an explicit path here in order to find our file
with environment variables in it.

Put my own creation of the Flask app back

Rather than relying on the one in the Slack events API.

This means the WSGI configuration should work once again.

Trim down the program to not have any custom routes

I'm just verifying here that I don't need to have these in order to
get the Slack challenge verification to work.

Add Slack dependencies and minimum boilerplate to our flask app

This entirely replaces our flask setup, (which also breaks our current
WSGI setup too) but is based on the exact demo code from:

https://github.com/slackapi/python-slack-events-api/blob/main/example/example.py

I want to start with this to ensure I can at least get a correct
challenge working. After I get this working this way, I'll plan to put
direct flask code back in place and integrated with the web server via
WSGI.

Initial commit of turbot

Turbot will eventually be a Slack bot for the Halibut That Bass team.

As of this commit, turbot.py is just a simple flask app implementing a
REST API (to query, add, delete TODO items). Additionally, this commit
includes the Makefile pieces to manage python dependencies and to
deploy the program to our server.

There's not yet any actual Slack-application code here yet.