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

def get_user_limits(self, user):
        """Get User Limits

        Implements command CMD_API_SHOW_USER_CONFIG

        Returns a dictionary with the user's upper limits
        and settings that defines their account

        Method info: http://www.directadmin.com/api.html#info
        """
        return self._execute_cmd("CMD_API_SHOW_USER_CONFIG", \
                                 [('user', user)])

#!/usr/local/bin/python2.7
import directadmin
u = "someuser"
api = directadmin.Api("admin", "Somepwd", "example.com", 2222)
user_config = api.get_user_limits(u)
print user_config

File "./test.py", line 23, in <module>
    user_config = api.get_user_limits(u)
  File "/usr/local/lib/python2.7/site-packages/directadmin/api.py", line 948, in get_user_limits
    [('user', user)])
  File "/usr/local/lib/python2.7/site-packages/directadmin/api.py", line 624, in _execute_cmd
    return self._connector.execute(cmd, parameters, get)
  File "/usr/local/lib/python2.7/site-packages/directadmin/api.py", line 512, in execute
    return self._handle_response(urllib2.urlopen(request))
  File "/usr/local/lib/python2.7/site-packages/directadmin/api.py", line 575, in _handle_response
    raise ApiError(response['details'][0])
directadmin.api.ApiError: no container class for data

   self.lst=gtk.ListStore(int,str,str,int,float)
   self.grid=gtk.TreeView(self.lst)
   renderText=gtk.CellRendererText()
   renderText.set_property( 'editable', True )
   renderText.connect('edited',self.__edit_col,self.lst)
   cell=gtk.TreeViewColumn('PLU',renderText,text=0)
   self.grid.append_column(cell)
   cell=gtk.TreeViewColumn('Штрихкод',renderText,text=1)
   self.grid.append_column(cell)
   cell=gtk.TreeViewColumn('Наименование',renderText,text=2,editable=2)
   self.grid.append_column(cell)
   cell=gtk.TreeViewColumn('Группа',renderText,text=3)
   self.grid.append_column(cell)
   cell=gtk.TreeViewColumn('Цена',renderText,text=4)
   self.grid.append_column(cell)

	def __edit_col(self,cell,path,new_text,model):
        	model[path][2]=new_text  # для проверки работы изменяем 3 столбец
		return

 
tree = ET.parse('file.xml')
    person = tree.find('/отправитель')

from utils import \
     transparent_white as transparent, \
     create_cairo_font_face_for_file, \
     middle_center
from PIL.ImageColor import getrgb
from cairo import ImageSurface, Context, FontOptions, FORMAT_ARGB32
from math import radians, sin, cos, pi

font_files = [
    "/WINDOWS/Fonts/cour.ttf",
    "/WINDOWS/Fonts/arial.ttf",
    "/WINDOWS/Fonts/times.ttf",
    "/WINDOWS/Fonts/georgia.ttf",
    "/WINDOWS/Fonts/DejaVuMonoSans.ttf",
    "/WINDOWS/Fonts/DejaVuCondensedSerif.ttf",
    ]

font_size = 60
letter = u"Ж"
text_angle = 15
font_color = getrgb("black")
border_color = getrgb("magenta")

# нарисовать букву в 0, 0

WIDTH = 200
HEIGHT = 200

im = ImageSurface(FORMAT_ARGB32, WIDTH, HEIGHT)
cr = Context(im)
face = create_cairo_font_face_for_file(font_files[0], reinit = 0)

cr.set_font_face(face)
cr.set_font_size(font_size)

px = max(cr.device_to_user_distance(1, 1))

canvas_center = WIDTH * 0.5, HEIGHT * 0.5
rectangle_origin = canvas_center[0] * 0.5, canvas_center[1] * 0.5

# квадрат, ограничивающий 100x100 в серединке холста
cr.translate(*rectangle_origin)
cr.set_source_rgb(*border_color) # СИРЕНЕВЫЙ
cr.set_line_width(1 * px)
cr.rectangle(0, 0, WIDTH * 0.5, HEIGHT * 0.5)

# вспомогательные оси x, y, пересекающиеся в центре квадрата
cr.move_to(0, rectangle_origin[1])
cr.line_to(rectangle_origin[0] * 2, rectangle_origin[1])
cr.move_to(rectangle_origin[0], 0)
cr.line_to(rectangle_origin[1], rectangle_origin[1] * 2)
cr.stroke()

width, height = cr.text_extents(letter)[2:4]
text_origin = middle_center(rectangle_origin[0], rectangle_origin[1], width, height)

print "rectangle_origin:", rectangle_origin[0], rectangle_origin[1]
print "width, height:", width, height
print "text_origin:", text_origin

######## сначала рисуем без поворота
cr.set_source_rgb(*getrgb("red"))
# перемещаемся к месту, от которого рисовать
cr.move_to(*text_origin)
# рисуем текст
cr.show_text(letter)

cr.move_to(*text_origin)
cr.translate(width/2, -height/2)
cr.rotate(radians(text_angle))
cr.set_source_rgb(*getrgb("blue"))
cr.show_text(letter)

del cr
im.write_to_png("task_6.png")

class Telephones(models.Model):
    show=models.BooleanField(default=True,
                verbose_name=u'Показывать телефон на сайте')
    prioritet=models.IntegerField(verbose_name=u'Приоритет')
    telnum=models.CharField(max_length=20, verbose_name=u'Номер телефона')
    prim=models.CharField(max_length=50, verbose_name=u'Примечание',
                          blank=True)


class Flats(models.Model):
    ...
    ...
    telephones=models.ManyToManyField(Telephones,verbose_name=u'Отображаемые на \
странице квартиры телефоны', blank=True)

class TelFlatsInline(admin.TabularInline):
    model=Flats.telephones.through


class TelephonesAdmin(admin.ModelAdmin):
    inlines=(TelFlatsInline,)

class Gui():
blah blah blah
    def start(self):
        if not self.window.get_visible(): # Если окно невидимо
            self.window.set_visible(True) # Показываем его
            self.window.set_child_visible(True) # Показываем дочерние виджеты (кнопки, label и т. д.)
        urlopen(myurl).read()
        self.text = database.preparation_results(tmp1)
blah blah blah

class Gui():
blah blah blah
    def close_app(self, widget):
        print 'Скрытие окна...'
        self.window.set_visible(False) # Скрываем его
blah blah blah

сlass CoordSysConverter:
    def __init__(self, center):
      self.center_x, self.center_y = center

  # pygame -> polar
    def pygame2polar(self, x, y):
      rx, ry = self._pygame2cartesian(x, y)
      return self._cartesian2polar(rx, ry)

  # polar -> pygame
    def polar2pygame(self, r, fi):
      x, y = self._polar2cartesian(r, fi)
      return self._cartesian2pygame(x, y)

  # pygame -> cartesian
    def _pygame2cartesian(self, x, y):
      rx = x - self.center_x
      ry = self.center_y - y
      return rx, ry

  # cartesian -> pygame
    def _cartesian2pygame(self, x, y):
      rx = x + self.center_x
      ry = self.center_y - y
      return rx, ry

  # polar -> cartesian
    def _polar2cartesian(self, r, fi):
      x = r * math.cos(fi)
      y = r * math.sin(fi)
      return x, y

  # cartesian -> polar
    def _cartesian2polar(self, x, y):
      r = math.sqrt(x**2 + y**2)
  
      if r == 0:
        return r, 0  

      if x == 0:
        if y > 0:
          return r, math.pi / 2
        else:
          return r, math.pi + math.pi / 2
    
      fi = math.atan(y / x)
      if x < 0:
        fi += math.pi
      if fi < 0:
        fi += math.pi * 2

      return r, fi

import pygame
import time
import math


pygame.init()


#main def
def main():
#screen
  size = 640, 480
  screen = pygame.display.set_mode(size, pygame.DOUBLEBUF | pygame.HWSURFACE)
  pygame.display.set_caption('Landing')


#process event

  damage = False
  done = False
  a = 2
  turretl = Turretl(size, a)
  turretr = Turretr(size, a)
  troop = Troop(size)
  while not done:
    for event in pygame.event.get():
      if event.type == pygame.QUIT:
        done = True
      turretl.events(event)
      turretr.events(event)  
  


    #step
  turretl.step()
  turretr.step()
  damage = turretl.step_bullets(troop) or turretr.step_ballets(troop)
  if troop_dead():
    a = a + 1
    	
#rendering
  if damage:
    screen.fill((255, 0, 0))
    damage = True
  else:
    screen.fill((255, 255, 255))
  turretl.render(screen)
  for bulletl in turretl.bullets:
      bulletl.render(screen)


  turretr.render(screen)
  for bulletr in turretr.ballets:
      bulletr.render(screen)

  pygame.draw.line(screen, (255, 0, 0), (0, 340), (640, 340), 3)
  pygame.display.flip()

#wait
  time.sleep(0.20)
#Classes
class Troop:
	def __init__(self, screen_size):
		self.x = 320
		self.y = 0
		self.dy = 2
		self.r = 10
		self.screen_size = screen_size
                self.pain = 0

		
	def step(self):
		self.y -= self.dy
		
	def cross_line(self):
		if self.y == 440:			
			return True
		return False
		
		
	def render(self, screen):
		pygame.draw.circle(screen, (0, 50, 0), (self.x, self.y), self.r)
	
        def troop_dead(self):
           if self.pain <= 2:
             self.pain += 1


        def pain(self):
           if self.pain >= 2.5:
             return True
           return False

	
class Turretl:
	def __init__(self, screen_size, a):
		self.x = 0
		self.y = 320
		self.damage = 0
		self.screen_size = screen_size
		self.bullets = []
		self.r = 50
                self.a = a

		
	def events(self, event):
	  if event.type == pygame.KEYDOWN:
	    if event.key == pygame.K_UP:
	      self.y += 15
	    if event.key == pygame.K_DOWN:
	      self.y -= 15
				
	    elif event.type == pygame.KEYDOWN:
		if event.key == pygame.K_SPACE and self.i == 2:
		  bulletl = Bulletl(self.screen_size, (self.x, self.y))
		  self.bullets.append(bulletl)
                  self.a -= 1 
				
	def step_bullets(self, troop):
    	  damage = False
          for i in reversed(range(0, len(self.bullets))):
            self.bullets[i].step()
            if self.bullets[i].is_out_of_screen():
              self.bullets.pop(i)
            elif self.bullets[i].in_troop(troop):
               damage = True
               self.bullets.pop(i)
               troop.pain()
            return damage

	
					
	def step(self):
	  if self.damage > 0:
	    self.damage += 0.00001
				
	def render(self, screen):
		pygame.draw.circle(screen, (255, 40, 0), (self.x, self.y), self.r)
		rect = pygame.Rect((self.x - 10, self.y - 10), (20, 20))
		pygame.draw.rect(screen, (100, 100, 40), rect)
		
	def damage(self):
	  if self.damage <= 10:
	    self.damage += 1
			
		
	def death(self):
	   if self.damage > 10.5:
	     return True
	   return False
		
class Turretr:
	def __init__(self, screen_size, a):
		self.x = 480
		self.y = 320
		self.damage = 0
		self.screen_size = screen_size
		self.ballets = []
		self.r = 50
		self.a = a


	def events(self, event):
	  if event.type == pygame.KEYDOWN:
	    if event.key == pygame.K_W:
	      self.y += 15
	    if event.key == pygame.K_S:
	      self.y -= 15
				
	    elif event.type == pygame.KEYDOWN:
		if event.key == pygame.K_P and self.a == 2:
		  bulletr = Bulletr(self.screen_size, (self.x, self.y))
		  self.ballets.append(bulletr)
		  self.a -= 1
					
	def step(self):
	  if self.damage > 0:
	    self.damage += 0.00001
				
	def render(self, screen):
	   pygame.draw.circle(screen, (255, 40, 0), (self.x, self.y), self.r)
           rect = pygame.Rect((self.x - 10, self.y - 10), (20, 20))
	   pygame.draw.rect(screen, (100, 100, 40), rect)
		
	def damage(self):
	  if self.damage <= 10:
	    self.damage += 1
			
		
	def death(self):
	  if self.damage > 10.5:
	    return True
	  return False

	def step_ballets(self, troop):
    	  damage = False
          for i in reversed(range(0, len(self.ballets))):
            self.ballets[i].step()
            if self.ballets[i].is_out_of_screen():
              self.ballets.pop(i)
            elif self.ballets[i].in_troop(troop):
               damage = True
               self.ballets.pop(i)
               troop.pain()
            return damage


	
	
class Bulletl:
	def __init__(self, screen, pos):
	  self.x, self.y = pos
	  self.dx = 5
	  self.r = 4
	  self.screen_size = screen_size
		
	def step(self):
	  self.x -= self.dx

	def in_troop(self, troop):
	  if self.x + self.r > troop.x:
            if self.y + self.r > troop.y and self.y - self.r < troop.y + troop.r:
              return True
          return False	
		
	def is_out_of_screen(self):
	  if (self.y - self.r) > self.screen_size[1]:
	    return True
	  return False
		
	def in_turret(self, turretr):
	  if self.x + self.r > turretr.x:
	    if self.y + self.r > turretr.y and self.y - self.r < turretr.y + turretr.r:
	      return True
	  return False
		
	def render(self, screen):
	  pygame.draw.circle(screen, (8, 80, 80), (self.x, self.y), self.r)
		
	

class Bulletr:
	def __init__(self, screen, pos):
	  self.x, self.y = pos
	  self.dx = 5
	  self.r = 4
	  self.screen_size = screen_size
		
	def step(self):
	  self.x += self.dx
		
	def is_out_of_screen(self):
	  if (self.y - self.r) > self.screen_size[1]:
	    return True
	  return False
		
	def in_turret(self, turretl):
	  if self.x + self.r > turretl.x:
	    if self.y + self.r > turretl.y and self.y - self.r < turretl.y + turretl.r:
	      return True
	  return False


	def in_troop(self, troop):
	  if self.x + self.r > troop.x:
            if self.y + self.r > troop.y and self.y - self.r < troop.y + troop.r:
              return True
          return False		


        def render(self, screen):
	  pygame.draw.circle(screen, (8, 80, 80), (self.x, self.y), self.r)

#class Land:
	#def
	
	
	
	
	
	
#class Base:
    #def __init__(self, screen_size):
		
	
	
	
	
#class Supertroop:
    #def __init__():
    
    
	
class CoordSysConverter:
    def __init__(self, center):
      self.center_x, self.center_y = center

  # pygame -> polar
    def pygame2polar(self, x, y):
      rx, ry = self._pygame2cartesian(x, y)
      return self._cartesian2polar(rx, ry)

  # polar -> pygame
    def polar2pygame(self, r, fi):
      x, y = self._polar2cartesian(r, fi)
      return self._cartesian2pygame(x, y)

  # pygame -> cartesian
    def _pygame2cartesian(self, x, y):
      rx = x - self.center_x
      ry = self.center_y - y
      return rx, ry

  # cartesian -> pygame
    def _cartesian2pygame(self, x, y):
      rx = x + self.center_x
      ry = self.center_y - y
      return rx, ry

  # polar -> cartesian
    def _polar2cartesian(self, r, fi):
      x = r * math.cos(fi)
      y = r * math.sin(fi)
      return x, y

  # cartesian -> polar
    def _cartesian2polar(self, x, y):
      r = math.sqrt(x**2 + y**2)
  
      if r == 0:
        return r, 0  

      if x == 0:
        if y > 0:
          return r, math.pi / 2
        else:
          return r, math.pi + math.pi / 2
    
      fi = math.atan(y / x)
      if x < 0:
        fi += math.pi
      if fi < 0:
        fi += math.pi * 2

      return r, fi
	

class Ttower:
  def __init__(self, csc, length, width, r):
    self.csc = csc
    self.length = 2
    self.width = 1
    self.fi = math.pi / 12

  def set_fi(self, fi):
    self.fi = fi


  #def process_event(self, event):
    #if event.type == pygame.KEYDOWN:
	    #if event.key == pygame.K_LEFT:
              
	  

  def render(self, screen):
    center = self.csc.center_x, self.csc.center_y
    end = self.csc.polar2pygame(self.length, self.fi)

    center = int(center[0]), int(center[1])
    end = int(end[0]), int(end[1])

    pygame.draw.line(screen, (0, 0, 90), center, end, self.width)


    
    	
main()

import sys
class _Getch:
	"""Gets a single character from standard input. Does not echo to the screen."""
	def __init__(self):
		try:
			self.impl = _GetchWindows()
		except ImportError:
			self.impl = _GetchUnix()

	def __call__(self):		
		ch = self.impl()
		if ord(ch) == 127:
			ch = '\x08'
			sys.stdout.write('\x08\x20')
		return ch

class _GetchUnix:
	def __init__(self):
		import tty, sys
		self.text = ''
		self.rch = ''

	def __call__(self):
		import sys, tty, termios, select
		fd = sys.stdin.fileno()
		fout = sys.stdout.fileno()		
		old_settings = termios.tcgetattr(fd)
		try:
			tty.setraw(sys.stdin.fileno())			
			ch = sys.stdin.read(1)
		finally:
			termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
		return ch

class _GetchWindows:
	def __init__(self):
		import msvcrt

	def __call__(self):
		import msvcrt
		return msvcrt.getch()

getch = _Getch()

#!/usr/bin/python
#coding:utf-8

from cli import getch
import sys

while True:
	ch = getch.__call__()
	sys.stdout.write(ch)
	if ord(ch) == 90: break