mobile.sniffer 0.1

Dependencies

You might need to install additional libraries depending on what handset database you use

• Wurfl: pywurlf library and python-Levenshtein

• WAP profiles: Django (for database abstraction) and rdflib

• Apex Vertex: Django (for database abstraction)

Simple example

This example will work out of the box with the included pywurlf database.

Example:

try:
    from mobile.sniffer.wurlf.sniffer import WurlfSniffer

    # Wrapper sniffer instance
    # All start-up delay goes on this line
    sniffer = WurlfSniffer()
except ImportError, e:
    import traceback
    traceback.print_exc()
    logger.exception(e)
    logger.error("Could not import Wurlf sniffer... add pywurfl and python-Lehvenstein to buildout.cfg eggs section")
    sniffer = None

def sniff_request(request):
    """
    @param request: Request can be Django, WSGI or Zope HTTPRequest object
    """

    if not sniffer:
        # We failed to initialize Wurfl
        return None

    user_agent = sniffer.sniff(request)

    if user_agent == None:
        # No match in the handset database,
        return None
    else:
        return user_agent # mobile.sniffer.wurlf.sniffer.UserAgent object


def web_or_mobile(request)
        ua = sniff_request(request)

        # How certain we must be about UA
        # match to make decisions
        # float 0...1, the actual value is UA search algorithm specific
        # We use JaroWinkler as the default algorithm
        certainty_threshold = 0.7

        if ua.get("is_wireless_device") and ua.getCertainty() > certainty_threshold:
                # Mobile code
                pass
        else:
                # Webby code
                pass

Match-making process for Wurfl

Since Wurfl is the default backend the process of finding UA record is explained more carefully

• Wurlf database is usually loaded during the start-up (slow operation) - it is possible to make this to use lazy initialization pattern

• The search algorithm is initialized with certain match threshold - all matches below this threshold will be ignored. The default search algorithm is JaroWinkler from Lehvenstein Python package.

• When the user agent is searched

  • Take in HTTP request User-Agent header

  • Go through all entries in database

  • Match this entry against incoming User-Agent using the search algorithm

    • First search pass is doing using exact string matches (no algorithm involved). In this case exposed certainty will be 1.1.

    • If there was no match in the first pass, do the second pass using the search algorithm

  • If match is found and threshold is exceed return this user agent record

    • User agent record is retrofitted with the information how accurate the match was (ua.getCertainty() method exposes this)

Chained example

Use all available handset information sources to accurately get device data. Matching is done on property level - if one data source lacks the property information the next data source is tried. Finally if the handset is unknown, but it publishes WAP profile information, the profile is downloaded and analyzed and saved for further requests.

Example:

from mobile.sniffer.chain import ChainedSniffer
from mobile.sniffer.apexvertex.sniffer import ApexVertexSniffer
from mobile.sniffer.wapprofile.sniffer import WAPProfileSniffer
from mobile.sniffer.deviceatlas.sniffer import DeviceAtlasSniffer

# Create all supported sniffers
da = DeviceAtlasSniffer(da_api_file)
apex = ApexVertexSniffer()
wap = WAPProfileSniffer()

# Preferred order of sniffers
sniffer = ChainedSniffer([apex, da, wap])

ua = sniffer.sniff(request) # Sniff HTTP_USER_AGENT, HTTP_PROFILE and many other fields
property = ua.get("usableDisplayWidth") # This will look up data from all the databases in the chain

Changelog