🌐 Mailman 3 January 2002 - Python-list - python.org

confused by isinstance()
by Francois Petitjean Feb. 1, 2002

Feb. 1, 2002

Environment: Python 2.1 on Windows NT4 SPx (x== 5 or 6) with IE 4.0 (1) In a Interpreter.py file : class Interpreter: .... # global procedures (module functions) def onload(obj): """Init_fn of Interpret.py""" if not getattr(obj, 'quiet', 1): print "obj %s type %s\nclass %s isinstance %s" % (`obj`, type(obj),obj.__class__,isinstance(obj, Interpreter) ) print "Interpreter %s\nrepr %s\ntype %s" % (Interpreter, `Interpreter`,type(Interpreter)) # print "Interpreter %s __class__ %s" % (Interpreter, Interpreter.__class__) # assert isinstance(obj, Interpreter) return (obj,) # tuple of objects # Note that the assert isinstance is commented out $ ../Python21/python.exe Interpreter.py obj <__main__.Interpreter instance at 007F7CBC> type <type 'instance'> class __main__.Interpreter isinstance 0 Interpreter Interpreter.Interpreter repr <class Interpreter.Interpreter at 00843BDC> type <type 'class'> We are in the if __name__ == '__main__': case, obj has an attribute named 'quiet' which is false (in fact 0), it is an instance of Interpreter. The onload function is called indirectly from the __init__ ctor of Interpreter. no exception (no TypeError) but isinstance silently returns 0 I can live with the assert commented out, it seems that it is good practice to avoid use of isinstance or of tests on the types, but I'd rather understand why in this case isinstance returns false. I suspect some namespace collision. (1) Thank you MicroSoft for shipping some system components with an application ==> It is practically impossible to assert the system's version. Regards --- Ce que l'on conçoit bien s'énonce clairement, Et les mots pour le dire arrivent aisément. Boileau Despréaux L'Art Poétique. Chant I

5 7

reading sendmail alaises
by David Bear Feb. 1, 2002

Feb. 1, 2002

I would like a quick way to resolve sendmail aliases. I've thought about reading and parsing /etc/aliases myself but thats too much work. Is there some module/interface to sendmail that would allow something like realaddress = sendmail.resolve-alias(name) Even though I could build a dictionary from aliases, the file may actually be in db format -- so I'm looking for a 'sendmail' way of grabbing them. -- David Bear College of Public Programs/ASU 480-965-8257 ...the way is like water, going where nobody wants it to go

4 4

Urllib conundrum
by Rick Kaye Feb. 1, 2002

Feb. 1, 2002

