<repo_name>everystone/is105<file_sep>/lab2.py
# -*- coding: latin-1 -*-#
#  IS-105 LAB2
#
#  lab2.py - kildekode som inneholder studentenes lQsning.
#         
#
#
import sys

# Skriv inn fullt navn paa gruppemedlemene (erstatte '-' med navn slikt '<NAME>')
gruppe = {  'student1': '<NAME>', \
			'student2': '<NAME>', \
}

#
#  Oppgave 1
#    Leke med utskrift 
#    Skriv ut fQlgende "ascii art" i en funksjon
#    Funksjonen skal hete ascii_fugl() og skal vaere uten argumenter og uten returverdier
#    Den skal skrive ut fQlgende naar den brukes ascii_fugl
#
#       \/_
#  \,   /( ,/
#   \\\' ///
#    \_ /_/
#    (./
#     '` 
def ascii_fugl():
	print "      \\/_"
	print " \\,   /( ,/"
	print "  \\\\\\' ///"
	print "   \\_ /_/"
	print "   (./"
	print "    '`"


# 
#  Oppgave 2
#    'return 2' - 2 skal erstattes med en korrekt returverdi, 2 er kun en stedsholder
#    bitAnd - x&y
#    Eksempel: bitAnd(6, 5) = 4
#
def bitAnd(x, y):
	return x & y

 
#  Oppgave 3
#    bitAnd - x&y
#    Eksempel: bitAnd(6, 5) = 4
#
#def bitAnd(x, y):
#  return 2

#
#  Oppgave 4
#    bitXor - x^y
#    Eksempel: bitXor(4, 5) = 1
#
def bitXor(x, y):
  return x ^ y

#
#  Oppgave 5
#    bitOr - x|y
#    Eksempel: bitOr(0, 1) = 1
#
def bitOr(x, y):
  return (x | y)

#
#  Oppgave 6
#    ascii8Bin - ta et tegn som argument og returnerer ascii-verdien som 8 bits streng binaert
#    Eksempel: ascii8('A) = 01000001
#
#  Tips:
#    For aa finne desimalverdien til et tegn bruk funksjonen ord, for eksempel
#      ord('A) , det vil gi et tall 65 i ti-tallssystemet
#    For aa formattere 6 i ti-tallssystemet til 00000110 i to-tallssystemet
#      '{0:08b}'.format(6)
#      00000110
#
#    Formatteringsstrengen forklart:
#      {} setter en variabel inn i strengen
#      0 tar variabelen i argument posisjon 0
#      : legger til formatteringsmuligheter for denne variabelen (ellers hadde den 6 desimalt)
#      08 formatterer tall til 8 tegn og fuller med nuller til venstre hvis nQdvendig
#      b konverterer tallet til dets binAEre representasjon
def ascii8Bin(bokstav):
	decVal = ord(bokstav)
	return "Ascii: ", bokstav,  " Decimal: ", decVal,  " Binary:  ", '{0:08b}'.format(decVal)

# 
#  Oppgave 7
#    transferBin - ta en tilfeldig streng som argument og skriver ut en blokk av 8-bits strenger
#   som er den binre representasjon av strengen
#    Eksempel: transferBin("Hi") skriver ut: 
#                01001000
#                01101001
#
def transferBin(string): 
	l = list(string)
	print "length of list: ", len(l)
	for c in l:
		print ascii8Bin(c)
# skriv ut den binQre representasjon av hvert tegn (bruk ascii8Bin funksjonen din)

def ascii2Hex(bokstav):
	decVal = ord(bokstav)
	return "Ascii ", bokstav, "Decimal : ", decVal, "Hex: ", '{0:02x}'.format(decVal)
	

# Oppgave 8
# transferHex - gjQr det samme som transferBin, bare skriver ut representasjonen
#av strengen heksadesimalt (bruk formattering forklart i Oppgave 6)
#Skriv gjerne en stQttefunksjon ascii2Hex, som representerer et tegn
#med 2 heksadesimale tegn

def transferHex(string):
	l = list(string)
	for c in l:
		print ascii2Hex(c)




#tests
print "Lab2 - IS105"
print gruppe
print "\nOppgave 1 - ascii_fugl():"
ascii_fugl()

print "\nOppgave 3 - bitAnd(6,5):",  bitAnd(6,5)

print "\nOppgave 4 - bitXor(4,5):", bitXor(4,5)

print "\nOppgave 5 - bitOr(0,1):", bitOr(0,1)

