If certain characters appear as part of a URL, they can end up malforming the response. More information can be found here.

find_comic(self, number) currently assumes that if the server returns a 404, that the comic doesn't actually exist and thus that the bot shouldn't display anything. However, as we all know, Randall purposefully skipped comic 404 as a nerdy joke, so that 404 error should be handled special.

Just found this project from the reddit thread! I like what I see - the whole project appears well-structured and clean. This issue is to help in validating user inputs.

Example of the behaviour this issue seeks to address: https://www.reddit.com/r/xkcd/comments/erydbl/introducing_ubobbytablesbot/ff7a610/

This is probably pretty obvious but pointing out all the same - validation on the inputs looks to be necessary at either 1 where the the body of the comment is pulled out, or 2 where the find_numbers actually makes use of the input. Looks like the one case where user input has been shown to cause a problem is when the input is simply too large, in which case you could curb this from breaking by doing one or multiples of the following:

1. Introduce a try/except block so a single user's invalid input doesn't cause the whole bot to stop for everyone, just for the one request.
2. Try to prevent a large input (like when a user writes an essay into a comment body, which could be unlikely to ever invoke the bot anyway) by truncating the body string to a manageable size. One could introduce a simple heuristic like...

body = comment.body[:1_000]

This heuristic ensures your comments can only ever be a certain size, and doesn't fail in the case that the input is an empty string. This of course relies on the input actually being a list-like object (as strings are in Python) so if for some reason the comment object were malformed this would fail. In that case, a try/except block within handle_comment() would help here.

1. Add further logic to valid_comment() to handle more of these cases. The truncation approach is likely a good addition here.

Implement the ability to comment "!latest" or "#latest" and have the bot respond with the most current comic. More information can be found here.

According to xkcd's JSON interface page, the most current comic can be found at: https://xkcd.com/info.0.json

Implement the ability to comment "!random" or "#random" to return a random comic. More information can be found here.

The bot currently matches numbers found in hyperlinks such as in this case. This should be explicitly avoided.

There is currently no way to monitor the activity of the bot. Logging should be implemented using Python's built-in logging class.

https://www.reddit.com/user/BobbyTablesBot doesn't appear to be live currently. It's also not responding to pings. I could probably host it, if needed. Also happy to take over keeping the repo working & up to date.

Since we are setting skip_existing to False when initializing the comment stream, even if the bot was down for whatever reason, when it goes back online, it should be able to respond to all the comments chronologically and eventually catch up. Am I wrong?

Sorry if It's a dumb issue I'm new to Github

https://www.reddit.com/r/ProgrammerHumor/comments/g9u3yh/oh_so_this_is_how_to_reproduce_that_weird_issue/foxppns/?context=0

Implement the ability to comment "!585...590" and return the comics with id's 585, 586, 587, 588, 589, 560. More information can be found here.

Add the ability to call the bot by commenting:
Relevant xkcd: {number}

Example comment:
Relevant xkcd: 327

The two streams that are currently being analyzed are:

• Comments in /r/xkcd
• Inbox items (username mentions, private messages)

This change will require analyzing comments from outside /r/xkcd which is currently not implemented. It will also require a new matching pattern.

Found in 1, there appears to be no upper bound to the size of a response. If I was to issue a comment like the following, I suspect the bot would try to post all hundred comics:

!1 !2 !3 !4 !5 !6 !7 !8 !9 !10 !11 !12 !13 !14 !15 !16 !17 !18 !19 !20 !21 !22 !23 !24 !25 !26 !27 !28 !29 !30 !31 !32 !33 !34 !35 !36 !37 !38 !39 !40 !41 !42 !43 !44 !45 !46 !47 !48 !49 !50 !51 !52 !53 !54 !55 !56 !57 !58 !59 !60 !61 !62 !63 !64 !65 !66 !67 !68 !69 !70 !71 !72 !73 !74 !75 !76 !77 !78 !79 !80 !81 !82 !83 !84 !85 !86 !87 !88 !89 !90 !91 !92 !93 !94 !95 !96 !97 !98 !99

Example of this behaviour in action: https://www.reddit.com/r/xkcd/comments/erydbl/introducing_ubobbytablesbot/ff7o6rt/

This may cause the bot to break if the bot tries to write a reply to a subreddit that has a comment max size limit, rather than failing that request. This can be wrapped in a try/except block to contain the failure from such an occurrence affecting other users' experience using the bot (though this should not be the only line of defense here), and the response size itself should be limited to prevent the bot trying to create a huge response in the first place.

In most cases users will probably ask for a single comic, but incredibly unlikely (unless they're pressure-testing the bot) to ask for more than a handful. But of course data would tell you where best that upper bound should be.