I wanted to write a Python program to retrieve and log my IP address from my Linksys Cable router. The router interface is available through http. To get the IP address manually, you access the router with a browser. However, the router asks for a username and password before letting you get to the interface. At first, I thought I would need to program the exchange of authentication information. To listen in on how the browser was exchanging this information, I installed the PC Magazine utility "Cookie Cop II" (http://www.pcmag.com) which acts as a proxy and lets you listen in the exchange between the browser and the outside world. But then I discovered that Python's urllib module handled user authentication and it seemed all was good. I wrote the program that appears below and it worked fine (with Cookie Cop II's Cookie Cop function disabled and it's IE proxy function enabled). Now comes my problem. Since I no longer needed Cookie Cop II, I removed it. But then my Python program stopped working. Normal browsing (through Internet Explorer) worked fine. And my program could access webpages that are not password protected (by changing the url). But the program no longer worked to get to a password protected page. The error occurs in the line: page=router.open("http://192.168.1.1/Status.htm") in the getstatuspage function as indicated below. The urllib code seems to go into an infinite loop trying and failing to authenticate itself to the router until I get a max recursion level error. Can anyone shed light on why the program below works with the Cookie Cop II proxy but not without it? Or I'd settle for how to make it work without the proxy. import urllib import re class myURLopener(urllib.FancyURLopener): def prompt_user_passwd(self, host, realm): return 'name', 'passwd' def getstatuspage(): router=myURLopener() page=router.open("http://192.168.1.1/Status.htm") #The error occurs on this line contents=page.readlines() router.close() return contents[0] def getipaddress(html=None): if not html: return "" match=re.search(r'WAN.+?IP Address.+?([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)', html) return match.group(1) def writetolog(IPAddress, logfile="C:\\IPAddress.log"): fp=open(logfile, 'a') fp.write(IPAddress) fp.write("\n") fp.close() p=getstatuspage() if p: i=getipaddress(p) if i: writetolog(i)

3 3

PyAppBar -- bug fix, nifty widget
by Keith Farmer Feb. 1, 2002

Feb. 1, 2002

Someone clued me in on a way to fix a lock-up problem I had with the PyAppBar code I wrote for Win32.. I now have it running without error, and am tossing it out to be tinkered with. I've got a simple demo, as well as a moderately entertaining Notebook panel docked to thebottom of the screen, running two Python interpreters with partially shared namespaces. A zip file can be found at http://www.thuban.org/projects ---------- Keith J. Farmer kfarmer(a)thuban.org http://www.thuban.org

3 6

Is thera a Metakit for Python 2.2 release ??
by jriveramerla＠yahoo.com Feb. 1, 2002

Feb. 1, 2002

Hi.. I just Installed Python 2.2 and I am getting the followin error: Traceback (most recent call last): File "D:\scripts\Rev_Si_Hay_Archivos_En_BCKS_Sin_Procesar.py", line 2, in ? import metakit File "D:\TOOLS\Python22\lib\metakit.py", line 12, in ? from Mk4py import * ImportError: Module use of python21.dll conflicts with this version of Python. It worked with Python 2.1, and I searched on the WEB and did not found a comment about a new release. Thanks for your help.

3 3

locale on cygwin
by Andy Todd Feb. 1, 2002

Feb. 1, 2002

Jason Tishler probably knows the answer to this off the top of his head, but ... I'm having problems getting 'locale' to work with Python under cygwin. On my Win2k box with standard Python 2.1.1 my session looks like; PythonWin 2.1.1 (#20, Jul 20 2001, 01:19:29) [MSC 32 bit (Intel)] on win32. Portions Copyright 1994-2001 Mark Hammond (MarkH(a)ActiveState.com) - see 'Help/About PythonWin' for further copyright information. >>> import locale >>> locale.getdefaultlocale() ('en_AU', 'cp1252') >>> locale.setlocale(locale.LC_ALL, '') 'English_Australia.1252' >>> But on the same machine with Cygwin python I get; Python 2.2 (#1, Dec 31 2001, 15:21:18) [GCC 2.95.3-5 (cygwin special)] on cygwin Type "help", "copyright", "credits" or "license" for more information. >>> import locale >>> locale.getdefaultlocale() (None, None) >>> locale.setlocale(locale.LC_ALL, '') 'C' >>> I presume this means that the _locale module is not present on Cygwin, or compiled in with Python. Is there any particular reason why? I've searched the archives of this newsgroup and the Cygwin mailing list and I'm fairly sure this hasn't come up before. If this is a duplicate then please accept my apologies in advance. Regards, Andy -- Contents free posts a speciality

3 8

Re: Equivalent of Perl chomp?
by Jeff Hinrichs Feb. 1, 2002

Feb. 1, 2002

Actually, it doesn't appear to the real "chomp" from perl. > def chomp(s): > if s[-1:]=='\n': return s[:-1] > else: return s According to the def of chomp: "...removes all trailing newlines from the string" http://www.perldoc.com/perl5.6/pod/func/chomp.html So then wouldn't a more accurate representation of chomp be: def chomp(s): while s[-1:]=='\n': s = s[:-1] return s -Jeff p.s. I'm a python newbie so if I made a bad string handling decision please let me know.

4 3

finding a module
by kdahlhaus＠yahoo.com Feb. 1, 2002

Feb. 1, 2002

I'm having a little trouble finding a c extension. Here's the situation: I have a web host that allows python cgi. I've also written a wrapper for a library. The wrapper is a subdirectory with an __init__.py file. In the same subdirectory is a swig-generated c wrapper ( sqlitec.so ) that is imported by one of the files imported by __init__.py. The main web application sits in the directory above the module directory: .....\webapp\main.cgi (imports sqlitedb) .....\webapp\sqlitedb\__init__.py (imports wrapper) .....\webapp\sqlitedb\wrapper.py (imports sqlitec) .....\webapp\sqlitedb\sqlitec.so The code on 'main.cgi' contains an import: 'import sqlitedb'. Python finds the sqlitedb python files, but can not find sqlitec.so. They are runing Python 1.6. How can I allow Python to see the loadable module? It is possible/common for the web providers to disallow import of native code modules? I've tried adding the following to main.cgi: import sys sys.path.append(".") sys.path.append("./sqlitedb") import sqlitedb but that did did not fix anything. Any ideas? If this works, we would be very close to having thread-safe python-based web sites w/an sql database but without an sql server. (Sqlite is a file-based database similar to gadfly).

2 2

isinstance() considered harmful
by Kragen Sitaker Feb. 1, 2002

Feb. 1, 2002

I had previously posted this to the kragen-tol mailing list; that copy is at http://lists.canonical.org/pipermail/kragen-tol/2002-January/000659.html There is an HTML version at http://pobox.com/~kragen/isinstance/ My apologies for the somewhat idiosyncratic markup. isinstance() considered harmful =============================== This is mostly in reference to \(href http://www.python.org Python) programs, and it may be more or less true with reference to programs in other languages. Python is an object-oriented programming language, which is a buzzword, and therefore can mean a wide variety of different things. What it actually means, in Python's case, is that you can implement your objects any way you please; it's the interface they support that determines whether or not they'll work with existing code --- that is, the methods they implement and the semantics of those methods. For example, you can write the first version of a data type in pure Python; you can then rewrite it as a Python extension that creates CObjects, and expect that it will work everywhere the Python version did, as long as it's implemented correctly. This is a useful property; it often results in being able to apply old code to completely new problems. For this promise to hold, the code your object works with must refrain from peeking behind the interface the object supposedly supports. There are probably some times that this is not desirable; transparent persistence and object migration systems can probably work better most of the time by not respecting published interfaces. Some languages, like Java and C++, offer explicit interface support. Python is not among them. It offers \(href http://www.shindich.com/sources/patterns/implied.html implied interfaces) in places where other languages would use explicit interfaces. This has a variety of effects, good and bad. In Python, what classes your object is derived from is not a part of your object's interface. \(b Every use of isinstance is a violation of this promise), large or small. Whenever isinstance is used, control flow forks; one type of object goes down one code path, and other types of object go down the other --- even if they implement the same interface! Bjarne Stroustrup often cited concerns like these when defending C++'s decision not to provide isinstance. (Now, of course, with RTTI in the C++ standard, C++ does provide isinstance.) Sometimes, of course, violating this promise is worth the payoffs --- isinstance, like goto, is not pure evil. But it is a trap for new programmers. Beware! Don't use isinstance unless you know what you're doing. It can make your code non-extensible and break it in strange ways down the line. Reasons for using isinstance ---------------------------- Isinstance is used for a variety of reasons: \(ul - to determine whether an object supports a particular interface - to keep people from writing possibly incorrect programs, or to indicate possible bugs (type-checking) - to test the implementation of an object to see if certain optimizations can be applied - to write regression tests with knowledge of the implementation - to define things that should really be methods outside of the class they operate on - for no apparent reason whatsoever ) To determine whether an object supports an interface ---------------------------------------------------- Using isinstance() to determine whether an object supports a particular interface is always a bad idea. You are, in essence, including inheritance from a particular class in the interface; if anyone wants to implement that interface, they must derive their class from the class you specify, which means they'll inherit its bugs, they'll probably have to understand its invariants, and, in Python, they'll have to be careful not to collide with names it defines. (This is especially bad if one of those names is __getattr__ or __setattr__, but that's another problem.) It's not just overly conservative; it's also overly liberal. Someone can override methods in the interface with broken methods --- in Python, they can even override them with non-callable objects. An object's derivation from a particular class doesn't guarantee that it implements all the protocol that class does. (Still, breaking protocols your base classes implement is almost always a bad idea.) Type-checking to find bugs -------------------------- Using isinstance() for type-checking to find bugs is a special case of the above. The bug you might catch is that the object being checked doesn't implement the interface the rest of your code expects. Here's a perfect example from distutils.cmd.Command.__init__: if not isinstance(dist, Distribution): raise TypeError, "dist must be a Distribution instance" In fact, all Command requires of 'dist' is that it have attributes verbose, dry_run, get_command_obj, reinitialize_command, and run_command, with the appropriate semantics. There's no reason that it should have to be derived from Distribution, which is a monster class nearly a thousand lines long. Determining whether optimizations are applicable ------------------------------------------------ Using isinstance() to determine whether or not a particular abstraction-violating optimization is applicable is a reasonable thing to do, but it is often better to package that optimization into a method and test for its existence: try: optmeth = obj.optmeth except AttributeError: do_it_the_slow_way(obj, stuff) return optmeth(stuff) You can also use hasattr() for this test. This allows your abstraction-violating optimization to work without violating abstraction --- simply by providing a more intimate interface into your objects. There's an example of this in the standard library in test_coercion.py: class CoerceNumber: def __init__(self, arg): self.arg = arg def __coerce__(self, other): if isinstance(other, CoerceNumber): return self.arg, other.arg else: return (self.arg, other) The __coerce__ method would be better written as: def __coerce__(self, other): num = self.arg try: return num, other.arg except AttributeError: return num, other As it's written, if you had instances of two textual copies of the CoerceNumber class, you wouldn't even be able to add them together in Python 1.5, and in Python 2, the interpreter would have to call both of their __coerce__ methods to add them together. (Something like this is actually not uncommon; see the comments below about reload.) Probably the best way to write this in Python 2.x --- although it's marginally slower --- is as follows: def __coerce__(self, other): return self.arg, other Of course, this probably doesn't matter; it isn't very likely that someone will try to inherit from CoerceNumber or add a CoerceNumber instance to an instance of some other similar type, since it is, after all, only a test case. (__coerce__ is kind of a tough routine to write, in general, though, and seems like one place where dispatching on the type of other arguments might be the least of all possible evils.) More instances of this are scattered through the UserDict, UserList, and UserString modules. Adding methods to someone else's classes ---------------------------------------- Sometimes one person wants to write a piece of code that accesses some data in someone else's class. So they check to see if the argument they're being applied to is of the correct type, and then proceed to mess with it in ways its public interface doesn't allow. Generally, this is asking for trouble down the road, but it can be useful for short-term hacks, or for code that is unlikely to change. Sometimes people even do it to their own classes, and that's just bad code. Here's an example from distutils.command.build_ext: # The python library is always needed on Windows. For MSVC, this # is redundant, since the library is mentioned in a pragma in # config.h that MSVC groks. The other Windows compilers all seem # to need it mentioned explicitly, though, so that's what we do. # Append '_d' to the python import library on debug builds. from distutils.msvccompiler import MSVCCompiler if sys.platform == "win32" and \ not isinstance(self.compiler, MSVCCompiler): template = "python%d%d" if self.debug: template = template + '_d' pythonlib = (template % (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) # don't extend ext.libraries, it may be shared with other # extensions, it is a reference to the original list return ext.libraries + [pythonlib] This stuff should probably live in a method of the compiler object, so you can say return self.compiler.get_libraries(ext.libraries) but possibly the best solution is to say if sys.platform == "win32" and not self.compiler.ismsvc(): or even if sys.platform == "win32" and not hasattr(self.compiler, 'msvc'): Writing regression tests ------------------------ If you implement an __add__ method that returns a new instance of the same class, and you decide to change it to return an instance of a different class, you should probably modify your regression tests to cover the new class. So it's perfectly reasonable for them to fail in this case. However, they should probably compare __class__ rather than using isinstance(). For no apparent reason ---------------------- I've seen isinstance used to check whether something was None or a real object, and I've seen it used in places where it apparently had no real effect. reload ------ Python's reload() function reloads modules of code into the running interpreter, re-executing their contents. This generally results in functions and classes in those modules being replaced with fresh versions, often identical fresh versions. References to those functions and classes elsewhere are not replaced, however, so old objects retain their old classes. The result is that the following code prints 0 twice, assuming that everything works perfectly: import somemod x = somemod.someclass() reload(somemod) print isinstance(x, somemod.someclass) y = somemod.someclass() print isinstance(y, x.__class__) This means that any code whose correctness depends on being able to tell that x is an instance of somemod.someclass will fail in the presence of reloading, and any code whose performance depends on it will perform poorly in the presence of reloading. Prevalence of isinstance in the standard library ------------------------------------------------ It appears to be recognized that isinstance is usually a bad idea; rather like Euclid's parallel postulate, the proof of this is in the frequency of its use. In Python 2.1.1, there are 98586 lines in 447 .py files in the standard library; 68 of those lines mention 'isinstance'. 19 of those 68 are in the test suite, which contains 19364 of the total lines; seven of these (10% of the total standard-library use!) are verifying that isinstance() itself works. 24 of these are in User*.py, which uses isinstance to see if it's safe to bypass public interfaces and use other objects' data members directly. They should use try-except or hasattr instead.

6 10

An improvement to Queue
by Michael Abbott Feb. 1, 2002

Feb. 1, 2002

I would like to suggest a simple and fully backwards compatible improvement to the standard Queue class. How do I go about arranging that this actually happens? The proposal is very simple: 1. The Queue.get() method be modified to return a flag indicating whether the queue has just changed state from empty to non-empty. This allows the generating process to know whether a "wake-up" signal needs to be passed to the client thread, and is useful for non-blocking use of the queue. 2. A new Queue.get_all() method be added which returns the entire content of the queue in one gulp. Of course this can be implemented by looping on Queue.get(), but get_all can be *much* more efficient. An assistant _get_all method is provided to be compatible with the existing _get, _put, _init etc methods. Below is my current implementation as a sub-class of Queue; I'm suggesting that this be rolled into the existing Queue in the obvious manner. import Queue class XQueue(Queue.Queue): def put(self, item, block=1): """Put an item into the queue. If optional arg 'block' is 1 (the default), block if necessary until a free slot is available. Otherwise (block is 0), put an item on the queue if a free slot is immediately available, else raise the Full exception. Returns true iff the queue was empty when this item was added. """ if block: self.fsema.acquire() elif not self.fsema.acquire(0): raise Full self.mutex.acquire() was_empty = self._empty() self._put(item) if was_empty: self.esema.release() if not self._full(): self.fsema.release() self.mutex.release() return was_empty # Only change to existing implementation # This code is modified from the existing get() implementation. def get_all(self, block=1): """Remove and returns the entire content of the queue as a list. If optional arg 'block' is 1 (the default), block if necessary until at least one item is available. Otherwise the entire content of the queue is unconditionally returned. """ self.esema.acquire(block) # After this the queue WILL be empty! self.mutex.acquire() was_full = self._full() items = self._get_all() # Hook for implementation override if was_full: self.fsema.release() self.mutex.release() return items # This is a new implementation hook. Note that this only needs to be # overridden if get_all() is actually used. def _get_all(self): item = self.queue self.queue = [] return item

5 11