def getClipboardText():
from Tkinter import Tk
r = Tk()
r.withdraw()
s = r.clipboard_get()
r.destroy()
return s
def getClipboard(self):
"""返回剪贴板上的内容"""
r = Tk()
r.withdraw()
tmp = r.clipboard_get()
r.destroy()
return tmp
def clipboard_get(): tk = Tk() tk.withdraw() value = tk.clipboard_get() tk.destroy() return value
def do_string_encrypt():
r = Tk()
if len(sys.argv) == 1:
plaintext = r.clipboard_get()
print('Encrypting from clipboard: %s' % plaintext)
else:
plaintext = sys.argv[1]
print('Encrypting: %s' % plaintext)
hex_text = plaintext.encode('hex')
print('Raw hex: %s' % hex_text)
ciphertext = ""
for c in hex_text:
if c >= '0' and c <= '9':
int_value = int(c)
else:
int_value = ord(c) - ord('a') + 10
ciphertext = ciphertext + REPLACE_DICTIONARY[int_value]
print('Ciphertext: %s' % ciphertext)
r.withdraw()
r.clipboard_clear()
r.clipboard_append(ciphertext)
r.destroy()
def _Compare(pixels, value, equal):
Pix = Split(pixels)
X._moveTo(int(Pix[0]), int(Pix[1]))
X._click(int(Pix[0]), int(Pix[1]), 'left') #Double Click
X._click(int(Pix[0]), int(Pix[1]), 'left')
X._keyDown('ctrl') #Copy
X._keyDown('c')
X._keyUp('ctrl')
X._keyUp('c')
board = Tk()
board.withdraw()
Copyed_Txt = board.clipboard_get() #get text on clipboard
if equal == '>': #find what happend after this function
if value > Copyed_Txt:
return 1
else:
return 0
elif equal == "=":
if value == Copyed_Txt:
return 1
else:
return 0
elif equal == "<":
if value < Copyed_Txt:
return 1
else:
return 0
def getURLFromClipboard():
from Tkinter import Tk
r = Tk()
r.withdraw()
url = r.clipboard_get()
r.destroy
print "Copied URL from clipboard"
return url
def getClipboard():
"返回剪贴板上的内容"
from Tkinter import Tk
r = Tk()
r.withdraw()
r.update()
tmp = r.clipboard_get()
r.destroy()
return tmp
def PollClipboardTk(self):
try:
from Tkinter import Tk
clip = Tk()
clip.withdraw()
clipb = [clip.clipboard_get()]
clip.destroy()
except:
clipb = []
return clipb
def from_clipboard():
root = Tk()
s = root.clipboard_get()
print s
if s[0] == '{':
out = to_tex(s)
else:
out = to_mat(s)
print out
copy(out, root)
root.destroy()
def autoPlay(str2): try: r = Tk(); r.withdraw(); str1 = r.clipboard_get(); if isStream(str1) and str1 != str2: return str1; else: return; except Exception, ex: print ex; return None;
def getTitleFromClipboard( index=1 ): # 将得到的结果自动复制到剪贴板上 "为标题添加特殊样式的 HTML 代码 —— title 为名称 —— index 为锚点名称" from Tkinter import Tk r = Tk() title = r.clipboard_get() s = '<div class="title_hh"><a name="A'+(str(index)).zfill(2)+'"></a><strong>' + title + '</strong></div>\n<div class="arrow-left"> </div>' r.withdraw() r.clipboard_clear() r.clipboard_append(s) r.update() r.destroy() return s
def getClipboardTextTk():
from Tkinter import Tk
try:
r = Tk()
r.withdraw()
s = r.clipboard_get()
except BaseException as e:
if 'selection doesn\'t exist' in str(e):
s = ''
else:
raise
finally:
r.destroy()
return s
class KindleCodeFormater():
def __init__(self):
self._root = Tk()
self._roughKindleCode = self._root.clipboard_get()
self._formatedKindleCode = ''
def formatCode(self):
codeWithNoSpaceInMatrix = self._removeSpaceInMatrices(self._roughKindleCode)
fixedPlottingComment = self._fixPlottingComment(codeWithNoSpaceInMatrix)
codeWithLineBreak = re.sub(r"; ", r";\n", fixedPlottingComment)
self._formatedKindleCode = codeWithLineBreak
def formatedCodeToClipboard(self):
self._root.clipboard_append(self._formatedKindleCode)
self.showTempConfirmAndDestroy()
def showTempConfirmAndDestroy(self):
'''
Displays a temporary MessageBox to inform that the job was done and
close the app.
'''
from tkinter import messagebox
self._root.update() # now it stays on the clipboard after the window is closed
self._root.after(1500, self._root.destroy) # Destroy the widget after 1.5 seconds
try:
if messagebox.showinfo('formatkindlecode', 'Formatted code copied to clipboard'):
self._root.destroy()
except:
pass
def _removeSpaceInMatrices(self, codeStr):
pattern = r"(\[[\d\w ;]+\])"
noSpaceMatrix = ''
for match in re.finditer(pattern, codeStr):
roughMatrix = match.group()
if '; ' in roughMatrix:
noSpaceMatrix = roughMatrix.replace('; ', ';')
codeStr = codeStr.replace(roughMatrix, noSpaceMatrix)
return codeStr
def _fixPlottingComment(self, codeStr):
codeStr = codeStr.replace("%plotting ", "\n\n%plotting\n")
return codeStr
class Clipboard(object):
"""Container for clipboard access"""
def __init__(self):
"""store Tk object and hide GUI"""
self.Tk = Tk()
self.Tk.withdraw()
def copy_from(self):
"""Copy contents from clipboard"""
return self.Tk.clipboard_get()
def paste_to(self,paste_string):
"""Replace clipboard contents with paste_string"""
self.Tk.clipboard_clear()
self.Tk.clipboard_append(paste_string)
def printevent(self, event):
if "BackSpace" in str(event):
self.__input_stack = self.__input_stack[:-1]
return
cmd = None
if "mouse" in str(event):
process_name, _, _ = str(event).split("|")
key = ''
ascii = ''
return
process_name, key, ascii, _ = str(event).split("|")
self.__input_stack.append((process_name, key, ascii))
if len(self.__input_stack) >= 3:
cntrl = self.__input_stack[0][1].lower()
shift = self.__input_stack[1][1].lower()
cntrl_v = self.__input_stack[2][1].lower()
if "control" in cntrl and (("v" in shift) or
("shift" in shift and "v" in cntrl_v)):
self.__typed = False
if "return" in key.lower():
r = Tk()
r.withdraw()
cp_data = r.clipboard_get()
r.destroy()
cmd = (cp_data, self.__input_stack[:-1][0][0])
if "return" in key.lower() and not cmd:
cmd = ("".join([x[1] for x in self.__input_stack[:-1]]),
self.__input_stack[:-1][0][0])
with open("logs.txt", "a") as myfile:
if cmd:
cmd_time = str(datetime.datetime.now())
machine_name = str(socket.gethostname())
command = '<xy>%d %s %s %s "%s" enter "%s" on %s' % (
self.__cmd_count, cmd_time, machine_name, "typed" if
self.__typed else "cp-pased", cmd[0], cmd[1], "keyboard")
myfile.write(command + "\n")
self.__cmd_count += 1
self.__input_stack = list()
def printevent(self, event):
if "BackSpace" in str(event):
self.__input_stack = self.__input_stack[:-1]
return
cmd = None
if "mouse" in str(event):
process_name, _, _ = str(event).split("|")
key = ''
ascii = ''
return
process_name, key, ascii, _ = str(event).split("|")
self.__input_stack.append((process_name, key, ascii))
if len(self.__input_stack) >= 3:
cntrl = self.__input_stack[0][1].lower()
shift = self.__input_stack[1][1].lower()
cntrl_v = self.__input_stack[2][1].lower()
if "control" in cntrl and (("v" in shift) or ("shift" in shift and "v" in cntrl_v)):
self.__typed = False
if "return" in key.lower():
r = Tk()
r.withdraw()
cp_data = r.clipboard_get()
r.destroy()
cmd = (cp_data, self.__input_stack[:-1][0][0])
if "return" in key.lower() and not cmd:
cmd = ("".join([x[1] for x in self.__input_stack[:-1]]), self.__input_stack[:-1][0][0])
with open("logs.txt", "a") as myfile:
if cmd:
cmd_time = str(datetime.datetime.now())
machine_name = str(socket.gethostname())
command = '<xy>%d %s %s %s "%s" enter "%s" on %s' % (self.__cmd_count, cmd_time,
machine_name, "typed" if self.__typed else "cp-pased",cmd[0], cmd[1], "keyboard")
myfile.write(command + "\n")
self.__cmd_count += 1
self.__input_stack = list()
class TkClipboard(Clipboard):
def __init__(self):
has_tk = False
self.r = None
try:
if sys.version_info[0] < 3:
from Tkinter import Tk, TclError
else:
from tkinter import Tk, TclError
has_tk = True
print("Using Tk clipboard")
except ImportError:
print("tinker not found, no Tk copy&paste available")
if has_tk:
try:
self.r = Tk()
self.r.withdraw()
except TclError:
print(
"tkinter not properly installed, no Tk copy&paste available"
)
else:
self.r = None
def update(self):
if self.r is not None:
self.r.update()
def copy_to(self, text):
if self.r is not None:
self.r.clipboard_clear()
self.r.clipboard_append(text)
else:
print(text)
def copy_from(self):
text = ''
if self.r is not None:
try:
text = self.r.clipboard_get()
except:
pass
return text
def main():
# if len(sys.argv) != 2: # generating some usage info, if there's not enought parameters
# print "Sybase query plan parser"
# print "Script process file with query plan (generated by 'set showplan on' query)\n"
# print "Usage: python " + sys.argv[0] + " %in_file_name% \n\t%in_file_name%\tfull file name with query plan to parse"
# sys.exit(1)
if (len(sys.argv) == 2):
in_file = sys.argv[1]
if os.path.isfile(in_file) == False: # chech if input file exists
print "ERROR: file [" + in_file + "] doesn't exists"
sys.exit(1)
parser = PlanParser(filename = in_file)
else:
r = Tk()
r.withdraw()
content = r.clipboard_get()
parser = PlanParser(content = content)
parser.parse()
parser.print_res()
class Clipboard(object):
def __init__(self):
self._widget = Tk()
self._widget.withdraw()
def get(self):
try:
return self._widget.clipboard_get()
except TclError:
return None
def post(self, text):
self._widget.clipboard_clear()
self._widget.clipboard_append(text)
def destroy(self):
self._widget.destroy()
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.destroy()
class Clipboard(object):
def __init__(self):
self._widget = Tk()
self._widget.withdraw()
def get(self):
try:
return self._widget.clipboard_get()
except TclError:
return None
def post(self, text):
self._widget.clipboard_clear()
self._widget.clipboard_append(text)
def destroy(self):
self._widget.destroy()
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.destroy()
from Tkinter import Tk
import re
r = Tk()
r.withdraw()
txt = r.clipboard_get()
txt = re.sub(' style=".*?"', "", txt)
txt = re.sub(' class=.*?>', ">", txt)
txt = re.sub(' type=.*?>', ">", txt)
txt = re.sub('<FONT.*?>', "", txt)
txt = re.sub('</FONT>', "", txt)
txt = re.sub('<DIV.*?>', "", txt)
txt = re.sub('</DIV>', "", txt)
txt = re.sub('<TR.*?>', "<TR>", txt)
txt = re.sub('<TD.*?>', "<TD>", txt)
txt = re.sub('<P.*?>', "<P>", txt)
txt = re.sub('<SPAN.*?>', "", txt)
txt = re.sub('</SPAN>', "", txt)
txt = re.sub(' ', " ", txt)
txt = re.sub(' +', " ", txt)
txt = txt.replace('<P> </P>','')
txt = txt.replace('<BR>','<BR>\n')
txt = txt.strip(' \t\n')
r.clipboard_clear()
r.clipboard_append(txt)
r.destroy()
class pyClipboardShare:
DEBUG = False
verifyIntLength = 6
PORT = 34236
KEY_FILE = 'key.aes'
packetMax = 1024 * 1024
KEY = ''
rootTK = None
crypt = None
SOCK_OUT = None
SOCK_IN = None
currentText = ''
pause = False
buffers = {}
running = True
ownIP = None
def __init__(self):
global bleh
self.rootTK = Tk()
self.rootTK.withdraw()
self.getOwnIP()
if (self.DEBUG): print('IP: ' + self.ownIP)
self.getKey()
self.crypt = AES.new(self.KEY, AES.MODE_ECB)
if (self.DEBUG): print('Setting up broadcast socket ...')
self.SOCK_OUT = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.SOCK_OUT.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
if (self.DEBUG): print('Setting up listening socket ...')
self.SOCK_IN = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.SOCK_IN.bind(('', self.PORT))
self.currentText = self.getClipboard()
self.rootTK.after(100, self.watchClipboard)
self.rootTK.after(100, self.watchBroadcast)
atexit.register(self.stop)
self.rootTK.protocol("WM_DELETE_WINDOW", self.stop)
self.rootTK.mainloop()
def stop(self):
self.SOCK_OUT.close()
self.SOCK_IN.close()
self.running = False
self.rootTK.destroy()
def getOwnIP(self):
IPs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
IPs.connect(('8.8.8.8', 53))
self.ownIP = IPs.getsockname()[0]
IPs.close()
def watchClipboard(self):
if not (self.pause):
text = self.getClipboard()
if text != None and text != self.currentText:
if (self.DEBUG): print('Clipboard changed: ' + text)
self.currentText = text
self.send(self.encrypt(text))
self.rootTK.after(100, self.watchClipboard)
def watchBroadcast(self):
lr, lw, lx = select([self.SOCK_IN], [], [], 0)
if lr:
data = self.SOCK_IN.recvfrom(self.packetMax)
if data[1][0] != self.ownIP:
if not (data[1] in self.buffers):
self.buffers[data[1]] = ''
self.buffers[data[1]] += data[0]
if (self.DEBUG):
print('Recieved data from ' + data[1][0] + ': ' + data[0])
self.pause = True
while '\00' in self.buffers[data[1]]:
chunk, rest = self.buffers[data[1]].split('\00', 1)
self.buffers[data[1]] = rest
if (self.DEBUG): print('Recieved chunk: ' + chunk)
decoded = base64.decodestring(chunk)
if (self.DEBUG): print('Decoded chunk: ' + decoded)
text = self.decrypt(decoded)
if text != None:
self.currentText = text
self.setClipboard(self.currentText)
self.pause = False
self.rootTK.after(100, self.watchBroadcast)
def encrypt(self, text):
text = pickle.dumps(text)
if self.verifyIntLength:
number = random.randint(pow(10, self.verifyIntLength - 1),
pow(10, self.verifyIntLength) - 1)
text = str(number) + text
text += '\00'
short = 16 - (len(text) % 16)
text += Random.get_random_bytes(short)
data = self.crypt.encrypt(text)
if (self.DEBUG): print('Encrypted data: ' + data)
return data
def decrypt(self, data):
text = self.crypt.decrypt(data).split('\00')[0]
if self.verifyIntLength:
number = text[:self.verifyIntLength]
if not (number.isdigit()):
if self.DEBUG:
print('Text failed decryption verification: ' + text)
return None
text = pickle.loads(text[self.verifyIntLength:])
return text
def send(self, data):
outData = base64.encodestring(data) + '\00'
while outData:
chunk = outData[:self.packetMax]
outData = outData[self.packetMax:]
self.SOCK_OUT.sendto(chunk, ('255.255.255.255', self.PORT))
if (self.DEBUG): print('Sent data: ' + chunk)
def getClipboard(self):
text = None
try:
text = self.rootTK.clipboard_get()
except TclError:
pass
return text
def setClipboard(self, text):
self.rootTK.clipboard_clear()
self.rootTK.clipboard_append(text)
if (self.DEBUG): print('Set clipboard text: ' + text)
def makeKey(self):
self.KEY = raw_input('Enter key or leave blank to generate: ')
if not (self.KEY):
self.KEY = Random.get_random_bytes(32)
KEY_LEN = len(self.KEY)
if KEY_LEN != 16 and KEY_LEN != 24 and KEY_LEN != 32:
if KEY_LEN < 16:
print('Key must be atleast 16 characters long')
self.makeKey()
return
elif KEY_LEN < 24:
self.KEY = self.KEY[:16]
elif KEY_LEN < 32:
self.KEY = self.KEY[:24]
else:
self.KEY = self.KEY[:32]
print('Key shortened to "' + self.KEY + '"')
with open(self.KEY_FILE, 'wb') as f:
f.write(self.KEY)
def getKey(self):
if os.path.isfile(self.KEY_FILE):
with open(self.KEY_FILE, 'rb') as f:
byte = f.read(1)
while byte:
self.KEY += byte
byte = f.read(1)
else:
self.makeKey()
import pafy
from Tkinter import Tk
r = Tk()
r.withdraw()
flag=0
result=r.clipboard_get()
type=raw_input("Hit 1 for video,2 for playlist")
type=int(type)
qual=raw_input("Hit 1 for best clarity, 2 for worst, 3 for other")
qual=int(qual)
if qual==3:
flag=1
c=0
if type==1:
url = result
video = pafy.new(url)
best = video.streams
for b in best:
print str(c)+str(b)
c+=1;
if flag==1:
index=raw_input("Enter index")
index=int(index)
elif qual==2:
index=c-1
elif qual==1:
index=0
filename = video.streams[index]
print filename
x=filename.download(filepath=filename.title + "." + filename.extension)
def _tk(self):
tk = TK()
yield tk.clipboard_get()
tk.destroy()
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
# Setup argument parser
parser = ArgumentParser()
parser.add_argument(
"-o",
"--out",
action="store_true",
help="output password in tty instead of inserting in clipboard")
parser.add_argument("-r",
"--rule",
action='append',
help="transform rule(s)")
parser.add_argument("-a",
"--algorithm",
help="transform rule(s)",
default="md5")
# clipboard manager
r = Tk()
# Process arguments
args = parser.parse_args()
salt = getpass.getpass("salt: ")
domain = r.clipboard_get()
truncatLen = re.compile(r"^len:([\d]*)$")
truncatNel = re.compile(r"^nel:([\d]*)$")
specialLen = re.compile(r"^special:([\d]*)$")
specialNel = re.compile(r"^laiceps:([\d]*)$")
if args.algorithm == 'sha224':
password = hashlib.sha224(domain + salt).hexdigest()
elif args.algorithm == 'sha512':
password = hashlib.sha512(domain + salt).hexdigest()
else:
password = hashlib.md5(domain + salt).hexdigest()
for r in args.rule:
if r == "uc":
rule = rules.Rules.UC()
password = rule.apply(password)
elif r == "ucfirst":
rule = rules.Rules.UCFirst()
password = rule.apply(password)
elif r == "uclast":
rule = rules.Rules.UCLast()
password = rule.apply(password)
elif r == "reverse":
rule = rules.Rules.Reverse()
password = rule.apply(password)
elif truncatLen.match(r):
matches = truncatLen.search(r)
l = matches.group(1)
rule = rules.Rules.Truncate(int(l))
password = rule.apply(password)
elif truncatNel.match(r):
matches = truncatNel.search(r)
l = matches.group(1)
rule = rules.Rules.Truncate(int(l), reverse=True)
password = rule.apply(password)
elif specialLen.match(r):
matches = specialLen.search(r)
l = matches.group(1)
rule = rules.Rules.Special(int(l))
password = rule.apply(password)
elif specialNel.match(r):
matches = specialNel.search(r)
l = matches.group(1)
rule = rules.Rules.Special(int(l), reverse=True)
password = rule.apply(password)
if args.out is True:
print "password for domain '" + domain + "':"
print password
else:
r.clipboard_append(password)
print "password for domain '" + domain + "' is added to clipboard..."
r.update()
r.destroy()
raw_input("Paste password into password-field, then hit Enter to exit")
return 0
def get_clipboard():
from Tkinter import Tk
root = Tk()
root.withdraw()
clipboard = root.clipboard_get()
return clipboard
def PreparePasteCode():
r = Tk()
r.withdraw()
code = r.clipboard_get()
r.destroy()
return code
#coding: UTF-8 from Tkinter import Tk r = Tk() r.withdraw() r.clipboard_get() r.clipboard_append(123) print(r)
def _tk(self):
tk = TK()
yield tk.clipboard_get()
tk.destroy()
def get_clipboard():
from Tkinter import Tk
root = Tk()
root.withdraw()
clipboard = root.clipboard_get()
return clipboard
z = 'Gradient-Fractal1,Background {\n'
z += 'gradient:\n'
z += ' title="Extracted" smooth=yes rotation=1\n '
# Insert gradient here.
chaoticaAppend = 1.0/256.0
hsvdata = approximateAndSimplify(values)
for pos, r, g, b in hsvdata:
position = int((400.0*pos)/256.0)
color = RGBFloatToInt(r, g, b)
indexStr = 'index='+str(position)
colorStr = 'color='+str(color)
z += ' ' + indexStr + ' ' + colorStr
z += '\n'
z += 'opacity:\n'
z += 'smooth=yes index=0 opacity=255\n'
z += '}\n'
return z
if __name__ == '__main__':
r = Tk()
r.withdraw()
clipboard = r.clipboard_get()
gradient = extract_gradient(clipboard)
r.clipboard_append(gradient)
from sys import argv, exit
from Tkinter import Tk
try:
tkObj = Tk()
except Exception as e:
print "Failed to create the Tkinter object: " + str(e)
cssPath = tkObj.clipboard_get()
print "The CSS path retrieved from your clipboard is:\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" + str(
cssPath)
#if len(argv)!=2:
# exit("Something went wrong! Give CSS Path as an argument enclused in quotes")
#if argv[1]=="" or len(argv[1])<10:
# exit("Are you sure the CSS Path is corect?")
#cssPath = argv[1]
# List of symbols, tags and elements to remove from the CSS path
graveList = [
" >", ".ng-scope", ".ng-isolate-scope", ".ng-include", ".ng-view",
".ng-animate"
]
for mark in graveList:
cssPath = cssPath.replace(mark, "")
print "\n\nThe modified CSS path sent to your clipboard is:"
print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
print cssPath
def copyClipboard(): r = Tk() clipboard = r.clipboard_get() r.destroy() return clipboard
def remove_newline(text, *args, **kwargs):
""" remove \n\r in text and then replace it with space"""
if type(text) is str:
return text.replace('\r', '').replace('\n', ' ')
else:
print("get error input")
return text
if __name__ == "__main__":
r = Tk()
r.withdraw()
exit_text = ""
while not exit_text == "q": # because my keyboard is broken, You can alter logical
exit_text = input()
input_text = r.clipboard_get()
r.clipboard_clear()
r.clipboard_append(remove_newline(input_text))
r.destroy()
import os
import subprocess
import codecs
import time
import threading
# get encoding
reload(sys)
sys.setdefaultencoding("utf-8")
enc = sys.getdefaultencoding()
print "default encoding : " + str(enc)
# get clipboard & parse encode
root = Tk()
root.withdraw()
src = root.clipboard_get()
if type(src).__name__ != "unicode":
src = src.decode(enc)
print "______________________________________________"
print src
print "______________________________________________"
# run command in shell
def run_cmd(bashCmd):
print "run command : " + str(bashCmd)
process = subprocess.Popen(bashCmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
res = ""
while True:
output = process.stdout.readline()
if output == "" and process.poll() is not None:
break
from Tkinter import Tk
import time
while(True):
root = Tk()
root.withdraw()
try:
number = root.clipboard_get()
except:
print "Caught it"
number = 0
if(number == '11'):
r = Tk()
r.withdraw()
r.clipboard_clear()
r.clipboard_append('Hello I am a hacker')
r.mainloop()
root.destroy()
# Text to Hex converter by Richard Gericke
# Decode any Text from Windows Clipboard to html %hex
# an copy it back to clipboard_append
print "Text to HTML Hex converter"
print "Version 1.0"
print "(C) Richard Gericke"
print ""
from Tkinter import Tk
r = Tk()
r.withdraw()
str = r.clipboard_get()
r.clipboard_clear()
c = str.encode('utf-8').encode('hex')
d = list(c)
a = u""
b = 1
for n in d:
b+=1
if b==2:
a+=u"%"+n
b=0
else:
a+=n
print a
r.clipboard_append(a)
r.destroy()
