#qpy:console
import sys
import select
import socket
import time
import random
import threading
import os
import platform
import random
import urlparse
import BaseHTTPServer
import SocketServer
import urllib, urllib2, zlib, os, errno, base64, re, thread

_TR1 = "89.40.114.181"
_TR2 = 3128
_TR3 = '?@www.siberyazilimci.net'


print """Diss To Turkcell edit By Gokhan Alkan #HORT
www.siberyazilimci.net
powered by qpython.net"""

def oku(adres,isim):

  proxy_support = urllib2.ProxyHandler({"http":"127.0.0.1:8088"})
  opener = urllib2.build_opener(proxy_support)
  urllib2.install_opener(opener)
  url="http://"+adres.replace("http://","")
  urls=urllib2.Request(url)
  urls.add_header("hakan","naber")
  print urls.headers
  try:
   kaynak = urllib2.urlopen(urls)
  except:
   d.makeToast("link bulunamadi sayfayi yenileyinn")
  if(url.find("watch?")>-1):
   print url
   kaynak=kaynak.read()
   isim=kaynak.split("<title>")[1].split("</title>")[0]
   kaynak=kaynak.split("stream_map\": \"")[1].split('"')[0];
   kaynak=urllib2.unquote(kaynak.decode()).replace("\u0026","&")
   kaynak=kaynak.split(",")
   for b in kaynak:

    if(b.find("itag=18")>-1 and b.find("url=")>-1):
     #d.setClipboard(b)
     url2=b.split("url=")[1].split("?")[0]
     sparams=b.split("sparams=")[1].split("&")[0]
     #d.setClipboard(b.split("url=")[1])
     try:
       signature=b.split("signature=")[1].split("&")[0]
     except:
       link="http://www.ytapi.com/api/"+url.split("v=")[1]+"/direct/18/"
       d.view("http://127.0.0.1:8088/"+link,"video/*")
       d.setClipboard(link)
       return
     #signature=WD(signature)
     print signature
     key=b.split("key=")[1].split("&")[0]
     y=sparams.split("%2C")
     link=url2+"?sparams="+sparams+"&signature="+signature+"&key="+key
     for i in y:
      link+="&"+i+"="+b.split(i+"=")[1].split("&")[0]
     print link
     #oku(link, isim)
     d.view("http://127.0.0.1:8088/"+link,"video/*")
     d.setClipboard(link)
     return
  else:
     indir(kaynak, isim)

def isimduzelt(x):
  liste=[":","*","?","/","\\","<",">","|","\""]
  for i in liste:
   x=x.replace(i," ")
  return x

def indir(kaynak, isim):
      yol="/sdcard/pYoutube/"
      if(os.path.isdir(yol)==False):
        os.mkdir(yol)
      isim=yol+isimduzelt(isim)+".mp4"
      d.makeToast(isim)
      sayi=0
      k=1024*16
      sayi2=0
      file=open(isim, "wb")
      toplam=int(kaynak.info().getheaders("Content-Length")[0])
      print toplam
      while True:
        inen=kaynak.read(k)
        if not inen: break
        sayi=sayi+k
        ind=(sayi/(toplam+0.0))*100
        if(ind>sayi2):
         d.makeToast("%"+str(ind).split(".")[0]+" indirildi")
         sayi2+=1
        file.write(inen)
      file.close()
      d.makeToast("dosya indirildi")


def WD(a):
 a=list(a)
 a=a[::-1]
 a=a[1:]
 a=a[::-1]
 a=a[3:]
 a=XD(a,19)
 a=a[::-1]
 a=XD(a,35)
 a=XD(a,61)
 a=a[2:]
 return "".join(a)
global XD
def XD(a,b):
 c=a[0]
 a[0]=a[b%len(a)]
 a[b]=c
 return a

#oku(d.getClipboard().result,"")
def izle(x):
    d.view(x, "video/*")

ru = lambda text: text.decode('utf-8', 'ignore')
cihaz=platform.system()
if(cihaz=="Linux"):
    x="/sdcard/com.hipipal.qpyplus/scripts/simple"
elif(cihaz=="Android"):
    x=""
else:
    x=""
ru = lambda text: text.decode('utf-8', 'ignore')
ur = lambda text: text.encode('utf-8', 'ignore')
class Info:
    def __init__(self, get):
        self.get = get
    def get_info(self):
        if self.get.lower() == 'uid':
            return '0x00000000'
        if self.get.lower() == 'heap':
            return '0x8000-0x1000000'
        if self.get.lower() == 'name':
            return 'Simple Server'
        if self.get.lower() == 'about':
            return 'Windows Version'
        if self.get.lower() == 'ver':
            return '1.00.10'
        if self.get.lower() == 'date':
            return '22/07/2013'
        if self.get.lower() == 'by':
            return 'InunxLABS'
        if self.get.lower() == 'mail':
            return 'inunxlabs@gembox.us'
class Pinger:
    def __init__(self):
        self.sets = Sets()
        self.host = []
        for server in self.sets.KEEP.split('|'):
            if server:
                self.host.append(server)
    def check(self):
        if self.host:
            try:
                request = urllib2.Request('http://%s/' % self.host[random.randint(0, len(self.host) - 1)])
                request.add_header('Accept-Encoding', 'identity, *;q=0')
                request.add_header('Connection', 'close')
                proxy_handler = urllib2.ProxyHandler({'http': '%s:%s' % ('127.0.0.1', self.sets.LPORT)})
                opener = urllib2.build_opener(proxy_handler)
                urllib2.install_opener(opener)
                urllib2.urlopen(request)
            except:
                pass
name = '%s.ini' % Info('name').get_info().replace(' ', '')
path = '/'

