home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / netextensions.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  14.1 KB  |  537 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. import urllib
  6. import base64
  7. import mimetools
  8. import os
  9. import time
  10. import httplib
  11. import os
  12. if os.name == 'nt':
  13.     from msvcrt import get_osfhandle
  14.     from ctypes import windll, WinError
  15.     SetHandleInformation = windll.kernel32.SetHandleInformation
  16.     
  17.     def set_noninheritable(socket):
  18.         SetHandleInformation(socket.fileno(), 1, 0)
  19.  
  20.     import socket
  21.     original_socket = socket.socket
  22.     _orig_connect = original_socket.connect
  23.     _orig_connect_ex = original_socket.connect_ex
  24.     _orig_accept = original_socket.accept
  25.     
  26.     def connect(self, address):
  27.         res = _orig_connect(self, address)
  28.         set_noninheritable(self)
  29.         return res
  30.  
  31.     
  32.     def connect_ex(self, address):
  33.         res = _orig_connect_ex(self, address)
  34.         set_noninheritable(self)
  35.         return res
  36.  
  37.     
  38.     def accept(self):
  39.         (conn, addr) = _orig_accept(self)
  40.         set_noninheritable(conn)
  41.         return (conn, addr)
  42.  
  43.     original_socket.connect = connect
  44.     original_socket.connect_ex = connect_ex
  45.     original_socket.accept = accept
  46.  
  47.  
  48. def open_data(self, url, data = None):
  49.     if not isinstance(url, str):
  50.         raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
  51.     isinstance(url, str)
  52.     
  53.     try:
  54.         StringIO = StringIO
  55.         import cStringIO
  56.     except ImportError:
  57.         StringIO = StringIO
  58.         import StringIO
  59.  
  60.     
  61.     try:
  62.         (type, data) = url.split(',', 1)
  63.     except ValueError:
  64.         raise IOError, ('data error', 'bad data URL')
  65.  
  66.     if not type:
  67.         type = 'text/plain;charset=US-ASCII'
  68.     
  69.     semi = type.rfind(';')
  70.     if semi >= 0 and '=' not in type[semi:]:
  71.         encoding = type[semi + 1:]
  72.         type = type[:semi]
  73.     else:
  74.         encoding = ''
  75.     msg = []
  76.     msg.append('Date: %s' % time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(time.time())))
  77.     msg.append('Content-type: %s' % type)
  78.     if encoding == 'base64':
  79.         data = base64.decodestring(data)
  80.     else:
  81.         data = urllib.unquote(data)
  82.     msg.append('Content-Length: %d' % len(data))
  83.     msg.append('')
  84.     msg.append(data)
  85.     msg = '\n'.join(msg)
  86.     f = StringIO(msg)
  87.     headers = mimetools.Message(f, 0)
  88.     return urllib.addinfourl(f, headers, url)
  89.  
  90. urllib.URLopener.open_data = open_data
  91.  
  92. def ab___init__(self, fp):
  93.     self.fp = fp
  94.     self._amt_read = 0
  95.     if hasattr(self.fp, 'readlines'):
  96.         self.readlines = self.fp.readlines
  97.     
  98.     if hasattr(self.fp, 'fileno'):
  99.         self.fileno = self.fp.fileno
  100.     else:
  101.         
  102.         self.fileno = lambda : pass
  103.     if hasattr(self.fp, '__iter__'):
  104.         self.__iter__ = self.fp.__iter__
  105.         if hasattr(self.fp, 'next'):
  106.             self.next = self.fp.next
  107.         
  108.     
  109.  
  110.  
  111. def ab_read(self, *a, **k):
  112.     v = self.fp.read(*a, **k)
  113.     self._amt_read += len(v)
  114.     return v
  115.  
  116.  
  117. def ab_readline(self, *a, **k):
  118.     v = self.fp.readline(*a, **k)
  119.     self._amt_read += len(v)
  120.     return v
  121.  
  122.  
  123. def ab_tell(self):
  124.     return self._amt_read
  125.  
  126.  
  127. def ab___repr__(self):
  128.     return '<%s at %r whose fp = %r>' % (self.__class__.__name__, id(self), self.fp)
  129.  
  130.  
  131. def ab_close(self):
  132.     self._amt_read = 0
  133.     self.read = None
  134.     self.readline = None
  135.     self.readlines = None
  136.     self.fileno = None
  137.     if self.fp:
  138.         self.fp.close()
  139.     
  140.     self.fp = None
  141.  
  142. for meth in '__init__ read readline tell __repr__ close'.split():
  143.     setattr(urllib.addbase, meth, globals()['ab_' + meth])
  144.  
  145. if os.name == 'nt':
  146.     
  147.     class OneProxy(dict):
  148.         
  149.         def proxyServer(self):
  150.             return self._proxyServer
  151.  
  152.         proxyServer = property(proxyServer)
  153.         
  154.         def __missing__(self, key):
  155.             val = '%s://%s' % (key, self.proxyServer)
  156.             self.__setitem__(key, val)
  157.             return val
  158.  
  159.  
  160.     
  161.     def getproxies_registry():
  162.         proxies = { }
  163.         
  164.         try:
  165.             import _winreg
  166.         except ImportError:
  167.             return proxies
  168.  
  169.         
  170.         try:
  171.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  172.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  173.             if proxyEnable:
  174.                 proxyServer = str(_winreg.QueryValueEx(internetSettings, 'ProxyServer')[0])
  175.                 if '=' in proxyServer:
  176.                     for p in proxyServer.split(';'):
  177.                         (protocol, address) = p.split('=', 1)
  178.                         import re
  179.                         if not re.match('^([^/:]+)://', address):
  180.                             address = '%s://%s' % (protocol, address)
  181.                         
  182.                         proxies[protocol] = address
  183.                     
  184.                 elif proxyServer[:5] == 'http:':
  185.                     proxies['http'] = proxyServer
  186.                 else:
  187.                     proxies = OneProxy()
  188.                     proxies._proxyServer = proxyServer
  189.                     proxies['https']
  190.                     proxies['http']
  191.                     proxies['ftp']
  192.             
  193.             internetSettings.Close()
  194.         except (WindowsError, ValueError, TypeError):
  195.             pass
  196.  
  197.         return proxies
  198.  
  199.     urllib.OneProxy = OneProxy
  200.     urllib.getproxies_registry = getproxies_registry
  201.  
  202. import urllib2
  203.  
  204. class ProxyHandler(urllib2.BaseHandler):
  205.     handler_order = 100
  206.     
  207.     def __init__(self, proxies = None):
  208.         self._proxies = proxies
  209.  
  210.     
  211.     def _get_proxies(self):
  212.         import urllib
  213.         if not self._proxies:
  214.             pass
  215.         return urllib.getproxies()
  216.  
  217.     
  218.     def _set_proxies(self, val):
  219.         self._proxies = val
  220.  
  221.     proxies = property(_get_proxies, _set_proxies)
  222.     
  223.     def http_open(self, req):
  224.         return self.proxy_open(req, 'http')
  225.  
  226.     
  227.     def https_open(self, req):
  228.         return self.proxy_open(req, 'https')
  229.  
  230.     
  231.     def ftp_open(self, req):
  232.         return self.proxy_open(req, 'ftp')
  233.  
  234.     
  235.     def proxy_open(self, req, type):
  236.         orig_type = req.get_type()
  237.         
  238.         try:
  239.             proxy = self.proxies[type]
  240.         except KeyError:
  241.             return None
  242.  
  243.         (proxy_type, user, password, hostport) = urllib2._parse_proxy(proxy)
  244.         if proxy_type is None:
  245.             proxy_type = orig_type
  246.         
  247.         if user and password:
  248.             user_pass = '%s:%s' % (urllib2.unquote(user), urllib2.unquote(password))
  249.             creds = base64.b64encode(user_pass).strip()
  250.             req.add_header('Proxy-Authorization', 'Basic ' + creds)
  251.         
  252.         hostport = urllib2.unquote(hostport)
  253.         req.set_proxy(hostport, proxy_type)
  254.         if orig_type == proxy_type:
  255.             return None
  256.         return self.parent.open(req)
  257.  
  258.  
  259. urllib2.ProxyHandler = ProxyHandler
  260.  
  261. def _no_ftp_file_open(self, req):
  262.     return self.open_local_file(req)
  263.  
  264. urllib2.FileHandler.file_open = _no_ftp_file_open
  265. urllib2.default_opener_classes = map((lambda x: getattr(urllib2, x)), ('UnknownHandler', 'HTTPHandler', 'HTTPDefaultErrorHandler', 'HTTPRedirectHandler', 'FTPHandler', 'FileHandler', 'HTTPErrorProcessor'))
  266.  
  267. def build_opener(*handlers, **kwds):
  268.     import types
  269.     opener_class = kwds.pop('opener_class', urllib2.OpenerDirector)
  270.     classes = kwds.pop('default_classes', urllib2.default_opener_classes)[:]
  271.     if kwds:
  272.         raise TypeError('Only opener_class and default_classes are accepted as keyword arguments for build_opener')
  273.     kwds
  274.     
  275.     def isclass(obj):
  276.         if not isinstance(obj, types.ClassType):
  277.             pass
  278.         return hasattr(obj, '__bases__')
  279.  
  280.     opener = opener_class()
  281.     if hasattr(httplib, 'HTTPS'):
  282.         classes.append(urllib2.HTTPSHandler)
  283.     
  284.     skip = []
  285.     for klass in classes:
  286.         for check in handlers:
  287.             if isclass(check):
  288.                 if isclass(klass) and issubclass(check, klass):
  289.                     skip.append(klass)
  290.                 elif not isclass(klass) and issubclass(check, type(klass)):
  291.                     skip.append(klass)
  292.                 
  293.             issubclass(check, type(klass))
  294.             if isinstance(check, type(klass)):
  295.                 skip.append(klass)
  296.                 continue
  297.             if isclass(klass) and isinstance(check, klass):
  298.                 skip.append(klass)
  299.                 continue
  300.         
  301.     
  302.     for klass in skip:
  303.         classes.remove(klass)
  304.     
  305.     for klass in classes:
  306.         
  307.         try:
  308.             instance = klass()
  309.         except (AttributeError, TypeError):
  310.             instance = klass
  311.  
  312.         opener.add_handler(instance)
  313.     
  314.     for h in handlers:
  315.         if isclass(h):
  316.             h = h()
  317.         
  318.         opener.add_handler(h)
  319.     
  320.     return opener
  321.  
  322. urllib2.build_opener = build_opener
  323. import socket
  324. from asynchat import find_prefix_at_end
  325. import sys
  326. if sys.hexversion > 33947648:
  327.     
  328.     def handle_read(self):
  329.         
  330.         try:
  331.             data = self.recv(self.ac_in_buffer_size)
  332.         except socket.error:
  333.             why = None
  334.             self.handle_error(why)
  335.             return None
  336.  
  337.         self.ac_in_buffer = self.ac_in_buffer + data
  338.         while self.ac_in_buffer:
  339.             lb = len(self.ac_in_buffer)
  340.             terminator = self.get_terminator()
  341.             if not terminator:
  342.                 self.collect_incoming_data(self.ac_in_buffer)
  343.                 self.ac_in_buffer = ''
  344.                 continue
  345.             if isinstance(terminator, int) or isinstance(terminator, long):
  346.                 n = terminator
  347.                 if lb < n:
  348.                     self.collect_incoming_data(self.ac_in_buffer)
  349.                     self.ac_in_buffer = ''
  350.                     self.terminator = self.terminator - lb
  351.                 else:
  352.                     self.collect_incoming_data(self.ac_in_buffer[:n])
  353.                     self.ac_in_buffer = self.ac_in_buffer[n:]
  354.                     self.terminator = 0
  355.                     self.found_terminator()
  356.             lb < n
  357.             terminator_len = len(terminator)
  358.             index = self.ac_in_buffer.find(terminator)
  359.             if index != -1:
  360.                 if index > 0:
  361.                     self.collect_incoming_data(self.ac_in_buffer[:index])
  362.                 
  363.                 self.ac_in_buffer = self.ac_in_buffer[index + terminator_len:]
  364.                 self.found_terminator()
  365.                 continue
  366.             index = find_prefix_at_end(self.ac_in_buffer, terminator)
  367.             if index:
  368.                 if index != lb:
  369.                     self.collect_incoming_data(self.ac_in_buffer[:-index])
  370.                     self.ac_in_buffer = self.ac_in_buffer[-index:]
  371.                 
  372.                 break
  373.                 continue
  374.             self.collect_incoming_data(self.ac_in_buffer)
  375.             self.ac_in_buffer = ''
  376.  
  377.     from sys import py3kwarning
  378.     from warnings import filterwarnings, catch_warnings
  379.     
  380.     def initiate_send(self):
  381.         while self.producer_fifo and self.connected:
  382.             first = self.producer_fifo.popleft()
  383.             if not first:
  384.                 if first is None:
  385.                     self.handle_close()
  386.                     return None
  387.             
  388.             obs = self.ac_out_buffer_size
  389.             
  390.             try:
  391.                 catch_warnings().__enter__()
  392.                 
  393.                 try:
  394.                     data = buffer(first, 0, obs)
  395.                 finally:
  396.                     pass
  397.  
  398.             except TypeError:
  399.                 data = first.more()
  400.                 if data is not None:
  401.                     self.producer_fifo.appendleft(first)
  402.                 
  403.                 if data:
  404.                     self.producer_fifo.appendleft(data)
  405.                     continue
  406.                 continue
  407.  
  408.             
  409.             try:
  410.                 num_sent = self.send(data)
  411.             except socket.error:
  412.                 why = None
  413.                 self.handle_error(why)
  414.                 self.producer_fifo.appendleft(first)
  415.                 return None
  416.  
  417.             if num_sent:
  418.                 if num_sent < len(data) or obs < len(first):
  419.                     self.producer_fifo.appendleft(first[num_sent:])
  420.                 
  421.             
  422.             return None
  423.  
  424. else:
  425.     
  426.     def handle_read(self):
  427.         
  428.         try:
  429.             data = self.recv(self.ac_in_buffer_size)
  430.         except socket.error:
  431.             why = None
  432.             self.handle_error(why)
  433.             return None
  434.  
  435.         self.ac_in_buffer = self.ac_in_buffer + data
  436.         while self.ac_in_buffer:
  437.             lb = len(self.ac_in_buffer)
  438.             terminator = self.get_terminator()
  439.             if not terminator:
  440.                 self.collect_incoming_data(self.ac_in_buffer)
  441.                 self.ac_in_buffer = ''
  442.                 continue
  443.             if isinstance(terminator, int) or isinstance(terminator, long):
  444.                 n = terminator
  445.                 if lb < n:
  446.                     self.collect_incoming_data(self.ac_in_buffer)
  447.                     self.ac_in_buffer = ''
  448.                     self.terminator = self.terminator - lb
  449.                 else:
  450.                     self.collect_incoming_data(self.ac_in_buffer[:n])
  451.                     self.ac_in_buffer = self.ac_in_buffer[n:]
  452.                     self.terminator = 0
  453.                     self.found_terminator()
  454.             lb < n
  455.             terminator_len = len(terminator)
  456.             index = self.ac_in_buffer.find(terminator)
  457.             if index != -1:
  458.                 if index > 0:
  459.                     self.collect_incoming_data(self.ac_in_buffer[:index])
  460.                 
  461.                 self.ac_in_buffer = self.ac_in_buffer[index + terminator_len:]
  462.                 self.found_terminator()
  463.                 continue
  464.             index = find_prefix_at_end(self.ac_in_buffer, terminator)
  465.             if index:
  466.                 if index != lb:
  467.                     self.collect_incoming_data(self.ac_in_buffer[:-index])
  468.                     self.ac_in_buffer = self.ac_in_buffer[-index:]
  469.                 
  470.                 break
  471.                 continue
  472.             self.collect_incoming_data(self.ac_in_buffer)
  473.             self.ac_in_buffer = ''
  474.  
  475.     
  476.     def initiate_send(self):
  477.         obs = self.ac_out_buffer_size
  478.         if len(self.ac_out_buffer) < obs:
  479.             self.refill_buffer()
  480.         
  481.         if self.ac_out_buffer and self.connected:
  482.             
  483.             try:
  484.                 num_sent = self.send(self.ac_out_buffer[:obs])
  485.                 if num_sent:
  486.                     self.ac_out_buffer = self.ac_out_buffer[num_sent:]
  487.             except socket.error:
  488.                 why = None
  489.                 self.handle_error(why)
  490.                 return None
  491.             
  492.  
  493.         None<EXCEPTION MATCH>socket.error
  494.  
  495. import asynchat
  496. asynchat.async_chat.handle_read = handle_read
  497. asynchat.async_chat.initiate_send = initiate_send
  498. del handle_read
  499. del initiate_send
  500.  
  501. def dispatcher_getattr(self, attr):
  502.     if attr == 'socket':
  503.         return object.__getattribute__(self, 'socket')
  504.     return getattr(self.socket, attr)
  505.  
  506. import asyncore
  507. asyncore.dispatcher.__getattr__ = dispatcher_getattr
  508. del dispatcher_getattr
  509.  
  510. def make_request(cls, full_url, data = None, *a, **k):
  511.     if not isinstance(full_url, cls):
  512.         default_host = k.pop('default_host', None)
  513.         ssl = k.pop('ssl', False)
  514.         proto = None % 'http%s' if ssl else ''
  515.         if default_host:
  516.             if not full_url.startswith(proto):
  517.                 pass
  518.             if not full_url.startswith(default_host):
  519.                 proto_host = '%s://%s' % (proto, default_host.rstrip('/'))
  520.                 full_url = proto_host + '/' + full_url.lstrip('/')
  521.             
  522.         if not full_url.startswith(proto):
  523.             full_url = '%s://%s' % (proto, full_url)
  524.         
  525.         req = cls(full_url, *a, **k)
  526.     else:
  527.         req = full_url
  528.     if data is not None:
  529.         if not isinstance(data, str):
  530.             data = urllib.urlencode(data)
  531.         
  532.         req.add_data(data)
  533.     
  534.     return req
  535.  
  536. urllib2.Request.make_request = classmethod(make_request)
  537.