[ TAG 270 ][16.12.2021] -Erfolgreich -IAP-20210601-20210722 -RAWARRAY Encoder und Decoder

Ich beginne heute die Worksession um [16.01.2022][1057]. Der Schwerpunkt bei den IAP-Modul liegt heute bei der Ausarbeitung der Attribute und die dafür benötigten Methoden.

Encoder-Methode

Die Encoder-Methode fasst die durch Attribut übergebene Zeichenkette als eine Byte-Sequenz in ein RAW-ARRAY zusammen. Dabei sollte die Zeichenkette in UTF-8 kodiert sein.

Decoder-Methode

Die Decoder-Methode fasst die Byte-Sequenz in einen RAW-ARRAY zu einer Zeichenkette zusammen.

Die Codierung von Zeichenketten ist ein wesentlicher Bestandteil, der Übergabe von Daten an den Prozess. Die numerischen Daten machen keinen großen aufwand, da Sie mit C-Datentypen abgedeckt werden.

Hier ist ein weiterer Test zum Thema Zeichenketten-Codierung.

def RAWARRAY_ENCODER(utf8_str=None):
    binarr = bytearray(utf8_str, 'utf8')
    rawArray = RawArray(c_uint8, len(binarr))

    print("")
    print("TEST-20220116-1318")
    print("RAWARRAY_ENCODER")
    print("Ausgabe des RAWARRAYS")
    i = 0
    for e in binarr:
        rawArray[i] = binarr[i]
        print(f"i:{i} binarr[{i}]: {binarr[i]} unichar: {chr(binarr[i])}")
        i += 1
    print("")
    print("Achtung! RAW-ARRAY-Elemente sind Integer keine Bytes!")
    print(f"unichar: {chr(binarr[3]+binarr[4])} <- das ist Falsch.")
    print("")
    print("Elemente des RAW-ARRAY werden in Bytes umgewandelt.")
    bin_3 = "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(int(binarr[3]))
    bin_4 = "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(int(binarr[4]))
    print(f"binarr[3].to_bytes(): {int(binarr[3]).to_bytes(1, 'big')}")
    print(f"bin_3: {bin_3}")
    print("")
    print(f"binarr[4].to_bytes(): {int(binarr[4]).to_bytes(1, 'big')}")
    print(f"bin_4: {bin_4}")
    print("")

    print("Byte-3 und Byte-4 werden mit \" + \"-Operator zusammen gesetzt.")
    b5 = int(binarr[3]).to_bytes(1, 'big') + int(binarr[4]).to_bytes(1, 'big')
    print(f"b: {b5} type: {type(b5)}")
    bin_5 = "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(int.from_bytes(b5, 'big'))
    print("U+00E4  ä  11000011 10100100  LATIN SMALL LETTER A WITH DIAERESIS")
    print(f"bin_5: {bin_5}")
    try:
        str = b5.decode(encoding="utf-8")
        print(f"str: {str}")
    except:
        print("decodierung fehlgeschlagen.")

    print("")
    print("")

    return rawArray

RAWARRAY_ENCODER

Ausgabe des RAWARRAYS

i:0 binarr[0]: 67 unichar: C

i:1 binarr[1]: 58 unichar: :

i:2 binarr[2]: 92 unichar: \

i:3 binarr[3]: 195 unichar: Ã

i:4 binarr[4]: 164 unichar: ¤

i:5 binarr[5]: 100 unichar: d

i:6 binarr[6]: 101 unichar: e

i:7 binarr[7]: 115 unichar: s

i:8 binarr[8]: 100 unichar: d

Achtung! RAW-ARRAY-Elemente sind Integer keine Bytes!

unichar: ŧ <- das ist Falsch.

Elemente des RAW-ARRAY werden in Bytes umgewandelt.

binarr[3].to_bytes(): b'\xc3'

bin_3: int: 195;  hex: c3;  oct: 303;  bin: 11000011

binarr[4].to_bytes(): b'\xa4'

bin_4: int: 164;  hex: a4;  oct: 244;  bin: 10100100

Byte-3 und Byte-4 werden mit " + "-Operator zusammen gesetzt.

b: b'\xc3\xa4' type: <class 'bytes'>

bin_5: int: 50084;  hex: c3a4;  oct: 141644;  bin: 1100001110100100

str: ä

Wie man sieht kann Byte-3 und Byte-4 zu Problemen führen. Diese zwei Bytes stellen "ä" dar. Ich vermute, dass es in Zukunft zu Problemen führen könnte, weil ich aus den numerischen Werten nicht weiß ob ein Char ein Byte groß ist oder zwei. Die Decodierungs-Methoden von Python haben damit scheinbar kein Problem.

Für dieses Problem habe ich genug Daten gesammelt.

Der nächste Schritt besteht in der Überlegung, welche Attribute an das ALOG-Prozess übergeben werden soll?

Hochachtungsvoll

Artem Kraft