Rth | Norm Matloff 's Rth package | GPU library

It does not match as it expects 2 characters using (([ .)\n|])([^a-zA-Z])) where the second one can not be a char a-zA-Z due to the negated character class, so it can not match the s in Jude some.

What you might do is make the character class in the second part optional, if you intent to keep all the capture groups.

You could also add word boundaries \b to make the pattern a bit more performant as it is right now.

See a regex demo

(Note that Jude is listed twice in the alternation)

If you only want to use 3 groups, you can write the first part as:

So correlated sub queries can normally be turn into some form of join in you case the primary things you are doing is matching on two columns and selecting what appears randomly (if you have more than 1 row in active=false state) a row, this can be turned into a row_number() and using QUALITY as the equivalent as LIMIT.

Thus:

I don't see a way to split the column, but you can use a combination of left_join() and mutate() to achieve the desired output.

After playing around with it for about an hour, I've come to a solution. I added --hidden-import "pywin32" to the pyinstaller command, and it worked! So if uninstalling and reinstalling doesn't work, try adding "pywin32" as a hidden import.

Does this work for you:

PBEWITHHMACSHA512ANDAES_256 applies PBKDF2 to generate the key. Encryption is performed with AES-256, CBC.

The (originally) posted Jasypt test function used RandomIvGenerator, which creates a random IV. For the salt, ZeroSaltGenerator is applied, which generates a salt consisting of 16 zero bytes.

To implement the Python function you are looking for, it is best to use a fixed IV, e.g. with StringFixedIvGenerator. StringFixedSaltGenerator provides a corresponding functionality for the salt (FixedStringSaltGenerator has the same functionality but is deprecated since 1.9.2). StringFixedSaltGenerator and StringFixedIvGenerator encode the passed string with UTF-8 by default (but another encoding can be specified), so that the salt (or IV) 0000000000000000 is hex encoded 0x30303030303030303030303030303030.

Note that a fixed salt and IV may only be used for testing. In practice, a new random salt and a new random IV must be used for each encryption. Since salt and IV are not secret, they are usually concatenated with the ciphertext on byte level (e.g. in the order salt, iv, ciphertext) and sent to the receiver, who separates the parts and uses them for decryption.

If the same parameters (especially the same salt and IV) are used on both sides, then encryption with Python and decryption with Java works.

Encryption with Python (PyCryptodome):

Use np.where its faster:

In the simplest case, like @jarlh said, you can just do an update:

If I followed you correctly, you can implement the priorization rules on the overall result of each user using conditional aggregation.

Starting from your existing query, the logic would be: