os.listdir und filesystemencoding

[jens]

Unter Windows funktioniert das tadellos:

Code: Alles auswählen

        for item in os.listdir(self.absolute_path):
            try:
                codec = self.request.context["filesystemencoding"]
                item = item.decode(codec)
                item = item.encode("utf-8")
            except UnicodeError, e:
                self.request.write(
                    "<small>(Unicode-Error: %s)</small><br />" % e
                )
                pass
            self.request.write(
                "<small>%s</small><br />" % item.encode("String_Escape")
            )

Es gibt unter Windows keine Unicode-Fehler. Das filesystemencoding ist mbcs

Unter Linux (ubuntu) klappt das aber nicht es gibt Fehler, wie diese:

'ascii' codec can't decode byte 0xc3 in position 10: ordinal not in range(128)

Das filesystemencoding ist ANSI_X3.4-1968 Wenn ich mir allerdings die Ausgabe der Dateinamen ansehe, sieht das für mich wie UTF-8 aus. z.B. "B\xc3\xbchne" (String_Escape) ist "Bühne"

Warum klappt das unter Linux nicht?

[Joghurt]

Ich glaube nicht, dass das Linuxdateisystem sich um das Encoding schert, leider.

Manche Programme legen bei mir Dateien im UTF-8 an, andere wiederum in Latin-1.

Das "ls" sieht dementsprechend auch lustig aus...

[gerold]

Warum klappt das unter Linux nicht?

Hi Jens!

Nur um sicher zu gehen. self.request.context["filesystemencoding"] liefert das gleiche Encoding wie os.getfilesystemencoding()?

lg
Gerold

[jens]

Nur um sicher zu gehen. self.request.context["filesystemencoding"] liefert das gleiche Encoding wie os.getfilesystemencoding()?

Nein, ich hab sys.getfilesystemencoding() genommen... Oder hast du dich verschrieben?

[gerold]

Oder hast du dich verschrieben?

Hi Jens!

Ich frage deshalb, weil du in deinem Beispielcode self.request.context["filesystemencoding"] und nicht sys.getfilesystemencoding() verwendest. Ich weiß ja nicht, was self.request.context["filesystemencoding"] zurück liefert und ob das wirklich das Filesystemencoding ist.

lg
Gerold

[jens]

Stimmt, aber es ist im Prinzip so:

Code: Alles auswählen

self.request.context["filesystemencoding"] = sys.getfilesystemencoding()

        for item in os.listdir(self.absolute_path):
            try:
                codec = self.request.context["filesystemencoding"]
                item = item.decode(codec)
                item = item.encode("utf-8")
            except UnicodeError, e:
                self.request.write(
                    "<small>(Unicode-Error: %s)</small><br />" % e
                )
                pass
            self.request.write(
                "<small>%s</small><br />" % item.encode("String_Escape")
            )

[gerold]

Hi Jens!

Code: Alles auswählen

        for item in os.listdir(self.absolute_path):
            item = item.decode("Eigenes Scriptcoding")
            item = item.encode("utf-8")
            self.request.write(
                "<small>%s</small><br />" % item.encode("String_Escape")
            )

Ich glaube nicht, dass der eingebaute Befehl "os.listdir()" dir die Daten im Filesystemencoding zurück gibt. Ich glaube eher, dass er dir die Daten im Encoding deines Skriptes zurück gibt. Genau wissen tu ich es aber nicht.

lg
Gerold

[jens]

Tja, keine Ahnung... Auf jeden Fall funktioniert das unter Linux und Windows unterschiedlich... Aber vielleicht sollte ich mal einen Test außerhab von WebServer/CGI machen

Aber das wird heute nix mehr...

[BlackJack]

`os.listdir()` gibt die Dateinamen als Unicode-Zeichenketten zurück, wenn man auch den Pfadnamen als Unicode-Zeichenkette übergibt. Wie sieht's dann bei Dir aus?

[modelnine]

Unter Unix gibts sowas wie ein Filesystem-Encoding auf Dateisystemebene prinzipiell erst mal nicht. Auf der Platte stehen nur Byte-Strings, die dann zumindest unter Linux vom VFS (dem virtuellen Dateisystem des Kernels, das die Devices abstrahiert) entsprechend der Mount-Option des Dateisystems interpretiert werden, allerdings dem Userspace immer noch als Binär-Strings zur Verfügung gestellt werden, und zwar in dem Encoding was als Standard-Encoding ausgewählt wurde beim compilieren des Kernels. Sowas wie Unicode-fähige Syscalls (wie unter Windows) gibts nicht.

Siehe hierzu am besten:

Code: Alles auswählen

man mount

Da steht ziemlich viel drin wie das Filesystem-Encoding unter Linux funktioniert...

[jens]

OK, also ich mach es jetzt so:

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import sys, dircache

for item in dircache.listdir("."):
    codec = sys.getfilesystemencoding()
    if codec == "mbcs":
        # f�Windows
        try:
            item = item.decode(codec).encode("utf-8")
        except UnicodeError, e:
            print ">>>Unicode-Error: %s" % e

    try:
        first_letter = item.decode("utf-8") # nach unicode wandeln
        first_letter = first_letter[0].upper()
        first_letter = first_letter.encode("utf-8") # zurück konvertieren
    except UnicodeError, e:
        print ">>>Unicode-Error 'first_letter': %s" % e
        first_letter = "#"

    print type(item), first_letter, "-", first_letter.encode("String_Escape")
    print item.encode("String_Escape")
    print item

    print

Hab direk das "first_letter"-Problem von http://www.python-forum.de/viewtopic.php?t=5579 angehängt...

Das scheit für mich erstmal gut zu funktionieren... Ist es die beste Lösung?

@BlackJack: dircache mag allerdings als Pfadangabe nur string, kein unicode...

[jens]

Also ich komm einfach nicht auf einen grünen Zweig....

Nun hab ich es versucht os.listdir() mit einem unicode-Pfad zu füttern...

Unter Windows habe ich dann alle Dateinamen als unicode... Unter Linux aber nur die, in denen _keine_ Sonderzeichen vorkommen Also ein Mischmasch

Die einzige Variante die funktioniert, ist einfach alle Dateinamen/Pfade zu ignorieren, in denen Sonderzeichen vorkommen. Aber das ist ja wohl nicht wirklich eine Lösung

EDIT: Wenn ich nun unter Linux versuche die nicht unicode Einträge in unicode zuwandlen, klappt das mit utf-8 erstmal... Später hab ich allerdings probleme.
os.path.isfile() funktioniert nicht mehr! Es sagt, das der Eintrag eine Datei ist, es ist aber ein Verzeichniss!
Mit os.stat() bekommte ich dann einen UnicodeEncodeError

Ich bau mir jetzt nochmal ein kleines Testscript und poste das mal...

[jens]

So, ich hab ein kleines Test-Skript. Im Testverz. sind folgenden Einträge:

• <verz> dir eins
  <verz> dir zwei äöüß
  <datei> file eins.txt
  <datei> file zwei äöüß.txt

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import sys, os

stdout_encoding = sys.stdout.encoding or sys.getfilesystemencoding()
print "stdout_encoding:", stdout_encoding



def filesystemTest(listPath):
    absolute_path = os.getcwd()

    print "-"*79
    print "absolute_path:", absolute_path
    print "listPath:", listPath
    print

    dirList = os.listdir(listPath)
    try:
        dirList.sort()
    except UnicodeError, e:
        print "sort() ERROR:", e

    for item in dirList:
        print type(item),
        if isinstance(item, unicode):
            try:
                print item.encode(stdout_encoding)
            except UnicodeError, e:
                print "ERROR 1:", e
        else:
            print item

        abs_path = os.path.join(absolute_path, item)
        print type(abs_path),
        if isinstance(item, unicode):
            try:
                print abs_path.encode(stdout_encoding)
            except UnicodeError, e:
                print "ERROR 2:", e
        else:
            print abs_path

        print "file: %s, dir: %s" % (os.path.isfile(abs_path), os.path.isdir(abs_path))

        try:
            abs_path = abs_path.decode(sys.getfilesystemencoding())
            print "file: %s, dir: %s" % (os.path.isfile(abs_path), os.path.isdir(abs_path))
        except UnicodeError, e:
            print "ERROR 3:", e

        print


#~ filesystemTest("FilesystemUnicodeTest")
#~ filesystemTest(u"FilesystemUnicodeTest")

filesystemTest("FilesystemUnicodeTestLinux")
filesystemTest(u"FilesystemUnicodeTestLinux")

Ausgaben Windows:

Code: Alles auswählen

stdout_encoding: mbcs
-------------------------------------------------------------------------------
absolute_path: W:\PyDown\PyDown
listPath: FilesystemUnicodeTest

<type 'str'> dir eins
<type 'str'> W:\PyDown\PyDown\dir eins
file: False, dir: False
file: False, dir: False

<type 'str'> dir zwei äöüß
<type 'str'> W:\PyDown\PyDown\dir zwei äöüß
file: False, dir: False
file: False, dir: False

<type 'str'> file eins.txt
<type 'str'> W:\PyDown\PyDown\file eins.txt
file: False, dir: False
file: False, dir: False

<type 'str'> file zwei äöüß.txt
<type 'str'> W:\PyDown\PyDown\file zwei äöüß.txt
file: False, dir: False
file: False, dir: False

-------------------------------------------------------------------------------
absolute_path: W:\PyDown\PyDown
listPath: FilesystemUnicodeTest

<type 'unicode'> dir eins
<type 'unicode'> W:\PyDown\PyDown\dir eins
file: False, dir: False
file: False, dir: False

<type 'unicode'> dir zwei äöüß
<type 'unicode'> W:\PyDown\PyDown\dir zwei äöüß
file: False, dir: False
ERROR 3: 'ascii' codec can't encode characters in position 26-29: ordinal not in range(128)

<type 'unicode'> file eins.txt
<type 'unicode'> W:\PyDown\PyDown\file eins.txt
file: False, dir: False
file: False, dir: False

<type 'unicode'> file zwei äöüß.txt
<type 'unicode'> W:\PyDown\PyDown\file zwei äöüß.txt
file: False, dir: False
ERROR 3: 'ascii' codec can't encode characters in position 27-30: ordinal not in range(128)

EDIT:
So jetzt das ganze unter Linux:

Code: Alles auswählen

stdout_encoding: UTF-8
-------------------------------------------------------------------------------
absolute_path: /daten/www/PyDown/PyDown
listPath: FilesystemUnicodeTestLinux

<type 'str'> dir eins
<type 'str'> /daten/www/PyDown/PyDown/dir eins
file: False, dir: False
file: False, dir: False

<type 'str'> dir zwei äöüß
<type 'str'> /daten/www/PyDown/PyDown/dir zwei äöüß
file: False, dir: False
ERROR 3: 'utf8' codec can't decode bytes in position 34-36: invalid data

<type 'str'> file eins.txt
<type 'str'> /daten/www/PyDown/PyDown/file eins.txt
file: False, dir: False
file: False, dir: False

<type 'str'> file zwei äöüß
<type 'str'> /daten/www/PyDown/PyDown/file zwei äöüß
file: False, dir: False
ERROR 3: 'utf8' codec can't decode bytes in position 35-37: invalid data

-------------------------------------------------------------------------------
absolute_path: /daten/www/PyDown/PyDown
listPath: FilesystemUnicodeTestLinux

sort() ERROR: 'ascii' codec can't decode byte 0xe4 in position 9: ordinal not in range(128)
<type 'unicode'> dir eins
<type 'unicode'> /daten/www/PyDown/PyDown/dir eins
file: False, dir: False
file: False, dir: False

<type 'str'> dir zwei äöüß
<type 'str'> /daten/www/PyDown/PyDown/dir zwei äöüß
file: False, dir: False
ERROR 3: 'utf8' codec can't decode bytes in position 34-36: invalid data

<type 'unicode'> file eins.txt
<type 'unicode'> /daten/www/PyDown/PyDown/file eins.txt
file: False, dir: False
file: False, dir: False

<type 'str'> file zwei äöüß
<type 'str'> /daten/www/PyDown/PyDown/file zwei äöüß
file: False, dir: False
ERROR 3: 'utf8' codec can't decode bytes in position 35-37: invalid data

Was ich jetzt gerad überhaupt nicht verstehe, das isfile() und isdir() immer false sind Das kann eigentlich nicht wirklich sein!

Unter Linux klappt komischerweise sort() auch nicht Ein Test mit sorted() klappt auch nicht...

[modelnine]

Jens, lies Dir man mount und Filesystem-Encoding da mal durch... Wie ich bereits sagte funktioniert die Kommunikation mit dem Userspace immer als Binär-Datenstrom, nicht per Unicode...