print "\nOppgave 6 - ascii8Bin:"
bokstav = raw_input(">bokstav: ")
print ascii8Bin(bokstav)

print "\nOppgave 7 - transferBin"
setning = raw_input(">Skriv inn et ord:")
transferBin(setning)

print "\nOppgave 8 - transferHex"
setning = raw_input(">Skriv inn et ord:")
transferHex(setning)
<file_sep>/ext1.py
#!/usr/bin/python
from sys import argv
script, user_name = argv
prompt = '> '

print "Hello %s, im the %s script." % (user_name, script) #skriver ut script + argv 0
print "is it true that 3 + 2 < 5 - 7?"
print 3 + 2 < 5 - 7 # returnerer true/false
print "what is 3 + 2?", 3+2
print "what is 5-7?", 5-7
print "give me a number"
number = raw_input(prompt) #input 
print "You gave me %r" % (number )

print """
flere linjer
i en print
very clever.
"""
<file_sep>/lab4.py
# -*- coding: latin-1 -*-
#
#  IS-105 LAB4
#
#  lab4.py - kildekode som inneholder studentenes løsning.
#         
#
#
import sys
import os
import subprocess
import re
import psutil # Kan installeres med "pip2.7 install psutil"

# Skriv inn fullt navn på gruppemedlemene (erstatte '-' med navn slikt 'Kari Trå')
gruppe = {  'student1': '<NAME>', \
}

# Oppgave 1
# 	Funksjonen lager en strukturert utskrift av resultater fra
#   kallet psutil.cpu_times(). 
#	Modulen psutil må være installert.
#
#   Utskriften skal være følgende (verdiene skal selvsagt være forskjellige):
#		user = 3088.16
#		nice = 0.99
#		system = 897.37
#		idle = 72353.81
#		iowait = 19.29
#		irq = 6.82
#		softirq = 3.07
#		steal = 0.00
#		guest = 0.00
#
def psutils_use():
	print """
	Henter lister med systeminformasjon fra /proc og bearbeider disse
	"""	
	data = str(psutil.cpu_times(True)) # hente output fra cpu_times inn i string data
	data2 = data.replace("cputimes(", "") # fjerne cputimes( fra starten av stringen
	data2 = data2[1:-2] #fjerner første char '[' og de 2 siste '])'
	list = data2.split(',') # splitte på komma

	for i in list:
		print i.replace("=", " = ") # legge til space før og etter = og printer
	

	
psutils_use()


# Oppgave 2
#	Gitt følgende liste (inn-data):
# 	proglangs = [('Python', '1989', '<NAME>'), ('C', '1969', '<NAME>'), ('Java/Oak', '1991', '<NAME>'), ('C++', '1979', 'Bjarne Stroustrup'), ('Ruby', '1991', 'Yukihiro "Matz" Matsumoto'), ('Perl', '1987' , '<NAME>'), ('Go/golang', '2007', '<NAME>, <NAME>, and <NAME>')]
#
#	skal funksjonen produsere følgende ut-data:
#
#		C ble startet 1969 av <NAME>.
#		C++ ble startet 1979 av Bjarne Stroustrup.
#		Perl ble startet 1987 av <NAME>.
#		Python ble startet 1989 av <NAME>.
#		Java/Oak ble startet 1991 av <NAME>.
#		Ruby ble startet 1991 av Yukihiro "Matz" Matsumoto.
#		Go/golang ble startet 2007 av <NAME>, <NAME>, and <NAME>.
#			
def print_history(proglangs):
	# Implementer funksjonen her
	sortert = sorted(proglangs, key=lambda year: year[1]) # sorter
	for line in sortert:
		print "\t%s ble startet i %s av %s" %(line[0], line[1], line[2])


proglangs = [('Python', '1989', '<NAME>'), ('C', '1969', '<NAME>'), ('Java/Oak', '1991', '<NAME>'), ('C++', '1979', '<NAME>'), ('Ruby', '1991', 'Yukihiro "Matz" Matsumoto'), ('Perl', '1987' , '<NAME>'), ('Go/golang', '2007', '<NAME>, <NAME>, and <NAME>')]
print_history(proglangs)


# Standardkall for evalueringen
print 5*"-" + " Studenter: " + 5*"-"
for s in gruppe.values():
	if s is not "-":
		print s





<file_sep>/poker-client.py
# -*- coding: latin-1 -*-

"""
Poker klient v 0.2
<NAME>

"""