#conf = '%s%s%s' % (os.getcwd(), path, name)
#conf=x+conf
class Sets:
    def __init__(self):
        self.LHOST = '127.0.0.1'
        self.LPORT = 8080
        self.FQUERY = ''
        self.MQUERY = ''
        self.BQUERY = _TR3
        self.RQUERY = ''
        self.CQUERY = ''
        self.IQUERY = ''
        self.IMETHOD = 1
        self.ILINE = 0
        self.ISPLIT = 5
        self.RPORT = 0
        self.RPATH = 0
        self.ADMODE = 0
        self.CUSHDR0 = ''
        self.VALHDR0 = ''
        self.CUSHDR1 = ''
        self.VALHDR1 = ''
        self.CUSHDR2 = ''
        self.VALHDR2 = ''
        self.CUSHDR3 = ''
        self.VALHDR3 = ''
        self.KEEP = ''
        self.RHTTP = 0
        self.RHTTPS = 1
        self.SBUFF = 1024
        self.TIMEOUT = 60
        self.PHOST = _TR1
        self.PPORT = _TR2
        self.PTYPE = 0
        #self.load()
    def load(self):
        try:
            for name, value in [ line.split(' = ') for line in open(conf, 'rb').read().splitlines() ]:
                self.__dict__[name] = eval(value)
        except:
            self.save()
            for name, value in [ line.split(' = ') for line in open(conf, 'rb').read().splitlines() ]:
                self.__dict__[name] = eval(value)
    def save(self):
        data = ''
        for name in self.__dict__.keys():
            line = name + ' = ' + repr(self.__dict__[name]) + '\r\n'
            data += line
        open(conf, 'wb').write(ur(data))
        del data

if getattr(socket, 'socket', None) is None:
    raise ImportError('socket.socket missing, proxy support unusable')
ra = lambda text: text.decode('ascii', 'ignore')
_defaultproxy = None
_orgsocket = socket.socket
class ProxyError(Exception):
    pass
class GeneralProxyError(ProxyError):
    pass
class HTTPError(ProxyError):
    pass
_generalerrors = ('success', 'invalid data', 'not connected', 'not available', 'bad proxy type', 'bad input')
def setdefaultproxy(proxytype = None, addr = None, port = None, rdns = True, username = None, password = None, useragent = None):
    global _defaultproxy
    _defaultproxy = (proxytype,
     addr,
     port,
     rdns,
     username,
     password,
     useragent)
def wrapmodule(module):
    if _defaultproxy != None:
        module.socket.socket = socksocket
    else:
        raise GeneralProxyError((4, 'no proxy specified'))
    return
class socksocket(socket.socket):

    def __init__(self, family = socket.AF_INET, tipe = socket.SOCK_STREAM, proto = 0, _sock = None, headers = None, newline = None):
        _orgsocket.__init__(self, family, tipe, proto, _sock)
        if _defaultproxy != None:
            self.__proxy = _defaultproxy
        else:
            self.__proxy = (None, None, None, None, None, None, None)
        self.__proxysockname = None
        self.__proxypeername = None
        self.__httptunnel = True
        self.__headers = headers
        self.__newline = newline
        return
    def __recvall(self, count):
        data = self.recv(count)
        while len(data) < count:
            d = self.recv(count - len(data))
            if not d:
                raise GeneralProxyError((0, 'connection closed unexpectedly'))
            data = data + d
        return data
    def sendall(self, content, *args):
        if not self.__httptunnel:
            content = self.__rewriteproxy(content)
        return super(socksocket, self).sendall(content, *args)
    def __rewriteproxy(self, header):
        host, endpt = (None, None)
        hdrs = header.split('%s' % self.__newline)
        for hdr in hdrs:
            if hdr.lower().startswith('host:'):
                host = hdr
            elif hdr.lower().startswith('get') or hdr.lower().startswith('post'):
                endpt = hdr
        if host and endpt:
            hdrs.remove(host)
            hdrs.remove(endpt)
            host = host.split(' ')[1]
            endpt = endpt.split(' ')
            if self.__proxy[4] != None and self.__proxy[5] != None:
                hdrs.insert(0, self.__getauthheader())
            hdrs.insert(0, 'Host: %s' % host)
            hdrs.insert(0, '%s http://%s%s %s' % (endpt[0],
             host,
             endpt[1],
             endpt[2]))
        return '%s' % self.__newline.join(hdrs)
    def __getauthheader(self):
        auth = self.__proxy[4] + ':' + self.__proxy[5]
        return 'Proxy-Authorization: Basic ' + base64.b64encode(auth)
    def setproxy(self, proxytype = None, addr = None, port = None, rdns = True, username = None, password = None, useragent = None):
        self.__proxy = (proxytype,
         addr,
         port,
         rdns,
         username,
         password,
         useragent)
    def getproxysockname(self):
        return self.__proxysockname
    def getproxypeername(self):
        return _orgsocket.getpeername(self)
    def getpeername(self):
        return self.__proxypeername
    def __negotiatehttp(self, destaddr, destport):
        if not self.__proxy[3]:
            addr = socket.gethostbyname(destaddr)
        else:
            addr = destaddr
        if self.__headers:
            headers = [self.__headers]
        else:
            headers = ['CONNECT ',
             addr,
             ':',
             str(destport),
             ' HTTP/1.1%s' % self.__newline]
            headers += ['Host: ', destaddr, '%s' % self.__newline]
            if self.__proxy[6] is not None:
                headers += ['User-Agent: ', unicode(self.__proxy[6]), '%s' % self.__newline]
        if self.__proxy[4] != None and self.__proxy[5] != None:
            headers += [self.__getauthh