Warum mußt Du eigentlich umbedingt wissen mit welchem Dateinamen-Encoding der File auf der Platte liegt?

[jens]

Warum mußt Du eigentlich umbedingt wissen mit welchem Dateinamen-Encoding der File auf der Platte liegt?

Also wirklich wissen möchte ich das nicht... Ich möchte nur einfach das Dateinamen (WSGI-WebApp) richtig im Browser dagestellt werden, auch wenn sie Sonderzeichen haben

Da ich die Webseiten als UTF-8 sende (über jinja mit charset=UTF8) brauche ich also unicode oder direkt UTF-8... Wie ich das jetzt anstelle, weiß ich allerdings nicht...

EDIT: es ist eine ext3 Partition, auszug aus der fstab:

Code: Alles auswählen

/dev/hda6  /daten  ext3  suid,dev,exec  0  1

EDIT2: Hab noch was gefunden zum Thema ( http://www.amk.ca/python/howto/unicode ):

MacOS X uses UTF-8 while Windows uses a configurable encoding; on Windows, Python uses the name "mbcs" to refer to whatever the currently configured encoding is. On Unix systems, there will only be a filesystem encoding if you've set the LANG or LC_CTYPE environment variables; if you haven't, the default encoding is ASCII.

LANG ist bei mir de_DE.UTF-8

Und noch was gefunden: http://kofoto.rosdahl.net/trac/wiki/UnicodeInPython (unter File system):

os.listdir

os.listdir(u"path") returns Unicode strings for names that can be decoded with sys.getfilesystemencoding() but silently returns byte strings for names that can't be decoded. That is, the return value of os.listdir(u"path") is potentially a mixed list of Unicode and byte strings.
...
os.path

On Unix, os.path.abspath throws UnicodeDecodeError when given a Unicode string with a relative path and os.getcwd() returns a non-ASCII binary string (or rather: a non-sys.getdefaultencoding()-encoded binary string). Therefore, the argument must be a byte string. On Windows, however, the argument must be a Unicode string so that the "wide" API calls are used. This leads to the nasty situation that a work-around is needed, but only on Unix:

Code: Alles auswählen

if os.name == "posix":
    fs_enc = sys.getfilesystemencoding()
    def abspath(path):
        return os.path.abspath(path.encode(fs_enc)).decode(fs_enc)
else:
    abspath = os.path.abspath
x = abspath(u"path")

Demnach muß ich wohl einige work-a-round's einbauen, was?

[jens]

So, ich bin jetzt ein wenig schlauer...

Es liegt definitiv an meinem Linux-System

Ich hab zwar mal das folgende Probiert, aber eine Lösung ist das nicht:

Code: Alles auswählen

import sys, locale

tryCodecs = ["utf-8", "latin-1"]

tryCodecs.append(sys.getdefaultencoding().lower())
tryCodecs.append(sys.getfilesystemencoding().lower())
tryCodecs.append(locale.getpreferredencoding().lower())

tryCodecs = tuple(set(tryCodecs))


def makeUnicodeList(items):
    def tryConvert(item):
        for codec in tryCodecs:
            try:
                return unicode(item, codec)
            except UnicodeError:
                pass
        raise UnicodeError("Can't convert item")

    result = []
    for item in items:
        if isinstance(item, unicode):
            result.append(item)
            continue

        try:
            item = tryConvert(item)
        except UnicodeError:
            continue
        else:
            result.append(item)

    return result

dirList = os.listdir(u".")
dirList = makeUnicodeList(dirList)

Das ganze hilft leider nicht viel. Ich hab zwar im Ergebnis unicode, aber es funktionieren dann keine Befehle wir os.stat() und os.path.* mehr. Da diese die Verz./Dateien nicht mehr finden können

Also hab ich nochmal ein neuen Test gemacht. Diesmal hab ich per Samba von Windows aus neue Dateien mit Umlauten gemacht. Siehe da, nun klappt es direkt! Also os.listdir() spuckt direkt unicode aus und os.stat() und os.path.* arbeiten richtig.


Das komische ist, das ich auf der Konsole folgendes für äöüß sehe: äöüà - Was für mich aussieht wie UTF-8. String Escaped ist das:
\xc3\xa4\xc3\xb6\xc3\xbc\xc3\x9f
Das für beide Fälle. Also einmal bei den Dateien die ich direkt auf dem Ubuntu-Rechner erzeugt hab und einmal die Dateien die ich per Samba
erstellt hab.
Ein Unterschied sieht man allerdings im mc! Die durch Samba erstellten Dateien sehe ich nur mit äöüà die unter Linux erstellten Dateien sehe ich richtig mit äöüß

Also liegt das ganze Problem wohl an meiner Linux installation

Nur sollte Python in dem Falle nicht irgendwie trotzdem funktionieren?

Kompliziert wird es, weil ich ja die Dateinamen als Webseite anzeigen lasse, mit Links. Diese Links sollten auch funktionieren

[jens]

Also es liegt wohl wirklich an meiner Linux installation... Also hab ich das gemacht:

Code: Alles auswählen

sudo dpkg-reconfigure locales

und nur "de_DE.UTF-8" aktiviert... Siehe da die Umlaute sehe ich nun in meinem lokalen Test-Skript richtig und os.listdir() spukt alles korrekt in unicode aus!

Allerdings ist das nur die halbe Miete Denn meine WebApp hat weiterhin das selbe Problem

Ich hab mal folgendes gemacht:

Code: Alles auswählen

def get_file_encoding(f):
    if hasattr(f, "encoding"):
        return f.encoding
    else:
        return "not set"

print "sys.stdin.encoding:", get_file_encoding(sys.stdin)
print "sys.stdout.encoding:", get_file_encoding(sys.stdout)
print "sys.stderr.encoding:", get_file_encoding(sys.stderr)
print "sys.getdefaultencoding():", sys.getdefaultencoding()
print "sys.getfilesystemencoding():", sys.getfilesystemencoding()
print "locale.getpreferredencoding():", locale.getpreferredencoding()

Das spukt mir mit meine lokalen-TestSkript folgendes aus:

sys.stdin.encoding: UTF-8
sys.stdout.encoding: UTF-8
sys.stderr.encoding: None
sys.getdefaultencoding(): ascii
sys.getfilesystemencoding(): UTF-8
locale.getpreferredencoding(): UTF-8

Das selbe mach ich mit PyDown und siehe da, es spuckt immer noch andere Werte aus:

sys.stdin.encoding: None
sys.stdout.encoding: None
sys.stderr.encoding: None
sys.getdefaultencoding(): utf-8
sys.getfilesystemencoding(): ANSI_X3.4-1968
locale.getpreferredencoding(): ANSI_X3.4-1968

Wie kommt das zustande?

Ich denke deswegen funktioniert PyDown auch immer noch nicht mit Umlauten, weil Python versucht die Dateinamen mit ANSI_X3.4-1968 zu entschlüsseln

[jens]

Dank Martin v. Löwis von der Maillingliste hab ich dafür nun auch ein Lösung:

Offenbar läuft Apache mit LANG=C. Es gibt zwei Möglichkeiten:

1. Du änderst die locale, in der Apache läuft, z.B. indem Du
in /etc/init.d/apache2 den Text

ENV="env -i LANG=C PATH=/usr/local/bin:/usr/bin:/bin"

durch

ENV="env -i LANG=de_DE.UTF-8 PATH=/usr/local/bin:/usr/bin:/bin"

ersetzt (besser würde man ENV in /etc/default/apache2 setzen)

Nach der Änderung geht's nun endlich!

EDIT:
Noch ein Anmerkung. URLs behandle ich nun so:

Code: Alles auswählen

url = urllib.quote(url.encode("utf-8"))

und zurück mit

Code: Alles auswählen

url = unicode(urllib.unquote(url), "utf-8")

Das klappt bei mir bisher unter Windows und Linux...

Außerdem muß ich bei ZIP-Dateien noch ein arcname = arcname.encode("cp437") machen, denn Namen in ZIP-Dateien werden immer mit dem codepage 437 gespeichert, siehe Kommentare im Python-Bug 878120
Leider steht das mal wieder nicht in der Doku, deswegen hab ich mal einen neuen BugReport geschrieben: http://sourceforge.net/tracker/index.ph ... tid=105470

Der Thread auf der Maillingliste ist hier zu finden:
"[Python-de] filesystemencoding jens"