Ajout de méthodes à un 'cas particulier' (cStringIO pour l'exemple) ?

Version imprimable

Bonjour,

Dans un premier temps désolé pour mon manque de vocabulaire, c'est sans doute pour cela que je ne trouve pas de réponse sur le web.
J'ai sans doute louper un chapitre à mon auto formation à Python mais comment faire ceci (c'est un exemple):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import StringIO
 
class StrIO(StringIO.StringIO):
    def setfn(self, fn):
        self.fn=fn
    def fileno(self):
        if self.closed:
            raise ValueError, "I/O operation on closed file"
        if self.fn:
            return self.fn
        else:
            raise ValueError, "fileno not set"
    def __exit__(self, *args):
        self.close()
    def __enter__(self):
        return self
 
with open('test.py', 'rb') as a:
    with StrIO(a.read()) as test:
        print test.read()
        test.setfn(a.fileno())
    print test.closed
    print test.fileno()

avec des modules tels que cStringIO ?

Merci d'avance

Edit : Simplification du code exemple

Bon, pour simplifier je pense bien à quelque chose de ce style

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import cStringIO
 
class Generator(object):
    def __init__(self, gen):
        self.gen = gen
    def __enter__(self):
        return self.gen
    def __exit__(self, type, value, traceback):
        self.gen.close()
    def setfn(self, fn):
        self.fn = fn
    def fileno(self):
        return self.fn
 
def manager(func):
    def helper(*args, **kwds):
        return Generator(func(*args, **kwds))
    return helper
 
@manager
def StrIO(source):
    f = cStringIO.StringIO(source.read())
    return f
 
with open('Luke.py', 'rb') as a:
    with StrIO(a) as test:
        print test.read()
        print test.closed
    print test.closed

Mais je bloque sur setfn/fileno. Cela viens sans doute d'une erreur dans le code mais à force de regarder le code je ne vois plus ou.

Merci

Salut,
Apparemment, tu cherches à associer un cStringIO à un "vrai" fichier mais on ne peut hériter de cStringIO. Une solution pourrait être d'écrire un myopen qui retourne une chose bizarre comme ci dessous:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from cStringIO import StringIO
from contextlib import contextmanager
 
@contextmanager
def myopen(name, mode):
 
    class MyStringIO:
        def __init__(self, file):
            self._file = file
            self._stringIObuf  = StringIO(file.read())
            self.is_closed = False
        def close(self):
            self._file.close()
            self.is_closed = True
        def fileno(self):
            if self.is_closed:
                raise ValueError, "I/O operation on closed file"
            return self._file.fileno()
        def __getattr__(self, key):
            return getattr(self._stringIObuf, key)
 
    f = MyStringIO(open(name, mode))
    try:
        yield f
    finally:
        f.close()
 
def test_myopen():
    with myopen('toto.txt', 'r') as f:
        print 'is_closed: ', f.is_closed
        print 'fileno: %d' % f.fileno()
    print 'is_closed: ', f.is_closed

Dans cette histoire, MyStringIO se contente de ressembler à un cStringIO via __getattr__ et re-écrit les méthodes "close" et "fileno" pour les appliquer au fichier associé.

Il devrait être possible de faire "mieux" avec le StringIO du module io mais je ne suis pas certain d'avoir tout compris dans ce que tu veux...
- W

Bonjour,

Citation:

Envoyé par wiztricks

mais on ne peut hériter de cStringIO

C'est bien de cela dont je parle
Code:

1 2 3 4 5 6 7 8 >>> class test(StringIO): ... def __init__(self): ... pass ... Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Error when calling the metaclass bases cannot create 'builtin_function_or_method' instances
En fait c'est juste pour l'exemple que j'utilise StringIO et cStringIO.
Je pars sur deux besoins distincts (et c'est sans doute ce qui te trouble) pour tester cela, soit:
L'ajout de l'__init__ et d'__enter__ pour une utilisation avec with.
L'ajout de méthodes. Ici fileno et setfn, seulement pour l'exemple et non pour refaire le monde.
Dans le cadre de la classe StrIO pas de problème, et c'est normal.
Par contre, et comme dit, ce n'est pas possible avec cStringIO. D'ou ma question.

Pour ce qui est de l'utilisation du with j'avais réussit à m'en sortir avec le context manager ou la classe Generator retourne au with ce qu'il demande.
C'est sur le deux autres fonctions ou je bloquais. Je ne pouvais pas utiliser la classe Generator et je n'ai pas penser à aller plus loin et utiliser contextlib.
Je vais regarder cela plus en détail.
Je reste ouvert à toute autre idée ou explication.

Merci

Ben cStringIO n'est pas sous classable mais on peut y accéder via un proxy comme je l'ai fait. Si on enlève el superflus, çà donne:
Code:

1 2 3 4 5 class MyStringIO: def __init__(self, *args, **kwds): self._stringIObuf = StringIO(*args, **kwds) def __getattr__(self, key): return getattr(self._stringIObuf, key)
Maintenant, si l'objet est d'avoir les performances de cStringIO + la "classe", tu peux utiliser la mouture qui vient avec le module io à partir de 2.6 et qui vise à remplacer tout çà.

- W