java-di | A java dependency injection tool | Dependency Injection library

You can definitely do this. Discord doesn't mind you running multiple instances on different machines using the same token. All events will get forwarded to all your bots (as appropriately) through the websocket protocol.

It's possible to partition your bots with different prefixes using this method. But I wouldn't recommend it since all your bot scripts will have to bear the resource cost of running the bot. You will be spending multiples of RAM and CPU resource as opposed to running a single bot and handling different prefixes internally.

However, this is the recommended method when your bot grows into hundreds of thousands of servers. Through the process known as "sharding", you can split your bot in different servers into "shards" (usually 1-2k per shard) and run different shard(s) on different machines to offload the impact on one specific host server.

Note, Discord API limits you to a maximum of 1000 token logins per 24 hours.

I would create a wrapper to make it easier to show things to your UI

For example:

You need to give more information. For example, what kind of file you want to compare, is there time constraint, whether you encountered a problem using Java-Diff-Utils. In absence of that, following is just a thought:

If you look at professional diff tools, I usually use winmerge (https://winmerge.org), they have different ways to treat different types of files. So, a XML or CSV or json with different order of tags is still file with same information. If you want to compare to non-structured files, for example .txt, it would not matter if java-diff-utils treats chunks as same file or not. Otherwise, you will have to worry about it.

Based on their help page and examples (https://github.com/java-diff-utils/java-diff-utils/wiki/Examples) it seems two blocks are essentially two files. But even if it is so, you should be able to override that behaviour (Seeing as it is open source).

After going through some documentation, I found the prefect solution.

There's a Google library which can be added as a dependency in the app and it parses the response from DetectIntentResponse object to original raw response JSON.

build.gradle

implementation 'com.google.protobuf:protobuf-java-util:4.0.0-rc-2'

detectIntent()

Instead of grabbing the text of whole body tag like:

text = soup.body.get_text()

Make it a bit more specific and just grab the article tag like:

article = ''.join([p.get_text() for p in soup.select_one('article').select('p')][1:-1])

What happens there?

1. soup.select_one('article') selects the article tag

2. select('p') selects all p tags in result of soup.select_one('article')

3. [p.get_text() for p in soup.select_one('article').select('p')] is looping over all results from select('p') and generating a list of its texts

4. last step is joining ''.join() all elements together, excluding the first and the last one by list slicing [1:-1]

I can export the signature, so what should I do with the signature?

You have to distinguish between Private Key, Certificate and Signature.
Private Key: User's private key, if created in cryptographic device, never comes out of the device.
Certificate, in very brief, is a signed Public Key. Certifying Authority (CA) Signed it and Certificate is publicly available.
Signature is Signed Content. In fact, content to be signed is hashed and then this hash is signed, which is called Signature.

Is this the correct flow of digital signature: create the signature with user's certificate, store the signature, create endpoint for signature verification?

Private key is used to sign content (hash of content). The string produced is called Signature. Certificate (Public key) is used to verify signature.

is there solution for all types of files (ie. I have found pdf based solutions).

Any content can be signed. Signing text files like CSV data, XML, Json, etc is used by web applications which accepts data from the users or members. Example being eReturns, Signed Payment settlement data from banks, Tender Forms, etc. PDF (and some other formats) supports signing and verifying signature and is format widely used to share document. Documents can display visible signature and hence pdf signatures are most discussed format of the Signatures.
Otherwise, any application can define the signing requirement, users (client application or web browser) follow the required standard of signing and then the application can verify that signature is attached (along with data) as per pre-define format and standard.

I need to implement digital signatures to my web app.

Modern Browsers may need to use Browser Extensions to access Certificate stored on local machine. ex: Signer.Digital Browser Extension

Based on guillaume blaquiere's suggestion in their comment, I tried following this guide for manually running Datastore locally.

I ran gcloud beta emulators datastore start in one command line, which seemed to run fine, and then I ran $(gcloud beta emulators datastore env-init) in another command line, and I got this error:

I think your problem is that you are including the Main class in the war itself, and App Engine is unable to find it.

As you can see in the GCP migration guide, the Main class is defined in an external dependency named simple-jetty-main.

With the execution of the maven-dependency-plugin this dependency is copied to the appengine-staging directory, making it accessible from the Java classpath.

This is the reason why the Main class can be found in the example proposed in the guide when executing the command from the app.yaml entrypoint:

I think I found a similar way of what we did at the beginning but this time with both exclusions.

Try this: