BA

#! -*- coding: utf-8 -*-

import io
import os
import zipfile

class InMemoryZip:
  """
    Basic idea behind was to be able to transfer single files or
    a folder (with sub folders) as zipped memory via communication
    to another machine
  """

  def __init__(self,data=None):
    """creating an in memory file(zip zrchive) """
    self.inMemory=io.BytesIO()
    if data:
      self.setData(data)

  def getData(self):
    """retrieving the whole file as buffer"""
    self.inMemory.seek(0)
    return self.inMemory.read()

  def setData(self, data):
    """creating new in memory file with new content"""
    self.inMemory=io.BytesIO()
    self.inMemory.write(data)

  def append(self,pathAndFileName):
    """ adding a file or path (recursive) to the zip archive in memory"""
    zf=zipfile.ZipFile(self.inMemory,"a",zipfile.ZIP_DEFLATED,False)

    if os.path.isfile(pathAndFileName):
      zf.write(pathAndFileName)
    else:
      path=pathAndFileName
      for root, folders, files in os.walk(path):
        for file in files:
          fullName=os.path.join(root,file)
          zf.write(fullName)

  def saveAs(self,pathAndFileName):
    """does save the in memory zip archive to a file"""
    file=open(pathAndFileName,"wb")
    file.write(self.getData())
    file.close()

  def readFrom(self,pathAndFileName):
    """reading a file expected to be a ZIP file """
    self.setData(open(pathAndFileName, "rb").read())
       
  def extractAllAt(self,path):
    zf=zipfile.ZipFile(self.inMemory)
    zf.extractall(path)

  def listContent(self):
    """getting list of zip files entries (ZipInfo instances) """
    zf=zipfile.ZipFile(self.inMemory)
    return zf.infolist()


def test():
  zm=InMemoryZip()
  zm.append(".")
  zm.saveAs("InMemoryZip_test.zip")

  zm2=InMemoryZip(zm.getData())
  zm2.extractAllAt("./tmp")

  zm3=InMemoryZip()
  zm3.readFrom("InMemoryZip_test.zip")
  for entry in zm3.listContent():
    print(entry.filename)

if __name__=="__main__":
  test()
 

#! -*- coding: utf-8 -*-

import wx
import wx.grid
import os
import sqlite3
import re
import string
import gettext

cwd=os.path.abspath(os.curdir)

def connect(): # this is the sqlite3 connection
  con_str=cwd+'/phonebook/phonebook.db'
  cnn=sqlite3.connect(con_str)
  return cnn
  cnn.close()

def data_rows_count():
  # to count the rows in the database
  con=connect()
  cur=con.cursor()
  cur.execute("SELECT * FROM Phone")
  rows=cur.fetchall()
  i=0
  for r in rows:
    i+=1
  return i

def fmtstr(fmt,strr):  # to format some string!!
  res=[]
  i=0
  s=re.sub(r'[^\w]','',strr)
  for c in fmt:
    if c=='#':
      res.append(s[i:i+1])
      i=i+1
    else:
      res.append(c)
  res.append(s[i:])
  return string.join(res)

def titling(name):
  # to display the names and surnames in uppercase for 1st letter
  return name.title()

def single_quote_remover(text):
  # to remove single quotes from entry to prevent SQL crash
  return text.replace("/","'")

class MyFrame(wx.Frame):
  # this is the parent frame
  def __init__(self,*args,**kwds):
    kwds["style"]=wx.DEFAULT_FRAME_STYLE
    wx.Frame.__init__(self,*args,**kwds)
    self.frame_1_menubar=wx.MenuBar()
    wxglade_tmp_menu=wx.Menu()
    wxglade_tmp_menu.Append(1,_("Index"),"",wx.ITEM_NORMAL)
    self.frame_1_menubar.Append(wxglade_tmp_menu,_("Phone Book"))
    wxglade_tmp_menu=wx.Menu()
    wxglade_tmp_menu.Append(2,_("Message"),"",wx.ITEM_NORMAL)
    self.SetMenuBar(self.frame_1_menubar)
    self.__set_properties()
    self.__do_layout()
    self.Bind(wx.EVT_MENU,self.open_dialog,id=1)
    self.Bind(wx.EVT_MENU,self.open_dialog,id=2)

  def __set_properties(self):
    self.SetTitle(_("MyPhoneBook"))
    self.SetSize((555,444))
    self.SetBackgroundColour(wx.Colour(255,255,255))

  def __do_layout(self):
    sizer_1=wx.BoxSizer(wx.VERTICAL)
    self.SetSizer(sizer_1)
    self.Layout()

  def open_dialog(self,event):
    MyDialog1(self).Show()

  def open_dialog1(self,event):
    wx.MessageBox("A simple Phonebook that resumes basic graphical database configuration\n\nEnjoy ...!")

