concensus | reading United States Census TIGER/Line Shapefiles

I'm putting together an API and need to add query parameters to the URI like https://www.example.com/api/endpoint?search=term&limit=10.

1. My first question is, in Django 3.0, I'd need to use re-path to accomplish parsing out the various parameters, correct?

2. Secondly, the question is about convention. It seems like two of the three APIs I've been working with a lot lately us a convention like:

   ...

I'm currently experimenting with mongodb the mongoshell.

I want get documents that have a value null for the tomato.consensus. The following query matches 1991 documents.

I am thinking to build a multichatbot architecture but I don't know what is the best. I have like 10 chatbots specialized in many fields (customers with phone problems, sellers, help with this or that product, etc...) and potentially 30 more. What is the best design to go with to centralize all of this and have only one interface answering questions ? One IA (which algo?) redirecting questions to the right bot ? One IA who have learned from all the bots (how?) ?

Thanks for your insights, I've searched on Google but didn't find any concensus.

I know there is a lot of information about undoing a merge in git, but I can't seem to find any concensus on how to do this in my specific situation.

Someone essentially merged our develop branch in to our master branch via a pull request in bitbucket. This just happened today, so it's the last thing that was done on the master branch (we don't have to worry about other commits on top of the merge commit).

Note: We host bitbucket ourselves, so we have an older version of bitbucket. There is no revert pull request option.

From what I've read, there is essentially two ways of handling this in git:

1. git reset --hard **

   • This will remove the merge commit as if it never happened.
   • Everywhere I read that "it's bad practice to rewrite history" or "never do this on a publicly shared repo" but they never really explain why not to do it. This seems like it will fix the problem, and it won't become a problem 6 months from now when we actually do want to redo this merge from develop to master
   • If this is the best way to do it, and we do it, what happens to the pull request in bitbucket? That pull request still exists in bitbucket, but we are removing the merge commit it created, so will that mess up bitbucket in any way?

2. git revert -m 1 **

   • This will create a new commit that undoes the changes that were done by the merge
   • This would be fine, except we do intend to merge develop into master at a later date (the next release), and from what I've read, we would have to remember to revert our revert commit before doing this, because otherwise when we merge develop into master, the changes that we revert today won't be included. I really don't want to have this become a problem 6 months from now, when no one remembers this revert.

TL;DR: I'm hesitant on doing git revert because of the issues it could cause 6 months from now when we do want to do this merge again. I'm also hesitant on doing git reset because everyone seems to warn against doing it, and it could cause issues with the pull request on bitbucket.

All,

This may take a moment to set up. I have a small editor project I've worked on the past several months[1]. I originally wanted to implement an inotify watch on the current editor file to protect against modification by a foreing process. I created a custom signal, and routines to add, remove, and monitor (with pselect) the watch and routines to block and unblock emission of the custom signal to allow for normal save/save as without triggering the callback. The problem I had was how to add the monitor to the gtk_event_loop so that a check was performed on each iteration of the loop. I settled on using g_idle_add and went to the gtk-app-devel list to determine if the approach was reasonable or if there was a better way. The concensus was to use GIO/GFileMonitor instead of working with inotify directly.

Fast forward to the current problem. I rewrote the implementation to use GFileMonitor/g_file_monitor_file and rewrote the block and unblock routines to block handling of the "changed" signal to allow a normal save/save as without firing the callback. The problem is when I block the instance and handler_id for the callback before saving the file, the callback still fires. When using the inotify implementation with a custom signal, blocking the emission of the signal worked great. I have posted this back to the gtk-app-devel list, but have received nothing in return -- that's why I'm asking here. Why does g_signal_handler_block with the GIO/GFileMonitor not block handling to the "changed" signal callback? (more importantly, how do I fix it)

note: (MCVE - complete test code is at https://github.com/drankinatty/gtktest). To build with GtkSourceView2, simply type make with=-DWGTKSOURCEVIEW2, it will build as bin/gtkwrite, otherwise to build without, simply type make and it will build as bin/gtkedit.

The logic of the relevant code is as follows (app is an instance of the struct holding relevant editor variables/info and settings) The GIO/GFileMonitor implementation is in gtk_filemon.[ch] and the wrapper around the save function is in gtk_filebuf.c: