def _send_packets(self):
finished = False
for pos in range(self.window_base, self.window_max + 1):
if pos >= len(self.queue):
data = self.data[:500]
self.data = self.data[500:]
if not data:
self._finish()
finished = True
break
header = Header(self.seqn,
self.received_seqn,
pos,
self.window_size,
Header.checksum(data),
ftp=True)
packet = Packet(header.formatted + data)
self.seqn += len(data)
self.queue.append(packet)
packet = self.queue[pos]
if packet.state not in [RECEIVED, SENT] or packet.timeout():
packet.send(self.udp_connection, self.host, self.port)
self._receive()
if finished is False:
self._advance_window()
else:
return False
def __init__(self):
super(SongListScreen, self).__init__(
clutter.BinLayout(clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_CENTER))
self.set_name('song list')
layout = self.get_layout_manager()
self.header = Header('All Songs')
self.header.set_width(self.get_width())
layout.add(self.header, clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_START)
self.left_arrow = LeftArrow()
self.right_arrow = RightArrow()
songs = Song.objects.filter(approved=True).order_by('title')
self.songs = ScrollingText(map(BlinkingText, songs),
items_on_screen=settings.SONG_LIST_ITEMS)
self.songs.set_width(self.get_width() - (self.left_arrow.get_width() +
self.right_arrow.get_width()))
self.songs.set_height(self.get_height() - self.header.get_height())
layout.add(self.songs, clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_END)
layout.add(self.left_arrow, clutter.BIN_ALIGNMENT_START,
clutter.BIN_ALIGNMENT_CENTER)
layout.add(self.right_arrow, clutter.BIN_ALIGNMENT_END,
clutter.BIN_ALIGNMENT_CENTER)
def _receivedResponse(self, r, uri):
'''Received a SIP response r (Message) from the uri (URI).'''
if not r.Via: raise ValueError('No Via header in received response')
try:
branch = r.first('Via').branch
except AttributeError:
branch = ''
method = r.CSeq.method
t = self.findTransaction(Transaction.createId(branch, method))
if not t:
if method == 'INVITE' and r.is2xx: # success of INVITE
d = self.findDialog(r)
if not d: # no dialog or transaction for success response of INVITE.
raise ValueError(
'No transaction or dialog for 2xx of INVITE')
else:
d.receivedResponse(None, r)
else:
if _debug:
print('transaction id %r not found' %
(Transaction.createId(branch, method), )
) # do not print the full transactions table
if method == 'INVITE' and r.isfinal: # final failure response for INVITE, send ACK to same transport
# TODO: check if this following is as per the standard
m = Message.createRequest('ACK', str(r.To.value.uri))
m['Call-ID'], m.From, m.To, m.Via, m.CSeq = r[
'Call-ID'], r.From, r.To, r.first('Via'), Header(
str(r.CSeq.number) + ' ACK', 'CSeq')
self.send(m, uri.hostPort)
raise ValueError('No transaction for response')
else:
t.receivedResponse(r)
def setUpClass(cls):
cls.driver = WebDriver()
cls.driver.implicitly_wait(5)
cls.header = Header(cls.driver)
def test_footer_links(self):
links = (
# MEN
'View All Men',
#'New Arrivals',
'Shirts',
'Tees, Knits and Polos',
#'Pants & Denim',
'Blazers',
# WOMEN
)
head = (
'Men',
# 'New Arrivals',
'Shirts',
'Tees, Knits and Polos',
# 'Pants & Denim',
'Blazers',
)
LoginPage(self.browser).open()
for link, heads in zip(links, head):
Link(self.browser, 'Men').hover()
Link(self.browser, link).click()
self.assertTrue(Header(self.browser, heads).is_visible)
def _parse_file_headers(self, data):
headers = list()
d_idx = 0
for h_idx in range(6):
h_prefix = data[d_idx]
d_idx += 1
# first byte is number of values
cnt = ord(h_prefix)
f_header = Header(h_idx, h_prefix, "")
for v_idx in range(cnt):
v_prefix = data[d_idx]
d_idx += 1
# first byte is length of value
length = ord(v_prefix)
v_data = data[d_idx:d_idx+length]
d_idx += length
h_value = HeaderValue(v_prefix, "", v_data)
f_header.values.append(h_value)
headers.append(f_header)
return headers, d_idx
def __init__(self, src_port=0x0, dst_port=0x0, data=''):
super().__init__()
self.src_port = src_port
self.dst_port = dst_port
self.header = Header()
self.data = data
pass
def simple_table():
doc = SimpleDocTemplate(r'C:\Skyhook\Helsingborg\Commission\sales\simple_table.pdf', pagesize=landscape((15*inch,20*inch)))
#,rightMargin=72, leftMargin=36,topMargin=36, bottomMargin=18)
story = []
# data = [['col_{}'.format(x) for x in range(1, 6)],
# [str(x) for x in range(1, 6)],
# ['a', 'b', 'c', 'd', 'e']
# ]
ts = [('ALIGN', (1, 1), (-1, -1), 'CENTER'),
('LINEABOVE', (0, 0), (-1, 0), 1, colors.purple),
('LINEBELOW', (0, 0), (-1, 0), 1, colors.purple),
('FONT', (0, 0), (-1, 0), 'Times-Bold'),
('LINEABOVE', (0, -1), (-1, -1), 1, colors.purple),
('LINEBELOW', (0, -1), (-1, -1), 0.5, colors.purple, 1, None, None, 4, 1),
('LINEBELOW', (0, -1), (-1, -1), 1, colors.red),
('FONT', (0, -1), (-1, -1), 'Times-Bold'),
('BACKGROUND', (1, 1), (-2, -2), colors.whitesmoke),
('TEXTCOLOR', (0, 0), (1, -1), colors.red)]
lista = [df.columns[:, ].values.astype(str).tolist()] + df.values.tolist()
xml = parse_xml(r'C:\Skyhook\Helsingborg\Commission\sales\eob.xml')
tbl = Table(lista, style=ts)
header = Header(xml)
story.append(header)
story.append(Spacer(1, 50))
story.append(tbl)
doc.build(story)
def sendNotify(self, dialog, pidf, status, expires):
notify = dialog.createRequest('NOTIFY')
h = notify.headers
h['subscription-state'] = Header(status, {'expires': str(expires)})
h['content-type'] = 'application/pidf+xml'
h['Event'] = 'presence'
notify.content = pidf
yield self.sendRequest(notify)
def ack(self, received_header, host, to_ack):
header = Header(self.seqn,
received_header.seqn + self.data_len,
received_header.ftp_pos,
WINDOW_SIZE,
'',
ack=to_ack)
self.udp_server.send_packet(header.formatted, host, self.port + 1)
def _set_header(self, key, value):
header = self._get_header(key)
if not header:
header = Header(key, value)
self._headers.append(header)
else:
header.value = value
return self
def createRequest(method, uri, headers=None, content=None):
m = Message()
m.method, m.uri, m.protocol = method, URI(uri), 'SIP/2.0'
Message._populateMessage(m, headers, content)
if m.CSeq != None and m.CSeq.method != method:
m.CSeq = Header(str(m.CSeq.number) + ' ' + method, 'CSeq')
return m
def create_header(headerText, rightHeaderLines, logoUrl):
header = Header(headerMarginTop=0.9, debug=False)
logo = importSVG(
logoUrl, scale=1.0, width=60,
height=110) # important for scaling inside the header table !
defaultHeader, reportTitle = header.headerBuild(
headerText, figure_left=logo, right_lines=rightHeaderLines)
return defaultHeader
def _populateMessage(m, headers=None, content=None):
if headers:
for h in headers:
m.insert(h, True) # append the header instead of overriding
if content:
m.body = content
else:
m['Content-Length'] = Header('0', 'Content-Length')
def load_midi(self):
chunk_extractor = ChunkExtractor(self.midi_path)
self.header = Header(chunk_extractor.header)
for track in chunk_extractor.tracks:
self._current_track = Track(track[1], track[2])
message_extractor = MessageExtractor(track)
self.tracks.append(
Track(message_extractor.track[1], message_extractor.track[2]))
self.allocate_messages(message_extractor.events)
def __init__(self):
Gtk.Window.__init__(self, title='Diary')
self.set_default_size(800, 600)
self.connect('destroy', Gtk.main_quit)
main_box = Gtk.Box()
size_group = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
# initializing all relevant classes
diary = Diary("Test User")
textview = Textview()
header = Header()
searchbar = Searchbar()
sidebox = Sidebox()
# transfer classes to linker
linker = Linker(diary, header, sidebox, searchbar, textview)
# transfer linker to header and sidebox
header.set_connection_linker(linker)
sidebox.set_connection_linker(linker)
sidebox.update_year()
searchbar.set_connection_linker(linker)
searchbar.set_revealer_signal()
# connect size_group to header and sidebox
header.set_size_group(size_group)
sidebox.set_size_group(size_group)
sidebox.set_revealer_signal()
# setup relevant buttons in header
header.set_backbutton()
header.set_forwardbutton()
header.set_searchbutton()
header.set_addbutton()
header.set_editbutton()
self.set_titlebar(header)
# create new side_box to add searchbar and sidebox
# and add it to beginning of mainbox
side_box = Gtk.VBox()
side_box.pack_start(searchbar, False, False, 0)
side_box.pack_start(sidebox, True, True, 0)
side_box.set_hexpand(False)
main_box.pack_start(side_box, False, False, 0)
# add separator between side_box and textview
separator = Gtk.HSeparator()
separator.set_size_request(1, 0)
main_box.pack_start(separator, False, False, 0)
# add textview to end of mainbox
main_box.pack_start(textview, False, True, 0)
self.add(main_box)
def createVia(self, secure=False):
if not self.transport:
raise ValueError('No transport in stack')
if secure and not self.transport.secure:
raise ValueError('Cannot find a secure transport')
return Header(
'SIP/2.0/' + self.transport.type.upper() + ' ' +
self.transport.host + ':' + str(self.transport.port) + ';rport',
'Via')
def _send_syn_ack(self, header, host):
header = Header(self.seqn,
header.seqn + 1,
0,
header.window_size,
'',
syn=True,
ack=True)
self.udp_server.send_packet(header.formatted, host, self.port + 1)
def _send_ack(self, received_seqn):
self.seqn += 1
header = Header(self.seqn,
received_seqn + 1,
0,
self.window_size,
'',
ack=True)
self.udp_connection.send_packet(header.formatted, self.host, self.port)
def changeState(c, message):
header = message.header
if header.flagSet(Flag.F):
c.ackPackages(message.header.aNum + 1)
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A]), c.window)
m = Message(h)
c.send(m, True)
c.resetFinTimer()
return Time_Wait
return Closed
def read_header(f):
header_string = read_null_terminated_string(f.read(26))
padding = read_struct(f, "4b")
if header_string == "Vocaloid Motion Data file":
pmd_model_name_length = 10
else:
pmd_model_name_length = 20
pmd_model_name = get_english_name(f.read(pmd_model_name_length))
return Header(header_string, padding, pmd_model_name,
pmd_model_name_length)
def run(self):
self.args = self.parser.parse_args()
self.license = self.args.license
self.setup_license_details()
self.setup_logs()
self.validate_cli_arguments()
self.check_if_already_has_license()
if self.args.r:
self.update_readme()
if self.args.remove_headers:
Header(self.args, self.longname, self.license_filename,
self.url).install_headers()
self.args.remove_headers = False
self.install_license()
Header(self.args, self.longname, self.license_filename,
self.url).install_headers()
def __init__(self):
super(Bundle, self).__init__()
self.header = Header()
self.body = Body()
self.footer = Footer()
self.status = NORMAL
self.output = urwid.Frame(self.body.output,
header=self.header.output,
footer=self.footer.output,
focus_part='body')
def _transmit_filename(self, filename):
header = Header(self.seqn,
self.received_seqn,
0,
self.window_size,
Header.checksum(filename),
file_name=True)
self.udp_connection.send_packet(header.formatted + filename, self.host,
self.port)
ack = self.udp_connection.recv()
def make(self):
num_panels = self.params.panels_pcb['num_panels']
space_tol = self.params.panels_pcb['panel_space_tol']
panel_length = self.params.panel['length']
panel_height = self.params.panel['height']
panel_width = self.params.panel['width']
panels_pcb_thickness = self.params.panels_pcb['thickness']
panels_pcb_width = self.params.panels_pcb['width']
header_height = self.params.header['height']
panel_header_overlap = self.params.panels_pcb['panel_header_overlap']
panel_header_offset = self.params.panels_pcb['panel_header_offset']
mount_hole_offset = self.params.panels_pcb['mount_hole_offset']
explode_z = self.params.explode_z
panels_pos = scipy.arange(0.0,num_panels)*(panel_length + space_tol)
panels_pos -= 0.5*(num_panels-1)*(panel_length + space_tol)
# Create components
panels_pcb = Panels_PCB(**self.params.panels_pcb)
panels_pcb.color(self.params.panels_pcb['color'])
header_list = []
panel_list = []
panel_offset = 0.5*panels_pcb_width - (0.5*panel_width + panel_header_offset + mount_hole_offset)
z_pos_header = 0.5*header_height + 0.5*panels_pcb_thickness
z_pos_panels = 0.5*panel_height
z_pos_panels += panels_pcb_thickness
z_pos_panels += header_height
z_pos_panels -= panel_header_overlap
z_pos_panels += explode_z
y_pos_header = panel_offset
y_pos_panels = panel_header_offset + panel_offset
for x_pos in panels_pos:
#print 8+x_pos/INCH2MM, 3+y_pos_header/INCH2MM
# Create header
header_temp = Header(**self.params.header)
header_temp.translate(v=(x_pos,y_pos_header,z_pos_header))
header_temp.color(rgba=self.params.header['color'])
header_list.append(header_temp)
# Create panel
panel_temp = Panel(**self.params.panel)
panel_temp.translate(v=(x_pos,y_pos_panels,z_pos_panels))
panel_temp.color(rgba=self.params.panel['color'])
panel_list.append(panel_temp)
# Create parts dictionary
self.parts = {'panels_pcb' : panels_pcb}
for i,h in enumerate(header_list):
self.parts['header_%d'%(i,)] = h
for i,p in enumerate(panel_list):
self.parts['panel_%d'%(i,)] = p
def changeState(c: Connection, message: Message):
header = message.header
if header.flagSet(Flag.A):
if header.sNum == c.aNum:
c.ackPackages(header.aNum)
#if it fits
if header.dataLength == 0:
if (c.lastReceivedAck == header.aNum):
c.duplicateAcks += 1
else:
c.lastReceivedAck = header.aNum
c.duplicateAcks = 0
if c.sendData():
return Fin_Wait_1
if c.duplicateAcks > 2:
c.resendInFlight()
if c.sendData():
return Fin_Wait_1
else:
#add data
c.lastReceivedAck = header.aNum
c.received += message.payload[:header.dataLength]
c.aNum = message.header.sNum + message.header.dataLength # update num
if c.sendData(True):
return Fin_Wait_1
else:
#duplicate Ack back - package did not fit
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A]),
c.window)
c.send(Message(h), True)
return Established
if header.flagSet(Flag.F):
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.F]), c.window)
message = Message(h)
c.send(message)
c.sNum += 1
return Close_Wait
return Established
def place_call(self, sender_address):
# get sender sock object
dest = peers[sender_address]
# send call request header
header = Header(TYPE_CALL_REQUEST, self.MYIP)
# send header
s = header.serialize()
dest.send(len(s))
dest.send(s)
def generate_h(struct: Struct):
header = Header()
header.set_header_guard(
"__{uname}_{proj}_DB_ENTITY_STRUCT_{name}_H".format(
name=struct.name.upper(),
proj=proj_name.upper(),
uname=os.getlogin()))
header.add_pragma("once")
header.add_local_include("db/orm/entity.h")
header.add_struct(struct)
return str(header)
def changeState(c, message):
header = message.header
if header.flagSet(Flag.S):
c.window = header.window
c.aNum += 1
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A, Flag.S]),
c.window)
message = Message(h)
c.send(message)
c.sNum += 1
return Syn_Rcvd
return Listen
def send(self, msg, msg_code, dest):
header = Header(msg_code, self.MYIP)
# send header
s = header.serialize()
dest.send(len(s))
dest.send(s)
# send msg
msg = str(msg)
dest.send(len(msg))
dest.send(msg)