class MyDialog1(wx.Dialog):
  # this is the phonebook dialog box...
  def __init__(self,*args,**kwds):
    kwds["style"]=wx.DEFAULT_DIALOG_STYLE
    wx.Dialog.__init__(self,*args,**kwds)
    self.label_10=wx.StaticText(self,-1,_(" ID"))
    self.txtID=wx.TextCtrl(self,-1,"")
    self.label_11=wx.StaticText(self,-1,_(" Name"))
    self.txtNAME=wx.TextCtrl(self,-1,"")
    self.label_12=wx.StaticText(self,-1,_(" Surname"))
    self.txtSURNAME=wx.TextCtrl(self,-1,"")
    self.label_13=wx.StaticText(self,-1,_(" Number"))
    self.txtNUMBER=wx.TextCtrl(self,-1,"")
    self.button_6=wx.Button(self,-1,_("UPDATE"))
    self.button_5=wx.Button(self,-1,_("ADD"))
    self.button_7=wx.Button(self,-1,_("DELETE"))
    self.button_8=wx.Button(self,-1,_("LOAD"))
    self.grid_1=wx.grid.Grid(self,-1,size=(1,1))
    self.label_14=wx.StaticText(self,-1,_(" Search Name:"))
    self.txtSearch=wx.TextCtrl(self,-1,"")
    self.button_9=wx.Button(self,-1,_(" Go"))
    self.button_10=wx.Button(self,-1,_("Renumber"))
    self.txtNAME.SetFocus()
    self.button_6.Enabled=False
    self.txtID.Enabled=False
    self.__set_properties()
    self.__do_layout()

    self.Bind(wx.EVT_BUTTON,self.clk_add,self.button_5)
    self.Bind(wx.EVT_BUTTON,self.clk_update,self.button_6)
    self.Bind(wx.EVT_BUTTON,self.clk_delete,self.button_7)
    self.Bind(wx.EVT_BUTTON,self.clk_load,self.button_8)
    self.Bind(wx.EVT_BUTTON,self.clk_go,self.button_9)
    self.Bind(wx.EVT_BUTTON,self.clk_renumber,self.button_10)

  def refresh_data(self):
    cnn=connect()
    cur=cnn.cursor()
    cur.execute("SELECT * FROM Phone")
    rows=cur.fetchall()
    for i in range (0,len(rows)):
      for j in range(0,4):
        cell=rows[i]
        self.grid_1.SetCellValue(i,j,str(cell[j]))

  def __set_properties(self):
    self.SetTitle(_("PyPhone"))
    self.SetSize((600,550))
    self.txtID.SetMinSize((120,27))
    self.txtNAME.SetMinSize((120,27))
    self.txtSURNAME.SetMinSize((127,27))
    self.txtNUMBER.SetMinSize((120,27))
    r=data_rows_count()
    self.grid_1.CreateGrid(r,4)
    #this is to create the grid with same rows as database
    self.grid_1.SetColLabelValue(0,_("ID"))
    self.grid_1.SetColSize(0,12)
    self.grid_1.SetColLabelValue(1,_("NAME"))
    self.grid_1.SetColSize(1,150)
    self.grid_1.SetColLabelValue(2,_("SURNAME"))
    self.grid_1.SetColSize(2,150)
    self.grid_1.SetColLabelValue(3,_("NUMBER"))
    self.grid_1.SetColSize(3,150)
    self.txtSearch.SetMinSize((100,27))
    self.refresh_data()

  def __do_layout(self):
    sizer_4=wx.BoxSizer(wx.VERTICAL)
    grid_sizer_4=wx.GridSizer(1,4,0,0)
    grid_sizer_3=wx.GridSizer(4,3,0,0)
    sizer_4.Add((20,20),0,0,0)
    grid_sizer_3.Add(self.label_10,0,0,0)
    grid_sizer_3.Add(self.txtID,0,0,0)
    grid_sizer_3.Add(self.button_5,0,0,0)
    grid_sizer_3.Add(self.label_11,0,0,0)
    grid_sizer_3.Add(self.txtNAME,0,0,0)
    grid_sizer_3.Add(self.button_6,0,0,0)
    grid_sizer_3.Add(self.label_12,0,0,0)
    grid_sizer_3.Add(self.txtSURNAME,0,0,0)
    grid_sizer_3.Add(self.button_7,0,0,0)
    grid_sizer_3.Add(self.label_13,0,0,0)
    grid_sizer_3.Add(self.txtNUMBER,0,0,0)
    grid_sizer_3.Add(self.button_8,0,0,0)
    sizer_4.Add(grid_sizer_3,1,wx.EXPAND,0)
    sizer_4.Add(self.grid_1,1,wx.EXPAND,0)
    sizer_4.Add((20,20),0,0,0)
    grid_sizer_4.Add(self.label_14,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_4.Add(self.txtSearch,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_4.Add(self.button_9,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_4.Add(self.button_10,0,wx.ALIGN_CENTER_VERTICAL,0)
    sizer_4.Add(grid_sizer_4,1,wx.EXPAND,0)
    self.SetSizer(sizer_4)
    self.Layout()

  def clear_grid(self):
    self.txtID.Value=""
    self.txtNAME.Value=""
    self.txtSURNAME.Value=""
    self.txtNUMBER.Value=""

  def auto_number(self):
    j=data_rows_count()
    return j+1

  def clk_add(self,event):
    if self.txtNAME.Value=="" or self.txtSURNAME.Value=="" or self.txtNUMBER.Value=="":
      wx.MessageBox("Some Fields Are Empty!")
    else:
      the_id=str(self.auto_number())
      the_name=single_quote_remover(str(self.txtNAME.Value))
      the_surname=single_quote_remover(str(self.txtSURNAME.Value))
      num=fmtstr('##-######',(str(self.txtNUMBER.Value)))
      #set the format here to country you want
      name=titling(the_name)
      surname=titling(the_surname)
      self.grid_1.AppendRows(1)
      cnn=connect()
      cursor=cnn.cursor()
      add_many="INSERT INTO Phone(ID,name,surname,telephone) VALUES("+(the_id)+",'"+(name)+"','"+(surname)+"','"+(num)+"')"
      cursor.execute(add_many)
      cnn.commit()
      cnn.close()
      self.refresh_data()
      self.clear_grid()
      self.txtNAME.SetFocus()
    event.Skip()

  def clk_update(self,event):
    try:
      num=fmtstr('##-######',str(self.txtNUMBER.Value))
      the_name=single_quote_remover(str(self.txtNAME.Value))
      the_surname=single_quote_remover(str(self.txtSURNAME.Value))
      name=titling(the_name)
      surname=titling(the_surname)
      row_index=self.grid_1.GetSelectedRows()[0]
      c=self.grid_1.GetCellValue(row_index,0)
      cnn=connect()
      cur=cnn.cursor()
      cur.execute("UPDATE Phone SET name = "+"'"+(name)+"'"+" ,surname"+"'"(surname)+"'"+",telephone="+"'"+(num)+"'"+"WHERE ID="+"'"+str(c)+"'")
      cnn.commit()
      cnn.close()
      self.clear_grid()
      self.button_6.Enabled=False
      self.button_5.Enabled=True
      self.txtNAME.SetFocus()
      event.Skip()
    except IndexError:
      wx.MessageBox("you have lost focus on the row you wanted to edit")

  def clk_delete(self,event):
    try:
      lst=self.grid_1.GetSelectedRows()[0]
      c=self.grid_1.GetCellValue(lst,0)
      cnn=connect()
      cur=cnn.cursor()
      cur.execute("DELETE FROM Phone WHERE ID="+"'"+str(c)+"'")
      cnn.commit()
      cnn.close()
      self.grid_1.DeleteRows(lst,1)
      self.refresh_data()
      self.txtNAME.SetFocus()
    except IndexError:
      wx.MessageBox("You did not select any row to delete!")
    event.Skip()

  def clk_load(self, event):
    try:
      row_index=self.grid_1.GetSelectedRows()[0]
      cell_value=[]
      for i in range(0,4):
        cell_value.append(self.grid_1.GetCellValue(row_index,i))
      self.txtID.Value=str(cell_value[0])
      self.txtNAME.Value=str(cell_value[1])
      self.txtSURNAME.Value=str(cell_value[2])
      self.txtNUMBER.Value=str(cell_value[3])
      self.button_6.Enabled=True
      self.button_5.Enabled=False
      self.txtNAME.SetFocus()
      event.Skip()
    except IndexError:
      wx.MessageBox("You did not select an row to load")

  def clk_go(self,event):
    r=data_rows_count()
    for e in range(0,r):
      for j in range(0,4):
        self.grid_1.SetCellValue(e,f,"")
    cnn=connect()
    cursor=cnn.cursor()
    cursor.execute("SELECT * FROM Phone WHERE name LIKE '%"+self.txtSearch.Value+"%'")
    cnn.commit()
    rows=cursor.fetchall()
    for i in range(len(rows)):
      for j in range(0,4):
        cell=rows[i]
        self.grid_1.SetCellValue(i,j,str(cell[j]))
    cnn.close()
    self.txtSearch.SetFocus()
    event.Skip()

  def clk_renumber(self,event):
    Backup_Message=wx.MessageDialog(None,"It is preferable to backup your database before you continue! Do you wish to preceed?",'Caution!',wx.YES_NO | wx.ICON_QUESTION)
    Response=Backup_Message.ShowModal()
    if(Response==wx.ID_NO):
      Backup_Message.Destroy()
    if(Response==wx.ID_YES):
      cnn=connect()
      cur=cnn.cursor()
      cur.execute("SELECT * FROM Phone")
      rows=cur.fetchall()
      i=0
      m=()
      for r in rows:
        i+=1
        s=str(r).replace(str(r[0]),str(i))
        t=s.replace("u'","'")
        x=eval(t)
        m+=(x,)
        cur.execute("DELETE FROM Phone")
        add_many="INSERT INTO Phone VALUES(?,?,?,?)"
        cur.executemany(add_many,m)
      wx.MessageBox("Renumbering Successful!")
      cur.execute("SELECT * FROM Phone")
      TheRows=cur.fetchall()
      for i in range(len(TheRows)):
        for j in range(0,4):
          cell=TheRows[i]
          self.grid_1.SetCellValue(i,j,str(cell[j]))
      cnn.commit()
      cnn.close()
      self.txtNAME.SetFocus()
      event.Skip()

if __name__=="__main__":
  gettext.install("app")
  app=wx.PySimpleApp(0)
  wx.InitAllImageHandlers()
  frame_1=MyFrame(None,wx.ID_ANY,"")
  app.SetTopWindow(frame_1)
  frame_1.Show()
  app.MainLoop()

#! -*- coding: utf-8 -*-

import wx
import wx.grid
import gettext
import os
import sqlite3
import datetime

cwd=os.path.abspath(os.curdir)

class MyFrame(wx.Frame):
  def __init__(self,*args,**kwds):
    kwds["style"]=wx.DEFAULT_FRAME_STYLE
    wx.Frame.__init__(self,*args,**kwds)
    self.frame_1_menubar=wx.MenuBar()
    wxglade_tmp_menu=wx.Menu()
    wxglade_tmp_menu.Append(1,_("Create sqlite3 DataBase"),"",wx.ITEM_NORMAL)
    self.frame_1_menubar.Append(wxglade_tmp_menu,_("DataBase Configuration"))
   
    wxglade_tmp_menu=wx.Menu()
    wxglade_tmp_menu.Append(2,_("Message"),"",wx.ITEM_NORMAL)
    self.frame_1_menubar.Append(wxglade_tmp_menu,_("About"))

    self.SetMenuBar(self.frame_1_menubar)
    self.__set_properties()
    self.__do_layout()
    self.Bind(wx.EVT_MENU, self.open_dialog, id=1)
    self.Bind(wx.EVT_MENU, self.open_dialog1,id=2)

  def __set_properties(self):
    self.SetTitle(_("Sqlite3 Creator"))
    self.SetSize((555,444))
    self.SetBackgroundColour(wx.Colour(255,255,255))
 
  def __do_layout(self):
    sizer_1=wx.BoxSizer(wx.VERTICAL)
    self.SetSizer(sizer_1)
    self.Layout()

  def open_dialog(self,event):
    MyDialog1(self).Show()

  def open_dialog1(self,event):
    wx.MessageBox("This App s made for you and for all developpers who use sqlite3")


class MyDialog1(wx.Dialog):
  def __init__(self,*args,**kwds):
    kwds["style"]=wx.DEFAULT_DIALOG_STYLE
    wx.Dialog.__init__(self,*args,**kwds)
    self.label_27=wx.StaticText(self,-1,_(" Create Your Data Tables :"))
    self.label_25=wx.StaticText(self,-1,_(" File/Data/Table"))
    self.txtFileName=wx.TextCtrl(self, -1,"")
    self.txtDataName=wx.TextCtrl(self,-1,"")
    self.txtDataTable=wx.TextCtrl(self,-1,"")
    self.grid_1=wx.grid.Grid(self,-1,size=(1,1))
    self.bnt_add=wx.Button(self, -1,_("Add Column"))
    self.bnt_remove=wx.Button(self,-1,_("Remove Column"))
    self.bnt_create=wx.Button(self,-1,_("Create DataBase"))
    self.bnt_reset=wx.Button(self,-1,_("Reset Grid"))
    self.txtDataFileOutput=wx.TextCtrl(self,-1,"",style=wx.TE_READONLY)

    self.__set_properties()
    self.__do_layout()

    self.Bind(wx.EVT_BUTTON,self.cl_add_col,self.bnt_add)
    self.Bind(wx.EVT_BUTTON,self.clk_remove_col, self.bnt_remove)
    self.Bind(wx.EVT_BUTTON,self.clk_Create_db,self.bnt_create)
    self.Bind(wx.EVT_BUTTON,self.clk_reset_grid,self.bnt_reset)

  def __set_properties(self):
    self.SetTitle(_("DataBase Creator"))
    self.SetSize((555,444))
    self.txtFileName.SetMinSize((100,27))
    self.txtDataName.SetMinSize((100,27))
    self.txtDataTable.SetMinSize((100,27))
    self.grid_1.CreateGrid(1,2)
    self.grid_1.SetColLabelValue(0,_("Name"))
    self.grid_1.SetColSize(0,200)
    self.grid_1.SetColLabelValue(1,_("Type"))
    self.grid_1.SetColSize(1,200)
    self.bnt_add.SetMinSize((200,29))
    self.bnt_remove.SetMinSize((200,29))
    self.bnt_create.SetMinSize((200,29))
    self.bnt_reset.SetMinSize((200,29))
    self.txtDataFileOutput.SetMinSize((400,30))

  def __do_layout(self):
    sizer_7=wx.BoxSizer(wx.VERTICAL)
    grid_sizer_10=wx.GridSizer(2,2,0,0)
    grid_sizer_8=wx.GridSizer(1,4,0,0)
    sizer_7.Add(self.label_27,0,0,0)
    grid_sizer_8.Add(self.label_25,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_8.Add(self.txtFileName,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_8.Add(self.txtDataName,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_8.Add(self.txtDataTable,0,wx.ALIGN_CENTER_VERTICAL,0)
    sizer_7.Add(grid_sizer_8,1,wx.EXPAND,0)
    sizer_7.Add(self.grid_1,1,wx.EXPAND,0)
    grid_sizer_10.Add(self.bnt_add,0,wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_10.Add(self.bnt_remove,0,wx.ALIGN_CENTER_VERTICAL,0)
    grid_sizer_10.Add(self.bnt_create,0,wx.ALIGN_RIGHT,0)
    grid_sizer_10.Add(self.bnt_reset,0,0,0)
    sizer_7.Add(grid_sizer_10,1,wx.EXPAND,0)
    sizer_7.Add(self.txtDataFileOutput,0,wx.EXPAND,0)
    self.SetSizer(sizer_7)
    self.Layout()

  def cl_add_col(self,event):
    self.grid_1.AppendRows(1)
    event.Skip()

  def clk_remove_col(self,event):
    try:
      lst=self.grid_1.GetSelectedRows()[0]
      self.grid_1.DeletRows(lst,1)
      event.Skip()
    except IndexError:
      wx.MessageBox("You did not select ant row to delete")

  def clk_Create_db(self,event):
    try:
      DataColumnsList=[]
      DataTypeList=[]
      DataString=[]
      DataTableName=str(self.txtDataTable.Value)
      ConnectionString=cwd+"/"+(self.txtFileName.Value + "/"+self.txtDataName.Value+".db")
      RowNum=self.grid_1.GetNumberRows()
 
      for i in range(0,RowNum):
        DataColumnsList.append(str(self.grid_1.GetCellValue(i,0)))
        DataTypeList.append(str(self.grid_1.GetCellValue(i,1)))

      for i in range(len(DataColumnsList)):
        DataString.append(DataColumnsList[i]+" "+DataTypeList[i])

      elem=",".join(DataString)
      CreateQuery=("""CREATE TABLE """+DataTableName+"""(%s)"""%elem)

      if not os.path.isfile("/python/CreationLog.txt"):
        f=open("CreationLog.txt","w")

      with open("/python/CreationLog.txt","wr+")as NewLog:
        OldLog=NewLog.read()
        NewLog.seek(0)
        NewLog.write(OldLog+ "\nCreated on "+str(datetime.date.isoformat(datetime.datetime.now()))+" in '"+ConnectionString+"' ,Used Query : "+CreateQuery+"\n")
      if not os.path.exists(self.txtFileName.Value):
        os.makedirs(self.txtFileName.Value)
      else:
        wx.MessageBox("The Folder Already Exists, but you can add to it data tables")

      cnn=sqlite3.connect(ConnectionString)
      cursor=cnn.cursor()
      cursor.execute(CreateQuery)
      cnn.close()

      self.txtDataFileOutput.Value=("A Data File Named "+self.txtDataName.Value+".db was created in "+self.txtFileName.Value)
    except OSError:
      wx.MessageBox("The Grid Is Empty!")
    event.Skip()

  def clk_reset_grid(self,event):
    r=self.grid_1.GetNumberRows()

    for i in range(0,r):
      self.grid_1.DelteRows(1,i)

    for c in range(0,2):
      self.grid_1.SetCellValue(0,c,"")

    self.txtFileName.Value=""
    self.txtDataName.Value=""
    self.txtDataTable.Value=""
    self.txtDataFileOutput.Value=""
    event.Skip()

if __name__=="__main__":
  gettext.install("app")
  app=wx.PySimpleApp(0)
  wx.InitAllImageHandlers()
  frame_1=MyFrame(None,wx.ID_ANY,"")
  app.SetTopWindow(frame_1)
  frame_1.Show()
  app.MainLoop()

#! coding: utf-8 -*-

from __future__ import division, absolute_import, print_function
from base64 import b64encode
from fractions import gcd
from random import randrange
from collections import namedtuple
from math import log
from binascii import hexlify, unhexlify
import sys

PY3=sys.version_info[0]==3
if PY3:
  binary_type=bytes
  range_func=range
else:
  binary_type=str
  range_func=xrange

def is_prime(n,k=30):
  # http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
 
  if n<=3:
    return n==2 or n==3
  neg_one=n-1

  # write n-1 as 2^s*d where d is odd
  s,d=0,neg_one
  while not d&1:
    s,d=s+1,d>>1
  assert 2**s*d==neg_one and d&1

  for _ in range_func(k):
    a=randrange(2,neg_one)
    x=pow(a,d,n)
    if x in (1,neg_one):
      continue
    for _ in range_func(s-1):
      x=x**2%n
      if x==1:
        return False
      if x==neg_one:
        break
    else:
      return False
  return True

def randprime(n=10**8):
  p=1
  while not is_prime(p):
    p=randrange(n)
  return p

def multinv(modulus, value):
  x,lastx=0,1
  a,b=modulus, value
  while b:
    a,q,b=b,a//b,a%b
    x,lastx=lastx-q*x,x
  result=(1-lastx*modulus) // value
  if result<0:
    result+= modulus
  assert 0<=result < modulus and value * result % modulus ==1
  return result

KeyPair=namedtuple('KeyPair','public private')
Key=namedtuple('Key','exponent modulus')

def keygen(n,public=None):
  prime1=randprime(n)
  prime2=randprime(n)
  composite=prime1*prime2
  totient=(prime1-1)*(prime2-1)
  if public is None:
      private=None
      while True:
        private=randrange(totient)
        if gcd(private, totient)==1:
          break
      public =multinv(totient, private)
  else:
    private=multinv(totient, public)
  assert public* private % totient==gcd(public, totient)==gcd(private, totient)==1
  assert pow(pow(1234567, public, composite),private, composite)==1234567
  return KeyPair(Key(public, composite), Key(private,composite))

def encode(msg, pubkey, verbose=False):
  chunksize=int(log(pubkey.modulus, 256))
  outchunk=chunksize+1
  outfmt='%%0%dx' % (outchunk*2,)
  bmsg=msg if isinstance(msg, binary_type) else msg.encode('utf-8')
  result=[]

  for start in range_func(0,len(bmsg),chunksize):
    chunk=bmsg[start:start+chunksize]
    chunk+=b'\x00' * (chunksize - len(chunk))
    plain=int(hexlify(chunk),16)
    coded=pow(plain,*pubkey)
    bcoded=unhexlify((outfmt% coded).encode())
    if verbose:
      print('Encode:',chunksize,chunk,plain,coded, bcoded)
    result.append(bcoded)
  return b''.join(result)


def decode(bcipher, privkey,verbose=False):
  chunksize=int(log(privkey.modulus,256))
  outchunk=chunksize+1
  outfmt='%%0%dx' % (chunksize *2,)
  result=[]
  for start in range_func(0,len(bcipher), outchunk):
    bcoded=bcipher[start:start+outchunk]
    coded=int(hexlify(bcoded),16)
    plain=pow(coded,*privkey)
    chunk=unhexlify((outfmt % plain).encode())
    if verbose:
      print('Decode:', chunksize, chunk, plain, coded, bcoded)
    result.append(chunk)
  return b''.join(result).rstrip(b'\x00').decode('utf-8')

def key_to_str(key):
  return ':'.join((('%%0%dx' % ((int(log(number,256))+1)*2))%number) for number in key)

def str_to_key(key_str):
  return Key(*(int(number,16) for number in key_str.split(':')))

def main():
  import doctest
  print(doctest.testmod())

  pubkey, privkey=keygen(2**64)
  msg=u'the quick brown fox jumped over the lazy dog ® ⌀'
  h=encode(msg, pubkey,True)
  p=decode(h,privkey,True)
  print('-'*20)
  print('message:',msg)
  print('encoded:',b64encode(h).decode())
  print('decoded:',p)
  print('private key:', key_to_str(privkey))
  print('public key:',key_to_str(pubkey))

if __name__=='__main__':
  main()

#! -*- coding: utf-8 -*-

from __future__ import (
    absolute_import, division, print_function, unicode_literals
)

import io
import logging

from pngcanvas import *

BUFSIZE=8*1024 # Taken from filecmp module
HEIGHT=WIDTH=512

logging.debug("Creating canvas: %d, %d",WIDTH, HEIGHT)
c=PNGCanvas(WIDTH, HEIGHT, color=(0xff,0,0,0xff))
c.rectangle(0,0,WIDTH-1,HEIGHT-1)

logging.debug("Generating gradient...")
c.vertical_gradient(1,1,WIDTH-2,HEIGHT-2,(0xff,0,0,0xff),(0x20,0,0xff,0x80))

logging.debug("Drawing some lines...")
c.color=bytearray((0,0,0,0xff))
c.line(0,0,WIDTH-1,HEIGHT-1)
c.line(0,0,WIDTH/2,HEIGHT-1)
c.line(0,0,WIDTH-1,HEIGHT/2)

with open("/python/try_pngcanvas.png","wb") as png_fil:
  logging.debug("Writing to file...")
  png_fil.write(c.dump())

socket_server.py

#! coding: utf-8 -*-

import socket

HOST=""
PORT=50007
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((HOST,PORT))
s.listen(1)
conn,addr=s.accept()
print('Connected by',addr)
while True:
  data=conn.recv(1024)
  if not data: break
  conn.send(data)
conn.close()


----------------------------

socket_client.py

#! -*- coding: utf-8 -*-

import socket

HOST='127.0.0.1'
PORT=50007
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST,PORT))
s.send(b'Hello, python')
data=s.recv(1024)
s.close()
print('Received',repr(data))

#! -*- coding: utf-8 -*-

import Tkinter as Tk
import ttk
import tkFont

class DraggableWindow(object):
  def __init__(self,disable_dragging=False, release_command=None):
    if disable_dragging==False:
      self.bind('<Button-1>',self.initiate_motion)
      self.bind('<ButtonRelease-1>',self.release_dragging)

    self.release_command=release_command

  def initiate_motion(self,event):
    mouse_x,mouse_y=self.winfo_pointerxy()
 
    self.deltaX=mouse_x-self.winfo_x()
    self.deltaY=mouse_y-self.winfo_y()

    self.bind('<Motion>',self.drag_window)

  def drag_window(self,event):
    mouse_x, mouse_y=self.winfo_pointerxy()

    new_x=mouse_x-self.deltaX
    new_y=mouse_y-self.deltaY

    if new_x<0:
      new_x=0

    if new_y<0:
      new_y=0

    self.wm_geometry("+%s+%s" % (new_x, new_y))


  def release_dragging(self,event):
    self.unbind('<Motion>')

    if self.release_command !=None:
      self.release_command()

  def disable_dragging(self):
    self.unbind('<Button-1>')
    self.unbind('<ButtonRelease-1>')
    self.unbind('<Motion>')

  def enable_dragging(self):
    self.bind('<Button-1>',self.initiate_motion)
    self.bind('<ButtonRelease-1>',self.release_dragging)


class AutoResizedText(Tk.Frame):
  def __init__(self,master, width=0, height=0, family=None, size=None, *args, **kwargs):
    Tk.Frame.__init__(self,master,width=width,height=height)
    self.pack_propagate(False)

    self.min_width=width
    self.min_height=height

    self.Text_widget=Tk.Text(self,*args,**kwargs)
    self.Text_widget.pack(expand=True,fill='both')

    if family !=None and size!=None:
      self.font=tkFont.Font(family=family, size=size)
    else:
      self.font=tkFont.Font(family=self.Text_widget.cget("font"))

    self.Text_widget.config(font=self.font)

    autoresizetext_tag="_autoresizetext_"+str(self)
    list_of_bind_tags=list(self.Text_widget.bindtags())
    list_of_bind_tags.insert(list_of_bind_tags.index('Text'), autoresizetext_tag)

    self.Text_widget.bindtags(tuple(list_of_bind_tags))
    self.Text_widget.bind_class(autoresizetext_tag, "<KeyPress>",self.update_textbox)
   
  def update_textbox(self,event):
    self.Text_widget.focus_set()

    if event.keysym=='BackSpace':
      self.Text_widget.delete("%s-1c" % Tk.INSERT)
      new_text=self.Text_widget.get("1.0",Tk.END)

    elif event.keysym=='Delete':
      self.Text_widget.delete("%s" % Tk.INSERT)
      new_text=self.Text_widget.get("1.0",Tk.END)

      # We check whether it is a puctuation or normal key
    elif len(event.char)==1:
        if event.keysym=='Return':
          new_char='\n'
        else:
          new_char=event.char

        old_text=self.Text_widget.get("1.0", Tk.END)
        new_text=self.insert_character_into_message(old_text,self.Text_widget.index(Tk.INSERT), new_char)
    else:
        # If it is a special key. we continue the binding chain
        return

      # Tk Text widget always adds a newline at the end of a line
      # This last character is also important for the Text coordinate system
    new_text=new_text[:-1]

    number_of_lines=0
    widget_width=0

    for line in new_text.split("\n"):
      widget_width=max(widget_width, self.font.measure(line))
      number_of_lines+=1

      # We need to add this extra space to calculate the correct width
    widget_width+=2*self.Text_widget['bd']+2*self.Text_widget['padx']+self.Text_widget['insertwidth']

    if widget_width <self.min_width:
      widget_width=self.min_width

    self.Text_widget.configure(height=number_of_lines)
    widget_height=max(self.Text_widget.winfo_reqheight(), self.min_height)

    self.config(width=widget_width, height=widget_height)

    # If we don't update_idletasks(), the window won't be resized before the insertion
    self.update_idletasks()
   
    #Finally we insert the new character
    if event.keysym!='BackSpace' and event.keysym!= 'Delete':
      self.Text_widget.insert(Tk.INSERT, new_char)
     
    return "break"

  def insert_character_into_message(self,message, coordinate, char):
    target_row, target_column=map(int, coordinate.split('.'))

    this_row=1
    this_column=0
    index=0

    for ch in message:
      if this_row==target_row and this_column ==target_column:
        message=message[:index] + char+message[index:]
        return message

      index+=1

      if ch=='\n':
        this_row+=1
        this_column=0
      else:
        this_column+=1

  def focus(self):
    self.Text_widget.focus()


class DesktopNote(Tk.Toplevel, DraggableWindow):
  BG_NOTE='#ffff7d'

  def __init__(self,parent, title='Without title',min_width=110,min_height=40):
    Tk.Toplevel.__init__(self,parent)
    DraggableWindow.__init__(self)

    self.overrideredirect(True)
    self.close_IMG = Tk.PhotoImage(data="R0lGODlhEAAQAPAAAAQEBAAAACH5BAEAAAEALAAAAAAQABAAAAImDI6ZFu3/DpxO0mlvBLFX7oEfJo5QZlZNaZTupp2shsY13So6VwAAOw==")
    self.minimize_IMG = Tk.PhotoImage(data="R0lGODlhEAAQAPAAAAQEBAAAACH5BAEAAAEALAAAAAAQABAAAAIiDI6ZFu3/DpxO0mlvBBrmbnBg83Wldl6ZgoljSsFYqNRcAQA7")
    self.restore_IMG = Tk.PhotoImage(data="R0lGODlhEAAQAPcAAAAAAAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAP8ALAAAAAAQABAAAAhFAP8FGEiwYEGB/xIqXLhwIMOHCh02NBgxAEODFhNKjNiwYsWDGQWGxIhQ48iJI09ynLhS48WUB1lCfLhxpkebHTHqtBgQADs=")
    self.minimizeAtRightSide_IMG = Tk.PhotoImage(data="R0lGODlhEAAQAPcAAAAAAAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAP8ALAAAAAAQABAAAAg+AP8FGEiwYEGB/xIqXLhwIMOHCh1CfChxosSKEC8GmJhQI0eBG0F+9MiRpMWQGCmiDPmxI8uWKUuCNEhzY0AAOw==")

    frameNote=Tk.Frame(self,bg=self.BG_NOTE, bd=1, highlightbackground='black', highlightcolor='black',highlightthickness=1)
    frameNote.pack()

    self.minizedNote=Tk.Label(frameNote, text=title, bg=self.BG_NOTE, wraplength=1)
    self.minizedNote.bind('<Button-1>',lambda event: self.maximize_from_right_side())

    self.maximizedNote=Tk.Frame(frameNote)
    self.maximizedNote.pack()

    Header=Tk.Frame(self.maximizedNote, bg=self.BG_NOTE)
    Header.pack(fill=Tk.X)

    ttk.Separator(self.maximizedNote, orient=Tk.HORIZONTAL).pack(padx=1, fill=Tk.X)

    titleLabel=Tk.Label(Header, text=title, bg=self.BG_NOTE)
    titleLabel.pack(side=Tk.LEFT)

    Tk.Button(Header, compound=Tk.TOP, image=self.close_IMG, bg=self.BG_NOTE, activebackground=self.BG_NOTE, command=self.destroy).pack(side=Tk.RIGHT)
   
    self.iconifyButton=Tk.Button(Header, image=self.minimize_IMG, command=self.minimize, bg=self.BG_NOTE, activebackground=self.BG_NOTE)
    self.iconifyButton.pack(side=Tk.RIGHT)

    Tk.Button(Header, compound=Tk.TOP, image=self.minimizeAtRightSide_IMG, bg=self.BG_NOTE,activebackground=self.BG_NOTE, command=self.minimize_at_right_side).pack(side=Tk.RIGHT)
 
    self.text_box=AutoResizedText(self.maximizedNote, bd=0, bg=self.BG_NOTE, width=min_width, height=min_height)
    self.text_box.pack(expand=Tk.YES, fill=Tk.BOTH)

  def minimize_at_right_side(self):
    self.disable_dragging()
    self.maximizedNote.pack_forget()
    self.minizedNote.pack()

    self.x=self.winfo_x()
    self.y=self.winfo_y()

    self.wm_geometry('-0+%d' %self.y)

  def maximize_from_right_side(self):
    self.maximizedNote.pack()
    self.minizedNote.pack_forget()
    self.wm_geometry('+%d+%d'% (self.x,self.y))
    self.enable_dragging()

  def minimize(self):
    self.text_box.pack_forget()
    self.iconifyButton['command']=self.maximize
    self.iconifyButton['image']=self.restore_IMG

  def maximize(self):
    self.text_box.pack(expand=Tk.YES, fill=Tk.BOTH)
    self.iconifyButton['command']=self.minimize
    self.iconifyButton['image']=self.minimize_IMG


class Test(Tk.Tk):
  def __init__(self):
    self.root=Tk.Tk()
    Tk.Label(self.root,text="Title:").pack(side=Tk.LEFT)

    self.title=Tk.StringVar()
    self.title.set('TITLE')

    entry_title=Tk.Entry(self.root, textvariable=self.title)
    entry_title.pack(side=Tk.LEFT)
    entry_title.bind('<Return>',lambda event: self.create_a_new_note())

    Tk.Button(self.root, text="Create another note", command=self.create_a_new_note).pack(side=Tk.LEFT)
       
    self.create_a_new_note()

  def create_a_new_note(self):
    New_note=DesktopNote(self.root, self.title.get())
    New_note.text_box.focus()

  def run(self):
    self.root.mainloop()


if __name__=='__main__':
  Test().run()

#! -*- coding: utf-8 -*-

from Tkinter import *

class Text2(Frame):
  def __init__(self, master, width=0, height=0, **kwargs):
    self.width=width
    self.height=height

    Frame.__init__(self, master,width=self.width,height=self.height)
    self.text_widget=Text(self,**kwargs)
    self.text_widget.pack(expand=YES, fill=BOTH)
 
  def pack(self,*args,**kwargs):
    Frame.pack(self,*args, **kwargs)
    self.pack_propagate(False)

  def grid(self,*args,**kwargs):
    Frame.grid(self,*args,**kwargs)
    self.grid_propagate(False)

root=Tk()

Text2(root,width=900,height=1200).pack()

root.mainloop()

#! -*- coding: utf-8 -*-

DEFAULT_ALPHABET='mn6j2c4rv8bpygw95z7hsdaetxuk3fq'
DEFAULT_BLOCK_SIZE=24
MIN_LENGTH=5

class UrlEncoder(object):
  def __init__(self,alphabet=DEFAULT_ALPHABET, block_size=DEFAULT_BLOCK_SIZE):
    self.alphabet=alphabet
    self.block_size=block_size
    self.mask=(1<<block_size)-1
    self.mapping=range(block_size)
    self.mapping.reverse()

  def encode_url(self,n,min_length=MIN_LENGTH):
    return self.enbase(self.encode(n), min_length)

  def decode_url(self,n):
    return self.decode(self.debase(n))

  def encode(self, n):
    return (n& ~self.mask) | self._encode(n & self.mask)

  def _encode(self,n):
    result=0
    for i, b in enumerate(self.mapping):
      if n & (1<<i):
        result |= (1<<b)
    return result

  def decode(self,n):
    return (n & ~self.mask) | self._decode(n & self.mask)

  def _decode(self,n):
    result=0
    for i,b in enumerate(self.mapping):
      if n & (1<<b):
        result |=(1<<i)
    return result

  def enbase(self,x,min_length=MIN_LENGTH):
    result=self._enbase(x)
    padding=self.alphabet[0] * (min_length - len(result))
    return '%s%s' % (padding, result)

  def _enbase(self,x):
    n=len(self.alphabet)
    if x <n:
      return self.alphabet[x]
    return self._enbase(x/n)+self.alphabet[x%n]

  def debase(self,x):
    n=len(self.alphabet)
    result=0
    for i,c in enumerate(reversed(x)):
      result+=self.alphabet.index(c) * (n**i)
    return result

DEFAULT_ENCODER=UrlEncoder()

def encode(n):
  return DEFAULT_ENCODER.encode(n)

def decode(n):
  return DEFAULT_ENCODER.decode(n)

def enbase(n,min_length=MIN_LENGTH):
  return DEFAULT_ENCODER.enbase(n,min_length)

def debase(n):
  return DEFAULT_ENCODER.debase(n)

def encode_url(n,min_length=MIN_LENGTH):
  return DEFAULT_ENCODER.encode_url(n,min_length)

def decode_url(n):
  return DEFAULT_ENCODER.decode_url(n)

if __name__=='__main__':
  for a in range(0,200000, 37):
    b=encode(a)
    c=enbase(b)
    d=debase(c)
    e=decode(d)
    assert a==e
    assert b==d
    c=(' '* (7-len(c)))+c
    print '%6d %12d %s %12d %6d' % (a,b,c,d,e)