Mailman 3 October 2001 - Python-Dev

CVS: python/dist/src/Lib xmlrpclib.py,1.11,1.12
by Martin v. Loewis Oct. 10, 2001

Oct. 10, 2001

> It seems like it ought to handle subclasses of builtin classes like > string. That's desirable, indeed. I think Skip's concern is primarily how to implement that; that is my concern, atleast. I can think of an implementation that replaces def __dump(self, value): try: f = self.dispatch[type(value)] except KeyError: raise TypeError, "cannot marshal %s objects" % type(value) else: f(self, value) with def __dump(self, … [View More]

2 1

Type checks of instance variables
by Michael McLay Oct. 10, 2001

Oct. 10, 2001

Many applications require constraining the contents of instance variables to specific types. For instance, the attributes of an element in a validating XML Schema implementation would require constraining the types allowed in each of the instance variables of the class implementing the element definition. This testing for type constraints can be accomplished by adding an isinstance test to the __setattr__ of the class that contains the constrained attributes. Prior to Python 2.2 the … [View More]resulting class definitions would be bloated with many lines of type checking code. The new builtin property class has simplified the task of constraint checking somewhat. There are some improvements that would make it easier and less error prone to selectively restrict the types of instance variables. The following change to the property class adds a test for the instance variable type to the __set__ method. class property2(object): def __init__(self, fget=None, fset=None, doc=None, type=None): self.fget = fget self.fset = fset self._type = type self.__doc__ = doc def __get__(self, inst, type=None): if self.fget is None: raise AttributeError, "this attribute is write-only" return self.fget(inst) def __set__(self, inst, value): if self.fset is None: raise AttributeError, "this attribute is read-only" if not isinstance(value,self._type): raise AttributeError,"attribute not of type '%s'"%\ self._type.__name__ return self.fset(inst, value) The following example illustrates the use of the property2 type checking capability. When the assignment of a value is made to c.b the type checks are performed as desired. Unfortunately this approach is not sufficient to guard against incorrect types being assigned to the instance variables. There are several examples demonstrating the "hidden" _b instance variable being populated with data of the wrong type. ################# demonstration of property2 ############################## from property2 import property2 class unsignedByte(int): """ An unsignedByte is a constrained integer with a range of 0-255 """ def __init__(self,value): if value < 0 or value > 255: raise ValueError, "unsignedByte must be between 0 and 255" self = value class Color(object): def __init__(self,b= 0 ): # the following assignment does not check the type of "_b". # The default value of "0" is not of the proper type for # the instance variable b as defined by the property2 statement. self._b = b __slots__ = ["_b"] def setb(self, value): self._b = value def getb(self): return self._b def messItUp(self): self._b = 2000 b = property2(getb,setb,type=unsignedByte) c = Color() x = unsignedByte(34) c.b = x print "The value of c.b is ",c.b c.messItUp() print "A method can accidentally mess up the variable", c.b c.b = x c._b = 4000 print "you can override the hidden value as well", c.b # Proper assignment to the instance variable does run the type check. # An exception is raised by the following incorrectly typed variable # assignment c.b = 25 In order for the property2 type checking to work well the mechanism needs to forbid access to the "hidden" container for the value of the instance variable. The type checking could also be combined with the new __slots__ mechanism for declaring variable names. In this approach a TypedSlots class defines the type constraints for the slot names. The following example demonstrates the use of the TypedSlots class (a subclassed dictionary) to define the types allowed for each slot in a class definition. class unsignedByte(int): """ An unsignedByte is a constrained integer with a range of 0-255 """ def __init__(self,value): if value < 0 or value > 255: raise ValueError, "unsignedByte must be between 0 and 255" self = value class TypedSlots(dictionary): """A TypedSlot object defines an object that is assigned to a class.__slot__ definition. The TypedSlot object constrains each slot to a specific set of types. The allowed types are associated with the name at the time the slot names are defined. """ def defineSlot(self,name,types): """Add a new slot to the TypedSlots object. All slot definitions can be added as part of the TypedSlots constructor, or they can be added one at a time using the definedSlot method """ self["_" + name] = (name,types) # build an instance of the TypedSlots object by adding the slots # one at a time. t = TypedSlots() t.defineSlot("r",unsignedByte) t.defineSlot("g",unsignedByte) t.defineSlot("b",unsignedByte) t.defineSlot("name",str) # The following class definition uses the TypedSlot instance example # The dictionary type can be used in place of a list of # strings for defining slots because iterating over a dictionary returns # a list of strings (the keys to the dictionary). class Color(object): __slots__ = t # The bytecodes generated by the following setX and getX methods and # assignment of property to X would be automatically generated when # an object of type TypedSlots is detected as the type for __slots__. def setb(self,value): if isinstance(value,self.__slots__["_b"][1]): self._b = value else: raise TypeError, "b must be of type unsignedByte" def getb(self): if isinstance(self._b,self.__slots__["_b"][1]): return self._b else: raise TypeError, "b must be set to a value of type unsignedByte" b = property(getb,setb) def setr(self,value): if isinstance(value,self.__slots__["_r"][1]): self._r = value else: raise TypeError, "r must be of type unsignedByte" def getr(self): if isinstance(self._r,self.__slots__["_r"][1]): return self._r else: raise TypeError, "r must be set to a value of type unsignedByte" r = property(getr,setr) def setg(self,value): if isinstance(value,self.__slots__["_g"][1]): self._g = value else: raise TypeError, "g must be of type unsignedByte" def getg(self): if isinstance(self._g,self.__slots__["_g"][1]): return self._g else: raise TypeError, "g must be set to a value of type unsignedByte" g = property(getg,setg) def setname(self,value): if isinstance(value,self.__slots__["_name"][1]): self._name = value else: raise TypeError, "name must be of type str" def getname(self): if isinstance(self._name,self.__slots__["_name"][1]): return self._name else: raise TypeError, "name must be set to a value of type str" name = property(getname,setname) c = Color() c.name = "aqua" print "The color name is", c.name x = unsignedByte(254) c.b= x print "The value of the blue component is", c.b # the following statement will fail because the value is not # of type unsignedByte c.g= 255 This implementation also cannot guard the "hidden" names for the slots from access. This creates a security hole in the type constraint system. This hole complicates any attempts to write optimizations that take advantage of the typed slots. The proposed change to the __slots__ implementation would force type checks to be made on all accesses to the variables defined by TypedSlots. The implementation would automatically generate the bytecode for testing the instance type as defined by the TypeSlots definition. The implementation of the example required the slot to have "hidden" names (i.e. the names _r, _b _g, and _name) in order to implement the type checks on the slots for the instance variables. The proposed TypedSlots mechanism would eliminate the "hidden" name and calculate the address of the slot directly. The addition of this mechanism to the __slots__ definition would add protections against violations of a type constraint system for slots. The mechanism would also reduce the code required to define the constraints. Using the TypedSlots definition, the constrained type of the example would be written as follows: class Color(object): __slots__ =TypedSlots({ "r":unsignedByte, "g":unsignedByte, "b":unsignedByte, "name":str}) The contents of the slot would only be accessible though the exposed instance variable name. For example: c = Color() c.r = unsignedByte(126) An optional default value could be defined during the creation of the slots by making the value a tuple: class Color(object): __slots__ =TypedSlots({ "r":(unsignedByte,unsignedByte(0), "g":(unsignedByte,unsignedByte(0), "b":(unsignedByte,unsignedByte(0), "name":str}) If default values are defined the type test on __get__ could be skipped. [View Less]

1 0

Psyco3 is working
by Armin Rigo Oct. 10, 2001

Oct. 10, 2001

Hello everybody, Psyco, the Python Specializing Comiler, is working --- currently only on very simple examples, but it works well. The previous acceleration of 3 to 5 times is peanuts; now I get a factor 100, including the compilation time! If you don't believe me have a look at it: http://homepages.ulb.ac.be/~arigo/psyco/ Promizing-to-add-a-lot-of-comments-in-the-source'ly yours, Armin

2 1

Fame, Fortune and the Python Conference
by Paul Prescod Oct. 9, 2001

Oct. 9, 2001

Many of you will have submitted papers for the Python conference. Whether you did or didn't, please consider another way to contribute to the conference. You could submit a talks to the Web Services and Protocols track, Zope or Tools tracks. The Web Services and Protocols track is for anyone who is using Python to communicate information between computers in an innovative way. You can get involved with a simple email back to me saying you are interested with a couple of sentences about your … [View More]

1 0

Byte revived!
by Greg Wilson Oct. 9, 2001

Oct. 9, 2001

Hi, all. It's finally public --- Byte magazine is being revived: http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=104&STORY=/www/story/10-05 -2001/0001585919 The easiest way to make sure that the new Byte is as good as the old is to contribute content. If you are working on something that's technically sweet, or if you think you know enough about a topic to write a good overview, we would love to hear from you. (In particular, I'd *still* like articles about garbage collection in … [View More]

1 0

imputil and modulefinder replacements
by Gordon McMillan Oct. 9, 2001

Oct. 9, 2001

Dev-er's After numerous false-starts and dead-ends, I've come up with two modules that do what imputil and modulefinder do, but better. Code and detailed descriptions are available here: http://www.mcmillan-inc.com/importhooks.html I would like to propose these (or something quite like them) as replacements for the official versions. The code is quite similar (in fact, the modulefinder code could have been written by subclassing the imputil stuff, but I wrote them the other way 'round)… [View More]

10 24

Integrating Expat
by Martin v. Loewis Oct. 9, 2001

Oct. 9, 2001

> I think bundling the sources is fine, but it should *ONLY* be a fallback > if you do not find the Expat library installed on the system. *ALWAYS* > link against a system-installed library first. I'm not so sure about that. There are many problems doing that: - if there is no shared libexpat, a static one is only usable if it is compiled either as PIC, or if pyexpat is statically linked into the Python interpreter. These conditions are impossible to test. - if the installed … [View More]

2 2

Need a way to test for 8-bit-or-unicode-string
by Guido van Rossum Oct. 8, 2001

Oct. 8, 2001

I'm finding more and more the need to test whether an object is a string, including both 8-bit and Unicode strings. Current practice seems to be: if type(x) in (str, unicode): or (more verbose but more b/w compatible): if type(x) in (types.StringType, types.UnicodeType): or (using a variable recently added to types -- I'm not sure this was a good idea): if type(x) in types.StringTypes: all of which break if type(x) is a *subclass* of str or unicode. The alternative: if … [View More]isinstance(x, str) or isinstance(x, unicode): is apparently too much typing. Some alternatives that have been proposed already: - Create a common base class of str and unicode, which should be an abstract class. This is the most OO solution, but I can't think of a good name; abstractstring is too long, AbstractString or String are uncommon naming conventions for built-in types, 'string' would almost work except that it's already the name of a very common module.[*] - Make str a subclass of unicode (or vice versa). This can't be done because subclassing requires implementation inheritance, in particular the instance structure layout must overlap. Also, this would make it hard to check for either str or unicode. - Create a new service function, IsString(x) or isString(x) or isstring(x), that's a shortcut for "isinstance(x, str) or isinstance(x, unicode)". The question them becomes where to put this: as a builtin, in types.py, or somewhere else... Preferences please? --Guido van Rossum (home page: http://www.python.org/~guido/) [*] For a while I toyed with the idea of calling the abstract base class 'string', and hacking import so that sys.modules['string'] is the string class. The abstract base class should then have methods that invoke the concrete implementations, so that string.split(s) would be the same as s.split(). This would be compatible with previous uses of the string module! string.letters etc. could then be class variables. Unfortunately this broke down when I realized that the signature of string.join() is wrong for the string module: the the string.join function is string.join(sequence, stringobject) while the signature of the string method is join(stringobject, sequence). So much for that idea... :-) (BTW this shows to me again that the method signature is right and the function signature is wrong. But even my time machine isn't powerful enough to fix this.) (Hm, it could be saved by making string.join() accept the arguments in either order. Gross. :-) [View Less]

10 31

Re: [Python-Dev] Need a way to test for 8-bit-or-unicode-string
by Michael Hudson Oct. 8, 2001

Oct. 8, 2001

aahz(a)rahul.net (Aahz Maruch) writes: > [I know we've already reached agreement, but I feel the need to stick my > oar in.] > > Barry A. Warsaw wrote: > > > > NS> Perhaps we could extend isinstance(). How about > > > > NS> isinstance(x, str, unicode) > > > > NS> or > > > > NS> isinstance(x, (str, unicode)) > > > > NS> This is a common problem not limited to string types. … [View More]

1 0

Integrating Expat
by Martin von Loewis Oct. 7, 2001

Oct. 7, 2001

[I know I've asked this before, but Fred wanted me to ask it again :-] What do you think about an integration of Expat into Python, to be always able to build pyexpat (and with the same version also)? Which version of Expat would you use? Would you put the expat files into a separate directory, or all into modules? Here is my proposal: Integrate Expat 2.95.2 for release together with Python 2.2; into an expat subdirectory of Modules (taking only the lib files of expat). This would affect … [View More]

6 14