XBB | C11 library to enable composition of 3d transforms | Math library

decompressed = zlib.decompress(message, -zlib.MAX_WBITS).decode('UTF-8')

As @MikeCAT and @Remy Lebeau said : sprintf(char_array, "\xAA\xBB\xCC%c\xEE", '0'); work. The issue was that later in my code I have a strlen(char_array) which returned :

6 for sprintf(char_array, "\xAA\xBB\xCC\xDD\xEE", 22); and

4 for sprintf(char_array, "\xAA\xBB\xCC%c\xEE", 0);

So for now i will fix the size at 6. Thanks for your help.

The initial bytes PK\x03\x04 suggest that it's PK Zip format. Try unzipping it first, either with unzip x or with Python builtin zipfile module.

The gRPC protocol is defined in this document. In particular, the section about "Length-Prefixed-Message" describes how the data is encoded:

The repeated sequence of Length-Prefixed-Message items is delivered in DATA frames

• Length-Prefixed-Message → Compressed-Flag Message-Length Message
• Compressed-Flag → 0 / 1 # encoded as 1 byte unsigned integer
• Message-Length → {length of Message} # encoded as 4 byte unsigned integer (big endian)
• Message → *{binary octet}

In other words, to read messages, read 1 byte for the compressed bit, then read 4 bytes for the length, then read that many bytes for the message. If he compressed bit is set, you will need to decompress the message using the format described in the "grpc-encoding" header. Then the format of the message is application-specific. Protobuf is common.

The problem is that when you convert numpy bytes to str it adds up the escape characters (i.e., \) to every \, which results in \\ instead of \ (e.g., \x00 turns into \\x00 etc.). This messes up the decoding of the string back to the numpy bytes object. In addition, the str() function adds the b\ and the ' to the string, which are then being also encoded as bytes.

The fix is to get rid of all the added characters, (i.e., the extra \ and of the first two b' and the last '). The b' and the last ' characters are easily removed by the [2:-1] indexing operation. Then the 'ISO-8859-1' will remove all the redundant \s and will bring it to the original form (i.e., the form of the vector_bytes)

Here is the solution:

Python doesn't have the equivalent of a "Buffer" type, which is solely a Node.js invention. However, if you want to export the bytes object as JSON in a Node.js-compatible way, you could use the built-in json module:

In python3 this can be decoded as follows:

A couple of problems I see right away:

1. You're asking printf to print a char (%c) but are passing a pointer to char instead of a char.

2. There's a line i % keyLength that doesn't do anything, it just performs a calculation and discards the results.

Also you're calling strlen every time through the loop, which is going to be kind of expensive.

I think what you're expected to do here is have two indexes, one that loops over the range 0 to keyLength, and another that iterates over the string to encode (starting at index keyLength). The function ends when the second index reaches the end of the string.

As said in the comments, I finally realised the nginx configmap was not needed, as the docker image embedded an nginx on its own.

Removing the configmap instructions in deployment.yaml did the trick !