import socket
import sys
import select

host = 'localhost'
port = 10000
size = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#connect to server
try:
	s.connect((host,port));
except:
	sys.stdout.write("Connection failed");
	sys.exit();
	
sys.stdout.write('[+]Connected to server\n');



while 1:
	socket_list = [sys.stdin, s] # userinput og  netsocket
	
	# get readable socket ( tcp socket or stdin ( user input ) )
	ready_to_read,ready_to_write,in_error = select.select(socket_list, [], []);
	
	for sock in ready_to_read:
		if sock == s:
			#incoming message from server
			data = sock.recv(size);
			if not data:
				sys.stdout.write("[!] Disconnected.\n\n");
				sys.exit(0);
			else :
				#print data from server
				sys.stdout.write(">>"+data+"\n");
				sys.stdout.write('%');
				sys.stdout.flush(); #flush output buffer
		else :
			# User input
			msg = sys.stdin.readline().rstrip(); #strip newline
			s.send(msg); #send meldingen
	
	

s.close()
sys.stdout.write("Terminating client..");
<file_sep>/math.py
#!/usr/bin/python
# LAB2 - <NAME>
import operator; # operator functions
from sys import exit # to invoke exit

#operators
ops = {"+": operator.add,
        "-": operator.sub,
        "*": operator.mul,
        "/": operator.div}

#try parse integer from string, returns false if int(string) fails.
def try_parse_int(s, base=10):
        try:
                int(s, base)
                return True
        except ValueError:
                return False

#Check if operator is valid ( check if op is in list )
def valid_operator(op):
        if op in ('+', '-', '*', '/'):
                return True
        else:
                return False


#respond to  math request. 
def math(n1, op, n2):
        if( try_parse_int(n1) and try_parse_int(n2) and valid_operator(op) ): #evaluate user input
                operand = ops[op]; # assign valid operator function
                result = operand(int(n1), int(n2)); # perform math operation
                return "%s %s %s = %d" % (n1, op, n2, result) # return answer
        else:
                return " (!) Syntax: x [+,-,*,/] y, ex: 5 * 2" # return error message


print "LAB2 - functions. Im a simple Math bot,\nI accept questions like this: x [+,-,*,/] y\n"


# main loop
while True:
	question = raw_input("> ") # input fra bruker
	q =  question.split(' '); # splitte opp question ved hver space
	#print "debug: %d items in q" % (len(q)) # debug msg to check number of items in array
	if( len(q) < 3 ): # om q arrayet inneholder mindre enn 3 elementer
		print " (!) Syntax: x [+,-,*,/] y"
				
	else:
		ans = math(q[0], q[1], q[2])	
		print ans

	if ("exit" in question):
		print "Good bye!"
		exit(0)
<file_sep>/ircbot.py
#!/usr/bin/python
#Simple IRC bot
# <NAME>

import socket;
import operator;

nick = 'everyb0t'
network = 'irc.quakenet.org'
port = 6667;
chan = "#uia.cs"

#operators
ops = {"+": operator.add,
	"-": operator.sub,
	"*": operator.mul,
	"/": operator.div}

#define socket
irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print "Connecting to ", network
irc.connect((network,port)) #connect
print "Connected! sending user info"
# send info
irc.recv(4096)
irc.send('NICK ' + nick + '\r\n') #send nickname
irc.send('USER everyb0t everyb0t everyb0t :everystone_bot\r\n') #send user info
print "********* Bot online *********"

#try parse integer from string
def try_parse_int(s, base=10):
	try:
    		int(s, base)
		return True
  	except ValueError:
    		return False

#Check if operator is valid
def valid_operator(op):
	if op in ('+', '-', '*', '/'):
		return True
	else:
		return False


# hente username of user sending PRIVMSG to channel
#:everystone!~everyston@192.168.127.12 PRIVMSG #uia.cs :hei
def getUserNick(data):
	nick = data.split('!');
	return nick[0].lstrip('#:');


#respond to ">hva er x + y math request
def math(user, n1, op, n2):
	if( try_parse_int(n1) and try_parse_int(n2) and valid_operator(op) ): #evaluate user input
		operand = ops[op];
		result = operand(int(n1), int(n2));
		return " :%s: %s %s %s = %d" % (user, n1, op, n2, result)
	else:
		return " :%s: (!) Syntax: >hva er x [+,-,*,/] y" % (user)	
		
		

while True: # Main loop
    data=irc.recv(4096) #receive data from socket
    print data # ( debug - print all socket data )

    if data.find('PING') != -1: #If PING is Found in the Data
        irc.send('PONG ' + data.split()[1] + '\r\n') #Send back a PONG
        print "PONG ",data.split()[1]

	################	JOIN CHANNEL		###############
    if data.find(':everyb0t!~everyb0t@192.168.127.12 MODE everyb0t +i') != -1: #we are connected
        irc.send('JOIN ' + chan + '\r\n') #join channel
	print "** Joining channel ", chan
        irc.send('PRIVMSG ' + chan + ' hello\r\n') #say hello to chan

	################# 	CS SERVER STATUS	 ######################
    if data.find('!status') != -1: #CS SERVER STATUS ( TODO: query port 27015 with status query )
        irc.send('PRIVMSG ' + chan + ' :server status: 0\r\n')

	################## 	Matte operasjoner	 #####################
    if data.find('>hva er') != -1: #hva er x (op) y
        raw=data.split(' ');
	user = getUserNick(data)
	svar = math(user, raw[5], raw[6], raw[7].rstrip('\n\r'))	

	irc.send('PRIVMSG ' + chan + svar + '\r\n')
	#print raw
<file_sep>/README.md
is105
=====
Diverse python kode for faget is105
<NAME>
<file_sep>/poker-server.py
# -*- coding: latin-1 -*-

# http://pymotw.com/2/select/
# http://www.tutorialspoint.com/python/python_dictionary.htm

# Sockets programmering i Python
# Utforskning av sockets api og andre Python moduler
# Module kan betraktes som en slags plug-in som utvider funksjonaliteten til et grunnlag
# Et grunnlag er programmeringsmiljø som man kan bruke for å gjøre "beregninger" / implementere "systemer"

# select module gir tilgang til platform-spesifikke INN/UT monitorerings-funksjoner
# select() er en POSIX funksjon som det finnes gode implementasjoner for i både UNIX- og Windows miljøer
# POSIX er et forsøk på å standardisere et operativsystem
import select

import socket
import sys
import Queue

import poker

# Her er data for pokerspillet
# For enkelhets skyld deler vi ut kort i det vi starter server
# Dette bør skje på forespørsel fra en klient i neste versjon av programmet
hands = poker.deal(3)
handsdelt = 0 # Vi trenger en variabel som holder styr på hvor mange hender er delt ut
players = 0;
players_ready = 0;
# Lage en TCP/IP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(0)

# Binde socketen på lokalmaskinen til porten 10000
server_address = ('localhost', 10000)
print >>sys.stderr, '[+]starter socket på %s og port %s' % server_address
server.bind(server_address)

# Høre / vente på innkommende forbindelser
server.listen(5)

# Med select() kan man følge med på mer enn en forbindelse av gangen
# Argumenter til select() er tre lister som inneholder kommunikasjonskanaler som skal observeres / monitoreres
# (1) liste av objekter for data som kommer inn fra andre enheter og skal leses/avleses/konsumeres
# (2) liste av objekter som vil motta data som er på vei ut, dvs. en slags lagerplass for data som sendes ut til andre enheter
# (3) en liste over de objektene som har feilet, kan være objekter fra både "input" og "output" kanaler
# Man må sette opp lister som inneholder INN-kilder og UT-bestemmelsessted
# Forbindelser blir lagt til og fjernet fra disse listen av hovedløkken til serveren

# Sockets som vi forventer å lese fra (kilder)
inputs = [ server ]

# Sockets hvilke vi forventer å skrive til (bestemmelsessted)
outputs = [ ]

# Man kan ha forskjellige kommunikasjonsstrategier
# Server kan vente for at en socket blir skrivbar (man kan skrive til den) før man sender noen data,
# istedenfor å sende responsen umiddelbart.
# I et slikt tilfelle, trenger hver UT-forbindelse en meldingskø, som fungerer som en mellomlager (buffer)
# Data må da sendes gjennom denne "bufferen", typen som brukes her er dictionary
message_queues = {}

#playernames
playerNames = {}

#player's hand
playerHands = {}

#Broadcast - send to all connected clients
def broadcast(message):
	for key in message_queues.keys():
		message_queues[key].put(message); # legg til message i meldings køen
		outputs.append(key) # legg til socket mottaker i outputs
	
