StringValidator (Python recipe) by Mark Nenadov

ActiveState Code (http://code.activestate.com/recipes/66439/)

Why compile Rx's each time? Why not implement lazy caching of the actual objects produced by compile() and keep them in the validator instance?

thanks. Thanks for the suggestion. That makes alot of sense. Its definately more efficient. I have made the change to the code, let me know if thats what you were thinking of.

actually.. Actually the other way would be more efficient if I know I was just going to use the "is" only once or twice, because it would only compile the Rx's it needs. However, assuming that we will call this "is" methods many times, the new way is more efficient because the Rx's wouldn't be compiled every time.

Either way, I think the new way is better design.

Lazy Rx compilations. So we could combine the ideas and reuse compiled regular expressions, but only compile them as they're needed. Each time a validity-testing method is invoked, just check to see whether the pattern has been compiled, if so use it, if not compile it but save it. I would also add support for arbitrary patterns stored by name that could be added at the class level. One last note, if you want to make the internal service method private, append "__" to the beginning of it's name.

Ok.. I implemented lazy compilations. Please review my code. Is there any way that I can directly detect whether a variable is a compiled re object? I tried "isinstance".. but it didn't seem to work.

In other words, are you saying.. you would like to see the ability to add arbitary patterns at run time?

Getting closer. Just about there... but I would set those class-level variables to None and then just test the variables like:

class StringValidator:
    RE_ALPHA = None
    ...

    def isAlpha(self):
        if not self.RE_ALPHA:
            self.RE_ALPHA = re.compile("^\D+$")
        return self.checkStringAgainstRe(self.RE_ALPHA)
    ...

Note that the return statement should NOT be under the else clause that you had before! This means that in the case where a pre-compiled Rx was not found in the cache-variable, it will perform the compilation but skip the return statement, meaning that the calling expression recieves the default return value of None.

<p>The idea I threw out about arbitrary patterns was just storing custom named patterns and lazy-compiling those as well. The user would then have to employ a method with the name as an argument or something similiar:

StringValidator.definePattern("year", "^\d{4}$")

strvalidator = StringValidator("text text abc123...")
if strvalidator.validForPattern("year"):
    print "Is a valid year!"

</p>

isValidForPattern. You can't call a method from a uninstantiated method withod an instance.

So here's a module function that stores the pattern in a class variable:

def storePattern(re_name, re_pat):
    StringValidator._patterns[re_name] = re_pat
<pre>


and a method to test the instance against that stored pattern:



<pre>
        def isValidForPattern(self, re_name):
                if self._patterns.has_key(re_name):
                    if type(self._patterns[re_name]) == type(''):
                        self._patterns[re_name] = re.compile(
                          self._patterns[re_name]
                        )
                    return self.checkStringAgainstRe(
                      self._patterns[re_name])
                else:
                    raise KeyError, "No pattern named '%s' stored."

here's the testing code (BTW: als testing code should be placed in an

if __name__ == '__main__':

construct):

# test for stored patterns
storePattern('inquisition', '.*inquisition.*')
sv3 = StringValidator('spammish requisition')
print sv3._patterns

if sv3.isValidForPattern('inquisition'):
    print "I didn't expect the spanish inquisition!"
else:
    print "Nobody expects the spanish inquisition!"

BTW: the method of testing the RE if they are of type string allows defining them at the start of the class definition for more clarity

</pre></pre>

isValidForPattern revisited. Of course you have to add a class variable '_patterns = {}' to the StringValidator class. Or you alter the storePattern method thus:

def storePattern(re_name, re_pat):
    if not hasattr(StringValidator, '_patterns'):
    StringValidator._patterns = {}
    StringValidator._patterns[re_name] = re_pat

ok. Ok. I have implemented all recommended changes, please review the code.

Short email addresses. It is important to note that email adresses _can_ be shorter than 7 characters. Although domain names shorter than 2 letters are not allowed in .com .net and .org, many ISO country domain registrars do allow one letter domain names. For example in Denmark, where I live. For example see http://www.n.dk

So a@n.dk is in fact a potential valid email address, which would not get through your regexp :-)

a slight enhancement. better to bind, e.g., self.__class__.RE_ALPHA=etc, rather than self.RE_ALPHA, so all other instances of the same class will transparently re-use the compiled re (keep per-class, not per-instance).

! Great idea! :]

! Great idea! :]

RE_EMAIL regex. The regex for isEmail will return true even if the string being validated contains space characters. The following regex allows for any character (just as the original) except a space:

self.__class__.RE_EMAIL = re.compile("^[^\s]+@[^\s]+\.[^\s]{2,3}$")

Classmethod. Why not make definePattern a classmethod i.e.

definePattern = classmethod(definePattern)

then you define patterns without requiring an instance i.e.

StringValidator.definePattern(....)