Python-сообщество

def pushButton_Clicked():
        data_dir = QtGui.QFileDialog.getOpenFileName()
        ui.textEdit_2.setText(("Файн выбран - "+ data_dir) )

QtCore.QObject.connect(ui.pushButton_chose_fifle, QtCore.SIGNAL("clicked()"),pushButton_Clicked)

def __init__(self):

import time
import threading
from gi.repository import Gtk, GLib, GObject
class ProgressBarWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="ProgressWin")
        self.set_border_width(20)
        self.connect("delete-event", self.del_progress, 1)
        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.add(vbox)
        self.progressbar = Gtk.ProgressBar()
        vbox.pack_start(self.progressbar, True, True, 0)
        self.show_all()
        threading.Thread(target=Gtk.main).start()
    def del_progress(self, *args):
        if args[2] == 1:
            self.destroy()
    def on_activity(self, *args):
        self.progressbar.set_fraction(args[0])
class TopWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="TopWin")
        self.s = ProgressBarWindow()
        time.sleep(1)
        GLib.idle_add(self.s.on_activity, 0.20)
        self.connect("delete-event", self.close_main_window, 2)
        time.sleep(1)
        GLib.idle_add(self.s.on_activity, 0.40)
        self.set_border_width(5)
        time.sleep(1)
        GLib.idle_add(self.s.on_activity, 0.60)
        self.set_default_size(200, 150)
        time.sleep(1)
        GLib.idle_add(self.s.on_activity, 0.80)
        self.spinner = Gtk.Spinner()
        self.spinner.start()
        time.sleep(1)
        GLib.idle_add(self.s.on_activity, 1.00)
        self.add(self.spinner)
        self.show_all()
        self.s.destroy()
    def close_main_window(self, *args):
        if args[2] == 2:
            Gtk.main_quit()
GObject.threads_init()
TopWindow()

options = []
options.append('--proxy=54.173.0.135:3128')
options.append('--proxy-type=http')
options.append('--load-images=false')
options.append('--ignore-ssl-errors=true')
browser = webdriver.PhantomJS('phantomjs',service_args=options)
browser.get('https://ya.ru/')
print browser.current_url
#about:blank

myProxy = "182.74.40.46:8080"
proxy = Proxy({
    'proxyType': ProxyType.MANUAL,
    'httpProxy': myProxy,
    'ftpProxy': myProxy,
    'sslProxy': myProxy,
    'noProxy': ''
    })
webdriver.Firefox(proxy=proxy)

from twisted.internet import reactor
from twisted.web import proxy, server

site = server.Site(proxy.ReverseProxyResource('www.yahoo.com', 80, ''))
reactor.listenTCP(8080, site)
reactor.run()

gettext.install('myapp', './locale', unicode=True)

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
from PyQt5.QtWidgets import QMainWindow, QAction, qApp, QApplication
from PyQt5.QtGui import QIcon
class Example(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        exitAction = QAction(QIcon('RM.png'), 'Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.triggered.connect(qApp.quit)
        self.toolbar = self.addToolBar('Exit')
        self.toolbar.addAction(exitAction)
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('Toolbar')
        self.show()
if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

    from comtypes.client import *
    from comtypes.automation import *
    def connect_acad(self):
        errcode = 0
        try:
            self.acad = GetActiveObject("AutoCAD.Application")
        except:
            errcode = 1
        if errcode == 0:
            try:
                self.dwg = self.acad.ActiveDocument
            except:
                errcode = 2
        if errcode == 0:
            self.mspace = self.dwg.ModelSpace
        return errcode
    def mark_point(self, xy, num, lay):
        
        def point(*args):
            lst = [0.]*3
            if len(args) < 3:
                lst[0:2] = [float(x) for x in args[0:2]]
            else:
                lst = [float(x) for x in args[0:3]]
            return VARIANT(array("d",lst))
        
        txthght = 1.0
        txtshft = 0.3
        crclrd = 0.3
        p1 = point(xy[0], xy[1])
        ent = self.mspace.AddCircle(p1, crclrd)
        ent.Layer = lay
        #htch = self.mspace.AddHatch(0, 'SOLID', False)
        #htch.AppendOuterLoop(array("i", [ent,]))
        #htch.Evaluate()
        #htch.Layer = lay
        p1 = point(xy[0]+txtshft, xy[1]+txtshft)
        sh = len(num)
        if (len(self.nprefix) > 0) and (len(num.replace(self.nprefix, '')) > 3):
            sh = sh // 2
        th = string.Template('\H'+str(txthght)+';$n')
        ent = self.mspace.AddMText(p1, sh, th.substitute(n=num))
        ent.LineSpacingFactor = 0.7
        ent.Layer = lay

Traceback (most recent call last):
  File "C:/Python34/constest/createImage.py", line 34, in <module>
    imageCreator("id_111_33333.png", 123)
  File "C:/Python34/constest/createImage.py", line 12, in imageCreator
    image.paste(qr_image, (1,0,x,y))
  File "C:\Python34\lib\site-packages\PIL\Image.py", line 1351, in paste
    self.im.paste(im, box)
ValueError: images do not match

from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw
from PIL import ImageOps
def imageCreator(link, ident):
    size = width, height = 39, 43
    image = Image.new("1", size, "#ccc")
    qr_image = Image.open(link, 'r')
    x, y = qr_image.size
    
    image.paste(qr_image, (0,0,x,y))
    id_size = len(str(ident))
    
    if id_size:
        null = str()
        
        while id_size != 7:
            id_size +=1
            null += '0'
        ident = str(null) + str(ident)
    # draw image
    draw = ImageDraw.Draw(image)
    font = ImageFont.truetype("tahoma.ttf", 9)
    draw.text((3, 33), ident, "#000", font=font)
    final_image = ImageOps.expand(image, border=1, fill='black')
    final_image.save("file.png")
    final_image.show()
imageCreator("id_111_33333.png", 123)

 image.paste(qr_image, (1,0,x,y))

# -*- coding: utf-8 -*-
from IPython.core.pylabtools import figsize
import numpy as np
import pymc as pm
from matplotlib import pyplot as plt
from matplotlib import rc
font = {'family': 'Verdana', 'weight': 'normal'}
rc('font', **font)
figsize(10, 5)
data = np.genfromtxt("v15.csv", skip_header = 1, dtype = int, delimiter=";")
data = data[np.argsort(data[:, 0])]
data = [d[1:] for d in data]
number_of_players = len(data)
number_of_checkpoints = len(data[0])
difficulty_checkpoint = pm.Uniform("dc", lower = 0, upper = 1, size = number_of_checkpoints)
skill_player = pm.Uniform("sp", lower = 0, upper = 1, size = number_of_players)
out = []
for i in range(number_of_players):
    out.append([0] * number_of_checkpoints)
@pm.deterministic
def theta(dc = difficulty_checkpoint, sp = skill_player):
#    out = np.zeros(number_of_checkpoints)
#    out = [d*s for s in sp for d in dc]
    for i in range(number_of_players):
        for j in range(number_of_checkpoints):
            out[i][j] = sp[i] * dc[j]
    return out
checkpoint1 = 0
checkpoint2 = 19
@pm.deterministic
def delta(dc = difficulty_checkpoint):
    return dc[checkpoint1] - dc[checkpoint2]
    
observation_player = np.arange(number_of_players * number_of_checkpoints)\
                        .reshape(number_of_players, number_of_checkpoints)
for i in range(number_of_players):
    for j in range(number_of_checkpoints):
        observation_player[i][j] = pm.Bernoulli("obs",
                                                p = theta[i][j],
                                                value = data[i][j],
                                                observed = True)
model = pm.Model([difficulty_checkpoint, skill_player, observation_player, delta])
mcmc = pm.MCMC(model)
mcmc.sample(5000, 100)
dc_samples = mcmc.trace("dc")[:]
sp_samples = mcmc.trace("sp")[:]
delta_samples = mcmc.trace("delta")[:]
print("\nВероятность, что КП_1 ЛЕГЧЕ КП_2: %.3f" % (delta_samples < 0).mean())
print("Вероятность, что КП_1 СЛОЖНЕЕ КП_2: %.3f" % (delta_samples > 0).mean())
plt.figure()
figsize(10, 6)
ax = plt.subplot(311)
ax.set_autoscaley_on(False)
for i in range(number_of_checkpoints):
    plt.hist(dc_samples.T[i], histtype='stepfilled', bins=30, alpha=0.33, normed=True)
    plt.legend(loc="upper right")
    plt.title(r"""Апостериорные распределения параметров""")
    plt.xlim([0, 1])
    plt.ylim([0, 10])
    plt.xlabel("Что это?")
plt.figure()
figsize(10, 6)
ax = plt.subplot(312)
ax.set_autoscaley_on(False)
for i in range(number_of_players):
    plt.hist(sp_samples.T[i], histtype='stepfilled', bins=30, alpha=0.33, normed=True)
    plt.legend(loc="upper right")
    plt.title(r"""Апостериорные распределения параметров""")
    plt.xlim([0, 1])
    plt.ylim([0, 10])
    plt.xlabel("А Что это?")
plt.figure()
figsize(10, 6)
ax = plt.subplot(313)
ax.set_autoscaley_on(False)
plt.hist(delta_samples, histtype='stepfilled', bins=30, alpha=0.85,
         label="Апостериорное распределение delta", color="#7A00A6", normed=True)
plt.ylim(0, 10)

import uinput,time
def main():
    events = (
        uinput.BTN_SELECT,
        uinput.BTN_START,
        uinput.BTN_1,        
        uinput.BTN_2,
        uinput.BTN_JOYSTICK,
        uinput.ABS_X,
        uinput.ABS_Y,
        )
    device = uinput.Device(events)
    for i in range(2):
        device.emit(uinput.ABS_X, 50, syn=False)
        device.emit(uinput.ABS_Y, 50)      
        device.emit_click(uinput.BTN_JOYSTICK,1)
        print("BTN_JOYSTICK")
        time.sleep(2)
        device.emit(uinput.BTN_JOYSTICK, 0)
        device.emit(uinput.BTN_JOYSTICK, 1)
        print("BTN_SELECT")
        time.sleep(2)
        device.emit(uinput.BTN_SELECT, 0)
        device.emit(uinput.BTN_SELECT, 1)
        print("BTN_START")		
        time.sleep(2)
        device.emit(uinput.BTN_START, 0)
        device.emit(uinput.BTN_START, 1)
        print("BTN_1")
        time.sleep(2)
        device.emit(uinput.BTN_1, 0)
        device.emit(uinput.BTN_1, 1)
        print("BTN_2")
        time.sleep(2)
        #device.emit_click(uinput.BTN_JOYSTICK)
        device.emit(uinput.BTN_2, 0)
        device.emit(uinput.BTN_2, 1)
        print("BTN_JOYSTICK")
        time.sleep(2)		
        device.emit(uinput.BTN_JOYSTICK, 0)
        device.emit(uinput.BTN_JOYSTICK, 1)
        print("END")
        time.sleep(5)
if __name__ == "__main__":
    time.sleep(4)
    main()

from django.db import models
class Author(models.Model):
   name = models.CharField(max_length=100)
class Book(models.Model):
   author = models.ForeignKey(Author)
   title = models.CharField(max_length=100)
from django.contrib import admin
class BookInline(admin.TabularInline):
    model = Book
class AuthorAdmin(admin.ModelAdmin):
    inlines = [
        BookInline,
    ]

import socket
# Default timeout
socket.setdefaulttimeout(2.5)
class SMTPConnectionFailed(Exception):
    pass
class SMTPServer(object):
    def __init__(self, server_name, port=587, message='ehlo localhost\r\n', ipv6=False):
        self.server = server_name
        self.port = port
        self.ipv6 = ipv6
        self._tried_connection = False
        self._connection_results = None
        self._ehlo_port = None
        self._ehlo_response = None
        self._conversation = None
        self._message = message
        self._socket = None
        self._connected = False
    def get_ip_version(self):
        if self.ipv6:
            return "IPv6"
        else:
            return "IPv4"
    ip_version = property(get_ip_version)
    def get_socket(self):
        if self._socket:
            return self._socket
        else:
            if self.ipv6:
                self._socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
            else:
                self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            return self._socket
    sock = property(get_socket)
    def get_max_message_size(self):
      try:
          size_option = filter(lambda x: x.split(" ")[0] == "250-SIZE",self.ehlo_options)[0]
          splitter = "250-SIZE"
      except IndexError:
          try:
              size_option = filter(lambda x: x.split("250 SIZE")[0] == "",self.ehlo_options)[0]
              splitter = "250 SIZE"
          except IndexError:
              return 0
      size_bytes = size_option.split(splitter)[1]
      return long(size_bytes)/1024.0/1024.0
    server_max_message_size = property(get_max_message_size)
    def get_server_supports_tls(self):
      return "250-STARTTLS" in self.ehlo_options
    server_supports_tls = property(get_server_supports_tls)
    def parse_ehlo(self):
      if not self._ehlo_response:
        self._ehlo_response = self.get_ehlo()
      return filter(lambda x: x[:3] == '250',self._ehlo_response.split("\r\n"))
    ehlo_options = property(parse_ehlo)
    def get_ehlo(self):
      if not self._connected:
        self.connect()
      try:
        self.sock.send(self._message)
        return self.sock.recv(1024)
      except Exception, e:
        print str(e)
        return "ehlo failed."
    ehlo = property(get_ehlo)
    def is_open_relay(self):
      if not self._conversation:
        self._conversation = self.have_relay_conversation()
      relay_results = filter(lambda x: x.replace("-", " ").lower().find('250 ok') != -1,
                             self._conversation.split("\r\n"))[1:]
      self.close()
      if len(relay_results) > 0:
        return True
      return False
    open_relay = property(is_open_relay)
    def have_relay_conversation(self):
      if not self._connected:
          self.connect()
      self._conversation = True
      self.sock.send(self._message)
      self.sock.send("mail from: axdjdiai@akxkskd.com\n")
      self.sock.send("rcpt to: aserjslkejrlskj@laslkjelrkjlekj.com\n")
      return self.sock.recv(1024)
    def connect(self):
        if not self._connected:
            try:
              self.sock.connect((self.server, self.port))
              self._connection_results = {'connected':True, 'message':unicode(self.sock.recv(1024))}
              self._ehlo_port          = self.port
              self._connected = True
            except socket.error:
              self._connection_results = {'connected':False, 'message':u'Connection failed'}
              self._socket = None
              raise(SMTPConnectionFailed('Connection failed'))
        return self._connection_results
    def close(self):
        self.sock.send("quit")
        self._socket = None
        self._connected = False
        return True
    def get_results(self):
        self.connect()
        self.close()
        return self._connection_results
    results = property(get_results)
if __name__ == "__main__":
  server_list = [{'server_name': 'mail.fentyplacecar.ru','port': 25, 'try_v6': False},
                 {'server_name': 'smtp.fentyplacecar.ru','port': 587, 'try_v6': False},
                 {'server_name': 'fentyplacecar.ru', 'port': 25, 'try_v6': True}]
  for server in server_list:
    print("Attepmting to connect to %s on port %d" % (server['server_name'],server['port']))
    s = SMTPServer(server['server_name'], server['port'], ipv6=server['try_v6'])
    try:
        print("Open relay? %s" % s.open_relay)
        print("EHLO options: %s" % ",\n".join(s.ehlo_options))
        print("TLS Supported? %s" % s.server_supports_tls)
        print("Max message size: %d MB" % s.server_max_message_size)
        print s.results, "\n"
    except SMTPConnectionFailed as error:
        print("""Error connection failed.  This means that the server is down, or your ISP does not allow you to
                 connect to other SMTP servers on the specified port (%d) (over %s)""" % (s.port, s.ip_version))