#Announce Winner	
def showdown(s):
	global players_ready;
	if(players_ready < 2): #ikke nok spillere er klare
		message_queues[s].put("[!]Not enough players are ready ("+str(players_ready)+")");
		outputs.append(s); #tell player
	else:
		#Show cards
		response = "*** Player Cards ***\n";
		for key in playerNames.keys():
			cards = ' '.join(str(x) for x in playerHands.get(key))
			response = response + playerNames.get(key)+": "+cards+"\n";
		broadcast(response);
			
		#TODO: kalkulere vinner med poker.hand_rank()
		poker_winner();
		
		players_ready = 0; # new round
	
def poker_winner():
	size=0;
	announce = "*** WINNER ***\n-------------\n";
	msg = "";
	
	for key in playerNames.keys():
		hand = playerHands.get(key);
		player = playerNames.get(key);
		result = poker.hand_rank(hand);
		size = len(result);
		if size == 2:
			if result[0] == 0:
				#player has nothing ( 0 )
				msg =  player + "has nothing.\n ";
			elif result[0] == 4:
				msg = player +" has Straigt! " + str(result[1])+"\n";
		elif size == 3:
			if result[0] == 1: #One pairs
				msg =  player + " has One pair of " + str(result[1])+"\n";
			elif result[0] == 2: #Two pairs
				msg =  player  + " has Two pairs of" + str(result[1])+"\n";
			elif result[0] == 3: #Three of a kind
				msg =  player + " has Three of a kind! " + str(result[1])+"\n";
		
		#Take away players cards
		del playerHands[key];
		announce = announce+msg; #append message
		
	#send message
	broadcast(announce);
				
		
def dealCard(s):
	global players_ready;
	if playerHands.get(s) == None: #player has no cards
		hands = poker.deal(1)
		cards = ' '.join(str(x) for x in hands[0])
		#playerHands.update({s:cards}); #give cards to player
		playerHands.update({s:hands[0]});
		message_queues[s].put("Welcome!\nYour hand: "+cards+"\n"); # add message to queue
		outputs.append(s); #send to player
		players_ready+=1; #one more player is ready
		
		#broadcast that player joined
		broadcast(playerNames.get(s)+"Is ready to play!\n");
		
	else : #player already has cards
		cards = ' '.join(str(x) for x in playerHands.get(s))
		message_queues[s].put("You already joined!\nYour hand: "+cards);
		outputs.append(s);
		
def showPlayers(s):
	response = "\n*** POKER PLAYERS ***\n";
	for key in playerNames.keys():
		response = response + playerNames.get(key)+"\n";
		
	message_queues[s].put(response); #send playerlist
	outputs.append(s); #to client asking
	
def isRegistered(s):
	test = playerNames.get(s);
	if test == None:
		return -1; # not registered
	else:
		return 0; # registered
		
def register_player(name, s):
	if isRegistered(s) == -1: #not registered
		playerNames.update({s:name});
		#message_queues[s].put(">>Registered!");
		#outputs.append(s);
		#broadcast that player registered
		broadcast("[+]"+name+" Registered!");
	else:
		message_queues[s].put("You are already registered as: "+playerNames.get(s));
	


# Hoveddelen av serverprogrammet er denne løkken som løper, og kaller select() som blokkerer utførelsen og 
# venter på nettverksaktivitet
while inputs:
	# Vent inntil minst en av socketene er klar for prosessering
	#print >>sys.stderr, '\nventer på neste hendelse'
	readable, writable, exceptional = select.select(inputs, outputs, inputs)

# select returnerer tre nye lister, som er subset av de opprinnelige listene
# (1) alle socketene i readable listen har mellomlagret INN-data og er klare til å bli lest
# (2) alle socketene i writable har fri lagringsplass i deres lager og kan bli skrevet til
# (3) socketene som er returnert gjennom exceptional har hatt en feil (definisjon av uttak er platformavhengig)

	#for key in message_queues.keys():
		#print >>sys.stderr, '[!]spiller %s er meldt seg for spill' % str(key.getpeername())



# Behandler inputs her
	for s in readable:
		if s is server:
			# En lesbar (readable) server socket er klar til å akseptere forbindelser
			connection, client_address = s.accept()
			print >>sys.stderr, '[+]en ny forbindelse fra', client_address
			connection.setblocking(0)
			inputs.append(connection)
			players+=1; #increase total players
			
			welcome_status = "Welcome to root poker!\nTotal players: %d\n------------------------\nuse \"help\" if you are stuck\n" % players
			
			# Gi forbindelse en kø for data som man ønsker å sende
			message_queues[connection] = Queue.Queue()
			message_queues[connection].put(welcome_status);
			#broadcast at en ny bruker har joina
			broadcast("[+]"+client_address[0]+" has joined!");
			
			
# (2) Dette er tilfelle når man har en allerede etablert forbindelse som man allerede 
#     har brukt for å sende data
#     Data leses med recv(), så blir plassert i en kø, slik at den kan bli sendt gjennom socketen tilbake til klienten
		else:
			data = s.recv(1024)
			if data:
			
				#if newline in data, remove it
				if '\n' in data:
					data = data.rstrip('\n');
					
				# En lesbar klient-socket som har data
				print >>sys.stderr, "mottok \"%s\" fra %s" % (data, s.getpeername())

				

				# Koden skrevet av studenter
				# Sjekk meldingskø og også inputs
				# Her kan man behandle data som man mottar
				# Man kan også gi forskjellig respons til forskjellige klienter
				# OPPGAVE: del ut en hånd til en klient som sender JOIN
				# Her må du tenke på en algoritme som klarer å begrense antall klienter som kan spille
				# og hvor du også må finne en måte å dele ut kort på til hver av spillere
				# hands er her laget ved start av server, men finn også ut 

				if data.startswith("REG"):
					register_player(data[4:], s); #start at char 4 after reg, and host s.getpeername()[0]
					
				#check if player is registered
				elif playerNames.get(s) == None:
					data = "\nPlease register first with REG <name>";
					message_queues[s].put(data);
				
				elif data == 'JOIN':
					dealCard(s); #deal hand to player
				
				elif data == "SHOWDOWN":
					showdown(s) # Announce winner
				
				elif data == "help": #help message
					data = "\nJOIN\t-Join a game of poker!\nSHOWDOWN\t-Show winner of hand\nsay <msg>\t-send chat to everyone\nPLAYERS\t-Show connected players\n";
					message_queues[s].put(data);
				
				elif data == "PLAYERS": #show total players
					showPlayers(s);
				
				elif data.startswith("say"): # chat melding
					meld = playerNames.get(s) + ": "+data[4:];
					broadcast(meld);
				else:
					message_queues[s].put("Unknown command - try \"help\"");
				

				# Legg til UT-kanalen for responsen
				if s not in outputs:
					outputs.append(s)
# (3) En lesbar socket uten tilgjengelige data er fra en klient som har koblet seg fra, slik at strømmen kan lukkes
			else:
				# Interpreter en tom resultat som en lukket forbindelse
				print >>sys.stderr, 'lukker', client_address, 'etter at ingen data kunne leses'
				# Stopper å høre for IN-data på denne forbindelsen
				if s in outputs:
					outputs.remove(s)
				inputs.remove(s)
				s.close()

				# Fjern meldingskø
				del message_queues[s]
				#fjern spillerens kort
				if playerHands.get(s) != None:
					del playerHands[s];
				
				#broadcast at spilleren har forlatt spillet
				if playerNames.get(s) != None:
					broadcast(playerNames.get(s)+" has left the game!");
					#fjern playerName fra playerNames
					del playerNames[s];

# Det er mindre antall muligheter for writable
# Hvis det er data i køen for en forbindelse, neste melding blir sendt
# Ellers, forbindelsen fjernes fra liste for UT-forbindelser, slik at i neste omgang i løkken select()
# ikke skal indikere at socketen er klar til å sende data
	for s in writable:
		try:
			next_msg = message_queues[s].get_nowait()
		except Queue.Empty:
			# Ingen meldinger venter -> stoppe sjekking for skrivbarhet
			print >>sys.stderr, 'UT køen for', s.getpeername(), 'er tom'
			outputs.remove(s)
		else:
			print >>sys.stderr, 'sender "%s" til %s' % (next_msg, s.getpeername())
			s.send(next_msg)

# Til slutt, hvis det er en feil i socketen, den blir lukket
	for s in exceptional:
		print >>sys.stderr, 'behandler feilsituasjon for', s.getpeername()
		# Stoppe å høre for input for forbindelsen
		inputs.remove(s)
		if s in outputs:
			outputs.remove(s)
		s.close()

		# Fjern meldingskø
		del message_queues[s]


		
	#for key in message_queues.keys():
		#print >>sys.stderr, '[!]spiller %s er meldt seg for spill' % str(key.getpeername())
s.close()
sys.stdout.write("Terminating Server..");